@decocms/mesh-sdk 1.2.2 → 1.2.3

package/src/lib/usage.ts

@@ -14,6 +14,18 @@ export interface UsageData {
   outputTokens?: number;
   reasoningTokens?: number;
   totalTokens?: number;
+  /**
+   * AI SDK normalizes cache token counts across providers via
+   * usage.inputTokenDetails — populated identically by the anthropic,
+   * openai, google and openrouter adapters. `cachedInputTokens` is the
+   * convenience shorthand the AI SDK also surfaces (= cacheReadTokens).
+   */
+  cachedInputTokens?: number;
+  inputTokenDetails?: {
+    cacheReadTokens?: number;
+    cacheWriteTokens?: number;
+    noCacheTokens?: number;
+  };
   providerMetadata?: {
     [key: string]: unknown;
   };
@@ -25,6 +37,10 @@ export interface UsageStats {
   reasoningTokens: number;
   totalTokens: number;
   cost: number;
+  /** Tokens read from prompt cache (anthropic / openrouter / openai / google). */
+  cacheReadTokens: number;
+  /** Tokens written to prompt cache (Anthropic only — others auto-cache without separate billing). */
+  cacheWriteTokens: number;
 }
 
 type ProviderCostExtractor = (
@@ -124,6 +140,8 @@ export function emptyUsageStats(): UsageStats {
     reasoningTokens: 0,
     totalTokens: 0,
     cost: 0,
+    cacheReadTokens: 0,
+    cacheWriteTokens: 0,
   };
 }
 
@@ -137,6 +155,12 @@ export function addUsage(
 ): UsageStats {
   if (!stepUsage) return accumulated;
 
+  const cacheRead =
+    stepUsage.inputTokenDetails?.cacheReadTokens ??
+    stepUsage.cachedInputTokens ??
+    0;
+  const cacheWrite = stepUsage.inputTokenDetails?.cacheWriteTokens ?? 0;
+
   return {
     inputTokens: accumulated.inputTokens + (stepUsage.inputTokens ?? 0),
     outputTokens: accumulated.outputTokens + (stepUsage.outputTokens ?? 0),
@@ -144,6 +168,8 @@ export function addUsage(
       accumulated.reasoningTokens + (stepUsage.reasoningTokens ?? 0),
     totalTokens: accumulated.totalTokens + (stepUsage.totalTokens ?? 0),
     cost: accumulated.cost + getCostFromUsage(stepUsage),
+    cacheReadTokens: accumulated.cacheReadTokens + cacheRead,
+    cacheWriteTokens: accumulated.cacheWriteTokens + cacheWrite,
   };
 }
 

package/src/types/ai-providers.ts

@@ -8,6 +8,8 @@ export const PROVIDER_IDS = [
   "openrouter",
   "google",
   "claude-code",
+  "codex",
+  "openai-compatible",
 ] as const;
 
 export type ProviderId = (typeof PROVIDER_IDS)[number];
@@ -45,6 +47,16 @@ export interface AiProviderModel {
   capabilities: ModelCapability[];
   limits: AiProviderModelLimits | null;
   costs: AiProviderModelCosts | null;
+  /** When true the upstream provider has flagged this model as deprecated. */
+  deprecated?: boolean;
+  /**
+   * When true, this model can ONLY be used through the provider's
+   * `AsyncResearchProvider` capability (e.g. Gemini Deep Research via the
+   * Interactions API). It is unusable as a Thinking/Coding/Fast/Image model
+   * because `streamText` / `generateContent` will reject it. UIs should
+   * restrict it to the deep-research slot.
+   */
+  asyncResearch?: boolean;
   /** Client-side only — the credential key ID used to fetch this model. */
   keyId?: string;
 }
@@ -53,6 +65,11 @@ export interface AiProviderKey {
   id: string;
   providerId: ProviderId;
   label: string;
+  /**
+   * Frontend preset id (e.g. "litellm", "ollama") for openai-compatible keys
+   * that were created from a branded preset card. Null otherwise.
+   */
+  presetId: string | null;
   createdBy: string;
   createdAt: string;
 }
@@ -62,7 +79,8 @@ export interface AiProviderInfo {
   name: string;
   description: string;
   logo?: string | null;
-  supportedMethods: ("api-key" | "oauth-pkce")[];
+  supportedMethods: ("api-key" | "oauth-pkce" | "cli-activate")[];
   supportsTopUp?: boolean;
   supportsCredits?: boolean;
+  supportsProvision?: boolean;
 }

package/src/types/connection.ts

@@ -102,6 +102,11 @@ export const ConnectionEntitySchema = z.object({
   icon: z.string().nullable().describe("Icon URL for the connection"),
   app_name: z.string().nullable().describe("Associated app name"),
   app_id: z.string().nullable().describe("Associated app ID"),
+  slug: z
+    .string()
+    .nullable()
+    .optional()
+    .describe("URL-safe slug derived from app_name, connection_url, or title"),
 
   connection_type: z
     .enum(["HTTP", "SSE", "Websocket", "STDIO", "VIRTUAL"])

package/src/types/decopilot-events.test.ts

@@ -0,0 +1,78 @@
+import { describe, expect, test } from "bun:test";
+import {
+  createDecopilotThreadStatusEvent,
+  DECOPILOT_EVENTS,
+} from "./decopilot-events";
+
+describe("createDecopilotThreadStatusEvent", () => {
+  test("carries virtualMcpId, createdBy, and triggerId on data", () => {
+    const e = createDecopilotThreadStatusEvent("task-1", "in_progress", {
+      virtualMcpId: "vm-1",
+      createdBy: "user-1",
+      triggerId: "trig-1",
+    });
+    expect(e.type).toBe(DECOPILOT_EVENTS.THREAD_STATUS);
+    expect(e.subject).toBe("task-1");
+    expect(e.data.status).toBe("in_progress");
+    expect(e.data.virtual_mcp_id).toBe("vm-1");
+    expect(e.data.created_by).toBe("user-1");
+    expect(e.data.trigger_id).toBe("trig-1");
+  });
+
+  test("omits optional fields when not provided", () => {
+    const e = createDecopilotThreadStatusEvent("task-1", "completed");
+    expect(e.data.status).toBe("completed");
+    expect(e.data.virtual_mcp_id).toBeUndefined();
+    expect(e.data.created_by).toBeUndefined();
+    expect(e.data.trigger_id).toBeUndefined();
+  });
+
+  test("preserves explicit null trigger_id (human-initiated thread)", () => {
+    const e = createDecopilotThreadStatusEvent("task-1", "completed", {
+      triggerId: null,
+    });
+    expect(e.data.trigger_id).toBeNull();
+  });
+
+  test("works with only virtualMcpId provided (migration shape)", () => {
+    const e = createDecopilotThreadStatusEvent("task-1", "in_progress", {
+      virtualMcpId: "vm-1",
+    });
+    expect(e.data.virtual_mcp_id).toBe("vm-1");
+    expect(e.data.created_by).toBeUndefined();
+    expect(e.data.trigger_id).toBeUndefined();
+  });
+});
+
+describe("createDecopilotThreadStatusEvent — enriched fields", () => {
+  test("round-trips title, branch, createdAt, updatedAt", () => {
+    const e = createDecopilotThreadStatusEvent("task-1", "in_progress", {
+      virtualMcpId: "vm-1",
+      title: "Refactor login",
+      branch: "feature/login",
+      createdAt: "2026-05-19T00:00:00.000Z",
+      updatedAt: "2026-05-19T00:05:00.000Z",
+    });
+    expect(e.data.title).toBe("Refactor login");
+    expect(e.data.branch).toBe("feature/login");
+    expect(e.data.created_at).toBe("2026-05-19T00:00:00.000Z");
+    expect(e.data.updated_at).toBe("2026-05-19T00:05:00.000Z");
+  });
+
+  test("omits the new fields when not provided", () => {
+    const e = createDecopilotThreadStatusEvent("task-1", "in_progress", {
+      virtualMcpId: "vm-1",
+    });
+    expect(e.data.title).toBeUndefined();
+    expect(e.data.branch).toBeUndefined();
+    expect(e.data.created_at).toBeUndefined();
+    expect(e.data.updated_at).toBeUndefined();
+  });
+
+  test("explicit null branch is preserved", () => {
+    const e = createDecopilotThreadStatusEvent("task-1", "in_progress", {
+      branch: null,
+    });
+    expect(e.data.branch).toBeNull();
+  });
+});

package/src/types/decopilot-events.ts

@@ -66,7 +66,28 @@ export interface DecopilotFinishEvent extends BaseDecopilotEvent {
 
 export interface DecopilotThreadStatusEvent extends BaseDecopilotEvent {
   type: typeof DECOPILOT_EVENTS.THREAD_STATUS;
-  data: { status: ThreadStatus };
+  data: {
+    status: ThreadStatus;
+    virtual_mcp_id?: string;
+    /** User who created the thread; needed to populate filter-complete cache rows on the client. */
+    created_by?: string;
+    /** Automation trigger id; null for human-initiated, omitted when unknown. */
+    trigger_id?: string | null;
+    /** Thread title at emit time. Absent if caller didn't load the row. */
+    title?: string;
+    /** Branch this thread is pinned to (null when unpinned). Absent if caller didn't load the row. */
+    branch?: string | null;
+    /** Thread creation timestamp. Absent if caller didn't load the row. */
+    created_at?: string;
+    /** Last update timestamp; useful for the client to sort/dedupe. Absent if caller didn't load the row. */
+    updated_at?: string;
+    /** Free-form thread metadata snapshot. The chat UI keys off
+     *  metadata.kind to switch between agent-thread and tool_call_run
+     *  renderings (avatar, message-renderer), so the workflow that
+     *  spawns those threads must include it on the first event or the
+     *  row renders with the wrong icon until a refetch. */
+    metadata?: Record<string, unknown>;
+  };
 }
 
 export type DecopilotSSEEvent =
@@ -86,43 +107,65 @@ export interface DecopilotEventMap {
 // ============================================================================
 
 export function createDecopilotStepEvent(
-  threadId: string,
+  taskId: string,
   stepCount: number,
 ): DecopilotStepEvent {
   return {
     id: crypto.randomUUID(),
     type: DECOPILOT_EVENTS.STEP,
     source: "decopilot",
-    subject: threadId,
+    subject: taskId,
     data: { stepCount },
     time: new Date().toISOString(),
   };
 }
 
 export function createDecopilotFinishEvent(
-  threadId: string,
+  taskId: string,
   status: ThreadStatus,
 ): DecopilotFinishEvent {
   return {
     id: crypto.randomUUID(),
     type: DECOPILOT_EVENTS.FINISH,
     source: "decopilot",
-    subject: threadId,
+    subject: taskId,
     data: { status },
     time: new Date().toISOString(),
   };
 }
 
 export function createDecopilotThreadStatusEvent(
-  threadId: string,
+  taskId: string,
   status: ThreadStatus,
+  opts?: {
+    virtualMcpId?: string;
+    createdBy?: string;
+    triggerId?: string | null;
+    title?: string;
+    branch?: string | null;
+    createdAt?: string;
+    updatedAt?: string;
+    metadata?: Record<string, unknown>;
+  },
 ): DecopilotThreadStatusEvent {
   return {
     id: crypto.randomUUID(),
     type: DECOPILOT_EVENTS.THREAD_STATUS,
     source: "decopilot",
-    subject: threadId,
-    data: { status },
+    subject: taskId,
+    data: {
+      status,
+      ...(opts?.virtualMcpId !== undefined && {
+        virtual_mcp_id: opts.virtualMcpId,
+      }),
+      ...(opts?.createdBy !== undefined && { created_by: opts.createdBy }),
+      ...(opts?.triggerId !== undefined && { trigger_id: opts.triggerId }),
+      ...(opts?.title !== undefined && { title: opts.title }),
+      ...(opts?.branch !== undefined && { branch: opts.branch }),
+      ...(opts?.createdAt !== undefined && { created_at: opts.createdAt }),
+      ...(opts?.updatedAt !== undefined && { updated_at: opts.updatedAt }),
+      ...(opts?.metadata !== undefined && { metadata: opts.metadata }),
+    },
     time: new Date().toISOString(),
   };
 }

package/src/types/index.ts

@@ -19,10 +19,28 @@ export {
   VirtualMCPEntitySchema,
   VirtualMCPCreateDataSchema,
   VirtualMCPUpdateDataSchema,
+  VirtualMcpUILayoutSchema,
+  VirtualMcpUILayoutTabSchema,
   type VirtualMCPEntity,
   type VirtualMCPCreateData,
   type VirtualMCPUpdateData,
   type VirtualMCPConnection,
+  type VirtualMcpUILayout,
+  type VirtualMcpUILayoutTab,
+  type VirtualMcpHomeTile,
+  getHomeTiles,
+  type GithubRepo,
+  SandboxMapSchema,
+  type SandboxMap,
+  SandboxRecordSchema,
+  type SandboxRecord,
+  type RuntimeMetadata,
+  type RuntimeEnvEntry,
+  ENV_VAR_KEY_RE,
+  parseSandboxRecord,
+  parseBranchMap,
+  normalizeSandboxMap,
+  type SandboxProviderKind,
 } from "./virtual-mcp";
 
 export {

package/src/types/virtual-mcp.test.ts

@@ -0,0 +1,202 @@
+import { describe, expect, it, test } from "bun:test";
+import {
+  VirtualMCPEntitySchema,
+  VirtualMcpUILayoutSchema,
+  VirtualMCPUpdateDataSchema,
+  SandboxRecordSchema,
+  parseSandboxRecord,
+  parseBranchMap,
+} from "./virtual-mcp";
+
+describe("VirtualMcpUILayoutSchema tabs", () => {
+  it("parses a tabs array with ext-app view", () => {
+    const parsed = VirtualMcpUILayoutSchema.parse({
+      tabs: [
+        {
+          id: "analytics",
+          title: "Analytics",
+          icon: "BarChart",
+          view: { type: "ext-app", appId: "app_abc", args: { range: "7d" } },
+        },
+      ],
+      defaultMainView: null,
+    });
+    expect(parsed.tabs).toHaveLength(1);
+    expect(parsed.tabs?.[0]!.view.type).toBe("ext-app");
+    expect(parsed.tabs?.[0]!.view.appId).toBe("app_abc");
+  });
+
+  it("accepts tabs omitted (backwards compatible)", () => {
+    const parsed = VirtualMcpUILayoutSchema.parse({
+      defaultMainView: null,
+    });
+    expect(parsed.tabs).toBeUndefined();
+  });
+
+  it("rejects a tab view with unknown type", () => {
+    const result = VirtualMcpUILayoutSchema.safeParse({
+      tabs: [
+        {
+          id: "bad",
+          title: "Bad",
+          view: { type: "mystery", appId: "app_x" },
+        },
+      ],
+    });
+    expect(result.success).toBe(false);
+  });
+});
+
+test("metadata.runtime is typed and round-trips through parse", () => {
+  const parsed = VirtualMCPEntitySchema.parse({
+    id: "x",
+    title: "x",
+    description: null,
+    icon: null,
+    created_at: "t",
+    updated_at: "t",
+    created_by: "u",
+    organization_id: "o",
+    status: "active",
+    pinned: false,
+    metadata: {
+      instructions: null,
+      runtime: { selected: "pnpm", port: "3000" },
+    },
+    connections: [],
+  });
+  expect(parsed.metadata.runtime?.selected).toBe("pnpm");
+  expect(parsed.metadata.runtime?.port).toBe("3000");
+});
+
+test("metadata.runtime accepts null/empty values", () => {
+  const parsed = VirtualMCPEntitySchema.parse({
+    id: "x",
+    title: "x",
+    description: null,
+    icon: null,
+    created_at: "t",
+    updated_at: "t",
+    created_by: "u",
+    organization_id: "o",
+    status: "active",
+    pinned: false,
+    metadata: {
+      instructions: null,
+      runtime: { selected: null, port: null },
+    },
+    connections: [],
+  });
+  expect(parsed.metadata.runtime?.selected).toBeNull();
+  expect(parsed.metadata.runtime?.port).toBeNull();
+});
+
+test("VirtualMCPUpdateDataSchema accepts metadata.runtime", () => {
+  const parsed = VirtualMCPUpdateDataSchema.parse({
+    metadata: { runtime: { selected: "bun", port: null } },
+  });
+  expect(parsed.metadata?.runtime?.selected).toBe("bun");
+  expect(parsed.metadata?.runtime?.port).toBeNull();
+});
+
+test("SandboxRecord.startedWith is optional with nullable packageManager/port/path", () => {
+  const a = SandboxRecordSchema.parse({ sandboxHandle: "v", previewUrl: null });
+  expect(a.startedWith).toBeUndefined();
+  const b = SandboxRecordSchema.parse({
+    sandboxHandle: "v",
+    previewUrl: null,
+    startedWith: { packageManager: "pnpm", port: "3000", path: "apps/web" },
+  });
+  expect(b.startedWith?.packageManager).toBe("pnpm");
+  expect(b.startedWith?.port).toBe("3000");
+  expect(b.startedWith?.path).toBe("apps/web");
+  const c = SandboxRecordSchema.parse({
+    sandboxHandle: "v",
+    previewUrl: null,
+    startedWith: { packageManager: null, port: null, path: null },
+  });
+  expect(c.startedWith?.packageManager).toBeNull();
+  expect(c.startedWith?.port).toBeNull();
+  expect(c.startedWith?.path).toBeNull();
+});
+
+describe("parseBranchMap", () => {
+  test("parses 3-level (kind-keyed) map with canonical kinds", () => {
+    const result = parseBranchMap({
+      cluster: {
+        sandboxHandle: "v1",
+        previewUrl: null,
+        sandboxProviderKind: "cluster",
+      },
+      "user-desktop": {
+        sandboxHandle: "v2",
+        previewUrl: null,
+        sandboxProviderKind: "user-desktop",
+      },
+    });
+    expect(result["cluster"]?.sandboxHandle).toBe("v1");
+    expect(result["user-desktop"]?.sandboxHandle).toBe("v2");
+  });
+
+  test("returns empty object for null/undefined/arrays", () => {
+    expect(parseBranchMap(null)).toEqual({});
+    expect(parseBranchMap(undefined)).toEqual({});
+    expect(parseBranchMap([])).toEqual({});
+  });
+
+  test("skips entries under legacy/retired kind keys", () => {
+    // Migrations 092/097 rewrote/dropped every legacy and retired key; reader
+    // no longer normalizes unknown keys, it just ignores them.
+    const result = parseBranchMap({
+      docker: {
+        sandboxHandle: "v-legacy",
+        previewUrl: null,
+        sandboxProviderKind: "cluster",
+      },
+      "local-docker": {
+        sandboxHandle: "v-retired",
+        previewUrl: null,
+        sandboxProviderKind: "cluster",
+      },
+    });
+    expect(result).toEqual({});
+  });
+});
+
+describe("parseSandboxRecord", () => {
+  test("accepts canonical sandboxProviderKind", () => {
+    const result = parseSandboxRecord({
+      sandboxHandle: "v1",
+      previewUrl: null,
+      sandboxProviderKind: "cluster",
+    });
+    expect(result.sandboxProviderKind).toBe("cluster");
+  });
+
+  test("rejects legacy/retired kind values", () => {
+    expect(() =>
+      parseSandboxRecord({
+        sandboxHandle: "v1",
+        previewUrl: null,
+        sandboxProviderKind: "docker",
+      }),
+    ).toThrow();
+    expect(() =>
+      parseSandboxRecord({
+        sandboxHandle: "v1",
+        previewUrl: null,
+        sandboxProviderKind: "local-docker",
+      }),
+    ).toThrow();
+  });
+
+  test("rejects rows missing `sandboxHandle` (legacy `vmId` no longer accepted)", () => {
+    expect(() =>
+      parseSandboxRecord({
+        vmId: "v-pre-rename",
+        previewUrl: null,
+        sandboxProviderKind: "cluster",
+      }),
+    ).toThrow();
+  });
+});