fix(openai): extract nested Responses message text

runtime/csharp/Prompty.Core.Tests/Model/ProcessorConformanceTests.cs

@@ -906,6 +906,111 @@ public async Task ResponsesEmptyOutput()
         Assert.NotNull(actual);
     }
 
+    [Fact]
+    public async Task ResponsesEmptyOutputTextMessageContentFallback()
+    {
+        string inputJson = """
+{
+  "agent": {
+    "model": {
+      "provider": "openai"
+    }
+  },
+  "apiType": "responses",
+  "response": {
+    "id": "resp_empty_output_text_fallback",
+    "object": "response",
+    "created_at": 1700000024,
+    "model": "gpt-5.5-pro",
+    "status": "completed",
+    "output": [
+      {
+        "type": "message",
+        "id": "msg_empty_output_text_fallback",
+        "status": "completed",
+        "role": "assistant",
+        "content": [
+          {
+            "type": "output_text",
+            "text": "Nested text wins.",
+            "annotations": []
+          }
+        ]
+      }
+    ],
+    "output_text": "",
+    "usage": {
+      "input_tokens": 12,
+      "output_tokens": 4,
+      "total_tokens": 16
+    }
+  },
+  "has_outputs": false
+}
+""";
+        using var document = JsonDocument.Parse(inputJson);
+        var root = document.RootElement;
+        var agent = Agent.FromJson(root.GetProperty("agent").GetRawText());
+        var response = JsonSerializer.Deserialize<object>(root.GetProperty("response").GetRawText());
+        var provider = agent.Model.Provider;
+        var impl = ProcessorResolver.Resolve(provider, Provider());
+        Assert.NotNull(impl);
+        var actual = await impl!.ProcessAsync(agent, response);
+        Assert.NotNull(actual);
+    }
+
+    [Fact]
+    public async Task ResponsesMessageContentFallback()
+    {
+        string inputJson = """
+{
+  "agent": {
+    "model": {
+      "provider": "openai"
+    }
+  },
+  "apiType": "responses",
+  "response": {
+    "id": "resp_content_fallback",
+    "object": "response",
+    "created_at": 1700000023,
+    "model": "gpt-5.5-pro",
+    "status": "completed",
+    "output": [
+      {
+        "type": "message",
+        "id": "msg_content_fallback",
+        "status": "completed",
+        "role": "assistant",
+        "content": [
+          {
+            "type": "output_text",
+            "text": "Visible final answer.",
+            "annotations": []
+          }
+        ]
+      }
+    ],
+    "usage": {
+      "input_tokens": 12,
+      "output_tokens": 4,
+      "total_tokens": 16
+    }
+  },
+  "has_outputs": false
+}
+""";
+        using var document = JsonDocument.Parse(inputJson);
+        var root = document.RootElement;
+        var agent = Agent.FromJson(root.GetProperty("agent").GetRawText());
+        var response = JsonSerializer.Deserialize<object>(root.GetProperty("response").GetRawText());
+        var provider = agent.Model.Provider;
+        var impl = ProcessorResolver.Resolve(provider, Provider());
+        Assert.NotNull(impl);
+        var actual = await impl!.ProcessAsync(agent, response);
+        Assert.NotNull(actual);
+    }
+
     [Fact]
     public async Task ResponsesStructured()
     {

runtime/go/prompty/model/process_response.go

@@ -100,10 +100,36 @@ func processOpenAIResponses(resp map[string]interface{}, hasOutputs bool) any {
 	if len(toolCalls) > 0 {
 		return toolCalls
 	}
-	outputText, _ := resp["output_text"].(string)
+	outputText := openAIResponsesOutputText(resp)
 	return maybeParseStructured(outputText, hasOutputs)
 }
 
+func openAIResponsesOutputText(resp map[string]interface{}) string {
+	if outputText, _ := resp["output_text"].(string); outputText != "" {
+		return outputText
+	}
+
+	output, _ := resp["output"].([]interface{})
+	var b strings.Builder
+	for _, item := range output {
+		it, _ := item.(map[string]interface{})
+		if it["type"] != "message" {
+			continue
+		}
+		content, _ := it["content"].([]interface{})
+		for _, part := range content {
+			p, _ := part.(map[string]interface{})
+			partType, _ := p["type"].(string)
+			if partType != "output_text" && partType != "text" {
+				continue
+			}
+			text, _ := p["text"].(string)
+			b.WriteString(text)
+		}
+	}
+	return b.String()
+}
+
 func processOpenAIEmbedding(resp map[string]interface{}) any {
 	data, _ := resp["data"].([]interface{})
 	if len(data) == 1 {

runtime/go/prompty/model/process_response_test.go

@@ -0,0 +1,33 @@
+package prompty_test
+
+import (
+	"testing"
+
+	prompty "prompty/model"
+)
+
+func TestOpenAIResponsesEmptyOutputTextFallsBackToMessageContent(t *testing.T) {
+	response := map[string]interface{}{
+		"object":      "response",
+		"output_text": "",
+		"output": []interface{}{
+			map[string]interface{}{
+				"type": "message",
+				"content": []interface{}{
+					map[string]interface{}{
+						"type": "output_text",
+						"text": "Nested text wins.",
+					},
+				},
+			},
+		},
+	}
+
+	result, err := prompty.ProcessResponse("openai", "responses", response, false)
+	if err != nil {
+		t.Fatalf("ProcessResponse failed: %v", err)
+	}
+	if result != "Nested text wins." {
+		t.Fatalf("expected nested text fallback, got %#v", result)
+	}
+}

runtime/java/prompty-openai/src/main/java/com/microsoft/prompty/openai/OpenAIProcessor.java

@@ -164,7 +164,7 @@ private List<Message> portableAssistantMessages(Object response) {
       if (!messages.isEmpty()) {
         return messages;
       }
-      messages.add(Messages.assistant(stringOrEmpty(Streams.pointer(response, "output_text"))));
+      messages.add(Messages.assistant(responsesOutputText(response)));
       return messages;
     }
 
@@ -280,7 +280,28 @@ private static Object processResponsesApi(Agent agent, Object response) {
     if (!toolCalls.isEmpty()) {
       return toolCalls;
     }
-    return structuredOrText(agent, stringOrEmpty(Streams.pointer(response, "output_text")));
+    return structuredOrText(agent, responsesOutputText(response));
+  }
+
+  private static String responsesOutputText(Object response) {
+    String outputText = stringOrEmpty(Streams.pointer(response, "output_text"));
+    if (!outputText.isEmpty()) {
+      return outputText;
+    }
+
+    StringBuilder text = new StringBuilder();
+    for (Object item : asList(Streams.pointer(response, "output"))) {
+      if (!"message".equals(Streams.pointer(item, "type"))) {
+        continue;
+      }
+      for (Object part : asList(Streams.pointer(item, "content"))) {
+        Object partType = Streams.pointer(part, "type");
+        if ("output_text".equals(partType) || "text".equals(partType)) {
+          text.append(stringOrEmpty(Streams.pointer(part, "text")));
+        }
+      }
+    }
+    return text.toString();
   }
 
   /**