@bastani/atomic 0.8.31-alpha.3 → 0.8.31-alpha.4

package/dist/core/copilot-gemini-payload-sanitizer.d.ts

@@ -0,0 +1,72 @@
+import type { Api, Model } from "@earendil-works/pi-ai";
+/**
+ * Sanitizes outbound OpenAI-compatible request payloads for GitHub Copilot
+ * Gemini models so their tool/function JSON Schemas survive translation to
+ * Google's GenAI `FunctionDeclaration` schema.
+ *
+ * Why this exists
+ * ---------------
+ * `github-copilot` Gemini models (e.g. `gemini-3.1-pro-preview`) are served
+ * through Copilot's CAPI gateway at `api.*.githubcopilot.com` using the
+ * `openai-completions` API. CAPI receives the OpenAI chat-completions request
+ * and translates it into a Google GenAI `GenerateContent` request. During that
+ * translation CAPI forwards JSON Schema `anyOf`/`oneOf` verbatim into the Gemini
+ * `FunctionDeclaration` schema. Gemini's function-declaration schema rejects an
+ * `anyOf`/`oneOf` whose branch is a complex *object* schema, so Google returns
+ * HTTP 400 and CAPI relabels it `{"error":{"code":"invalid_request_body"}}`.
+ *
+ * Atomic's bundled tools (notably the `workflow` tool) use the TypeBox
+ * `Type.Union([Type.Object(...), Type.String()])` pattern for fields like
+ * `task`, `chain`, and `parallel`, which emit exactly that construct. Because
+ * those tools are present in normal chat turns, every Gemini request fails with
+ * `400 invalid request body` until the schema is sanitized.
+ *
+ * What it does
+ * ------------
+ * Recursively rewrites each tool's `parameters` JSON Schema into the reduced
+ * subset that CAPI/Gemini actually honors (`type`, `description`, `enum`,
+ * `properties`, `required`, `items`, `nullable`, and scalar-only `anyOf`):
+ *  - Resolves `anyOf`/`oneOf` that contain an object/array branch to the most
+ *    expressive object/array branch (the core fix), preserving `description`
+ *    and collapsing a `"null"` branch into `nullable: true`.
+ *  - Converts `const` (and `anyOf` of `const`/`enum` scalars) into `enum`,
+ *    which Gemini supports, so `Type.Literal(...)` unions keep their constraint.
+ *  - Drops JSON Schema keywords CAPI strips or Gemini rejects (`$schema`,
+ *    `$ref`, `$defs`, `patternProperties`, `additionalProperties`, `allOf`,
+ *    `not`, `format`, `pattern`, numeric/length bounds, `default`, etc.).
+ *  - Filters `required` down to keys still present under `properties`.
+ *
+ * The transform is gated to GitHub Copilot Gemini models only, so it never
+ * changes payloads for any currently-working provider/model.
+ */
+type JsonObject = {
+    [key: string]: JsonValue;
+};
+type JsonValue = string | number | boolean | null | JsonValue[] | JsonObject;
+/**
+ * Keywords that are dropped because CAPI strips them before Google and/or
+ * Gemini's function schema rejects them. Listing them explicitly keeps the
+ * intent auditable; any keyword not in {@link KEPT_SCHEMA_KEYWORDS} and not a
+ * union keyword is dropped regardless. Exported so the documented drop-list has
+ * a real consumer (and stays linted) without a per-iteration `void` reference.
+ */
+export declare const DROPPED_SCHEMA_KEYWORDS: Set<string>;
+/**
+ * Whether this model is a GitHub Copilot Gemini model routed through the
+ * OpenAI-completions CAPI path that needs schema sanitization.
+ */
+export declare function isCopilotGeminiModel(model: Pick<Model<Api>, "provider" | "api" | "id">): boolean;
+/**
+ * Recursively rewrite a JSON Schema node into the Gemini-compatible subset.
+ */
+export declare function sanitizeGeminiSchema(schema: JsonValue): JsonValue;
+/**
+ * Sanitize an outbound provider payload for GitHub Copilot Gemini models.
+ *
+ * Returns the payload unchanged for any other provider/model, or when the
+ * payload has no sanitizable `tools`. Mirrors the `onPayload`
+ * `(payload: unknown) => unknown` contract used elsewhere in the SDK wiring.
+ */
+export declare function sanitizeCopilotGeminiPayload(payload: unknown, model: Pick<Model<Api>, "provider" | "api" | "id">): unknown;
+export {};
+//# sourceMappingURL=copilot-gemini-payload-sanitizer.d.ts.map

package/dist/core/copilot-gemini-payload-sanitizer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"copilot-gemini-payload-sanitizer.d.ts","sourceRoot":"","sources":["../../src/core/copilot-gemini-payload-sanitizer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,GAAG,EAAE,KAAK,EAAE,MAAM,uBAAuB,CAAC;AAExD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AAEH,KAAK,UAAU,GAAG;IAAE,CAAC,GAAG,EAAE,MAAM,GAAG,SAAS,CAAA;CAAE,CAAC;AAC/C,KAAK,SAAS,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,IAAI,GAAG,SAAS,EAAE,GAAG,UAAU,CAAC;AAa7E;;;;;;GAMG;AACH,eAAO,MAAM,uBAAuB,aAwClC,CAAC;AAMH;;;GAGG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,EAAE,UAAU,GAAG,KAAK,GAAG,IAAI,CAAC,GAAG,OAAO,CAMhG;AAqCD;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,SAAS,GAAG,SAAS,CAgDjE;AA2GD;;;;;;GAMG;AACH,wBAAgB,4BAA4B,CAC1C,OAAO,EAAE,OAAO,EAChB,KAAK,EAAE,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,EAAE,UAAU,GAAG,KAAK,GAAG,IAAI,CAAC,GACjD,OAAO,CA+BT","sourcesContent":["import type { Api, Model } from \"@earendil-works/pi-ai\";\n\n/**\n * Sanitizes outbound OpenAI-compatible request payloads for GitHub Copilot\n * Gemini models so their tool/function JSON Schemas survive translation to\n * Google's GenAI `FunctionDeclaration` schema.\n *\n * Why this exists\n * ---------------\n * `github-copilot` Gemini models (e.g. `gemini-3.1-pro-preview`) are served\n * through Copilot's CAPI gateway at `api.*.githubcopilot.com` using the\n * `openai-completions` API. CAPI receives the OpenAI chat-completions request\n * and translates it into a Google GenAI `GenerateContent` request. During that\n * translation CAPI forwards JSON Schema `anyOf`/`oneOf` verbatim into the Gemini\n * `FunctionDeclaration` schema. Gemini's function-declaration schema rejects an\n * `anyOf`/`oneOf` whose branch is a complex *object* schema, so Google returns\n * HTTP 400 and CAPI relabels it `{\"error\":{\"code\":\"invalid_request_body\"}}`.\n *\n * Atomic's bundled tools (notably the `workflow` tool) use the TypeBox\n * `Type.Union([Type.Object(...), Type.String()])` pattern for fields like\n * `task`, `chain`, and `parallel`, which emit exactly that construct. Because\n * those tools are present in normal chat turns, every Gemini request fails with\n * `400 invalid request body` until the schema is sanitized.\n *\n * What it does\n * ------------\n * Recursively rewrites each tool's `parameters` JSON Schema into the reduced\n * subset that CAPI/Gemini actually honors (`type`, `description`, `enum`,\n * `properties`, `required`, `items`, `nullable`, and scalar-only `anyOf`):\n *  - Resolves `anyOf`/`oneOf` that contain an object/array branch to the most\n *    expressive object/array branch (the core fix), preserving `description`\n *    and collapsing a `\"null\"` branch into `nullable: true`.\n *  - Converts `const` (and `anyOf` of `const`/`enum` scalars) into `enum`,\n *    which Gemini supports, so `Type.Literal(...)` unions keep their constraint.\n *  - Drops JSON Schema keywords CAPI strips or Gemini rejects (`$schema`,\n *    `$ref`, `$defs`, `patternProperties`, `additionalProperties`, `allOf`,\n *    `not`, `format`, `pattern`, numeric/length bounds, `default`, etc.).\n *  - Filters `required` down to keys still present under `properties`.\n *\n * The transform is gated to GitHub Copilot Gemini models only, so it never\n * changes payloads for any currently-working provider/model.\n */\n\ntype JsonObject = { [key: string]: JsonValue };\ntype JsonValue = string | number | boolean | null | JsonValue[] | JsonObject;\n\n/** JSON Schema keywords Gemini's function-declaration schema honors. */\nconst KEPT_SCHEMA_KEYWORDS = new Set<string>([\n  \"type\",\n  \"description\",\n  \"enum\",\n  \"properties\",\n  \"required\",\n  \"items\",\n  \"nullable\",\n]);\n\n/**\n * Keywords that are dropped because CAPI strips them before Google and/or\n * Gemini's function schema rejects them. Listing them explicitly keeps the\n * intent auditable; any keyword not in {@link KEPT_SCHEMA_KEYWORDS} and not a\n * union keyword is dropped regardless. Exported so the documented drop-list has\n * a real consumer (and stays linted) without a per-iteration `void` reference.\n */\nexport const DROPPED_SCHEMA_KEYWORDS = new Set<string>([\n  \"$schema\",\n  \"$id\",\n  \"$ref\",\n  \"$defs\",\n  \"$comment\",\n  \"definitions\",\n  \"patternProperties\",\n  \"propertyNames\",\n  \"unevaluatedProperties\",\n  \"additionalProperties\",\n  \"additionalItems\",\n  \"unevaluatedItems\",\n  \"allOf\",\n  \"not\",\n  \"if\",\n  \"then\",\n  \"else\",\n  \"format\",\n  \"pattern\",\n  \"minLength\",\n  \"maxLength\",\n  \"minItems\",\n  \"maxItems\",\n  \"uniqueItems\",\n  \"minimum\",\n  \"maximum\",\n  \"exclusiveMinimum\",\n  \"exclusiveMaximum\",\n  \"multipleOf\",\n  \"minProperties\",\n  \"maxProperties\",\n  \"default\",\n  \"examples\",\n  \"title\",\n  \"readOnly\",\n  \"writeOnly\",\n  \"deprecated\",\n  \"contentEncoding\",\n  \"contentMediaType\",\n]);\n\nfunction isPlainObject(value: JsonValue | undefined): value is JsonObject {\n  return typeof value === \"object\" && value !== null && !Array.isArray(value);\n}\n\n/**\n * Whether this model is a GitHub Copilot Gemini model routed through the\n * OpenAI-completions CAPI path that needs schema sanitization.\n */\nexport function isCopilotGeminiModel(model: Pick<Model<Api>, \"provider\" | \"api\" | \"id\">): boolean {\n  return (\n    model.provider === \"github-copilot\" &&\n    model.api === \"openai-completions\" &&\n    /(^|[/-])gemini/i.test(model.id)\n  );\n}\n\nfunction jsonScalarType(value: JsonValue): string | undefined {\n  switch (typeof value) {\n    case \"string\":\n      return \"string\";\n    case \"boolean\":\n      return \"boolean\";\n    case \"number\":\n      return Number.isInteger(value) ? \"integer\" : \"number\";\n    default:\n      return value === null ? \"null\" : undefined;\n  }\n}\n\nfunction isObjectOrArraySchema(schema: JsonValue): boolean {\n  if (!isPlainObject(schema)) return false;\n  return (\n    schema.type === \"object\" ||\n    schema.type === \"array\" ||\n    \"properties\" in schema ||\n    \"items\" in schema\n  );\n}\n\nfunction isNullSchema(schema: JsonValue): boolean {\n  return isPlainObject(schema) && schema.type === \"null\";\n}\n\n/** Collect literal values from a scalar branch expressed as `const` or `enum`. */\nfunction literalValues(schema: JsonValue): JsonValue[] | undefined {\n  if (!isPlainObject(schema)) return undefined;\n  if (\"const\" in schema) return [schema.const as JsonValue];\n  if (Array.isArray(schema.enum)) return schema.enum as JsonValue[];\n  return undefined;\n}\n\n/**\n * Recursively rewrite a JSON Schema node into the Gemini-compatible subset.\n */\nexport function sanitizeGeminiSchema(schema: JsonValue): JsonValue {\n  if (Array.isArray(schema)) {\n    return schema.map((entry) => sanitizeGeminiSchema(entry));\n  }\n  if (!isPlainObject(schema)) {\n    return schema;\n  }\n\n  const union = (schema.anyOf ?? schema.oneOf) as JsonValue | undefined;\n  if (Array.isArray(union)) {\n    return sanitizeUnion(schema, union);\n  }\n\n  const result: JsonObject = {};\n\n  // const -> enum (Gemini supports enum, not const).\n  if (\"const\" in schema && !(\"enum\" in schema)) {\n    const constValue = schema.const as JsonValue;\n    const inferred = jsonScalarType(constValue);\n    if (inferred && inferred !== \"null\") result.type = inferred;\n    result.enum = [constValue];\n  }\n\n  for (const [key, value] of Object.entries(schema)) {\n    if (key === \"const\") continue;\n    if (key === \"properties\" && isPlainObject(value)) {\n      const props: JsonObject = {};\n      for (const [propName, propSchema] of Object.entries(value)) {\n        props[propName] = sanitizeGeminiSchema(propSchema);\n      }\n      result.properties = props;\n      continue;\n    }\n    if (key === \"items\") {\n      result.items = sanitizeItems(value);\n      continue;\n    }\n    if (KEPT_SCHEMA_KEYWORDS.has(key)) {\n      result[key] = value;\n      continue;\n    }\n    // Everything else (the documented DROPPED_SCHEMA_KEYWORDS plus any unknown\n    // keyword) is omitted: the rule is simply \"keep only KEPT_SCHEMA_KEYWORDS\".\n  }\n\n  inferContainerType(result);\n  pruneRequired(result);\n  return result;\n}\n\n/**\n * Resolve an `items` schema. Gemini's function-declaration schema expects a\n * single `items` schema, so a tuple-form `items` (array of schemas) is collapsed\n * to its most expressive (object/array) entry, falling back to the first entry.\n */\nfunction sanitizeItems(items: JsonValue): JsonValue {\n  if (!Array.isArray(items)) return sanitizeGeminiSchema(items);\n  const sanitized = items.map((entry) => sanitizeGeminiSchema(entry));\n  const objectOrArray = sanitized.find((entry) => isObjectOrArraySchema(entry));\n  return objectOrArray ?? sanitized[0] ?? { type: \"string\" };\n}\n\n/**\n * Gemini resolves function arguments more reliably when container nodes carry an\n * explicit `type`. Infer it when omitted: a node with `properties`/`required` is\n * an object, and a node with `items` is an array.\n */\nfunction inferContainerType(schema: JsonObject): void {\n  if (schema.type !== undefined) return;\n  if (isPlainObject(schema.properties) || Array.isArray(schema.required)) {\n    schema.type = \"object\";\n  } else if (schema.items !== undefined) {\n    schema.type = \"array\";\n  }\n}\n\n/** Resolve an `anyOf`/`oneOf` union node into the Gemini-compatible subset. */\nfunction sanitizeUnion(parent: JsonObject, branches: JsonValue[]): JsonValue {\n  const sanitizedBranches = branches.map((branch) => sanitizeGeminiSchema(branch));\n  const nullable =\n    branches.some((branch) => isNullSchema(branch)) || parent.nullable === true;\n  const nonNull = sanitizedBranches.filter((branch) => !isNullSchema(branch));\n\n  const carryDescription = (target: JsonValue): JsonValue => {\n    if (isPlainObject(target) && typeof parent.description === \"string\" && !(\"description\" in target)) {\n      target.description = parent.description;\n    }\n    if (nullable && isPlainObject(target)) target.nullable = true;\n    return target;\n  };\n\n  // Core fix: if any branch is an object/array schema, collapse to the first\n  // such branch (Gemini rejects unions whose branch is a complex object). For\n  // the TypeBox `Type.Union([Type.Object(...), Type.String()])` pattern this is\n  // the object branch; a union of two distinct object shapes keeps only the\n  // first, so the others' properties are intentionally dropped.\n  const objectOrArray = nonNull.find((branch) => isObjectOrArraySchema(branch));\n  if (objectOrArray) {\n    return carryDescription(objectOrArray);\n  }\n\n  if (nonNull.length === 0) {\n    return carryDescription({ type: \"string\" });\n  }\n  if (nonNull.length === 1) {\n    return carryDescription(nonNull[0]);\n  }\n\n  // All-scalar union: prefer an `enum` when every branch is a literal/enum of\n  // one underlying type; otherwise keep a scalar `anyOf` (Gemini accepts it).\n  const literals: JsonValue[] = [];\n  const scalarTypes = new Set<string>();\n  let allLiteral = true;\n  for (const branch of nonNull) {\n    const values = literalValues(branch);\n    if (!values) {\n      allLiteral = false;\n      break;\n    }\n    for (const value of values) {\n      literals.push(value);\n      const inferred = jsonScalarType(value);\n      if (inferred) scalarTypes.add(inferred);\n    }\n  }\n  if (allLiteral && literals.length > 0) {\n    const collapsed: JsonObject = { enum: literals };\n    if (scalarTypes.size === 1) collapsed.type = [...scalarTypes][0];\n    return carryDescription(collapsed);\n  }\n\n  const node: JsonObject = { anyOf: nonNull };\n  return carryDescription(node);\n}\n\n/** Drop `required` entries that are not present under `properties`. */\nfunction pruneRequired(schema: JsonObject): void {\n  if (!Array.isArray(schema.required)) return;\n  const properties = isPlainObject(schema.properties) ? schema.properties : undefined;\n  if (!properties) {\n    delete schema.required;\n    return;\n  }\n  const filtered = schema.required.filter(\n    (key): key is string => typeof key === \"string\" && key in properties,\n  );\n  if (filtered.length > 0) schema.required = filtered;\n  else delete schema.required;\n}\n\n/** Sanitize a single tool's `parameters` schema in place-safe (returns new value). */\nfunction sanitizeToolParameters(parameters: JsonValue): JsonValue {\n  return sanitizeGeminiSchema(parameters);\n}\n\n/**\n * Sanitize an outbound provider payload for GitHub Copilot Gemini models.\n *\n * Returns the payload unchanged for any other provider/model, or when the\n * payload has no sanitizable `tools`. Mirrors the `onPayload`\n * `(payload: unknown) => unknown` contract used elsewhere in the SDK wiring.\n */\nexport function sanitizeCopilotGeminiPayload(\n  payload: unknown,\n  model: Pick<Model<Api>, \"provider\" | \"api\" | \"id\">,\n): unknown {\n  if (!isCopilotGeminiModel(model)) return payload;\n  if (!isPlainObject(payload as JsonValue)) return payload;\n  const payloadObject = payload as JsonObject;\n  const tools = payloadObject.tools;\n  if (!Array.isArray(tools) || tools.length === 0) return payload;\n\n  let mutated = false;\n  const sanitizedTools = tools.map((tool) => {\n    if (!isPlainObject(tool)) return tool;\n    // OpenAI chat-completions tool shape: { type: \"function\", function: { parameters } }\n    if (isPlainObject(tool.function) && tool.function.parameters !== undefined) {\n      mutated = true;\n      return {\n        ...tool,\n        function: {\n          ...tool.function,\n          parameters: sanitizeToolParameters(tool.function.parameters),\n        },\n      };\n    }\n    // Defensive: flat tool shape { name, parameters }.\n    if (tool.parameters !== undefined) {\n      mutated = true;\n      return { ...tool, parameters: sanitizeToolParameters(tool.parameters) };\n    }\n    return tool;\n  });\n\n  if (!mutated) return payload;\n  return { ...payloadObject, tools: sanitizedTools };\n}\n"]}

package/dist/core/copilot-gemini-payload-sanitizer.js

@@ -0,0 +1,296 @@
+/** JSON Schema keywords Gemini's function-declaration schema honors. */
+const KEPT_SCHEMA_KEYWORDS = new Set([
+    "type",
+    "description",
+    "enum",
+    "properties",
+    "required",
+    "items",
+    "nullable",
+]);
+/**
+ * Keywords that are dropped because CAPI strips them before Google and/or
+ * Gemini's function schema rejects them. Listing them explicitly keeps the
+ * intent auditable; any keyword not in {@link KEPT_SCHEMA_KEYWORDS} and not a
+ * union keyword is dropped regardless. Exported so the documented drop-list has
+ * a real consumer (and stays linted) without a per-iteration `void` reference.
+ */
+export const DROPPED_SCHEMA_KEYWORDS = new Set([
+    "$schema",
+    "$id",
+    "$ref",
+    "$defs",
+    "$comment",
+    "definitions",
+    "patternProperties",
+    "propertyNames",
+    "unevaluatedProperties",
+    "additionalProperties",
+    "additionalItems",
+    "unevaluatedItems",
+    "allOf",
+    "not",
+    "if",
+    "then",
+    "else",
+    "format",
+    "pattern",
+    "minLength",
+    "maxLength",
+    "minItems",
+    "maxItems",
+    "uniqueItems",
+    "minimum",
+    "maximum",
+    "exclusiveMinimum",
+    "exclusiveMaximum",
+    "multipleOf",
+    "minProperties",
+    "maxProperties",
+    "default",
+    "examples",
+    "title",
+    "readOnly",
+    "writeOnly",
+    "deprecated",
+    "contentEncoding",
+    "contentMediaType",
+]);
+function isPlainObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/**
+ * Whether this model is a GitHub Copilot Gemini model routed through the
+ * OpenAI-completions CAPI path that needs schema sanitization.
+ */
+export function isCopilotGeminiModel(model) {
+    return (model.provider === "github-copilot" &&
+        model.api === "openai-completions" &&
+        /(^|[/-])gemini/i.test(model.id));
+}
+function jsonScalarType(value) {
+    switch (typeof value) {
+        case "string":
+            return "string";
+        case "boolean":
+            return "boolean";
+        case "number":
+            return Number.isInteger(value) ? "integer" : "number";
+        default:
+            return value === null ? "null" : undefined;
+    }
+}
+function isObjectOrArraySchema(schema) {
+    if (!isPlainObject(schema))
+        return false;
+    return (schema.type === "object" ||
+        schema.type === "array" ||
+        "properties" in schema ||
+        "items" in schema);
+}
+function isNullSchema(schema) {
+    return isPlainObject(schema) && schema.type === "null";
+}
+/** Collect literal values from a scalar branch expressed as `const` or `enum`. */
+function literalValues(schema) {
+    if (!isPlainObject(schema))
+        return undefined;
+    if ("const" in schema)
+        return [schema.const];
+    if (Array.isArray(schema.enum))
+        return schema.enum;
+    return undefined;
+}
+/**
+ * Recursively rewrite a JSON Schema node into the Gemini-compatible subset.
+ */
+export function sanitizeGeminiSchema(schema) {
+    if (Array.isArray(schema)) {
+        return schema.map((entry) => sanitizeGeminiSchema(entry));
+    }
+    if (!isPlainObject(schema)) {
+        return schema;
+    }
+    const union = (schema.anyOf ?? schema.oneOf);
+    if (Array.isArray(union)) {
+        return sanitizeUnion(schema, union);
+    }
+    const result = {};
+    // const -> enum (Gemini supports enum, not const).
+    if ("const" in schema && !("enum" in schema)) {
+        const constValue = schema.const;
+        const inferred = jsonScalarType(constValue);
+        if (inferred && inferred !== "null")
+            result.type = inferred;
+        result.enum = [constValue];
+    }
+    for (const [key, value] of Object.entries(schema)) {
+        if (key === "const")
+            continue;
+        if (key === "properties" && isPlainObject(value)) {
+            const props = {};
+            for (const [propName, propSchema] of Object.entries(value)) {
+                props[propName] = sanitizeGeminiSchema(propSchema);
+            }
+            result.properties = props;
+            continue;
+        }
+        if (key === "items") {
+            result.items = sanitizeItems(value);
+            continue;
+        }
+        if (KEPT_SCHEMA_KEYWORDS.has(key)) {
+            result[key] = value;
+            continue;
+        }
+        // Everything else (the documented DROPPED_SCHEMA_KEYWORDS plus any unknown
+        // keyword) is omitted: the rule is simply "keep only KEPT_SCHEMA_KEYWORDS".
+    }
+    inferContainerType(result);
+    pruneRequired(result);
+    return result;
+}
+/**
+ * Resolve an `items` schema. Gemini's function-declaration schema expects a
+ * single `items` schema, so a tuple-form `items` (array of schemas) is collapsed
+ * to its most expressive (object/array) entry, falling back to the first entry.
+ */
+function sanitizeItems(items) {
+    if (!Array.isArray(items))
+        return sanitizeGeminiSchema(items);
+    const sanitized = items.map((entry) => sanitizeGeminiSchema(entry));
+    const objectOrArray = sanitized.find((entry) => isObjectOrArraySchema(entry));
+    return objectOrArray ?? sanitized[0] ?? { type: "string" };
+}
+/**
+ * Gemini resolves function arguments more reliably when container nodes carry an
+ * explicit `type`. Infer it when omitted: a node with `properties`/`required` is
+ * an object, and a node with `items` is an array.
+ */
+function inferContainerType(schema) {
+    if (schema.type !== undefined)
+        return;
+    if (isPlainObject(schema.properties) || Array.isArray(schema.required)) {
+        schema.type = "object";
+    }
+    else if (schema.items !== undefined) {
+        schema.type = "array";
+    }
+}
+/** Resolve an `anyOf`/`oneOf` union node into the Gemini-compatible subset. */
+function sanitizeUnion(parent, branches) {
+    const sanitizedBranches = branches.map((branch) => sanitizeGeminiSchema(branch));
+    const nullable = branches.some((branch) => isNullSchema(branch)) || parent.nullable === true;
+    const nonNull = sanitizedBranches.filter((branch) => !isNullSchema(branch));
+    const carryDescription = (target) => {
+        if (isPlainObject(target) && typeof parent.description === "string" && !("description" in target)) {
+            target.description = parent.description;
+        }
+        if (nullable && isPlainObject(target))
+            target.nullable = true;
+        return target;
+    };
+    // Core fix: if any branch is an object/array schema, collapse to the first
+    // such branch (Gemini rejects unions whose branch is a complex object). For
+    // the TypeBox `Type.Union([Type.Object(...), Type.String()])` pattern this is
+    // the object branch; a union of two distinct object shapes keeps only the
+    // first, so the others' properties are intentionally dropped.
+    const objectOrArray = nonNull.find((branch) => isObjectOrArraySchema(branch));
+    if (objectOrArray) {
+        return carryDescription(objectOrArray);
+    }
+    if (nonNull.length === 0) {
+        return carryDescription({ type: "string" });
+    }
+    if (nonNull.length === 1) {
+        return carryDescription(nonNull[0]);
+    }
+    // All-scalar union: prefer an `enum` when every branch is a literal/enum of
+    // one underlying type; otherwise keep a scalar `anyOf` (Gemini accepts it).
+    const literals = [];
+    const scalarTypes = new Set();
+    let allLiteral = true;
+    for (const branch of nonNull) {
+        const values = literalValues(branch);
+        if (!values) {
+            allLiteral = false;
+            break;
+        }
+        for (const value of values) {
+            literals.push(value);
+            const inferred = jsonScalarType(value);
+            if (inferred)
+                scalarTypes.add(inferred);
+        }
+    }
+    if (allLiteral && literals.length > 0) {
+        const collapsed = { enum: literals };
+        if (scalarTypes.size === 1)
+            collapsed.type = [...scalarTypes][0];
+        return carryDescription(collapsed);
+    }
+    const node = { anyOf: nonNull };
+    return carryDescription(node);
+}
+/** Drop `required` entries that are not present under `properties`. */
+function pruneRequired(schema) {
+    if (!Array.isArray(schema.required))
+        return;
+    const properties = isPlainObject(schema.properties) ? schema.properties : undefined;
+    if (!properties) {
+        delete schema.required;
+        return;
+    }
+    const filtered = schema.required.filter((key) => typeof key === "string" && key in properties);
+    if (filtered.length > 0)
+        schema.required = filtered;
+    else
+        delete schema.required;
+}
+/** Sanitize a single tool's `parameters` schema in place-safe (returns new value). */
+function sanitizeToolParameters(parameters) {
+    return sanitizeGeminiSchema(parameters);
+}
+/**
+ * Sanitize an outbound provider payload for GitHub Copilot Gemini models.
+ *
+ * Returns the payload unchanged for any other provider/model, or when the
+ * payload has no sanitizable `tools`. Mirrors the `onPayload`
+ * `(payload: unknown) => unknown` contract used elsewhere in the SDK wiring.
+ */
+export function sanitizeCopilotGeminiPayload(payload, model) {
+    if (!isCopilotGeminiModel(model))
+        return payload;
+    if (!isPlainObject(payload))
+        return payload;
+    const payloadObject = payload;
+    const tools = payloadObject.tools;
+    if (!Array.isArray(tools) || tools.length === 0)
+        return payload;
+    let mutated = false;
+    const sanitizedTools = tools.map((tool) => {
+        if (!isPlainObject(tool))
+            return tool;
+        // OpenAI chat-completions tool shape: { type: "function", function: { parameters } }
+        if (isPlainObject(tool.function) && tool.function.parameters !== undefined) {
+            mutated = true;
+            return {
+                ...tool,
+                function: {
+                    ...tool.function,
+                    parameters: sanitizeToolParameters(tool.function.parameters),
+                },
+            };
+        }
+        // Defensive: flat tool shape { name, parameters }.
+        if (tool.parameters !== undefined) {
+            mutated = true;
+            return { ...tool, parameters: sanitizeToolParameters(tool.parameters) };
+        }
+        return tool;
+    });
+    if (!mutated)
+        return payload;
+    return { ...payloadObject, tools: sanitizedTools };
+}
+//# sourceMappingURL=copilot-gemini-payload-sanitizer.js.map

package/dist/core/copilot-gemini-payload-sanitizer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"copilot-gemini-payload-sanitizer.js","sourceRoot":"","sources":["../../src/core/copilot-gemini-payload-sanitizer.ts"],"names":[],"mappings":"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","sourcesContent":["import type { Api, Model } from \"@earendil-works/pi-ai\";\n\n/**\n * Sanitizes outbound OpenAI-compatible request payloads for GitHub Copilot\n * Gemini models so their tool/function JSON Schemas survive translation to\n * Google's GenAI `FunctionDeclaration` schema.\n *\n * Why this exists\n * ---------------\n * `github-copilot` Gemini models (e.g. `gemini-3.1-pro-preview`) are served\n * through Copilot's CAPI gateway at `api.*.githubcopilot.com` using the\n * `openai-completions` API. CAPI receives the OpenAI chat-completions request\n * and translates it into a Google GenAI `GenerateContent` request. During that\n * translation CAPI forwards JSON Schema `anyOf`/`oneOf` verbatim into the Gemini\n * `FunctionDeclaration` schema. Gemini's function-declaration schema rejects an\n * `anyOf`/`oneOf` whose branch is a complex *object* schema, so Google returns\n * HTTP 400 and CAPI relabels it `{\"error\":{\"code\":\"invalid_request_body\"}}`.\n *\n * Atomic's bundled tools (notably the `workflow` tool) use the TypeBox\n * `Type.Union([Type.Object(...), Type.String()])` pattern for fields like\n * `task`, `chain`, and `parallel`, which emit exactly that construct. Because\n * those tools are present in normal chat turns, every Gemini request fails with\n * `400 invalid request body` until the schema is sanitized.\n *\n * What it does\n * ------------\n * Recursively rewrites each tool's `parameters` JSON Schema into the reduced\n * subset that CAPI/Gemini actually honors (`type`, `description`, `enum`,\n * `properties`, `required`, `items`, `nullable`, and scalar-only `anyOf`):\n *  - Resolves `anyOf`/`oneOf` that contain an object/array branch to the most\n *    expressive object/array branch (the core fix), preserving `description`\n *    and collapsing a `\"null\"` branch into `nullable: true`.\n *  - Converts `const` (and `anyOf` of `const`/`enum` scalars) into `enum`,\n *    which Gemini supports, so `Type.Literal(...)` unions keep their constraint.\n *  - Drops JSON Schema keywords CAPI strips or Gemini rejects (`$schema`,\n *    `$ref`, `$defs`, `patternProperties`, `additionalProperties`, `allOf`,\n *    `not`, `format`, `pattern`, numeric/length bounds, `default`, etc.).\n *  - Filters `required` down to keys still present under `properties`.\n *\n * The transform is gated to GitHub Copilot Gemini models only, so it never\n * changes payloads for any currently-working provider/model.\n */\n\ntype JsonObject = { [key: string]: JsonValue };\ntype JsonValue = string | number | boolean | null | JsonValue[] | JsonObject;\n\n/** JSON Schema keywords Gemini's function-declaration schema honors. */\nconst KEPT_SCHEMA_KEYWORDS = new Set<string>([\n  \"type\",\n  \"description\",\n  \"enum\",\n  \"properties\",\n  \"required\",\n  \"items\",\n  \"nullable\",\n]);\n\n/**\n * Keywords that are dropped because CAPI strips them before Google and/or\n * Gemini's function schema rejects them. Listing them explicitly keeps the\n * intent auditable; any keyword not in {@link KEPT_SCHEMA_KEYWORDS} and not a\n * union keyword is dropped regardless. Exported so the documented drop-list has\n * a real consumer (and stays linted) without a per-iteration `void` reference.\n */\nexport const DROPPED_SCHEMA_KEYWORDS = new Set<string>([\n  \"$schema\",\n  \"$id\",\n  \"$ref\",\n  \"$defs\",\n  \"$comment\",\n  \"definitions\",\n  \"patternProperties\",\n  \"propertyNames\",\n  \"unevaluatedProperties\",\n  \"additionalProperties\",\n  \"additionalItems\",\n  \"unevaluatedItems\",\n  \"allOf\",\n  \"not\",\n  \"if\",\n  \"then\",\n  \"else\",\n  \"format\",\n  \"pattern\",\n  \"minLength\",\n  \"maxLength\",\n  \"minItems\",\n  \"maxItems\",\n  \"uniqueItems\",\n  \"minimum\",\n  \"maximum\",\n  \"exclusiveMinimum\",\n  \"exclusiveMaximum\",\n  \"multipleOf\",\n  \"minProperties\",\n  \"maxProperties\",\n  \"default\",\n  \"examples\",\n  \"title\",\n  \"readOnly\",\n  \"writeOnly\",\n  \"deprecated\",\n  \"contentEncoding\",\n  \"contentMediaType\",\n]);\n\nfunction isPlainObject(value: JsonValue | undefined): value is JsonObject {\n  return typeof value === \"object\" && value !== null && !Array.isArray(value);\n}\n\n/**\n * Whether this model is a GitHub Copilot Gemini model routed through the\n * OpenAI-completions CAPI path that needs schema sanitization.\n */\nexport function isCopilotGeminiModel(model: Pick<Model<Api>, \"provider\" | \"api\" | \"id\">): boolean {\n  return (\n    model.provider === \"github-copilot\" &&\n    model.api === \"openai-completions\" &&\n    /(^|[/-])gemini/i.test(model.id)\n  );\n}\n\nfunction jsonScalarType(value: JsonValue): string | undefined {\n  switch (typeof value) {\n    case \"string\":\n      return \"string\";\n    case \"boolean\":\n      return \"boolean\";\n    case \"number\":\n      return Number.isInteger(value) ? \"integer\" : \"number\";\n    default:\n      return value === null ? \"null\" : undefined;\n  }\n}\n\nfunction isObjectOrArraySchema(schema: JsonValue): boolean {\n  if (!isPlainObject(schema)) return false;\n  return (\n    schema.type === \"object\" ||\n    schema.type === \"array\" ||\n    \"properties\" in schema ||\n    \"items\" in schema\n  );\n}\n\nfunction isNullSchema(schema: JsonValue): boolean {\n  return isPlainObject(schema) && schema.type === \"null\";\n}\n\n/** Collect literal values from a scalar branch expressed as `const` or `enum`. */\nfunction literalValues(schema: JsonValue): JsonValue[] | undefined {\n  if (!isPlainObject(schema)) return undefined;\n  if (\"const\" in schema) return [schema.const as JsonValue];\n  if (Array.isArray(schema.enum)) return schema.enum as JsonValue[];\n  return undefined;\n}\n\n/**\n * Recursively rewrite a JSON Schema node into the Gemini-compatible subset.\n */\nexport function sanitizeGeminiSchema(schema: JsonValue): JsonValue {\n  if (Array.isArray(schema)) {\n    return schema.map((entry) => sanitizeGeminiSchema(entry));\n  }\n  if (!isPlainObject(schema)) {\n    return schema;\n  }\n\n  const union = (schema.anyOf ?? schema.oneOf) as JsonValue | undefined;\n  if (Array.isArray(union)) {\n    return sanitizeUnion(schema, union);\n  }\n\n  const result: JsonObject = {};\n\n  // const -> enum (Gemini supports enum, not const).\n  if (\"const\" in schema && !(\"enum\" in schema)) {\n    const constValue = schema.const as JsonValue;\n    const inferred = jsonScalarType(constValue);\n    if (inferred && inferred !== \"null\") result.type = inferred;\n    result.enum = [constValue];\n  }\n\n  for (const [key, value] of Object.entries(schema)) {\n    if (key === \"const\") continue;\n    if (key === \"properties\" && isPlainObject(value)) {\n      const props: JsonObject = {};\n      for (const [propName, propSchema] of Object.entries(value)) {\n        props[propName] = sanitizeGeminiSchema(propSchema);\n      }\n      result.properties = props;\n      continue;\n    }\n    if (key === \"items\") {\n      result.items = sanitizeItems(value);\n      continue;\n    }\n    if (KEPT_SCHEMA_KEYWORDS.has(key)) {\n      result[key] = value;\n      continue;\n    }\n    // Everything else (the documented DROPPED_SCHEMA_KEYWORDS plus any unknown\n    // keyword) is omitted: the rule is simply \"keep only KEPT_SCHEMA_KEYWORDS\".\n  }\n\n  inferContainerType(result);\n  pruneRequired(result);\n  return result;\n}\n\n/**\n * Resolve an `items` schema. Gemini's function-declaration schema expects a\n * single `items` schema, so a tuple-form `items` (array of schemas) is collapsed\n * to its most expressive (object/array) entry, falling back to the first entry.\n */\nfunction sanitizeItems(items: JsonValue): JsonValue {\n  if (!Array.isArray(items)) return sanitizeGeminiSchema(items);\n  const sanitized = items.map((entry) => sanitizeGeminiSchema(entry));\n  const objectOrArray = sanitized.find((entry) => isObjectOrArraySchema(entry));\n  return objectOrArray ?? sanitized[0] ?? { type: \"string\" };\n}\n\n/**\n * Gemini resolves function arguments more reliably when container nodes carry an\n * explicit `type`. Infer it when omitted: a node with `properties`/`required` is\n * an object, and a node with `items` is an array.\n */\nfunction inferContainerType(schema: JsonObject): void {\n  if (schema.type !== undefined) return;\n  if (isPlainObject(schema.properties) || Array.isArray(schema.required)) {\n    schema.type = \"object\";\n  } else if (schema.items !== undefined) {\n    schema.type = \"array\";\n  }\n}\n\n/** Resolve an `anyOf`/`oneOf` union node into the Gemini-compatible subset. */\nfunction sanitizeUnion(parent: JsonObject, branches: JsonValue[]): JsonValue {\n  const sanitizedBranches = branches.map((branch) => sanitizeGeminiSchema(branch));\n  const nullable =\n    branches.some((branch) => isNullSchema(branch)) || parent.nullable === true;\n  const nonNull = sanitizedBranches.filter((branch) => !isNullSchema(branch));\n\n  const carryDescription = (target: JsonValue): JsonValue => {\n    if (isPlainObject(target) && typeof parent.description === \"string\" && !(\"description\" in target)) {\n      target.description = parent.description;\n    }\n    if (nullable && isPlainObject(target)) target.nullable = true;\n    return target;\n  };\n\n  // Core fix: if any branch is an object/array schema, collapse to the first\n  // such branch (Gemini rejects unions whose branch is a complex object). For\n  // the TypeBox `Type.Union([Type.Object(...), Type.String()])` pattern this is\n  // the object branch; a union of two distinct object shapes keeps only the\n  // first, so the others' properties are intentionally dropped.\n  const objectOrArray = nonNull.find((branch) => isObjectOrArraySchema(branch));\n  if (objectOrArray) {\n    return carryDescription(objectOrArray);\n  }\n\n  if (nonNull.length === 0) {\n    return carryDescription({ type: \"string\" });\n  }\n  if (nonNull.length === 1) {\n    return carryDescription(nonNull[0]);\n  }\n\n  // All-scalar union: prefer an `enum` when every branch is a literal/enum of\n  // one underlying type; otherwise keep a scalar `anyOf` (Gemini accepts it).\n  const literals: JsonValue[] = [];\n  const scalarTypes = new Set<string>();\n  let allLiteral = true;\n  for (const branch of nonNull) {\n    const values = literalValues(branch);\n    if (!values) {\n      allLiteral = false;\n      break;\n    }\n    for (const value of values) {\n      literals.push(value);\n      const inferred = jsonScalarType(value);\n      if (inferred) scalarTypes.add(inferred);\n    }\n  }\n  if (allLiteral && literals.length > 0) {\n    const collapsed: JsonObject = { enum: literals };\n    if (scalarTypes.size === 1) collapsed.type = [...scalarTypes][0];\n    return carryDescription(collapsed);\n  }\n\n  const node: JsonObject = { anyOf: nonNull };\n  return carryDescription(node);\n}\n\n/** Drop `required` entries that are not present under `properties`. */\nfunction pruneRequired(schema: JsonObject): void {\n  if (!Array.isArray(schema.required)) return;\n  const properties = isPlainObject(schema.properties) ? schema.properties : undefined;\n  if (!properties) {\n    delete schema.required;\n    return;\n  }\n  const filtered = schema.required.filter(\n    (key): key is string => typeof key === \"string\" && key in properties,\n  );\n  if (filtered.length > 0) schema.required = filtered;\n  else delete schema.required;\n}\n\n/** Sanitize a single tool's `parameters` schema in place-safe (returns new value). */\nfunction sanitizeToolParameters(parameters: JsonValue): JsonValue {\n  return sanitizeGeminiSchema(parameters);\n}\n\n/**\n * Sanitize an outbound provider payload for GitHub Copilot Gemini models.\n *\n * Returns the payload unchanged for any other provider/model, or when the\n * payload has no sanitizable `tools`. Mirrors the `onPayload`\n * `(payload: unknown) => unknown` contract used elsewhere in the SDK wiring.\n */\nexport function sanitizeCopilotGeminiPayload(\n  payload: unknown,\n  model: Pick<Model<Api>, \"provider\" | \"api\" | \"id\">,\n): unknown {\n  if (!isCopilotGeminiModel(model)) return payload;\n  if (!isPlainObject(payload as JsonValue)) return payload;\n  const payloadObject = payload as JsonObject;\n  const tools = payloadObject.tools;\n  if (!Array.isArray(tools) || tools.length === 0) return payload;\n\n  let mutated = false;\n  const sanitizedTools = tools.map((tool) => {\n    if (!isPlainObject(tool)) return tool;\n    // OpenAI chat-completions tool shape: { type: \"function\", function: { parameters } }\n    if (isPlainObject(tool.function) && tool.function.parameters !== undefined) {\n      mutated = true;\n      return {\n        ...tool,\n        function: {\n          ...tool.function,\n          parameters: sanitizeToolParameters(tool.function.parameters),\n        },\n      };\n    }\n    // Defensive: flat tool shape { name, parameters }.\n    if (tool.parameters !== undefined) {\n      mutated = true;\n      return { ...tool, parameters: sanitizeToolParameters(tool.parameters) };\n    }\n    return tool;\n  });\n\n  if (!mutated) return payload;\n  return { ...payloadObject, tools: sanitizedTools };\n}\n"]}

package/dist/core/copilot-gemini-reasoning.d.ts

@@ -0,0 +1,118 @@
+import type { Api, Model } from "@earendil-works/pi-ai";
+/**
+ * Round-trips GitHub Copilot Gemini "thought signatures" so multi-turn tool use
+ * does not silently die after the first tool call.
+ *
+ * Why this exists
+ * ---------------
+ * `github-copilot` Gemini models (e.g. `gemini-3.1-pro-preview`) are served
+ * through Copilot's CAPI gateway, which proxies to Google's GenAI API. Gemini
+ * is a thinking model: when it emits a function/tool call it also returns an
+ * opaque **thought signature** that must be sent back, verbatim, on the next
+ * request or Gemini refuses to continue the reasoning chain.
+ *
+ * CAPI carries that signature in a non-standard OpenAI-completions field named
+ * **`reasoning_opaque`** (an encrypted blob) on the assistant message / streamed
+ * delta, and on replay it reads the same `reasoning_opaque` back off the
+ * assistant message and re-attaches the signature to each Gemini function-call
+ * part (keyed by `tool_call.id`). The underlying OpenAI-completions client
+ * (`@earendil-works/pi-ai`) does not understand `reasoning_opaque`; it captures
+ * thought signatures only from the OpenRouter-style
+ * `reasoning_details: [{ type: "reasoning.encrypted", id, data }]` shape, which
+ * CAPI never emits. So the real Gemini thought signature was being dropped on
+ * the way in and never replayed on the way out.
+ *
+ * With the signature missing, CAPI substitutes the sentinel
+ * `skip_thought_signature_validator` on the first replayed function call, and
+ * Gemini responds with an empty candidate / `finish_reason: "stop"` and zero
+ * output tokens — the harness sees a degenerate empty completion, retries with
+ * the same signature-less history, and eventually gives up: "Gemini just stops
+ * responding."
+ *
+ * What this does
+ * --------------
+ * Two gated, self-contained transforms bridge CAPI's `reasoning_opaque` to the
+ * `reasoning_details` mechanism the client already round-trips:
+ *
+ *  - **Inbound** ({@link rewriteCopilotGeminiSseData} via
+ *    {@link createCopilotGeminiSseStream}): rewrites the CAPI Gemini SSE
+ *    stream so each streamed delta that carries both `reasoning_opaque` and a
+ *    `tool_calls[].id` gains a
+ *    `reasoning_details: [{ type: "reasoning.encrypted", id, data: <opaque> }]`
+ *    entry. The client then stores it as the tool call's `thoughtSignature`.
+ *    CAPI confirms `reasoning_opaque` rides on the same streamed delta as the
+ *    first (id-bearing) tool-call chunk, so the association is exact.
+ *  - **Outbound** ({@link restoreCopilotGeminiReasoningOpaque} from the
+ *    `onPayload` hook): converts the `reasoning_details` the client re-emits on
+ *    replayed assistant messages back into a single `reasoning_opaque` field on
+ *    that assistant message, which is the only shape CAPI reads.
+ *
+ * Both transforms are gated to GitHub Copilot Gemini and are no-ops for every
+ * other provider/model (and for Gemini turns that carry no thought signature).
+ */
+type JsonObject = {
+    [key: string]: JsonValue;
+};
+type JsonValue = string | number | boolean | null | JsonValue[] | JsonObject;
+/**
+ * Inject `reasoning_details` into a parsed CAPI Gemini streaming chunk so the
+ * pi-ai OpenAI-completions parser captures the Gemini thought signature.
+ *
+ * For each `choices[].delta` that carries a non-empty `reasoning_opaque` string
+ * and a `tool_calls[]` entry with an `id`, adds a single
+ * `reasoning_details: [{ type: "reasoning.encrypted", id, data: <opaque> }]`
+ * entry keyed by that tool-call id. Returns whether the chunk was mutated.
+ *
+ * No-op when the delta already has `reasoning_details`, has no id-bearing tool
+ * call (e.g. argument-continuation deltas or pure-text thought chunks), or has
+ * no `reasoning_opaque`.
+ */
+export declare function injectCopilotGeminiReasoningDetails(chunk: JsonValue): boolean;
+/**
+ * Rewrite the JSON payload of a single SSE `data:` line. Returns the original
+ * string unchanged when it is not a Gemini chunk that needs a thought signature
+ * bridged, or when parsing fails (fail-open: never corrupt the stream).
+ */
+export declare function rewriteCopilotGeminiSseData(dataPayload: string): string;
+/**
+ * Wrap a CAPI Gemini SSE byte stream so `reasoning_opaque` is bridged into
+ * `reasoning_details`. Buffers across chunk boundaries and rewrites whole lines
+ * only; bytes that are not affected pass through unchanged.
+ *
+ * Implemented as a `ReadableStream` over the source reader (rather than a
+ * `TransformStream` piped via `pipeThrough`) so the transform pulls lazily and
+ * propagates cancellation to the upstream body.
+ */
+export declare function createCopilotGeminiSseStream(source: ReadableStream<Uint8Array>): ReadableStream<Uint8Array>;
+/**
+ * Convert the `reasoning_details` the pi-ai client re-emits on replayed
+ * assistant messages back into the single `reasoning_opaque` field CAPI reads.
+ *
+ * For GitHub Copilot Gemini payloads, each assistant message that carries a
+ * `reasoning_details` entry of `type: "reasoning.encrypted"` has its `data`
+ * (the original CAPI thought-signature blob) promoted to `reasoning_opaque`,
+ * and the now-redundant `reasoning_details` removed. No-op for every other
+ * provider/model and for payloads without such messages.
+ */
+export declare function restoreCopilotGeminiReasoningOpaque(payload: unknown, model: Pick<Model<Api>, "provider" | "api" | "id">): unknown;
+/**
+ * Rewrite a streaming CAPI Gemini response so its SSE body bridges
+ * `reasoning_opaque` into `reasoning_details`. Returns the original response
+ * untouched for non-Copilot hosts, non-event-stream responses, or bodyless
+ * responses, keeping the blast radius to streaming CAPI Gemini turns only.
+ */
+export declare function maybeRewriteCopilotGeminiResponse(url: string | undefined, response: Response): Response;
+/**
+ * Install a `globalThis.fetch` wrapper that rewrites CAPI Gemini SSE responses
+ * to bridge `reasoning_opaque` into `reasoning_details` (see
+ * {@link createCopilotGeminiSseStream}). Idempotent.
+ *
+ * The OpenAI SDK used by the `openai-completions` provider resolves
+ * `globalThis.fetch` at client-construction time, and a new client is built per
+ * request, so wrapping the global before the first request is reliably picked
+ * up. Non-Copilot hosts and non-event-stream responses are returned untouched,
+ * keeping the blast radius to streaming CAPI Gemini turns only.
+ */
+export declare function installCopilotGeminiReasoningInterceptor(): void;
+export {};
+//# sourceMappingURL=copilot-gemini-reasoning.d.ts.map

package/dist/core/copilot-gemini-reasoning.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"copilot-gemini-reasoning.d.ts","sourceRoot":"","sources":["../../src/core/copilot-gemini-reasoning.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,GAAG,EAAE,KAAK,EAAE,MAAM,uBAAuB,CAAC;AAGxD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkDG;AAEH,KAAK,UAAU,GAAG;IAAE,CAAC,GAAG,EAAE,MAAM,GAAG,SAAS,CAAA;CAAE,CAAC;AAC/C,KAAK,SAAS,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,IAAI,GAAG,SAAS,EAAE,GAAG,UAAU,CAAC;AAS7E;;;;;;;;;;;;GAYG;AACH,wBAAgB,mCAAmC,CAAC,KAAK,EAAE,SAAS,GAAG,OAAO,CAiC7E;AAED;;;;GAIG;AACH,wBAAgB,2BAA2B,CAAC,WAAW,EAAE,MAAM,GAAG,MAAM,CAWvE;AAeD;;;;;;;;GAQG;AACH,wBAAgB,4BAA4B,CAC1C,MAAM,EAAE,cAAc,CAAC,UAAU,CAAC,GACjC,cAAc,CAAC,UAAU,CAAC,CAyC5B;AAED;;;;;;;;;GASG;AACH,wBAAgB,mCAAmC,CACjD,OAAO,EAAE,OAAO,EAChB,KAAK,EAAE,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,EAAE,UAAU,GAAG,KAAK,GAAG,IAAI,CAAC,GACjD,OAAO,CA2BT;AAyBD;;;;;GAKG;AACH,wBAAgB,iCAAiC,CAC/C,GAAG,EAAE,MAAM,GAAG,SAAS,EACvB,QAAQ,EAAE,QAAQ,GACjB,QAAQ,CAWV;AAID;;;;;;;;;;GAUG;AACH,wBAAgB,wCAAwC,IAAI,IAAI,CAuB/D","sourcesContent":["import type { Api, Model } from \"@earendil-works/pi-ai\";\nimport { isCopilotGeminiModel } from \"./copilot-gemini-payload-sanitizer.ts\";\n\n/**\n * Round-trips GitHub Copilot Gemini \"thought signatures\" so multi-turn tool use\n * does not silently die after the first tool call.\n *\n * Why this exists\n * ---------------\n * `github-copilot` Gemini models (e.g. `gemini-3.1-pro-preview`) are served\n * through Copilot's CAPI gateway, which proxies to Google's GenAI API. Gemini\n * is a thinking model: when it emits a function/tool call it also returns an\n * opaque **thought signature** that must be sent back, verbatim, on the next\n * request or Gemini refuses to continue the reasoning chain.\n *\n * CAPI carries that signature in a non-standard OpenAI-completions field named\n * **`reasoning_opaque`** (an encrypted blob) on the assistant message / streamed\n * delta, and on replay it reads the same `reasoning_opaque` back off the\n * assistant message and re-attaches the signature to each Gemini function-call\n * part (keyed by `tool_call.id`). The underlying OpenAI-completions client\n * (`@earendil-works/pi-ai`) does not understand `reasoning_opaque`; it captures\n * thought signatures only from the OpenRouter-style\n * `reasoning_details: [{ type: \"reasoning.encrypted\", id, data }]` shape, which\n * CAPI never emits. So the real Gemini thought signature was being dropped on\n * the way in and never replayed on the way out.\n *\n * With the signature missing, CAPI substitutes the sentinel\n * `skip_thought_signature_validator` on the first replayed function call, and\n * Gemini responds with an empty candidate / `finish_reason: \"stop\"` and zero\n * output tokens — the harness sees a degenerate empty completion, retries with\n * the same signature-less history, and eventually gives up: \"Gemini just stops\n * responding.\"\n *\n * What this does\n * --------------\n * Two gated, self-contained transforms bridge CAPI's `reasoning_opaque` to the\n * `reasoning_details` mechanism the client already round-trips:\n *\n *  - **Inbound** ({@link rewriteCopilotGeminiSseData} via\n *    {@link createCopilotGeminiSseStream}): rewrites the CAPI Gemini SSE\n *    stream so each streamed delta that carries both `reasoning_opaque` and a\n *    `tool_calls[].id` gains a\n *    `reasoning_details: [{ type: \"reasoning.encrypted\", id, data: <opaque> }]`\n *    entry. The client then stores it as the tool call's `thoughtSignature`.\n *    CAPI confirms `reasoning_opaque` rides on the same streamed delta as the\n *    first (id-bearing) tool-call chunk, so the association is exact.\n *  - **Outbound** ({@link restoreCopilotGeminiReasoningOpaque} from the\n *    `onPayload` hook): converts the `reasoning_details` the client re-emits on\n *    replayed assistant messages back into a single `reasoning_opaque` field on\n *    that assistant message, which is the only shape CAPI reads.\n *\n * Both transforms are gated to GitHub Copilot Gemini and are no-ops for every\n * other provider/model (and for Gemini turns that carry no thought signature).\n */\n\ntype JsonObject = { [key: string]: JsonValue };\ntype JsonValue = string | number | boolean | null | JsonValue[] | JsonObject;\n\n/** OpenRouter-style encrypted reasoning detail the pi-ai client round-trips. */\nconst REASONING_ENCRYPTED_TYPE = \"reasoning.encrypted\";\n\nfunction isPlainObject(value: unknown): value is JsonObject {\n  return typeof value === \"object\" && value !== null && !Array.isArray(value);\n}\n\n/**\n * Inject `reasoning_details` into a parsed CAPI Gemini streaming chunk so the\n * pi-ai OpenAI-completions parser captures the Gemini thought signature.\n *\n * For each `choices[].delta` that carries a non-empty `reasoning_opaque` string\n * and a `tool_calls[]` entry with an `id`, adds a single\n * `reasoning_details: [{ type: \"reasoning.encrypted\", id, data: <opaque> }]`\n * entry keyed by that tool-call id. Returns whether the chunk was mutated.\n *\n * No-op when the delta already has `reasoning_details`, has no id-bearing tool\n * call (e.g. argument-continuation deltas or pure-text thought chunks), or has\n * no `reasoning_opaque`.\n */\nexport function injectCopilotGeminiReasoningDetails(chunk: JsonValue): boolean {\n  if (!isPlainObject(chunk)) return false;\n  const choices = chunk.choices;\n  if (!Array.isArray(choices)) return false;\n\n  let mutated = false;\n  for (const choice of choices) {\n    if (!isPlainObject(choice)) continue;\n    const delta = choice.delta;\n    if (!isPlainObject(delta)) continue;\n\n    const opaque = delta.reasoning_opaque;\n    if (typeof opaque !== \"string\" || opaque.length === 0) continue;\n\n    // Already carries the encrypted detail (don't double-inject / clobber).\n    if (Array.isArray(delta.reasoning_details) && delta.reasoning_details.length > 0) {\n      continue;\n    }\n\n    const toolCalls = delta.tool_calls;\n    if (!Array.isArray(toolCalls)) continue;\n    const idBearing = toolCalls.find(\n      (call): call is JsonObject =>\n        isPlainObject(call) && typeof call.id === \"string\" && call.id.length > 0,\n    );\n    if (!idBearing) continue;\n\n    delta.reasoning_details = [\n      { type: REASONING_ENCRYPTED_TYPE, id: idBearing.id as string, data: opaque },\n    ];\n    mutated = true;\n  }\n  return mutated;\n}\n\n/**\n * Rewrite the JSON payload of a single SSE `data:` line. Returns the original\n * string unchanged when it is not a Gemini chunk that needs a thought signature\n * bridged, or when parsing fails (fail-open: never corrupt the stream).\n */\nexport function rewriteCopilotGeminiSseData(dataPayload: string): string {\n  // Cheap gate: only chunks that actually carry a thought signature are touched.\n  if (!dataPayload.includes(\"reasoning_opaque\")) return dataPayload;\n  let parsed: JsonValue;\n  try {\n    parsed = JSON.parse(dataPayload) as JsonValue;\n  } catch {\n    return dataPayload;\n  }\n  if (!injectCopilotGeminiReasoningDetails(parsed)) return dataPayload;\n  return JSON.stringify(parsed);\n}\n\n/** Rewrite one SSE line, preserving a trailing carriage return when present. */\nfunction rewriteSseLine(line: string): string {\n  const hasCr = line.endsWith(\"\\r\");\n  const core = hasCr ? line.slice(0, -1) : line;\n  if (!core.startsWith(\"data:\")) return line;\n  const payload = core.slice(\"data:\".length).trimStart();\n  if (payload.length === 0 || payload === \"[DONE]\") return line;\n  const rewritten = rewriteCopilotGeminiSseData(payload);\n  if (rewritten === payload) return line;\n  const rebuilt = `data: ${rewritten}`;\n  return hasCr ? `${rebuilt}\\r` : rebuilt;\n}\n\n/**\n * Wrap a CAPI Gemini SSE byte stream so `reasoning_opaque` is bridged into\n * `reasoning_details`. Buffers across chunk boundaries and rewrites whole lines\n * only; bytes that are not affected pass through unchanged.\n *\n * Implemented as a `ReadableStream` over the source reader (rather than a\n * `TransformStream` piped via `pipeThrough`) so the transform pulls lazily and\n * propagates cancellation to the upstream body.\n */\nexport function createCopilotGeminiSseStream(\n  source: ReadableStream<Uint8Array>,\n): ReadableStream<Uint8Array> {\n  const reader = source.getReader();\n  const decoder = new TextDecoder();\n  const encoder = new TextEncoder();\n  let buffer = \"\";\n\n  return new ReadableStream<Uint8Array>({\n    async pull(controller) {\n      // Loop until we emit at least one chunk or close, so a read that yields no\n      // complete line still makes progress without relying on the runtime to\n      // re-invoke pull after a no-enqueue return.\n      for (;;) {\n        const { done, value } = await reader.read();\n        if (done) {\n          buffer += decoder.decode();\n          if (buffer.length > 0) {\n            controller.enqueue(encoder.encode(rewriteSseLine(buffer)));\n            buffer = \"\";\n          }\n          controller.close();\n          return;\n        }\n        buffer += decoder.decode(value, { stream: true });\n        let newlineIndex = buffer.indexOf(\"\\n\");\n        let out = \"\";\n        while (newlineIndex !== -1) {\n          const line = buffer.slice(0, newlineIndex);\n          buffer = buffer.slice(newlineIndex + 1);\n          out += `${rewriteSseLine(line)}\\n`;\n          newlineIndex = buffer.indexOf(\"\\n\");\n        }\n        if (out.length > 0) {\n          controller.enqueue(encoder.encode(out));\n          return;\n        }\n      }\n    },\n    cancel(reason) {\n      return reader.cancel(reason);\n    },\n  });\n}\n\n/**\n * Convert the `reasoning_details` the pi-ai client re-emits on replayed\n * assistant messages back into the single `reasoning_opaque` field CAPI reads.\n *\n * For GitHub Copilot Gemini payloads, each assistant message that carries a\n * `reasoning_details` entry of `type: \"reasoning.encrypted\"` has its `data`\n * (the original CAPI thought-signature blob) promoted to `reasoning_opaque`,\n * and the now-redundant `reasoning_details` removed. No-op for every other\n * provider/model and for payloads without such messages.\n */\nexport function restoreCopilotGeminiReasoningOpaque(\n  payload: unknown,\n  model: Pick<Model<Api>, \"provider\" | \"api\" | \"id\">,\n): unknown {\n  if (!isCopilotGeminiModel(model)) return payload;\n  if (!isPlainObject(payload as JsonValue)) return payload;\n  const payloadObject = payload as JsonObject;\n  const messages = payloadObject.messages;\n  if (!Array.isArray(messages)) return payload;\n\n  let mutated = false;\n  const nextMessages = messages.map((message) => {\n    if (!isPlainObject(message) || message.role !== \"assistant\") return message;\n    const details = message.reasoning_details;\n    if (!Array.isArray(details) || details.length === 0) return message;\n    const encrypted = details.find(\n      (detail): detail is JsonObject =>\n        isPlainObject(detail) &&\n        detail.type === REASONING_ENCRYPTED_TYPE &&\n        typeof detail.data === \"string\" &&\n        detail.data.length > 0,\n    );\n    if (!encrypted) return message;\n    mutated = true;\n    const { reasoning_details: _omitted, ...rest } = message;\n    return { ...rest, reasoning_opaque: encrypted.data as string };\n  });\n\n  if (!mutated) return payload;\n  return { ...payloadObject, messages: nextMessages };\n}\n\n/** Whether the URL targets Copilot's CAPI gateway (`*.githubcopilot.com`). */\nfunction isCopilotApiHost(url: string): boolean {\n  try {\n    const host = new URL(url).hostname.toLowerCase();\n    // Exact host or a real subdomain only — never a look-alike suffix such as\n    // `notgithubcopilot.com` (CodeQL: incomplete URL substring sanitization).\n    return host === \"githubcopilot.com\" || host.endsWith(\".githubcopilot.com\");\n  } catch {\n    return false;\n  }\n}\n\n/** Resolve the request URL string from a `fetch` input argument. */\nfunction resolveRequestUrl(input: Parameters<typeof fetch>[0]): string | undefined {\n  if (typeof input === \"string\") return input;\n  if (input instanceof URL) return input.href;\n  if (typeof input === \"object\" && input !== null && \"url\" in input) {\n    const url = (input as { url?: unknown }).url;\n    if (typeof url === \"string\") return url;\n  }\n  return undefined;\n}\n\n/**\n * Rewrite a streaming CAPI Gemini response so its SSE body bridges\n * `reasoning_opaque` into `reasoning_details`. Returns the original response\n * untouched for non-Copilot hosts, non-event-stream responses, or bodyless\n * responses, keeping the blast radius to streaming CAPI Gemini turns only.\n */\nexport function maybeRewriteCopilotGeminiResponse(\n  url: string | undefined,\n  response: Response,\n): Response {\n  if (!url || !isCopilotApiHost(url)) return response;\n  const contentType = response.headers.get(\"content-type\") ?? \"\";\n  if (!contentType.includes(\"text/event-stream\")) return response;\n  if (!response.body) return response;\n  const transformed = createCopilotGeminiSseStream(response.body);\n  return new Response(transformed, {\n    status: response.status,\n    statusText: response.statusText,\n    headers: response.headers,\n  });\n}\n\nlet originalFetch: typeof fetch | undefined;\n\n/**\n * Install a `globalThis.fetch` wrapper that rewrites CAPI Gemini SSE responses\n * to bridge `reasoning_opaque` into `reasoning_details` (see\n * {@link createCopilotGeminiSseStream}). Idempotent.\n *\n * The OpenAI SDK used by the `openai-completions` provider resolves\n * `globalThis.fetch` at client-construction time, and a new client is built per\n * request, so wrapping the global before the first request is reliably picked\n * up. Non-Copilot hosts and non-event-stream responses are returned untouched,\n * keeping the blast radius to streaming CAPI Gemini turns only.\n */\nexport function installCopilotGeminiReasoningInterceptor(): void {\n  if (originalFetch) return;\n  if (typeof globalThis.fetch !== \"function\") return;\n  const base = globalThis.fetch;\n  originalFetch = base;\n  const boundFetch = base.bind(globalThis);\n\n  const wrapped = (async (input, init) => {\n    const response = await boundFetch(input, init);\n    try {\n      return maybeRewriteCopilotGeminiResponse(resolveRequestUrl(input), response);\n    } catch {\n      return response;\n    }\n  }) as typeof fetch;\n\n  // Preserve `fetch.preconnect` so the wrapper remains a drop-in replacement.\n  const preconnect = (base as { preconnect?: unknown }).preconnect;\n  if (typeof preconnect === \"function\") {\n    (wrapped as { preconnect?: unknown }).preconnect = preconnect.bind(globalThis);\n  }\n\n  globalThis.fetch = wrapped;\n}\n"]}