gsd-pi 2.68.1-dev.362687a → 2.68.1-dev.abc8f2b

package/packages/pi-ai/src/providers/provider-capabilities.test.ts

@@ -0,0 +1,174 @@
+// GSD-2 — Provider Capabilities Registry Tests (ADR-005 Phase 1)
+import { describe, test } from "node:test";
+import assert from "node:assert/strict";
+
+import {
+  PROVIDER_CAPABILITIES,
+  getProviderCapabilities,
+  getUnsupportedFeatures,
+  mergeCapabilityOverrides,
+  getRegisteredApis,
+} from "./provider-capabilities.js";
+
+// ─── Registry Completeness ──────────────────────────────────────────────────
+
+describe("PROVIDER_CAPABILITIES registry", () => {
+  const EXPECTED_APIS = [
+    "anthropic-messages",
+    "anthropic-vertex",
+    "openai-responses",
+    "azure-openai-responses",
+    "openai-codex-responses",
+    "openai-completions",
+    "google-generative-ai",
+    "google-gemini-cli",
+    "google-vertex",
+    "mistral-conversations",
+    "bedrock-converse-stream",
+    "ollama-chat",
+  ];
+
+  test("covers all expected API providers", () => {
+    for (const api of EXPECTED_APIS) {
+      assert.ok(
+        PROVIDER_CAPABILITIES[api],
+        `Missing capability entry for API: ${api}`,
+      );
+    }
+  });
+
+  test("getRegisteredApis returns all entries", () => {
+    const registered = getRegisteredApis();
+    for (const api of EXPECTED_APIS) {
+      assert.ok(registered.includes(api), `getRegisteredApis missing: ${api}`);
+    }
+  });
+
+  test("all entries have required fields", () => {
+    for (const [api, caps] of Object.entries(PROVIDER_CAPABILITIES)) {
+      assert.equal(typeof caps.toolCalling, "boolean", `${api}.toolCalling`);
+      assert.equal(typeof caps.maxTools, "number", `${api}.maxTools`);
+      assert.equal(typeof caps.imageToolResults, "boolean", `${api}.imageToolResults`);
+      assert.equal(typeof caps.structuredOutput, "boolean", `${api}.structuredOutput`);
+      assert.ok(caps.toolCallIdFormat, `${api}.toolCallIdFormat`);
+      assert.equal(typeof caps.toolCallIdFormat.maxLength, "number", `${api}.toolCallIdFormat.maxLength`);
+      assert.ok(caps.toolCallIdFormat.allowedChars instanceof RegExp, `${api}.toolCallIdFormat.allowedChars`);
+      assert.ok(
+        ["full", "text-only", "none"].includes(caps.thinkingPersistence),
+        `${api}.thinkingPersistence is "${caps.thinkingPersistence}"`,
+      );
+      assert.ok(Array.isArray(caps.unsupportedSchemaFeatures), `${api}.unsupportedSchemaFeatures`);
+    }
+  });
+});
+
+// ─── Provider-specific Values ───────────────────────────────────────────────
+
+describe("provider-specific capabilities", () => {
+  test("Anthropic supports full thinking persistence", () => {
+    assert.equal(PROVIDER_CAPABILITIES["anthropic-messages"].thinkingPersistence, "full");
+  });
+
+  test("Anthropic supports image tool results", () => {
+    assert.equal(PROVIDER_CAPABILITIES["anthropic-messages"].imageToolResults, true);
+  });
+
+  test("Anthropic tool call ID is 64 chars max", () => {
+    assert.equal(PROVIDER_CAPABILITIES["anthropic-messages"].toolCallIdFormat.maxLength, 64);
+  });
+
+  test("Mistral tool call ID is 9 chars max", () => {
+    assert.equal(PROVIDER_CAPABILITIES["mistral-conversations"].toolCallIdFormat.maxLength, 9);
+  });
+
+  test("Mistral has no thinking persistence", () => {
+    assert.equal(PROVIDER_CAPABILITIES["mistral-conversations"].thinkingPersistence, "none");
+  });
+
+  test("Google does not support patternProperties", () => {
+    assert.ok(
+      PROVIDER_CAPABILITIES["google-generative-ai"].unsupportedSchemaFeatures.includes("patternProperties"),
+    );
+  });
+
+  test("Google does not support const", () => {
+    assert.ok(
+      PROVIDER_CAPABILITIES["google-generative-ai"].unsupportedSchemaFeatures.includes("const"),
+    );
+  });
+
+  test("OpenAI Responses does not support image tool results", () => {
+    assert.equal(PROVIDER_CAPABILITIES["openai-responses"].imageToolResults, false);
+  });
+
+  test("OpenAI Responses has text-only thinking persistence", () => {
+    assert.equal(PROVIDER_CAPABILITIES["openai-responses"].thinkingPersistence, "text-only");
+  });
+});
+
+// ─── getProviderCapabilities ────────────────────────────────────────────────
+
+describe("getProviderCapabilities", () => {
+  test("returns known provider capabilities", () => {
+    const caps = getProviderCapabilities("anthropic-messages");
+    assert.equal(caps.toolCalling, true);
+    assert.equal(caps.thinkingPersistence, "full");
+  });
+
+  test("returns permissive defaults for unknown providers", () => {
+    const caps = getProviderCapabilities("unknown-provider-xyz");
+    assert.equal(caps.toolCalling, true);
+    assert.equal(caps.imageToolResults, true);
+    assert.deepEqual(caps.unsupportedSchemaFeatures, []);
+  });
+});
+
+// ─── getUnsupportedFeatures ─────────────────────────────────────────────────
+
+describe("getUnsupportedFeatures", () => {
+  test("returns unsupported features for Google", () => {
+    const unsupported = getUnsupportedFeatures("google-generative-ai", ["patternProperties", "const"]);
+    assert.deepEqual(unsupported, ["patternProperties", "const"]);
+  });
+
+  test("returns empty for Anthropic with any features", () => {
+    const unsupported = getUnsupportedFeatures("anthropic-messages", ["patternProperties", "const"]);
+    assert.deepEqual(unsupported, []);
+  });
+
+  test("returns empty for unknown provider", () => {
+    const unsupported = getUnsupportedFeatures("unknown-xyz", ["patternProperties"]);
+    assert.deepEqual(unsupported, []);
+  });
+});
+
+// ─── mergeCapabilityOverrides ───────────────────────────────────────────────
+
+describe("mergeCapabilityOverrides", () => {
+  test("overrides individual fields", () => {
+    const merged = mergeCapabilityOverrides("openai-responses", {
+      imageToolResults: true,
+    });
+    assert.equal(merged.imageToolResults, true);
+    // Non-overridden fields preserved
+    assert.equal(merged.toolCalling, true);
+    assert.equal(merged.thinkingPersistence, "text-only");
+  });
+
+  test("deep-merges toolCallIdFormat", () => {
+    const merged = mergeCapabilityOverrides("anthropic-messages", {
+      toolCallIdFormat: { maxLength: 128 },
+    });
+    assert.equal(merged.toolCallIdFormat.maxLength, 128);
+    // allowedChars preserved from base
+    assert.ok(merged.toolCallIdFormat.allowedChars instanceof RegExp);
+  });
+
+  test("uses permissive defaults for unknown provider", () => {
+    const merged = mergeCapabilityOverrides("unknown-xyz", {
+      imageToolResults: false,
+    });
+    assert.equal(merged.imageToolResults, false);
+    assert.equal(merged.toolCalling, true); // from default
+  });
+});

package/packages/pi-ai/src/providers/provider-capabilities.ts

@@ -0,0 +1,215 @@
+// GSD-2 — Provider Capabilities Registry (ADR-005 Phase 1)
+// Declarative registry of what each API provider supports, consolidating
+// scattered knowledge from *-shared.ts files into a queryable data structure.
+
+import type { Api } from "../types.js";
+
+// ─── Types ──────────────────────────────────────────────────────────────────
+
+/**
+ * Declarative capability profile for an API provider.
+ * Used by the model router to filter incompatible models and by the tool
+ * system to adjust tool sets per provider.
+ */
+export interface ProviderCapabilities {
+  /** Whether models from this provider support tool/function calling */
+  toolCalling: boolean;
+  /** Maximum number of tools the provider handles well (0 = unlimited) */
+  maxTools: number;
+  /** Whether tool results can contain images */
+  imageToolResults: boolean;
+  /** Whether the provider supports structured JSON output */
+  structuredOutput: boolean;
+  /** Tool call ID format constraints */
+  toolCallIdFormat: {
+    maxLength: number;
+    allowedChars: RegExp;
+  };
+  /** Whether thinking/reasoning blocks are preserved cross-turn */
+  thinkingPersistence: "full" | "text-only" | "none";
+  /** Schema features NOT supported (tools using these get filtered) */
+  unsupportedSchemaFeatures: string[];
+}
+
+// ─── Registry ───────────────────────────────────────────────────────────────
+
+/**
+ * Built-in provider capability profiles.
+ *
+ * Sources (consolidated from scattered *-shared.ts files):
+ * - anthropic-shared.ts: normalizeToolCallId (64-char, [a-zA-Z0-9_-])
+ * - openai-responses-shared.ts: ID normalization (64-char, fc_ prefix), image-in-tool-result workaround
+ * - google-shared.ts: sanitizeSchemaForGoogle (patternProperties, const), requiresToolCallId
+ * - mistral.ts: MISTRAL_TOOL_CALL_ID_LENGTH = 9
+ * - amazon-bedrock.ts: normalizeToolCallId (64-char, [a-zA-Z0-9_-])
+ */
+export const PROVIDER_CAPABILITIES: Record<string, ProviderCapabilities> = {
+  "anthropic-messages": {
+    toolCalling: true,
+    maxTools: 0,
+    imageToolResults: true,
+    structuredOutput: true,
+    toolCallIdFormat: { maxLength: 64, allowedChars: /^[a-zA-Z0-9_-]+$/ },
+    thinkingPersistence: "full",
+    unsupportedSchemaFeatures: [],
+  },
+  "anthropic-vertex": {
+    toolCalling: true,
+    maxTools: 0,
+    imageToolResults: true,
+    structuredOutput: true,
+    toolCallIdFormat: { maxLength: 64, allowedChars: /^[a-zA-Z0-9_-]+$/ },
+    thinkingPersistence: "full",
+    unsupportedSchemaFeatures: [],
+  },
+  "openai-responses": {
+    toolCalling: true,
+    maxTools: 0,
+    imageToolResults: false,  // images sent as separate user message, not in tool result
+    structuredOutput: true,
+    toolCallIdFormat: { maxLength: 512, allowedChars: /^.+$/ },
+    thinkingPersistence: "text-only",
+    unsupportedSchemaFeatures: [],
+  },
+  "azure-openai-responses": {
+    toolCalling: true,
+    maxTools: 0,
+    imageToolResults: false,
+    structuredOutput: true,
+    toolCallIdFormat: { maxLength: 512, allowedChars: /^.+$/ },
+    thinkingPersistence: "text-only",
+    unsupportedSchemaFeatures: [],
+  },
+  "openai-codex-responses": {
+    toolCalling: true,
+    maxTools: 0,
+    imageToolResults: false,
+    structuredOutput: true,
+    toolCallIdFormat: { maxLength: 64, allowedChars: /^[a-zA-Z0-9_-]+$/ },
+    thinkingPersistence: "text-only",
+    unsupportedSchemaFeatures: [],
+  },
+  "openai-completions": {
+    toolCalling: true,
+    maxTools: 0,
+    imageToolResults: false,
+    structuredOutput: true,
+    toolCallIdFormat: { maxLength: 64, allowedChars: /^[a-zA-Z0-9_-]+$/ },
+    thinkingPersistence: "text-only",
+    unsupportedSchemaFeatures: [],
+  },
+  "google-generative-ai": {
+    toolCalling: true,
+    maxTools: 0,
+    imageToolResults: true,
+    structuredOutput: true,
+    toolCallIdFormat: { maxLength: 64, allowedChars: /^[a-zA-Z0-9_-]+$/ },
+    thinkingPersistence: "text-only",
+    unsupportedSchemaFeatures: ["patternProperties", "const"],
+  },
+  "google-gemini-cli": {
+    toolCalling: true,
+    maxTools: 0,
+    imageToolResults: true,
+    structuredOutput: true,
+    toolCallIdFormat: { maxLength: 64, allowedChars: /^[a-zA-Z0-9_-]+$/ },
+    thinkingPersistence: "text-only",
+    unsupportedSchemaFeatures: ["patternProperties", "const"],
+  },
+  "google-vertex": {
+    toolCalling: true,
+    maxTools: 0,
+    imageToolResults: true,
+    structuredOutput: true,
+    toolCallIdFormat: { maxLength: 64, allowedChars: /^[a-zA-Z0-9_-]+$/ },
+    thinkingPersistence: "text-only",
+    unsupportedSchemaFeatures: ["patternProperties", "const"],
+  },
+  "mistral-conversations": {
+    toolCalling: true,
+    maxTools: 0,
+    imageToolResults: false,
+    structuredOutput: true,
+    toolCallIdFormat: { maxLength: 9, allowedChars: /^[a-zA-Z0-9]+$/ },
+    thinkingPersistence: "none",
+    unsupportedSchemaFeatures: [],
+  },
+  "bedrock-converse-stream": {
+    toolCalling: true,
+    maxTools: 0,
+    imageToolResults: true,  // Bedrock supports image content blocks in tool results
+    structuredOutput: true,
+    toolCallIdFormat: { maxLength: 64, allowedChars: /^[a-zA-Z0-9_-]+$/ },
+    thinkingPersistence: "text-only",
+    unsupportedSchemaFeatures: [],
+  },
+  "ollama-chat": {
+    toolCalling: true,
+    maxTools: 0,
+    imageToolResults: false,
+    structuredOutput: false,
+    toolCallIdFormat: { maxLength: 64, allowedChars: /^[a-zA-Z0-9_-]+$/ },
+    thinkingPersistence: "none",
+    unsupportedSchemaFeatures: [],
+  },
+};
+
+// ─── Default (permissive) profile for unknown providers ─────────────────────
+
+const DEFAULT_CAPABILITIES: ProviderCapabilities = {
+  toolCalling: true,
+  maxTools: 0,
+  imageToolResults: true,
+  structuredOutput: true,
+  toolCallIdFormat: { maxLength: 512, allowedChars: /^.+$/ },
+  thinkingPersistence: "text-only",
+  unsupportedSchemaFeatures: [],
+};
+
+// ─── Public API ─────────────────────────────────────────────────────────────
+
+/**
+ * Get capabilities for a provider API. Returns a permissive default for
+ * unknown providers (preserving existing behavior per ADR-005 principle 5).
+ */
+export function getProviderCapabilities(api: string): ProviderCapabilities {
+  return PROVIDER_CAPABILITIES[api] ?? DEFAULT_CAPABILITIES;
+}
+
+/**
+ * Check if a provider supports all required schema features.
+ * Returns the list of unsupported features (empty if all supported).
+ */
+export function getUnsupportedFeatures(api: string, requiredFeatures: string[]): string[] {
+  const caps = getProviderCapabilities(api);
+  return requiredFeatures.filter(f => caps.unsupportedSchemaFeatures.includes(f));
+}
+
+/**
+ * Deep-merge user-provided capability overrides with built-in defaults.
+ * Partial overrides merge with the built-in profile for the given API.
+ */
+export function mergeCapabilityOverrides(
+  api: string,
+  overrides: Partial<Omit<ProviderCapabilities, "toolCallIdFormat">> & {
+    toolCallIdFormat?: Partial<ProviderCapabilities["toolCallIdFormat"]>;
+  },
+): ProviderCapabilities {
+  const base = getProviderCapabilities(api);
+  return {
+    ...base,
+    ...overrides,
+    toolCallIdFormat: overrides.toolCallIdFormat
+      ? { ...base.toolCallIdFormat, ...overrides.toolCallIdFormat }
+      : base.toolCallIdFormat,
+  };
+}
+
+/**
+ * Get all registered API names in the capability registry.
+ * Used by lint rules to verify all providers in register-builtins.ts
+ * have corresponding capability entries.
+ */
+export function getRegisteredApis(): string[] {
+  return Object.keys(PROVIDER_CAPABILITIES);
+}

package/packages/pi-ai/src/providers/transform-messages-report.test.ts

@@ -0,0 +1,189 @@
+// GSD-2 — ProviderSwitchReport Tests (ADR-005 Phase 3)
+import { describe, test } from "node:test";
+import assert from "node:assert/strict";
+
+import { transformMessages, createEmptyReport, hasTransformations } from "./transform-messages.js";
+import type { ProviderSwitchReport } from "./transform-messages.js";
+import type { Message, Model, AssistantMessage, ToolCall } from "../types.js";
+
+// ─── Helpers ────────────────────────────────────────────────────────────────
+
+function makeModel(overrides: Partial<Model<any>> = {}): Model<any> {
+  return {
+    id: "claude-sonnet-4-6",
+    name: "Claude Sonnet 4.6",
+    api: "anthropic-messages",
+    provider: "anthropic",
+    baseUrl: "",
+    reasoning: false,
+    input: ["text", "image"],
+    cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+    contextWindow: 200000,
+    maxTokens: 8192,
+    ...overrides,
+  } as Model<any>;
+}
+
+function makeAssistantMsg(overrides: Partial<AssistantMessage> = {}): AssistantMessage {
+  return {
+    role: "assistant",
+    content: [],
+    api: "anthropic-messages",
+    provider: "anthropic",
+    model: "claude-sonnet-4-6",
+    usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, totalTokens: 0, cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 } },
+    stopReason: "stop",
+    timestamp: Date.now(),
+    ...overrides,
+  };
+}
+
+// ─── createEmptyReport / hasTransformations ─────────────────────────────────
+
+describe("createEmptyReport", () => {
+  test("creates report with zero counters", () => {
+    const report = createEmptyReport("anthropic-messages", "openai-responses");
+    assert.equal(report.fromApi, "anthropic-messages");
+    assert.equal(report.toApi, "openai-responses");
+    assert.equal(report.thinkingBlocksDropped, 0);
+    assert.equal(report.thinkingBlocksDowngraded, 0);
+    assert.equal(report.toolCallIdsRemapped, 0);
+    assert.equal(report.syntheticToolResultsInserted, 0);
+    assert.equal(report.thoughtSignaturesDropped, 0);
+  });
+});
+
+describe("hasTransformations", () => {
+  test("returns false for empty report", () => {
+    const report = createEmptyReport("a", "b");
+    assert.equal(hasTransformations(report), false);
+  });
+
+  test("returns true when any counter is non-zero", () => {
+    const report = createEmptyReport("a", "b");
+    report.thinkingBlocksDropped = 1;
+    assert.equal(hasTransformations(report), true);
+  });
+});
+
+// ─── Report Tracking in transformMessages ───────────────────────────────────
+
+describe("transformMessages with report tracking", () => {
+  test("tracks thinking blocks dropped for redacted cross-model", () => {
+    const model = makeModel({ id: "gpt-5", api: "openai-responses", provider: "openai" });
+    const messages: Message[] = [
+      makeAssistantMsg({
+        content: [
+          { type: "thinking", thinking: "", redacted: true },
+          { type: "text", text: "Hello" },
+        ],
+      }),
+    ];
+    const report = createEmptyReport("anthropic-messages", "openai-responses");
+    transformMessages(messages, model, undefined, report);
+    assert.equal(report.thinkingBlocksDropped, 1);
+  });
+
+  test("tracks thinking blocks downgraded to plain text", () => {
+    const model = makeModel({ id: "gpt-5", api: "openai-responses", provider: "openai" });
+    const messages: Message[] = [
+      makeAssistantMsg({
+        content: [
+          { type: "thinking", thinking: "Let me think about this..." },
+          { type: "text", text: "Here is my answer" },
+        ],
+      }),
+    ];
+    const report = createEmptyReport("anthropic-messages", "openai-responses");
+    transformMessages(messages, model, undefined, report);
+    assert.equal(report.thinkingBlocksDowngraded, 1);
+  });
+
+  test("tracks tool call IDs remapped", () => {
+    const model = makeModel({ id: "claude-sonnet-4-6", api: "anthropic-messages", provider: "anthropic" });
+    const toolCall: ToolCall = {
+      type: "toolCall",
+      id: "original-long-id-that-needs-normalization|with-special-chars",
+      name: "bash",
+      arguments: { command: "ls" },
+    };
+    const messages: Message[] = [
+      makeAssistantMsg({
+        provider: "openai",
+        api: "openai-responses",
+        model: "gpt-5",
+        content: [toolCall],
+      }),
+    ];
+    const normalizer = (id: string) => id.replace(/[^a-zA-Z0-9_-]/g, "_").slice(0, 64);
+    const report = createEmptyReport("openai-responses", "anthropic-messages");
+    transformMessages(messages, model, normalizer, report);
+    assert.equal(report.toolCallIdsRemapped, 1);
+  });
+
+  test("tracks thought signatures dropped", () => {
+    const model = makeModel({ id: "claude-sonnet-4-6", api: "anthropic-messages", provider: "anthropic" });
+    const toolCall: ToolCall = {
+      type: "toolCall",
+      id: "tc_001",
+      name: "bash",
+      arguments: { command: "ls" },
+      thoughtSignature: "some-opaque-signature",
+    };
+    const messages: Message[] = [
+      makeAssistantMsg({
+        provider: "google",
+        api: "google-generative-ai",
+        model: "gemini-2.5-pro",
+        content: [toolCall],
+      }),
+    ];
+    const report = createEmptyReport("google-generative-ai", "anthropic-messages");
+    transformMessages(messages, model, undefined, report);
+    assert.equal(report.thoughtSignaturesDropped, 1);
+  });
+
+  test("tracks synthetic tool results inserted", () => {
+    const model = makeModel();
+    const toolCall: ToolCall = {
+      type: "toolCall",
+      id: "tc_orphan",
+      name: "bash",
+      arguments: { command: "ls" },
+    };
+    // Assistant message with tool call followed by another assistant (no tool result)
+    const messages: Message[] = [
+      makeAssistantMsg({ content: [toolCall, { type: "text", text: "Using bash" }] }),
+      makeAssistantMsg({ content: [{ type: "text", text: "Next message" }] }),
+    ];
+    const report = createEmptyReport("anthropic-messages", "anthropic-messages");
+    transformMessages(messages, model, undefined, report);
+    assert.equal(report.syntheticToolResultsInserted, 1);
+  });
+
+  test("does not count transformations for same-model messages", () => {
+    const model = makeModel();
+    const messages: Message[] = [
+      makeAssistantMsg({
+        content: [
+          { type: "thinking", thinking: "Let me think..." },
+          { type: "text", text: "Answer" },
+        ],
+      }),
+    ];
+    const report = createEmptyReport("anthropic-messages", "anthropic-messages");
+    transformMessages(messages, model, undefined, report);
+    assert.equal(report.thinkingBlocksDowngraded, 0);
+    assert.equal(report.thinkingBlocksDropped, 0);
+  });
+
+  test("works without report parameter (backward compatible)", () => {
+    const model = makeModel();
+    const messages: Message[] = [
+      makeAssistantMsg({ content: [{ type: "text", text: "Hello" }] }),
+    ];
+    // Should not throw
+    const result = transformMessages(messages, model);
+    assert.ok(Array.isArray(result));
+  });
+});