feat: add cross-platform support for OpenAI Apps SDK

- Dynamic capability detection based on window.openai availability
- Report availableDisplayModes when requestDisplayMode is available
- Include toolResponseMetadata as _meta in tool-result notification
- registerAppTool adds openai/outputTemplate metadata automatically
- registerAppResource registers both MCP and OpenAI (+skybridge) variants
- Preserve custom MIME types in OpenAI resource callback

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <[email protected]>

Author: ochafik

src/openai/transport.test.ts

@@ -128,6 +128,75 @@ describe("OpenAITransport", () => {
         },
       });
     });
+
+    test("dynamically reports capabilities based on available methods", async () => {
+      // Remove callTool to test dynamic detection
+      delete mockOpenAI.callTool;
+
+      const transport = new OpenAITransport();
+      let response: unknown;
+      transport.onmessage = (msg) => {
+        response = msg;
+      };
+
+      await transport.send({
+        jsonrpc: "2.0",
+        id: 1,
+        method: "ui/initialize",
+        params: {
+          protocolVersion: "2025-11-21",
+          appInfo: { name: "TestApp", version: "1.0.0" },
+          appCapabilities: {},
+        },
+      });
+
+      await new Promise((resolve) => setTimeout(resolve, 0));
+
+      const result = (response as { result: { hostCapabilities: unknown } })
+        .result.hostCapabilities as Record<string, unknown>;
+
+      // serverTools should NOT be present since callTool is missing
+      expect(result.serverTools).toBeUndefined();
+      // openLinks should be present since openExternal exists
+      expect(result.openLinks).toBeDefined();
+      // logging is always available
+      expect(result.logging).toBeDefined();
+    });
+
+    test("includes availableDisplayModes when requestDisplayMode is available", async () => {
+      mockOpenAI.requestDisplayMode = mock(() =>
+        Promise.resolve(),
+      ) as unknown as OpenAIGlobal["requestDisplayMode"];
+
+      const transport = new OpenAITransport();
+      let response: unknown;
+      transport.onmessage = (msg) => {
+        response = msg;
+      };
+
+      await transport.send({
+        jsonrpc: "2.0",
+        id: 1,
+        method: "ui/initialize",
+        params: {
+          protocolVersion: "2025-11-21",
+          appInfo: { name: "TestApp", version: "1.0.0" },
+          appCapabilities: {},
+        },
+      });
+
+      await new Promise((resolve) => setTimeout(resolve, 0));
+
+      expect(response).toMatchObject({
+        jsonrpc: "2.0",
+        id: 1,
+        result: {
+          hostContext: {
+            availableDisplayModes: ["inline", "pip", "fullscreen"],
+          },
+        },
+      });
+    });
   });
 
   describe("tools/call request", () => {
@@ -334,6 +403,32 @@ describe("OpenAITransport", () => {
       expect(toolResultNotification).toBeDefined();
     });
 
+    test("includes _meta from toolResponseMetadata in tool result", async () => {
+      mockOpenAI.toolResponseMetadata = { widgetId: "abc123", version: 2 };
+
+      const transport = new OpenAITransport();
+      const messages: unknown[] = [];
+      transport.onmessage = (msg) => {
+        messages.push(msg);
+      };
+
+      transport.deliverInitialState();
+
+      await new Promise((resolve) => setTimeout(resolve, 0));
+
+      const toolResultNotification = messages.find(
+        (m: unknown) =>
+          (m as { method?: string }).method === "ui/notifications/tool-result",
+      );
+      expect(toolResultNotification).toMatchObject({
+        jsonrpc: "2.0",
+        method: "ui/notifications/tool-result",
+        params: {
+          _meta: { widgetId: "abc123", version: 2 },
+        },
+      });
+    });
+
     test("does not deliver notifications when data is missing", async () => {
       delete mockOpenAI.toolInput;
       delete mockOpenAI.toolOutput;

src/openai/transport.ts

@@ -245,24 +245,40 @@ export class OpenAITransport implements Transport {
       theme: this.openai.theme,
       locale: this.openai.locale,
       displayMode: this.openai.displayMode,
+      // If requestDisplayMode is available, ChatGPT supports all three modes
+      availableDisplayModes: this.openai.requestDisplayMode
+        ? ["inline", "pip", "fullscreen"]
+        : undefined,
       viewport: this.openai.maxHeight
         ? { width: 0, height: 0, maxHeight: this.openai.maxHeight }
         : undefined,
       safeAreaInsets,
       userAgent,
     };
 
+    // Dynamically determine capabilities based on what window.openai supports
+    const hostCapabilities: Record<string, unknown> = {
+      // Logging is always available (we map to console.log)
+      logging: {},
+    };
+
+    // Only advertise serverTools if callTool is available
+    if (this.openai.callTool) {
+      hostCapabilities.serverTools = {};
+    }
+
+    // Only advertise openLinks if openExternal is available
+    if (this.openai.openExternal) {
+      hostCapabilities.openLinks = {};
+    }
+
     return this.createSuccessResponse(id, {
       protocolVersion: LATEST_PROTOCOL_VERSION,
       hostInfo: {
         name: "ChatGPT",
         version: "1.0.0",
       },
-      hostCapabilities: {
-        serverTools: {},
-        openLinks: {},
-        logging: {},
-      },
+      hostCapabilities,
       hostContext,
     });
   }
@@ -494,6 +510,8 @@ export class OpenAITransport implements Transport {
                     text: JSON.stringify(this.openai.toolOutput),
                   },
                 ],
+            // Include _meta from toolResponseMetadata if available
+            _meta: this.openai.toolResponseMetadata,
           },
         } as JSONRPCNotification);
       });