@providerkit/core 0.9.0 → 0.10.1

package/src/schema.ts

@@ -133,3 +133,130 @@ export function isStrictSchema(node: unknown): boolean {
     ([key, value]) => required.has(key) && isStrictSchema(value),
   );
 }
+
+/**
+ * Sanitize a JSON Schema for Google Gemini's REST API.
+ *
+ * Gemini's functionDeclarations schema parser only accepts a strict OpenAPI 3.0 subset.
+ * It rejects:
+ * - Nullable type arrays (`type: ["string", "null"]`), requiring `{ type: "string", nullable: true }`.
+ * - Union types with null (`anyOf: [{ type: "string" }, { type: "null" }]`), requiring `{ type: "string", nullable: true }`.
+ * - Numeric enums (`enum: [1, 2, 3]`), requiring string enums.
+ * - `const: "val"`, requiring `enum: ["val"]`.
+ * - Arrays without `items`, requiring an explicit items schema.
+ * - Unsupported keywords ($schema, definitions, $defs, patternProperties, additionalProperties: true).
+ */
+export function toGeminiToolSchema(node: unknown): Record<string, unknown> {
+  if (!node || typeof node !== "object" || Array.isArray(node)) {
+    return { type: "object", properties: {} };
+  }
+  const schema = { ...(node as Record<string, unknown>) };
+
+  delete schema.$schema;
+  delete schema.$id;
+  delete schema.$ref;
+  delete schema.definitions;
+  delete schema.$defs;
+  delete schema.patternProperties;
+
+  if (schema.additionalProperties === true) {
+    delete schema.additionalProperties;
+  }
+
+  if ("const" in schema && !("enum" in schema)) {
+    schema.enum = [String(schema.const)];
+    delete schema.const;
+  }
+
+  const union = schema.anyOf ?? schema.oneOf;
+  if (Array.isArray(union)) {
+    const nonNullBranches = union.filter(
+      (b) => typeof b === "object" && b !== null && (b as Record<string, unknown>).type !== "null",
+    );
+    const hasNull = union.some(
+      (b) => typeof b === "object" && b !== null && (b as Record<string, unknown>).type === "null",
+    );
+    if (nonNullBranches.length === 1 && typeof nonNullBranches[0] === "object") {
+      const merged = toGeminiToolSchema(nonNullBranches[0]);
+      if (hasNull) merged.nullable = true;
+      return merged;
+    }
+  }
+
+  if (Array.isArray(schema.type)) {
+    const types = schema.type as string[];
+    const hasNull = types.includes("null");
+    const nonNull = types.filter((t) => t !== "null");
+    schema.type = nonNull[0] ?? "string";
+    if (hasNull) schema.nullable = true;
+  }
+
+  if (Array.isArray(schema.enum)) {
+    schema.enum = schema.enum.map((val) => String(val));
+  }
+
+  if (schema.type === "array" && !schema.items) {
+    schema.items = { type: "string" };
+  } else if (schema.items && typeof schema.items === "object") {
+    schema.items = toGeminiToolSchema(schema.items);
+  }
+
+  if (schema.properties && typeof schema.properties === "object") {
+    const props = schema.properties as Record<string, unknown>;
+    const sanitizedProps: Record<string, unknown> = {};
+    for (const [key, val] of Object.entries(props)) {
+      sanitizedProps[key] = toGeminiToolSchema(val);
+    }
+    schema.properties = sanitizedProps;
+  }
+
+  return schema;
+}
+
+/**
+ * Sanitize a tool's JSON Schema for Anthropic's Messages API.
+ *
+ * Anthropic rejects schemas where the root is an `anyOf` / `oneOf` / `allOf` union,
+ * requiring a root object schema (`{ type: "object", properties: ... }`).
+ */
+export function toAnthropicToolSchema(node: unknown): Record<string, unknown> {
+  if (!node || typeof node !== "object" || Array.isArray(node)) {
+    return { type: "object", properties: {} };
+  }
+  const schema = { ...(node as Record<string, unknown>) };
+
+  delete schema.$schema;
+  delete schema.$id;
+
+  const union = schema.anyOf ?? schema.oneOf;
+  if (Array.isArray(union)) {
+    const mergedProperties: Record<string, unknown> = {};
+    const mergedRequired = new Set<string>();
+    for (const branch of union) {
+      if (typeof branch === "object" && branch !== null) {
+        const b = branch as Record<string, unknown>;
+        if (b.properties && typeof b.properties === "object") {
+          Object.assign(mergedProperties, b.properties);
+        }
+        if (Array.isArray(b.required)) {
+          for (const req of b.required) {
+            if (typeof req === "string") mergedRequired.add(req);
+          }
+        }
+      }
+    }
+    delete schema.anyOf;
+    delete schema.oneOf;
+    schema.type = "object";
+    schema.properties = mergedProperties;
+    if (mergedRequired.size > 0 && !schema.required) {
+      schema.required = Array.from(mergedRequired);
+    }
+  }
+
+  if (!schema.type) {
+    schema.type = "object";
+  }
+
+  return schema;
+}

package/src/tool-args.ts

@@ -85,9 +85,54 @@ function salvageStringFields(raw: string): Record<string, unknown> {
   return out;
 }
 
+/**
+ * Attempt to recover the last valid JSON object from concatenated or prepended JSON
+ * (e.g. `{}{"query":"hello"}` or `{"a":1}{"b":2}`).
+ */
+export function findLastValidJsonObject(raw: string): Record<string, unknown> | null {
+  const trimmed = raw.trim();
+  if (!trimmed.includes("{")) return null;
+
+  let startIdx = trimmed.lastIndexOf("{");
+  while (startIdx >= 0) {
+    const candidate = trimmed.slice(startIdx);
+    try {
+      const parsed: unknown = JSON.parse(candidate);
+      if (isRecord(parsed)) return parsed;
+    } catch {
+      // Keep searching earlier '{'
+    }
+    if (startIdx === 0) break;
+    startIdx = trimmed.lastIndexOf("{", startIdx - 1);
+  }
+  return null;
+}
+
+/**
+ * Normalizes tool call IDs:
+ * 1. Synthesizes a fallback if empty/whitespace.
+ * 2. Clamps oversized IDs (> 64 chars) to avoid ChatGPT Responses 400 errors.
+ */
+export function normalizeToolId(id: string | undefined | null, prefix = "call_pk_"): string {
+  const clean = id?.trim();
+  if (!clean) {
+    return `${prefix}${Math.random().toString(36).slice(2, 10)}`;
+  }
+  if (clean.length > 64) {
+    let hash = 0;
+    for (let i = 0; i < clean.length; i++) {
+      hash = (Math.imul(31, hash) + clean.charCodeAt(i)) | 0;
+    }
+    const hashHex = (hash >>> 0).toString(16).padStart(8, "0");
+    return `${clean.slice(0, 48)}_${hashHex}`;
+  }
+  return clean;
+}
+
 /**
  * Parse a tool call's raw argument string into an object, salvaging what a
- * truncated stream left behind and healing double-escaped text either way.
+ * truncated stream left behind, resolving concatenated JSON, and healing
+ * double-escaped text either way.
  *
  * Never throws: a tool call the model malformed is data the caller decides
  * about, not an exception in the transport.
@@ -98,6 +143,8 @@ export function parseToolArgs(raw: string): Record<string, unknown> {
   try {
     parsed = JSON.parse(raw);
   } catch {
+    const lastObj = findLastValidJsonObject(raw);
+    if (lastObj !== null) return healArgs(lastObj);
     return healArgs(salvageStringFields(raw));
   }
   // A non-object payload is a protocol violation, not a value to pass on.

package/src/transport.ts

@@ -68,9 +68,13 @@ async function errorFor(provider: string, res: Response): Promise<ProviderError>
   const message = text
     ? `${provider} ${res.status}: ${text.slice(0, 500)}`
     : `${provider} ${res.status} ${res.statusText}`;
+  const shouldRetryHeader = res.headers.get("x-should-retry");
+  const shouldRetry =
+    shouldRetryHeader === "false" ? false : shouldRetryHeader === "true" ? true : undefined;
   return new ProviderError(provider, kind, message, {
     status: res.status,
     ...reset,
+    shouldRetry,
     retryAfterMs: retryAfterFromHeaders(res.headers) ?? parseRetryAfterMs({}, text),
     body: text.slice(0, 2_000) || undefined,
   });

package/src/usage.ts

@@ -36,6 +36,19 @@ export function addUsage(a: TokenUsage, b: TokenUsage): TokenUsage {
   };
 }
 
+/**
+ * Subtract usage `b` from `a`, clamping each field at zero.
+ * Used when an optimistic turn or speculative stream is rolled back.
+ */
+export function subtractUsage(a: TokenUsage, b: TokenUsage): TokenUsage {
+  return {
+    inputTokens: Math.max(0, a.inputTokens - b.inputTokens),
+    cachedInputTokens: Math.max(0, a.cachedInputTokens - b.cachedInputTokens),
+    cacheWriteTokens: Math.max(0, (a.cacheWriteTokens ?? 0) - (b.cacheWriteTokens ?? 0)),
+    outputTokens: Math.max(0, a.outputTokens - b.outputTokens),
+  };
+}
+
 /**
  * USD for one call.
  *
@@ -79,6 +92,14 @@ export class UsageTracker {
     this.saved += (cached * (rate.input - rate.cacheRead)) / 1_000_000;
   }
 
+  subtract(usage: TokenUsage, rate?: ModelRate): void {
+    this.usage = subtractUsage(this.usage, usage);
+    if (!rate) return;
+    this.cost = Math.max(0, this.cost - costUsd(usage, rate));
+    const cached = Math.min(Math.max(0, usage.cachedInputTokens), Math.max(0, usage.inputTokens));
+    this.saved = Math.max(0, this.saved - (cached * (rate.input - rate.cacheRead)) / 1_000_000);
+  }
+
   get totals(): TokenUsage {
     return { ...this.usage };
   }