@cognipeer/agent-sdk 0.10.3 → 0.10.5

package/dist/index.mjs

@@ -503,7 +503,7 @@ function getModelCapabilities(model) {
     return {
       provider,
       structuredOutput: supportsNativeStructuredOutput(provider) ? "native" : "tool_based",
-      strictToolCalling: requiresStrictToolCalling(provider),
+      strictToolCalling: requiresStrictToolCalling(provider) && isOpenAIHostedEndpoint(model._lc),
       streaming: true
     };
   }
@@ -546,6 +546,17 @@ function supportsNativeStructuredOutput(provider) {
 function requiresStrictToolCalling(provider) {
   return ["openai"].includes(provider);
 }
+function isOpenAIHostedEndpoint(lcModel) {
+  if (!lcModel) return true;
+  const baseURL = lcModel.clientConfig?.baseURL ?? lcModel.configuration?.baseURL ?? lcModel.baseURL;
+  if (typeof baseURL !== "string" || baseURL.trim() === "") return true;
+  try {
+    const host = new URL(baseURL).hostname.toLowerCase();
+    return host === "api.openai.com" || host.endsWith(".openai.azure.com") || host.endsWith(".cognitiveservices.azure.com");
+  } catch {
+    return false;
+  }
+}
 
 // src/model.ts
 function isSmartModel(m) {
@@ -2510,13 +2521,19 @@ function resolveCapabilities(provider) {
   switch (provider) {
     case "openai":
     case "azure":
-    case "openai-compatible":
       return {
         structuredOutput: "native",
         strictToolCalling: true,
         streaming: true,
         provider
       };
+    case "openai-compatible":
+      return {
+        structuredOutput: "native",
+        strictToolCalling: false,
+        streaming: true,
+        provider
+      };
     case "anthropic":
       return {
         structuredOutput: "tool_based",
@@ -3845,6 +3862,187 @@ Identical to an earlier ${duplicate.toolName} result. Use get_tool_response with
   }
   return notApplied4(output);
 }
+var identity = (value) => value;
+function describeLike(schema, source, suffix) {
+  const description = [source.description, suffix].filter(Boolean).join(" ");
+  return description ? schema.describe(description) : schema;
+}
+function jsonString(source) {
+  return {
+    schema: describeLike(z.string(), source, "(a JSON value, encoded as a string)"),
+    restore: (value) => {
+      if (typeof value !== "string") return value;
+      try {
+        return JSON.parse(value);
+      } catch {
+        return value;
+      }
+    }
+  };
+}
+function unwrapOptional(schema) {
+  const def = schema._def;
+  if (def?.typeName === "ZodOptional") return { inner: def.innerType, optional: true };
+  if (def?.typeName === "ZodDefault") return { inner: def.innerType, optional: true };
+  return { inner: schema, optional: false };
+}
+function isZodSchema2(schema) {
+  return Boolean(schema) && typeof schema.safeParse === "function" && Boolean(schema._def);
+}
+function toStrictCompatible(schema) {
+  const def = schema?._def;
+  switch (def?.typeName) {
+    case "ZodObject": {
+      const shape = typeof def.shape === "function" ? def.shape() : def.shape;
+      const keys = Object.keys(shape ?? {});
+      const open = def.unknownKeys === "passthrough" || def.catchall && def.catchall._def?.typeName !== "ZodNever";
+      if (keys.length === 0 && open) return jsonString(schema);
+      const nextShape = {};
+      const restores = {};
+      for (const key of keys) {
+        const field = shape[key];
+        const { inner, optional } = unwrapOptional(field);
+        const child = toStrictCompatible(inner);
+        const childSchema = describeLike(child.schema, field.description ? field : inner);
+        nextShape[key] = optional ? childSchema.nullable() : childSchema;
+        restores[key] = { restore: child.restore, optional };
+      }
+      return {
+        schema: describeLike(z.object(nextShape), schema),
+        restore: (value) => {
+          if (!value || typeof value !== "object" || Array.isArray(value)) return value;
+          const out = {};
+          for (const [key, raw] of Object.entries(value)) {
+            const entry = restores[key];
+            if (raw === null && entry?.optional) continue;
+            out[key] = entry ? entry.restore(raw) : raw;
+          }
+          return out;
+        }
+      };
+    }
+    case "ZodOptional":
+    case "ZodDefault": {
+      const child = toStrictCompatible(def.innerType);
+      return {
+        schema: describeLike(child.schema.nullable(), schema),
+        restore: (value) => value === null ? void 0 : child.restore(value)
+      };
+    }
+    case "ZodNullable": {
+      const child = toStrictCompatible(def.innerType);
+      return {
+        schema: describeLike(child.schema.nullable(), schema),
+        restore: (value) => value === null ? null : child.restore(value)
+      };
+    }
+    case "ZodArray": {
+      const child = toStrictCompatible(def.type);
+      return {
+        schema: describeLike(z.array(child.schema), schema),
+        restore: (value) => Array.isArray(value) ? value.map(child.restore) : value
+      };
+    }
+    case "ZodUnion":
+    case "ZodDiscriminatedUnion": {
+      const rawOptions = def.options instanceof Map ? [...def.options.values()] : def.options;
+      const options = rawOptions.map(toStrictCompatible);
+      if (options.length === 1) return options[0];
+      if (options.every((option, index) => option.schema === rawOptions[index])) {
+        return { schema, restore: identity };
+      }
+      return {
+        schema: describeLike(z.union(options.map((option) => option.schema)), schema),
+        restore: (value) => {
+          const candidates = options.map((option) => option.restore(value));
+          const index = candidates.findIndex((candidate, i) => rawOptions[i].safeParse(candidate).success);
+          return candidates[index >= 0 ? index : 0];
+        }
+      };
+    }
+    case "ZodEffects":
+      return toStrictCompatible(def.schema);
+    case "ZodRecord":
+    case "ZodAny":
+    case "ZodUnknown":
+      return jsonString(schema);
+    default:
+      return { schema, restore: identity };
+  }
+}
+function topLevelObject(transform) {
+  if (transform.schema._def?.typeName === "ZodObject") return transform;
+  return {
+    schema: z.object({
+      input: transform.schema.describe(
+        transform.schema.description ?? "The tool arguments as a JSON object, encoded as a string"
+      )
+    }),
+    restore: (value) => {
+      const input = value && typeof value === "object" ? value.input : void 0;
+      const restored = transform.restore(input);
+      return restored && typeof restored === "object" ? restored : {};
+    }
+  };
+}
+function toStrictToolSchema(schema) {
+  return topLevelObject(toStrictCompatible(schema));
+}
+function restoreToolCalls(message, restorers) {
+  if (!message || typeof message !== "object" || restorers.size === 0) return message;
+  const restoreList = (calls) => {
+    if (!Array.isArray(calls) || calls.length === 0) return calls;
+    return calls.map((call) => {
+      const fn = call?.function;
+      const name = call?.name ?? fn?.name;
+      const restore = name ? restorers.get(name) : void 0;
+      if (!restore) return call;
+      let next = call;
+      if (call.args && typeof call.args === "object") next = { ...next, args: restore(call.args) };
+      if (fn && typeof fn.arguments === "string") {
+        try {
+          next = { ...next, function: { ...fn, arguments: JSON.stringify(restore(JSON.parse(fn.arguments))) } };
+        } catch {
+        }
+      }
+      return next;
+    });
+  };
+  const m = message;
+  const hasDirect = Array.isArray(m.tool_calls) && m.tool_calls.length > 0;
+  const hasKwargs = Array.isArray(m.additional_kwargs?.tool_calls) && m.additional_kwargs.tool_calls.length > 0;
+  if (!hasDirect && !hasKwargs) return message;
+  return {
+    ...message,
+    ...hasDirect ? { tool_calls: restoreList(m.tool_calls) } : {},
+    ...hasKwargs ? { additional_kwargs: { ...m.additional_kwargs, tool_calls: restoreList(m.additional_kwargs.tool_calls) } } : {}
+  };
+}
+var strictViews = /* @__PURE__ */ new WeakMap();
+function prepareStrictToolMenu(tools) {
+  const restorers = /* @__PURE__ */ new Map();
+  const menu = tools.map((tool) => {
+    const t = tool;
+    if (!t || typeof t.name !== "string" || !isZodSchema2(t.schema)) return tool;
+    const cached = strictViews.get(tool);
+    if (cached && cached.schema === t.schema) {
+      restorers.set(t.name, cached.restore);
+      return cached.view;
+    }
+    try {
+      const transform = toStrictToolSchema(t.schema);
+      const view = Object.create(tool);
+      view.schema = transform.schema;
+      view.__lcTool = void 0;
+      strictViews.set(tool, { schema: t.schema, view, restore: transform.restore });
+      restorers.set(t.name, transform.restore);
+      return view;
+    } catch {
+      return tool;
+    }
+  });
+  return { menu, restorers };
+}
 
 // src/nodes/agentCore.ts
 function createAgentCoreNode(opts) {
@@ -3865,10 +4063,17 @@ function createAgentCoreNode(opts) {
     };
     let tools = runtime.tools ?? [];
     const shouldUseStrictToolCalling = Boolean(
-      runtime.responseFormat && runtime.model?.capabilities?.strictToolCalling
+      runtime.model?.capabilities?.strictToolCalling
     );
+    let strictRestorers = /* @__PURE__ */ new Map();
+    const wireMenu = (menu) => {
+      if (!shouldUseStrictToolCalling) return menu;
+      const prepared = prepareStrictToolMenu(menu);
+      strictRestorers = prepared.restorers;
+      return prepared.menu;
+    };
     const bindToolMenu = (menu) => runtime.model?.bindTools ? runtime.model.bindTools(
-      menu,
+      wireMenu(menu),
       shouldUseStrictToolCalling ? { strict: true } : void 0
     ) : runtime.model;
     const menuMutationReachesProvider = typeof runtime.model?.bindTools === "function";
@@ -3879,7 +4084,8 @@ function createAgentCoreNode(opts) {
     const computeTraceToolDefinitions = (menu) => {
       if (!traceSession || !traceSession.resolvedConfig.logData || menu.length === 0) return void 0;
       try {
-        return menu.map((tool) => {
+        const wire = shouldUseStrictToolCalling ? prepareStrictToolMenu(menu).menu : menu;
+        return wire.map((tool) => {
           const def = toToolDefinition(tool, shouldUseStrictToolCalling ? true : void 0);
           return { name: def.name, description: def.description || void 0, parameters: def.parameters };
         });
@@ -4185,6 +4391,9 @@ ${append}`;
           throw err;
         }
       }
+      if (shortCircuited === void 0 && strictRestorers.size > 0) {
+        response = restoreToolCalls(response, strictRestorers);
+      }
       if (!host?.has("postModelCall")) break;
       const postGate = await host.runGate("postModelCall", {
         message: response,
@@ -8783,6 +8992,21 @@ var todoUpdateItemSchema = z.object({
   status: todoStatusSchema.optional(),
   evidence: z.string().max(300).optional()
 });
+var todoItemWireSchema = z.object({
+  id: z.number().int().min(1).describe("Sequential id starting from 1 (write) or an existing id (update)"),
+  step: z.string().min(1).optional(),
+  title: z.string().min(1).optional(),
+  description: z.string().min(1).optional(),
+  owner: z.string().min(1).optional(),
+  exitCriteria: z.string().min(1).optional(),
+  status: todoStatusSchema.optional().describe("Required for every item on write"),
+  evidence: z.string().max(300).optional()
+});
+function describeTodoIssue(issue) {
+  if (!issue) return void 0;
+  const path2 = issue.path.length > 0 ? `todoList[${issue.path[0]}]${issue.path.slice(1).map((p) => `.${String(p)}`).join("")}` : "todoList";
+  return `${path2}: ${issue.message}`;
+}
 function normalizeTodoItem(item, existing) {
   const id = item.id ?? existing?.id;
   const step = item.step || item.title || item.description || existing?.step || existing?.title || existing?.description || `Step ${id}`;
@@ -8899,7 +9123,7 @@ function createPlanTool(stateRef, toolName, description) {
     schema: z.object({
       operation: z.enum(["write", "read", "update"]),
       expectedVersion: z.number().int().min(0).optional(),
-      todoList: z.array(z.union([todoWriteItemSchema, todoUpdateItemSchema])).optional()
+      todoList: z.array(todoItemWireSchema).optional()
     }),
     func: async ({ operation, expectedVersion, todoList }) => {
       const toolStateRef = manageTodo._stateRef;
@@ -8965,7 +9189,10 @@ function createPlanTool(stateRef, toolName, description) {
           return {
             status: "error",
             operation,
-            error: parsed.error.issues[0]?.message || "Invalid todoList for write.",
+            // The wire schema has `status` optional (one shape for write and
+            // update), so a missing one is caught here — named, so the model
+            // can fix the call.
+            error: describeTodoIssue(parsed.error.issues[0]) || "Invalid todoList for write.",
             version: currentVersion,
             adherenceScore: stateRef.adherenceScore || 0
           };
@@ -8988,7 +9215,7 @@ function createPlanTool(stateRef, toolName, description) {
           return {
             status: "error",
             operation,
-            error: parsed.error.issues[0]?.message || "Invalid todoList for update.",
+            error: describeTodoIssue(parsed.error.issues[0]) || "Invalid todoList for update.",
             version: currentVersion,
             adherenceScore: stateRef.adherenceScore || 0
           };
@@ -14754,8 +14981,127 @@ function sanitizeBedrockDocName(name, fallback = "document") {
   return cleaned || fallback;
 }
 
+// src/providers/utils/jsonSchemaRefs.ts
+var DEFINITION_KEYS = ["definitions", "$defs"];
+function inlineJsonSchemaRefs(schema) {
+  if (!isObject(schema) || !containsRef(schema)) return schema;
+  const root = structuredClone(schema);
+  const selfReaching = /* @__PURE__ */ new Map();
+  const targetOf = (ref) => {
+    const target = resolvePointer(root, ref);
+    return isObject(target) ? target : void 0;
+  };
+  const reachesItself = (target) => {
+    const known = selfReaching.get(target);
+    if (known !== void 0) return known;
+    const seen = /* @__PURE__ */ new Set();
+    const walk = (node) => {
+      if (Array.isArray(node)) return node.some(walk);
+      if (!isObject(node)) return false;
+      if (typeof node.$ref === "string") {
+        const next = targetOf(node.$ref);
+        if (next === target) return true;
+        if (next && !seen.has(next)) {
+          seen.add(next);
+          if (walk(next)) return true;
+        }
+      }
+      return Object.entries(node).some(([key, value]) => key !== "$ref" && walk(value));
+    };
+    const result2 = walk(target);
+    selfReaching.set(target, result2);
+    return result2;
+  };
+  const keptRefs = /* @__PURE__ */ new Set();
+  const expand = (node) => {
+    if (Array.isArray(node)) return node.map(expand);
+    if (!isObject(node)) return node;
+    if (typeof node.$ref === "string") {
+      const target = targetOf(node.$ref);
+      if (target && !reachesItself(target)) {
+        const { $ref: _inlined, ...siblings } = node;
+        return { ...expand(target), ...expandEntries(siblings) };
+      }
+      keptRefs.add(node.$ref);
+      return expandEntries(node);
+    }
+    return expandEntries(node);
+  };
+  const expandEntries = (node) => {
+    const out = {};
+    for (const [key, value] of Object.entries(node)) out[key] = key === "$ref" ? value : expand(value);
+    return out;
+  };
+  const { definitions: _definitions, $defs: _defs, ...rootBody } = root;
+  const result = typeof root.$ref === "string" ? expand(rootBody) : expandEntries(rootBody);
+  for (const key of DEFINITION_KEYS) delete result[key];
+  for (const key of DEFINITION_KEYS) {
+    const block = root[key];
+    if (!isObject(block)) continue;
+    const needed = neededEntries(key, block, keptRefs);
+    if (needed.length === 0) continue;
+    const kept = {};
+    for (const name of Object.keys(block)) if (needed.includes(name)) kept[name] = block[name];
+    result[key] = kept;
+  }
+  return result;
+}
+function neededEntries(key, block, keptRefs) {
+  const needed = [];
+  const queue = [...keptRefs];
+  while (queue.length > 0) {
+    const ref = queue.shift();
+    const segments = pointerSegments(ref);
+    if (!segments || segments[0] !== key || segments.length < 2) continue;
+    const name = segments[1];
+    if (needed.includes(name) || !(name in block)) continue;
+    needed.push(name);
+    collectRefs(block[name], queue);
+  }
+  return needed;
+}
+function collectRefs(node, into) {
+  if (Array.isArray(node)) {
+    node.forEach((child) => collectRefs(child, into));
+    return;
+  }
+  if (!isObject(node)) return;
+  if (typeof node.$ref === "string") into.push(node.$ref);
+  for (const [k, value] of Object.entries(node)) if (k !== "$ref") collectRefs(value, into);
+}
+function containsRef(node) {
+  if (Array.isArray(node)) return node.some(containsRef);
+  if (!isObject(node)) return false;
+  if (typeof node.$ref === "string") return true;
+  return Object.values(node).some(containsRef);
+}
+function pointerSegments(ref) {
+  if (ref === "#") return [];
+  if (!ref.startsWith("#/")) return null;
+  return ref.slice(2).split("/").map((segment) => segment.replace(/~1/g, "/").replace(/~0/g, "~"));
+}
+function resolvePointer(document, ref) {
+  const segments = pointerSegments(ref);
+  if (!segments) return void 0;
+  let current = document;
+  for (const segment of segments) {
+    if (Array.isArray(current)) {
+      if (!/^\d+$/.test(segment)) return void 0;
+      current = current[Number(segment)];
+    } else if (isObject(current) && Object.prototype.hasOwnProperty.call(current, segment)) {
+      current = current[segment];
+    } else {
+      return void 0;
+    }
+  }
+  return current;
+}
+function isObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
 // src/providers/openai.ts
-var OpenAIProvider = class extends BaseProvider {
+var OpenAIProvider = class _OpenAIProvider extends BaseProvider {
   constructor(config) {
     super();
     this.providerName = "openai";
@@ -14767,8 +15113,21 @@ var OpenAIProvider = class extends BaseProvider {
       ...config.organization ? { "OpenAI-Organization": config.organization } : {}
     };
     this.responsesApi = config.responsesApi ?? "auto";
+    const ownInstance = new.target === _OpenAIProvider;
+    this.responsesApiModels = ownInstance ? [...config.responsesApiModels ?? []] : [];
+    this.responsesStreaming = ownInstance && config.responsesStreaming === true;
     if (config.retry) this.retryPolicy = { ...this.retryPolicy, ...config.retry };
   }
+  /** True when the caller listed this request's model in `responsesApiModels`. */
+  isResponsesApiModel(request) {
+    if (this.responsesApiModels.length === 0) return false;
+    const model = request.model || this.defaultModel;
+    return this.responsesApiModels.some((entry) => {
+      if (typeof entry === "string") return entry === model;
+      entry.lastIndex = 0;
+      return entry.test(model);
+    });
+  }
   /** True when this request should go to the Responses API rather than Chat
    * Completions — which exposes `reasoning.effort` and reasoning summaries that
    * Chat Completions silently drops.
@@ -14777,10 +15136,14 @@ var OpenAIProvider = class extends BaseProvider {
    * carries a reasoning config AND the model name looks like an o-series/gpt-5
    * model. `never`/`always` let a caller state the answer instead, because the
    * name check is a guess and the two APIs differ in far more than reasoning —
-   * see `responsesApi` in OpenAIProviderConfig. */
+   * see `responsesApi` in OpenAIProviderConfig.
+   *
+   * A model listed in `responsesApiModels` is the caller stating the answer
+   * for that model alone; `never` still overrides it. */
   useResponsesApi(request) {
     if (this.responsesApi === "never") return false;
     if (this.responsesApi === "always") return true;
+    if (this.isResponsesApiModel(request)) return true;
     if (!request.reasoning) return false;
     return isReasoningModel(request.model || this.defaultModel);
   }
@@ -14795,6 +15158,10 @@ var OpenAIProvider = class extends BaseProvider {
   }
   async *completeStream(request) {
     if (this.useResponsesApi(request)) {
+      if (this.responsesStreaming && this.isResponsesApiModel(request)) {
+        yield* this.streamResponses(request);
+        return;
+      }
       const response = await this.completeResponses(request);
       yield {
         id: response.id,
@@ -14910,10 +15277,101 @@ var OpenAIProvider = class extends BaseProvider {
   // ─── Responses API (reasoning models) ──────────────────────────────────────
   async completeResponses(request) {
     const body = this.buildResponsesBody(request);
+    if (this.isResponsesApiModel(request)) adaptChatExtrasForResponses(body, request.extra);
     const res = await this.responsesFetch(body);
     const json = await res.json();
     return this.parseResponsesResponse(json, request.model || this.defaultModel);
   }
+  /** Real Responses SSE streaming, for models opted in through
+   * `responsesApiModels` with `responsesStreaming` on. Emits the same chunk
+   * shapes as the Chat Completions stream: text deltas as they arrive, a tool
+   * call's id + name when it opens and its argument fragments under that id,
+   * then one final chunk with usage, finish reason and any reasoning summary
+   * (taken from the completed response, exactly as the non-streaming parse
+   * reads it). */
+  async *streamResponses(request) {
+    const modelId = request.model || this.defaultModel;
+    const body = this.buildResponsesBody(request);
+    adaptChatExtrasForResponses(body, request.extra);
+    body.stream = true;
+    const res = await this.responsesFetch(body);
+    if (!res.body) throw new ProviderError("No response body for stream", this.providerName);
+    let id = "";
+    let model = modelId;
+    const calls = /* @__PURE__ */ new Map();
+    let final;
+    for await (const event of parseSSEStream(res.body)) {
+      if (event.data === "[DONE]") break;
+      let data;
+      try {
+        data = JSON.parse(event.data);
+      } catch {
+        continue;
+      }
+      switch (data.type ?? event.event) {
+        case "response.created":
+        case "response.in_progress":
+          id = data.response?.id ?? id;
+          model = data.response?.model ?? model;
+          break;
+        case "response.output_text.delta":
+          if (data.delta) yield { id, model, delta: { content: data.delta } };
+          break;
+        case "response.output_item.added": {
+          const item = data.item;
+          if (item?.type !== "function_call") break;
+          const call = { callId: item.call_id ?? item.id ?? "", name: item.name ?? "", arguments: item.arguments ?? "" };
+          calls.set(item.id ?? call.callId, call);
+          yield { id, model, delta: { toolCalls: [{ id: call.callId, name: call.name, arguments: call.arguments }] } };
+          break;
+        }
+        case "response.function_call_arguments.delta": {
+          const call = calls.get(data.item_id);
+          if (!call || !data.delta) break;
+          call.arguments += data.delta;
+          yield { id, model, delta: { toolCalls: [{ id: call.callId, arguments: data.delta }] } };
+          break;
+        }
+        case "response.output_item.done": {
+          const item = data.item;
+          if (item?.type !== "function_call") break;
+          const full = typeof item.arguments === "string" ? item.arguments : "";
+          const call = calls.get(item.id ?? item.call_id);
+          if (!call) {
+            const added = { callId: item.call_id ?? item.id ?? "", name: item.name ?? "", arguments: full };
+            calls.set(item.id ?? added.callId, added);
+            yield { id, model, delta: { toolCalls: [{ id: added.callId, name: added.name, arguments: full }] } };
+          } else if (full.length > call.arguments.length && full.startsWith(call.arguments)) {
+            const rest = full.slice(call.arguments.length);
+            call.arguments = full;
+            yield { id, model, delta: { toolCalls: [{ id: call.callId, arguments: rest }] } };
+          }
+          break;
+        }
+        case "response.completed":
+        case "response.incomplete":
+          final = this.parseResponsesResponse(data.response ?? {}, modelId);
+          break;
+        case "response.failed":
+        case "error": {
+          const err = data.response?.error ?? data.error ?? data;
+          throw new ProviderError(
+            `OpenAI Responses API stream error: ${err?.message ?? "unknown error"}`,
+            this.providerName,
+            void 0,
+            data
+          );
+        }
+      }
+    }
+    yield {
+      id: final?.id || id,
+      model: final?.model || model,
+      delta: final?.reasoning ? { reasoning: final.reasoning } : {},
+      usage: final?.usage,
+      finishReason: final?.finishReason ?? (calls.size > 0 ? "tool_calls" : "stop")
+    };
+  }
   buildResponsesBody(request) {
     const body = {
       model: request.model || this.defaultModel,
@@ -14943,7 +15401,7 @@ var OpenAIProvider = class extends BaseProvider {
           format: {
             type: "json_schema",
             name: request.responseFormat.name ?? "response",
-            schema: request.responseFormat.schema,
+            schema: inlineJsonSchemaRefs(request.responseFormat.schema),
             strict: true
           }
         };
@@ -15198,6 +15656,48 @@ function isReasoningModel(model) {
   const m = model.toLowerCase();
   return /(^|[/_-])o[0-9]/.test(m) || m.startsWith("o1") || m.startsWith("o3") || m.startsWith("o4") || m.includes("gpt-5") || m.includes("gpt5");
 }
+function adaptChatExtrasForResponses(body, extra) {
+  const native = extra ?? {};
+  if ("reasoning_effort" in body) {
+    const effort = body.reasoning_effort;
+    delete body.reasoning_effort;
+    if (effort != null) {
+      const reasoning = body.reasoning && typeof body.reasoning === "object" ? body.reasoning : {};
+      if (reasoning.effort == null) body.reasoning = { ...reasoning, effort };
+    }
+  }
+  for (const key of ["max_tokens", "max_completion_tokens"]) {
+    if (!(key in body)) continue;
+    const value = body[key];
+    delete body[key];
+    if (value != null && !("max_output_tokens" in native)) body.max_output_tokens = value;
+  }
+  if ("response_format" in body) {
+    const format = toResponsesTextFormat(body.response_format);
+    delete body.response_format;
+    if (format && !("text" in native)) body.text = { ...body.text, format };
+  }
+  if (body.stream_options && typeof body.stream_options === "object" && "include_usage" in body.stream_options) {
+    const { include_usage: _dropped, ...rest } = body.stream_options;
+    if (Object.keys(rest).length > 0) body.stream_options = rest;
+    else delete body.stream_options;
+  }
+}
+function toResponsesTextFormat(rf) {
+  if (!rf || typeof rf !== "object") return void 0;
+  if (rf.type === "json_schema") {
+    const js = rf.json_schema ?? {};
+    return {
+      type: "json_schema",
+      name: js.name ?? "response",
+      schema: inlineJsonSchemaRefs(js.schema),
+      ...js.description != null ? { description: js.description } : {},
+      ...js.strict != null ? { strict: js.strict } : {}
+    };
+  }
+  if (rf.type === "json_object" || rf.type === "text") return { type: rf.type };
+  return void 0;
+}
 function expandResponsesInput(input) {
   const out = [];
   for (const item of input) {
@@ -16517,6 +17017,6 @@ function createProvider(config) {
   }
 }
 
-export { ASK_USER_TOOL_NAME, AnthropicProvider, AzureProvider, BaseProvider, BedrockProvider, CCRStore, CONSOLE_HOOK_MAP, CONTEXT_PILOT_JSON_MARKER_KEY, CONTROL_PLANE_TOOL_NAMES, DEFAULT_MAX_TOOL_INPUT_FIELD_CHARS, DEFAULT_PROFILE_CONFIGS, DEFAULT_SKILL_POLICY, DEFAULT_SUBAGENT_POLICY, DEFAULT_SUBAGENT_TOOL_NAMES, DEFAULT_TOOL_INPUT_DIGEST_HEAD_CHARS, DELEGATION_TOOL_NAMES, DedupTracker, GuardrailPhase, HOOK_CONTRACT_VERSION, HOOK_NAMES, HookTimeoutError, InMemoryMemoryStore, NativeJsonSchemaStrategy, OpenAICompatibleProvider, OpenAIProvider, PREOPEN_TOOL_CALL_PREFIX, ProviderError, SMALL_TIER_SKILL_POLICY, StructuredOutputManager, TOOL_INPUT_DIGEST_KEY, ToolBasedStrategy, VertexProvider, agentVerdictRule, appendBoundTools, auditLog, azureContentSafety, bedrockGuardrail, budgetGuard, buildHandoffTools, buildResponseFormatSection, buildSkillHeaderBlock, buildSubagentCatalogBlock, buildSystemPrompt, buildToolDefinitionsSection, canOpenSkill, canSpawn, captureSnapshot, checkpointing, codePresenceRule, coerceToolArgs, cognipeerGuardrail, cognipeerSink, collectAttachments, collectToolRetentionDeclarations, composeToolSets, compressDiffOutput, compressJsonOutput, compressLogOutput, compressSearchOutput, compressTextOutput, compressToolOutput, contentToString, conversationHistory, countApproxTokens, countMessagesTokens, createAgent, createAgentNode, createAskUserQuestionTool, createBindSkillToolsTool, createCodeGuardrail, createContextPilotRuntime, createContextSummarizeNode, createContextTools, createDelegateTool, createGetToolResponseTool, createGuardrail, createGuardrailPlugin, createJsonGuardrail, createManageTodoListAliasTool, createManageTodoTool, createOpenSkillTool, createParallelTool, createPluginHost, createProvider, createRegexGuardrail, createResolverNode, createSearchSkillsTool, createSkillRegistryRef, createSkillTools, createSmartAgent, createSpawnTool, createSubagentRegistryRef, createSubagentTools, createTool, createToolLimitFinalizeNode, createToolsNode, customCallbackRule, customGuardrail, customSink, dedupeToolsByName, defaultTokenCounter, defineHook, definePlugin, detectLanguage, detectTextFormat, detectVolatileContent, digestToolInputArguments, digestToolInputValue, emptyUsage, evaluateGuardrails, extractLatestUserQuery, extractMessageText2 as extractMessageText, fileCheckpointStore, fileSink, findSubagent, formatZodError, fromLangchainModel, fromLangchainTools, fromNativeProvider, generateSpanId, generateTraceId, getModelCapabilities, getNestedValue, getResolvedSmartConfig, getTokenCounter, hasToolResponseRecoveryReference, httpGuardrail, httpSink, inMemoryCheckpointStore, inMemoryConversationStore, isHookImplemented, isSmartModel, isValidIban, isValidLuhn, isValidTckn, jsonSchemaRule, defaultBuildPayload as langfuseDefaultPayload, langfuseTracing, languageGuard, loadSkillsFromDisk, mapConsoleHookVerdict, mapTextParts, mcp, mediaPolicy, normalizeSmartAgentOptions, normalizeVerdicts, openAIModeration, otelTracing, otlpSink, outputGuard, parseApprovalDecision, parseSkillFrontmatter, pathSandbox, piiRedaction, pluginCapabilities, portkeyGateway, portkeyGuardrail, preopenSkills, preopenToolCallId, promptInjectionGuard, rateLimit, readMemoryFacts, redactText, regexGuardrail, regexRule, replaceTextContent, resolveAvailableSkills, resolveAvailableSubagents, resolveInputRetention, resolveMemoryStore, resolveReasoning, resolveStrategy, resolveSubagentTools, resolveSummarizationRetention, resolveToolApprovalState, resolveUserQuestionState, responseCache, restoreSnapshot, runSmartAgentEvalHarness, scoreItemsByRelevance, searchSkills, seedChildMessages, selectTopIndicesInOrder, sessionMetrics, setTokenCounter, startStreamingSession, summarizeObject, textFromContent, tokenize, toolPolicy, traceSessionToOtlp, validateReasoningConfig, validateToolArgs, webhookApproval, withTools, withinDepth, writeSummaryFactsToMemory };
+export { ASK_USER_TOOL_NAME, AnthropicProvider, AzureProvider, BaseProvider, BedrockProvider, CCRStore, CONSOLE_HOOK_MAP, CONTEXT_PILOT_JSON_MARKER_KEY, CONTROL_PLANE_TOOL_NAMES, DEFAULT_MAX_TOOL_INPUT_FIELD_CHARS, DEFAULT_PROFILE_CONFIGS, DEFAULT_SKILL_POLICY, DEFAULT_SUBAGENT_POLICY, DEFAULT_SUBAGENT_TOOL_NAMES, DEFAULT_TOOL_INPUT_DIGEST_HEAD_CHARS, DELEGATION_TOOL_NAMES, DedupTracker, GuardrailPhase, HOOK_CONTRACT_VERSION, HOOK_NAMES, HookTimeoutError, InMemoryMemoryStore, NativeJsonSchemaStrategy, OpenAICompatibleProvider, OpenAIProvider, PREOPEN_TOOL_CALL_PREFIX, ProviderError, SMALL_TIER_SKILL_POLICY, StructuredOutputManager, TOOL_INPUT_DIGEST_KEY, ToolBasedStrategy, VertexProvider, agentVerdictRule, appendBoundTools, auditLog, azureContentSafety, bedrockGuardrail, budgetGuard, buildHandoffTools, buildResponseFormatSection, buildSkillHeaderBlock, buildSubagentCatalogBlock, buildSystemPrompt, buildToolDefinitionsSection, canOpenSkill, canSpawn, captureSnapshot, checkpointing, codePresenceRule, coerceToolArgs, cognipeerGuardrail, cognipeerSink, collectAttachments, collectToolRetentionDeclarations, composeToolSets, compressDiffOutput, compressJsonOutput, compressLogOutput, compressSearchOutput, compressTextOutput, compressToolOutput, contentToString, conversationHistory, countApproxTokens, countMessagesTokens, createAgent, createAgentNode, createAskUserQuestionTool, createBindSkillToolsTool, createCodeGuardrail, createContextPilotRuntime, createContextSummarizeNode, createContextTools, createDelegateTool, createGetToolResponseTool, createGuardrail, createGuardrailPlugin, createJsonGuardrail, createManageTodoListAliasTool, createManageTodoTool, createOpenSkillTool, createParallelTool, createPluginHost, createProvider, createRegexGuardrail, createResolverNode, createSearchSkillsTool, createSkillRegistryRef, createSkillTools, createSmartAgent, createSpawnTool, createSubagentRegistryRef, createSubagentTools, createTool, createToolLimitFinalizeNode, createToolsNode, customCallbackRule, customGuardrail, customSink, dedupeToolsByName, defaultTokenCounter, defineHook, definePlugin, detectLanguage, detectTextFormat, detectVolatileContent, digestToolInputArguments, digestToolInputValue, emptyUsage, evaluateGuardrails, extractLatestUserQuery, extractMessageText2 as extractMessageText, fileCheckpointStore, fileSink, findSubagent, formatZodError, fromLangchainModel, fromLangchainTools, fromNativeProvider, generateSpanId, generateTraceId, getModelCapabilities, getNestedValue, getResolvedSmartConfig, getTokenCounter, hasToolResponseRecoveryReference, httpGuardrail, httpSink, inMemoryCheckpointStore, inMemoryConversationStore, isHookImplemented, isOpenAIHostedEndpoint, isSmartModel, isValidIban, isValidLuhn, isValidTckn, jsonSchemaRule, defaultBuildPayload as langfuseDefaultPayload, langfuseTracing, languageGuard, loadSkillsFromDisk, mapConsoleHookVerdict, mapTextParts, mcp, mediaPolicy, normalizeSmartAgentOptions, normalizeVerdicts, openAIModeration, otelTracing, otlpSink, outputGuard, parseApprovalDecision, parseSkillFrontmatter, pathSandbox, piiRedaction, pluginCapabilities, portkeyGateway, portkeyGuardrail, preopenSkills, preopenToolCallId, prepareStrictToolMenu, promptInjectionGuard, rateLimit, readMemoryFacts, redactText, regexGuardrail, regexRule, replaceTextContent, resolveAvailableSkills, resolveAvailableSubagents, resolveInputRetention, resolveMemoryStore, resolveReasoning, resolveStrategy, resolveSubagentTools, resolveSummarizationRetention, resolveToolApprovalState, resolveUserQuestionState, responseCache, restoreSnapshot, restoreToolCalls, runSmartAgentEvalHarness, scoreItemsByRelevance, searchSkills, seedChildMessages, selectTopIndicesInOrder, sessionMetrics, setTokenCounter, startStreamingSession, summarizeObject, textFromContent, toStrictCompatible, toStrictToolSchema, tokenize, toolPolicy, traceSessionToOtlp, validateReasoningConfig, validateToolArgs, webhookApproval, withTools, withinDepth, writeSummaryFactsToMemory };
 //# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map