feat(api): Add Responses API support for GPT-5.4 and newer models

Implement full OpenAI Responses API streaming for GitHub Copilot models
that exclusively support /responses (e.g. GPT-5.4). Six bugs fixed in
the initial implementation:

- Content type: use input_text/output_text per Responses API spec
- Tool parameters: encode as JSON objects via CodableAny wrapper,
  not base64 strings (JSONSerialization.data -> Codable was base64)
- System prompt: include as developer-role messages (was filtered
  out during token counting and never re-added)
- Unsupported parameter: remove top_p from Responses requests
- Finish reason: track tool call presence across streaming events
  and emit "tool_calls" instead of always "stop", so the orchestrator
  actually executes tools instead of treating them as natural completion
- Stream events: handle all 9 Responses API informational event types
  (response.created, response.in_progress, function_call_arguments.delta,
  etc.) as .ignored instead of throwing DecodingError warnings

API routing: prefer Chat Completions when model supports both endpoints,
only use Responses API when model exclusively supports /responses.
Added truncation and reasoning configuration to ResponsesRequest.

Mermaid diagram improvements:
- Bundle mermaid.min.js locally for offline rendering (no CDN dependency)
- New MermaidWebRenderer: renders via offscreen WKWebView using bundled
  engine, respects light/dark theme, proper image sizing
- CachedDiagramView rewritten to use MermaidWebRenderer instead of
  inline WKWebView with CDN script tag
- Export/print: diagrams render as high-quality images in PDF, DOCX,
  and PPTX instead of showing raw mermaid code
- MermaidDiagramExporter: dedicated exporter for static image capture
  using WKNavigationDelegate for reliable completion detection
- Expanded system prompt with 20+ diagram types: state, ER, sankey,
  kanban, block, packet, C4 architecture, and syntax correction notes
  for commonly misgenerated types (xychart-beta, sankey-beta, etc.)

Version: 20260316.2

Author: fewtarius

Info.plist

@@ -19,9 +19,9 @@
 	<key>CFBundlePackageType</key>
 	<string>APPL</string>
 	<key>CFBundleShortVersionString</key>
-	<string>20260316.1</string>
+	<string>20260316.2</string>
 	<key>CFBundleVersion</key>
-	<string>20260316.1</string>
+	<string>20260316.2</string>
 	<key>LSApplicationCategoryType</key>
 	<string>public.app-category.productivity</string>
 	<key>LSMinimumSystemVersion</key>

Makefile

@@ -73,6 +73,8 @@ build-debug: llamacpp
 	@cp Resources/vendor/xterm/xterm-addon-fit.js .build/Build/Products/Debug/SAM.app/Contents/Resources/
 	@cp Sources/ConfigurationSystem/Resources/model_config.json .build/Build/Products/Debug/SAM.app/Contents/Resources/
 	@cp Resources/whats-new.json .build/Build/Products/Debug/SAM.app/Contents/Resources/
+	@cp Resources/help.json .build/Build/Products/Debug/SAM.app/Contents/Resources/
+	@cp Resources/vendor/mermaid/mermaid.min.js .build/Build/Products/Debug/SAM.app/Contents/Resources/
 	@cp -R .build/Build/Products/Debug/PackageFrameworks/llama.framework .build/Build/Products/Debug/SAM.app/Contents/Frameworks/
 	@if [ -d ".build/Build/Products/Debug/Sparkle.framework" ]; then \
 		echo "Copying Sparkle.framework to app bundle..."; \
@@ -115,6 +117,8 @@ build-release: llamacpp
 	@cp Resources/vendor/xterm/xterm-addon-fit.js .build/Build/Products/Release/SAM.app/Contents/Resources/
 	@cp Sources/ConfigurationSystem/Resources/model_config.json .build/Build/Products/Release/SAM.app/Contents/Resources/
 	@cp Resources/whats-new.json .build/Build/Products/Release/SAM.app/Contents/Resources/
+	@cp Resources/help.json .build/Build/Products/Release/SAM.app/Contents/Resources/
+	@cp Resources/vendor/mermaid/mermaid.min.js .build/Build/Products/Release/SAM.app/Contents/Resources/
 	@cp -R .build/Build/Products/Release/PackageFrameworks/llama.framework .build/Build/Products/Release/SAM.app/Contents/Frameworks/
 	@echo "Fixing llama framework install name..."
 	@install_name_tool -id "@rpath/llama.framework/Versions/A/llama" .build/Build/Products/Release/SAM.app/Contents/Frameworks/llama.framework/Versions/A/llama 2>/dev/null || true

Resources/vendor/mermaid/mermaid.min.js

@@ -1,5 +1,50 @@
 {
   "releases": [
+    {
+      "version": "20260316.2",
+      "release_date": "March 16, 2026",
+      "introduction": "This release adds support for the latest GPT models, overhauls diagram rendering for better quality and offline use, and fixes several agent reliability issues.",
+      "improvements": [
+        {
+          "id": "gpt-5-4-support",
+          "icon": "cpu.fill",
+          "title": "GPT-5.4 & New Model Support",
+          "description": "SAM now supports GPT-5.4 and other models that use OpenAI's newer Responses API. These models are automatically detected from your GitHub Copilot subscription and work with all of SAM's tools and agent capabilities."
+        },
+        {
+          "id": "mermaid-rendering",
+          "icon": "chart.bar.doc.horizontal.fill",
+          "title": "Improved Diagram Rendering",
+          "description": "Diagrams now render using a bundled engine instead of loading from the internet, so they appear faster and work offline. Rendering respects your light/dark theme setting, and diagrams are properly sized instead of stretching to fill the window."
+        },
+        {
+          "id": "more-diagram-types",
+          "icon": "square.grid.3x3.fill",
+          "title": "More Diagram Types",
+          "description": "SAM can now generate over 20 diagram types including state diagrams, ER diagrams, Sankey flow charts, Kanban boards, packet diagrams, block diagrams, and C4 architecture diagrams - in addition to the existing flowcharts, sequence diagrams, Gantt charts, pie charts, and more."
+        },
+        {
+          "id": "diagram-in-documents",
+          "icon": "doc.richtext.fill",
+          "title": "Diagrams in Exported Documents",
+          "description": "When you export a conversation as PDF, Word, or PowerPoint, any diagrams are now rendered as high-quality images in the document. Previously, exports would show the raw diagram code instead of the rendered visual."
+        }
+      ],
+      "bugfixes": [
+        {
+          "id": "tool-execution-responses-api",
+          "icon": "wrench.and.screwdriver.fill",
+          "title": "Fixed Agent Tool Execution",
+          "description": "Fixed a bug where the agent would recognize tool calls but never execute them when using certain models. The agent now correctly runs tools and continues multi-step workflows on all supported models."
+        },
+        {
+          "id": "system-prompt-responses",
+          "icon": "text.bubble.fill",
+          "title": "Fixed System Prompt for New Models",
+          "description": "System prompts and agent instructions are now correctly sent to all models. Previously, some newer models would ignore the system prompt entirely, leading to generic responses without SAM's personality or capabilities."
+        }
+      ]
+    },
     {
       "version": "20260316.1",
       "release_date": "March 16, 2026",

Resources/whats-new.json

@@ -167,33 +167,45 @@ public struct ResponsesRequest: Codable {
     public let previousResponseId: String?
     public let stream: Bool
     public let tools: [ResponsesFunctionTool]?
-    public let topP: Double?
     public let maxOutputTokens: Int?
     public let toolChoice: String?
     public let store: Bool
+    public let truncation: String?
+    public let reasoning: ResponsesReasoning?
 
     enum CodingKeys: String, CodingKey {
         case model
         case input
         case previousResponseId = "previous_response_id"
         case stream
         case tools
-        case topP = "top_p"
         case maxOutputTokens = "max_output_tokens"
         case toolChoice = "tool_choice"
         case store
+        case truncation
+        case reasoning
     }
 
-    public init(model: String, input: [ResponsesInputItem], previousResponseId: String?, stream: Bool, tools: [ResponsesFunctionTool]?, topP: Double?, maxOutputTokens: Int?, toolChoice: String?, store: Bool = false) {
+    public init(model: String, input: [ResponsesInputItem], previousResponseId: String?, stream: Bool, tools: [ResponsesFunctionTool]?, maxOutputTokens: Int?, toolChoice: String?, store: Bool = false, truncation: String? = "disabled", reasoning: ResponsesReasoning? = ResponsesReasoning()) {
         self.model = model
         self.input = input
         self.previousResponseId = previousResponseId
         self.stream = stream
         self.tools = tools
-        self.topP = topP
         self.maxOutputTokens = maxOutputTokens
         self.toolChoice = toolChoice
         self.store = store
+        self.truncation = truncation
+        self.reasoning = reasoning
+    }
+}
+
+/// Responses API reasoning configuration.
+public struct ResponsesReasoning: Codable {
+    public let effort: String
+
+    public init(effort: String = "medium") {
+        self.effort = effort
     }
 }
 
@@ -263,7 +275,8 @@ public struct ResponsesInputMessage: Codable {
 
 /// Responses API content item.
 public enum ResponsesContentItem: Codable {
-    case text(ResponsesTextContent)
+    case inputText(ResponsesInputTextContent)
+    case outputText(ResponsesOutputTextContent)
 
     enum CodingKeys: String, CodingKey {
         case type
@@ -274,9 +287,13 @@ public enum ResponsesContentItem: Codable {
         let type = try container.decode(String.self, forKey: .type)
 
         switch type {
-        case "text":
-            let text = try ResponsesTextContent(from: decoder)
-            self = .text(text)
+        case "input_text":
+            let text = try ResponsesInputTextContent(from: decoder)
+            self = .inputText(text)
+
+        case "output_text":
+            let text = try ResponsesOutputTextContent(from: decoder)
+            self = .outputText(text)
 
         default:
             throw DecodingError.dataCorruptedError(forKey: .type, in: container, debugDescription: "Unknown content item type: \(type)")
@@ -285,15 +302,27 @@ public enum ResponsesContentItem: Codable {
 
     public func encode(to encoder: Encoder) throws {
         switch self {
-        case .text(let text):
+        case .inputText(let text):
+            try text.encode(to: encoder)
+        case .outputText(let text):
             try text.encode(to: encoder)
         }
     }
 }
 
-/// Responses API text content.
-public struct ResponsesTextContent: Codable {
-    public var type: String = "text"
+/// Responses API input text content (for user/developer messages).
+public struct ResponsesInputTextContent: Codable {
+    public var type: String = "input_text"
+    public let text: String
+
+    public init(text: String) {
+        self.text = text
+    }
+}
+
+/// Responses API output text content (for assistant messages).
+public struct ResponsesOutputTextContent: Codable {
+    public var type: String = "output_text"
     public let text: String
 
     public init(text: String) {
@@ -345,7 +374,8 @@ public struct ResponsesFunctionTool: Codable {
     public var type: String = "function"
     public let name: String
     public let description: String
-    public let parameters: [String: Any]
+    /// Parameters stored as raw JSON data to preserve structure during encoding.
+    public let parametersData: Data
     public let strict: Bool = false
 
     enum CodingKeys: String, CodingKey {
@@ -355,20 +385,18 @@ public struct ResponsesFunctionTool: Codable {
     public init(name: String, description: String, parameters: [String: Any]) {
         self.name = name
         self.description = description
-        self.parameters = parameters
+        self.parametersData = (try? JSONSerialization.data(withJSONObject: parameters)) ?? Data()
     }
 
     public init(from decoder: Decoder) throws {
         let container = try decoder.container(keyedBy: CodingKeys.self)
         self.name = try container.decode(String.self, forKey: .name)
         self.description = try container.decode(String.self, forKey: .description)
-
-        /// Decode parameters as JSON object.
-        let parametersData = try container.decode(Data.self, forKey: .parameters)
-        if let parametersDict = try JSONSerialization.jsonObject(with: parametersData) as? [String: Any] {
-            self.parameters = parametersDict
+        /// Decode parameters however they come.
+        if let rawJSON = try? container.decode(RawJSON.self, forKey: .parameters) {
+            self.parametersData = rawJSON.data
         } else {
-            self.parameters = [:]
+            self.parametersData = Data()
         }
     }
 
@@ -379,9 +407,104 @@ public struct ResponsesFunctionTool: Codable {
         try container.encode(description, forKey: .description)
         try container.encode(strict, forKey: .strict)
 
-        /// Encode parameters as JSON.
-        let parametersData = try JSONSerialization.data(withJSONObject: parameters)
-        try container.encode(parametersData, forKey: .parameters)
+        /// Encode parameters as a raw JSON object (not as a string).
+        let rawJSON = RawJSON(data: parametersData)
+        try container.encode(rawJSON, forKey: .parameters)
+    }
+}
+
+/// Helper type that preserves raw JSON structure through Codable encoding/decoding.
+/// Encodes as a native JSON object/array/value rather than a string or base64.
+private struct RawJSON: Codable {
+    let data: Data
+
+    init(data: Data) {
+        self.data = data
+    }
+
+    init(from decoder: Decoder) throws {
+        let container = try decoder.singleValueContainer()
+        /// Try decoding as various JSON types and re-serialize.
+        if let dict = try? container.decode([String: RawJSON].self) {
+            let rebuilt = dict.mapValues { (try? JSONSerialization.jsonObject(with: $0.data)) ?? NSNull() }
+            self.data = (try? JSONSerialization.data(withJSONObject: rebuilt)) ?? Data()
+        } else if let string = try? container.decode(String.self) {
+            /// Maybe it's a JSON string - try parsing it.
+            if let parsed = string.data(using: .utf8),
+               (try? JSONSerialization.jsonObject(with: parsed)) != nil {
+                self.data = parsed
+            } else {
+                self.data = (try? JSONSerialization.data(withJSONObject: string)) ?? Data()
+            }
+        } else {
+            self.data = Data()
+        }
+    }
+
+    func encode(to encoder: Encoder) throws {
+        var container = encoder.singleValueContainer()
+        guard !data.isEmpty,
+              let jsonObject = try? JSONSerialization.jsonObject(with: data) else {
+            try container.encode([String: String]())
+            return
+        }
+        /// Re-encode via a CodableAny wrapper.
+        let wrapped = CodableAny(jsonObject)
+        try container.encode(wrapped)
+    }
+}
+
+/// Wraps Any JSON value for Codable encoding.
+private enum CodableAny: Codable {
+    case string(String)
+    case int(Int)
+    case double(Double)
+    case bool(Bool)
+    case null
+    case array([CodableAny])
+    case object([String: CodableAny])
+
+    init(_ value: Any) {
+        if let s = value as? String { self = .string(s) }
+        else if let n = value as? NSNumber {
+            // Check for boolean before numeric (NSNumber bridges both)
+            if CFGetTypeID(n) == CFBooleanGetTypeID() {
+                self = .bool(n.boolValue)
+            } else if n.doubleValue == Double(n.intValue) {
+                self = .int(n.intValue)
+            } else {
+                self = .double(n.doubleValue)
+            }
+        }
+        else if let a = value as? [Any] { self = .array(a.map { CodableAny($0) }) }
+        else if let d = value as? [String: Any] { self = .object(d.mapValues { CodableAny($0) }) }
+        else if value is NSNull { self = .null }
+        else { self = .null }
+    }
+
+    init(from decoder: Decoder) throws {
+        let container = try decoder.singleValueContainer()
+        if let s = try? container.decode(String.self) { self = .string(s) }
+        else if let i = try? container.decode(Int.self) { self = .int(i) }
+        else if let d = try? container.decode(Double.self) { self = .double(d) }
+        else if let b = try? container.decode(Bool.self) { self = .bool(b) }
+        else if let a = try? container.decode([CodableAny].self) { self = .array(a) }
+        else if let o = try? container.decode([String: CodableAny].self) { self = .object(o) }
+        else if container.decodeNil() { self = .null }
+        else { self = .null }
+    }
+
+    func encode(to encoder: Encoder) throws {
+        var container = encoder.singleValueContainer()
+        switch self {
+        case .string(let s): try container.encode(s)
+        case .int(let i): try container.encode(i)
+        case .double(let d): try container.encode(d)
+        case .bool(let b): try container.encode(b)
+        case .null: try container.encodeNil()
+        case .array(let a): try container.encode(a)
+        case .object(let o): try container.encode(o)
+        }
     }
 }
 
@@ -394,6 +517,7 @@ public enum ResponsesStreamEvent: Codable {
     case outputItemAdded(ResponsesOutputItemAddedEvent)
     case outputItemDone(ResponsesOutputItemDoneEvent)
     case completed(ResponsesCompletedEvent)
+    case ignored
 
     enum CodingKeys: String, CodingKey {
         case type
@@ -424,8 +548,21 @@ public enum ResponsesStreamEvent: Codable {
             let event = try ResponsesCompletedEvent(from: decoder)
             self = .completed(event)
 
+        case "response.created",
+             "response.in_progress",
+             "response.content_part.added",
+             "response.content_part.done",
+             "response.output_text.done",
+             "response.function_call_arguments.delta",
+             "response.function_call_arguments.done",
+             "response.reasoning_summary_text.delta",
+             "response.reasoning_summary_text.done":
+            /// Informational events - safely ignored.
+            /// Tool call args come via outputItemDone with complete data.
+            self = .ignored
+
         default:
-            /// Ignore unknown event types.
+            /// Truly unknown event types.
             throw DecodingError.dataCorruptedError(forKey: .type, in: container, debugDescription: "Unknown event type: \(type)")
         }
     }
@@ -446,6 +583,9 @@ public enum ResponsesStreamEvent: Codable {
 
         case .completed(let event):
             try event.encode(to: encoder)
+
+        case .ignored:
+            break
         }
     }
 }