fix(ui): restore ChatGPT cards after revisit

package.json

@@ -28,7 +28,7 @@
     "dev": "node scripts/dev-server.mjs",
     "postinstall": "node scripts/fix-node-pty-permissions.mjs",
     "start": "node dist/cli.js serve",
-    "test": "tsx src/config.test.ts && tsx src/request-meta.test.ts && tsx src/incoming-artifacts.test.ts && tsx src/artifact-download.test.ts && tsx src/ui/card-types.test.ts && tsx src/ui/patch-display.test.ts && tsx src/ui/tool-display.test.ts && tsx src/apply-patch.test.ts && tsx src/process-platform.test.ts && tsx src/process-sessions.test.ts && tsx src/mcp-sessions.test.ts && tsx src/server-shutdown.test.ts && tsx src/local-agent-runtime.test.ts && tsx src/local-agent-adapters.test.ts && tsx src/local-agent-availability.test.ts && tsx src/local-agent-profiles.test.ts && tsx src/local-agent-targets.test.ts && tsx src/local-agent-store.test.ts && tsx src/roots.test.ts && tsx src/skills.test.ts && tsx src/workspaces.test.ts && tsx src/workspace-conversation.test.ts && tsx src/review-checkpoints.test.ts && tsx src/server.test.ts && tsx src/oauth-store.test.ts && tsx src/cli.test.ts",
+    "test": "tsx src/config.test.ts && tsx src/request-meta.test.ts && tsx src/incoming-artifacts.test.ts && tsx src/artifact-download.test.ts && tsx src/ui/card-types.test.ts && tsx src/ui/card-persistence.test.ts && tsx src/ui/patch-display.test.ts && tsx src/ui/tool-display.test.ts && tsx src/apply-patch.test.ts && tsx src/process-platform.test.ts && tsx src/process-sessions.test.ts && tsx src/mcp-sessions.test.ts && tsx src/server-shutdown.test.ts && tsx src/local-agent-runtime.test.ts && tsx src/local-agent-adapters.test.ts && tsx src/local-agent-availability.test.ts && tsx src/local-agent-profiles.test.ts && tsx src/local-agent-targets.test.ts && tsx src/local-agent-store.test.ts && tsx src/roots.test.ts && tsx src/skills.test.ts && tsx src/workspaces.test.ts && tsx src/workspace-conversation.test.ts && tsx src/review-checkpoints.test.ts && tsx src/server.test.ts && tsx src/oauth-store.test.ts && tsx src/cli.test.ts",
     "typecheck": "tsc -p tsconfig.json --noEmit"
   },
   "keywords": [],

src/server.test.ts

@@ -58,6 +58,17 @@ test("open_workspace keeps lifecycle flags out of model output and preserves com
   assert.ok(Array.isArray(card.agents));
 });
 
+test("widget tools advertise the ChatGPT output template alias", async (t) => {
+  const tools = await (await fixture(t)).client.listTools();
+  const meta = tools.tools.find((tool) => tool.name === "open_workspace")?._meta as
+    | Record<string, unknown>
+    | undefined;
+  const ui = meta?.ui as Record<string, unknown> | undefined;
+
+  assert.equal(ui?.resourceUri, "ui://devspace/workspace-app/v1.html");
+  assert.equal(meta?.["openai/outputTemplate"], "ui://devspace/workspace-app/v1.html");
+});
+
 test("concurrent checkout opens return one full context and one reuse instruction", async (t) => {
   const context = await fixture(t);
   const [first, second] = await Promise.all([

src/server.ts

@@ -67,7 +67,7 @@ type Transport = StreamableHTTPServerTransport;
 // session retention so abandoned MCP servers do not accumulate for the life of the process.
 const MCP_SESSION_IDLE_TIMEOUT_MS = 24 * 60 * 60 * 1_000;
 const MCP_SESSION_CLEANUP_INTERVAL_MS = 5 * 60 * 1_000;
-const WORKSPACE_APP_URI = "ui://devspace/workspace-app.html";
+const WORKSPACE_APP_URI = "ui://devspace/workspace-app/v1.html";
 const WORKSPACE_APP_MANIFEST_ENTRY = "workspace-app.html";
 const WRITE_TOOL_ANNOTATIONS = {
   readOnlyHint: false,
@@ -127,6 +127,7 @@ interface ToolDefinitionMeta extends Record<string, unknown> {
     resourceUri: string;
     visibility: ["model"];
   };
+  "openai/outputTemplate": string;
 }
 
 type EmptyToolDefinitionMeta = Record<string, unknown> & {
@@ -160,6 +161,7 @@ function toolWidgetDescriptorMeta(
         resourceUri: WORKSPACE_APP_URI,
         visibility: ["model"],
       },
+      "openai/outputTemplate": WORKSPACE_APP_URI,
     },
   };
 }

src/ui/card-persistence.test.ts

@@ -0,0 +1,46 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import {
+  cardFromOpenAIToolGlobals,
+  persistedCardFromOpenAIHost,
+  persistedCardFromWidgetState,
+  widgetStateWithPersistedCard,
+} from "./card-persistence.js";
+import type { ToolResultCard } from "./card-types.js";
+
+test("card state round-trips without clobbering host state", () => {
+  const card: ToolResultCard = { tool: "read", path: "README.md" };
+  const state = widgetStateWithPersistedCard(
+    { modelContent: "keep", privateContent: { selectedTab: "files" } },
+    card,
+  );
+
+  assert.equal(state.modelContent, "keep");
+  assert.equal((state.privateContent as Record<string, unknown>).selectedTab, "files");
+  assert.deepEqual(persistedCardFromWidgetState(state), card);
+});
+
+test("persisted state wins over ChatGPT globals", () => {
+  const card: ToolResultCard = { tool: "read", path: "README.md" };
+  assert.deepEqual(
+    persistedCardFromOpenAIHost({
+      widgetState: widgetStateWithPersistedCard(undefined, card),
+      toolOutput: { path: "other.txt" },
+    }),
+    card,
+  );
+});
+
+test("ChatGPT globals can rehydrate a historical card", () => {
+  assert.deepEqual(
+    cardFromOpenAIToolGlobals(
+      { workspaceId: "ws_history" },
+      {
+        mcp_tool_result: {
+          _meta: { tool: "show_changes", card: { workspaceId: "ws_history" } },
+        },
+      },
+    ),
+    { tool: "show_changes", workspaceId: "ws_history" },
+  );
+});

src/ui/card-persistence.ts

@@ -0,0 +1,96 @@
+import {
+  isToolName,
+  isToolResultCard,
+  type ToolResultCard,
+} from "./card-types.js";
+
+const PERSISTED_CARD_KEY = "devspaceCard";
+const PERSISTED_CARD_VERSION = 1;
+
+export interface OpenAIWidgetStateBridge {
+  toolOutput?: unknown;
+  toolResponseMetadata?: unknown;
+  widgetState?: unknown;
+  setWidgetState?: (state: unknown) => void;
+}
+
+interface PersistedCardEnvelope {
+  version: number;
+  card: ToolResultCard;
+}
+
+function asRecord(value: unknown): Record<string, unknown> | undefined {
+  return value && typeof value === "object" && !Array.isArray(value)
+    ? value as Record<string, unknown>
+    : undefined;
+}
+
+export function persistedCardFromWidgetState(widgetState: unknown): ToolResultCard | undefined {
+  const state = asRecord(widgetState);
+  const privateContent = asRecord(state?.privateContent);
+  const envelope = asRecord(privateContent?.[PERSISTED_CARD_KEY]);
+
+  if (envelope?.version !== PERSISTED_CARD_VERSION) return undefined;
+
+  const candidate = asRecord(envelope.card);
+  if (!candidate || !isToolName(candidate.tool) || !isToolResultCard(candidate)) {
+    return undefined;
+  }
+
+  return candidate as unknown as ToolResultCard;
+}
+
+export function cardFromOpenAIToolGlobals(
+  toolOutput: unknown,
+  toolResponseMetadata: unknown,
+): ToolResultCard | undefined {
+  const responseMetadata = asRecord(toolResponseMetadata);
+  const result = asRecord(responseMetadata?.mcp_tool_result)
+    ?? asRecord(responseMetadata?.call_tool_result);
+  const resultMeta = asRecord(result?._meta);
+  const metaCard = asRecord(resultMeta?.card);
+  const structuredContent = asRecord(toolOutput)
+    ?? asRecord(result?.structuredContent)
+    ?? {};
+  const tool = resultMeta?.tool;
+
+  if (!isToolName(tool)) return undefined;
+
+  const candidate = {
+    ...structuredContent,
+    ...(metaCard ?? {}),
+    tool,
+  };
+  if (!isToolResultCard(candidate)) return undefined;
+
+  return candidate as unknown as ToolResultCard;
+}
+
+export function persistedCardFromOpenAIHost(
+  bridge: OpenAIWidgetStateBridge | undefined,
+): ToolResultCard | undefined {
+  if (!bridge) return undefined;
+
+  return persistedCardFromWidgetState(bridge.widgetState)
+    ?? cardFromOpenAIToolGlobals(bridge.toolOutput, bridge.toolResponseMetadata);
+}
+
+export function widgetStateWithPersistedCard(
+  widgetState: unknown,
+  card: ToolResultCard,
+): Record<string, unknown> {
+  const currentState = asRecord(widgetState) ?? {};
+  const currentPrivateContent = asRecord(currentState.privateContent) ?? {};
+  const persisted: PersistedCardEnvelope = {
+    version: PERSISTED_CARD_VERSION,
+    card,
+  };
+
+  return {
+    ...currentState,
+    privateContent: {
+      ...currentPrivateContent,
+      [PERSISTED_CARD_KEY]: persisted,
+    },
+  };
+}

src/ui/card-types.test.ts

@@ -7,6 +7,7 @@ import {
   isPatchTool,
   isShellTool,
   isToolName,
+  isToolResultCard,
 } from "./card-types.js";
 
 test("the supported coding tools are recognized as card tools", () => {
@@ -111,3 +112,11 @@ test("a workspace card expands when it contains available instruction files", ()
 test("an empty workspace card stays collapsed", () => {
   assert.equal(isExpandableCard({ tool: "open_workspace" }), false);
 });
+
+test("card validation rejects malformed renderer data", () => {
+  for (const value of [
+    { files: { path: "src/a.ts", operation: "update" } },
+    { files: [{ path: "src/a.ts", additions: Number.NaN }] },
+    { payload: { content: [{ type: "video" }] } },
+  ]) assert.equal(isToolResultCard(value), false);
+});

src/ui/card-types.ts

@@ -140,7 +140,155 @@ export function isReviewTool(tool: ToolName): boolean {
 }
 
 export function isToolResultCard(value: unknown): value is Omit<ToolResultCard, "tool"> {
-  return Boolean(value && typeof value === "object");
+  const card = asRecord(value);
+  if (!card) return false;
+
+  return (
+    isOptionalString(card.workspaceId)
+    && isOptionalString(card.path)
+    && isOptionalString(card.root)
+    && isOptionalBoolean(card.workspaceReused)
+    && isOptionalBoolean(card.includeBootstrapContext)
+    && (card.mode === undefined || card.mode === "checkout" || card.mode === "worktree")
+    && isOptionalString(card.sourceRoot)
+    && isOptionalRecord(card.worktree, isWorktree)
+    && isOptionalString(card.status)
+    && (card.summary === undefined || asRecord(card.summary) !== undefined)
+    && isOptionalArray(card.files, isReviewFile)
+    && isOptionalRecord(card.payload, isToolPayload)
+    && isOptionalArray(card.agentsFiles, isAgentFile)
+    && isOptionalArray(card.availableAgentsFiles, isAvailableAgentFile)
+    && isOptionalArray(card.skills, isSkill)
+    && isOptionalArray(card.agentProviders, isAgentProvider)
+    && isOptionalArray(card.agents, isAgent)
+    && isOptionalString(card.instruction)
+  );
+}
+
+function asRecord(value: unknown): Record<string, unknown> | undefined {
+  return value && typeof value === "object" && !Array.isArray(value)
+    ? value as Record<string, unknown>
+    : undefined;
+}
+
+function isOptionalString(value: unknown): boolean {
+  return value === undefined || typeof value === "string";
+}
+
+function isOptionalBoolean(value: unknown): boolean {
+  return value === undefined || typeof value === "boolean";
+}
+
+function isOptionalNumber(value: unknown): boolean {
+  return value === undefined || (typeof value === "number" && Number.isFinite(value));
+}
+
+function isOptionalRecord(
+  value: unknown,
+  validate: (record: Record<string, unknown>) => boolean,
+): boolean {
+  if (value === undefined) return true;
+  const record = asRecord(value);
+  return Boolean(record && validate(record));
+}
+
+function isOptionalArray(
+  value: unknown,
+  validate: (record: Record<string, unknown>) => boolean,
+): boolean {
+  if (value === undefined) return true;
+  if (!Array.isArray(value)) return false;
+  return value.every((item) => {
+    const record = asRecord(item);
+    return Boolean(record && validate(record));
+  });
+}
+
+function isWorktree(value: Record<string, unknown>): boolean {
+  return (
+    isOptionalString(value.path)
+    && isOptionalString(value.baseRef)
+    && isOptionalString(value.baseSha)
+    && isOptionalBoolean(value.dirtySource)
+    && isOptionalBoolean(value.detached)
+    && isOptionalBoolean(value.managed)
+  );
+}
+
+function isReviewFile(value: Record<string, unknown>): boolean {
+  return (
+    isOptionalString(value.path)
+    && isOptionalString(value.previousPath)
+    && (
+      value.operation === undefined
+      || value.operation === "add"
+      || value.operation === "update"
+      || value.operation === "delete"
+      || value.operation === "move"
+    )
+    && (
+      value.type === undefined
+      || value.type === "change"
+      || value.type === "rename-pure"
+      || value.type === "rename-changed"
+      || value.type === "new"
+      || value.type === "deleted"
+    )
+    && isOptionalNumber(value.additions)
+    && isOptionalNumber(value.removals)
+  );
+}
+
+function isToolPayload(value: Record<string, unknown>): boolean {
+  if (!isOptionalString(value.diff) || !isOptionalString(value.patch)) return false;
+  if (value.content === undefined) return true;
+  if (!Array.isArray(value.content)) return false;
+
+  return value.content.every((item) => {
+    const content = asRecord(item);
+    if (!content || (content.type !== "text" && content.type !== "image")) return false;
+    return (
+      isOptionalString(content.text)
+      && isOptionalString(content.data)
+      && isOptionalString(content.mimeType)
+    );
+  });
+}
+
+function isAgentFile(value: Record<string, unknown>): boolean {
+  return isOptionalString(value.path) && isOptionalString(value.content);
+}
+
+function isAvailableAgentFile(value: Record<string, unknown>): boolean {
+  return isOptionalString(value.path);
+}
+
+function isSkill(value: Record<string, unknown>): boolean {
+  return (
+    isOptionalString(value.name)
+    && isOptionalString(value.description)
+    && isOptionalString(value.path)
+  );
+}
+
+function isAgentProvider(value: Record<string, unknown>): boolean {
+  return (
+    isOptionalString(value.name)
+    && isOptionalBoolean(value.available)
+    && isOptionalString(value.reason)
+  );
+}
+
+function isAgent(value: Record<string, unknown>): boolean {
+  return (
+    isOptionalString(value.name)
+    && isOptionalString(value.description)
+    && isOptionalString(value.provider)
+    && isOptionalString(value.model)
+    && isOptionalString(value.thinking)
+    && isOptionalBoolean(value.providerAvailable)
+    && isOptionalString(value.providerUnavailableReason)
+  );
 }
 
 export function payloadText(payload: ToolPayload | undefined): string {