@cognipeer/agent-sdk 0.10.3 → 0.10.5

package/dist/index.cjs

@@ -513,7 +513,7 @@ function getModelCapabilities(model) {
     return {
       provider,
       structuredOutput: supportsNativeStructuredOutput(provider) ? "native" : "tool_based",
-      strictToolCalling: requiresStrictToolCalling(provider),
+      strictToolCalling: requiresStrictToolCalling(provider) && isOpenAIHostedEndpoint(model._lc),
       streaming: true
     };
   }
@@ -556,6 +556,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) {
@@ -2520,13 +2531,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",
@@ -3855,6 +3872,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(zod.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(zod.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(zod.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(zod.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: zod.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) {
@@ -3875,10 +4073,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";
@@ -3889,7 +4094,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 };
         });
@@ -4195,6 +4401,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,
@@ -8793,6 +9002,21 @@ var todoUpdateItemSchema = zod.z.object({
   status: todoStatusSchema.optional(),
   evidence: zod.z.string().max(300).optional()
 });
+var todoItemWireSchema = zod.z.object({
+  id: zod.z.number().int().min(1).describe("Sequential id starting from 1 (write) or an existing id (update)"),
+  step: zod.z.string().min(1).optional(),
+  title: zod.z.string().min(1).optional(),
+  description: zod.z.string().min(1).optional(),
+  owner: zod.z.string().min(1).optional(),
+  exitCriteria: zod.z.string().min(1).optional(),
+  status: todoStatusSchema.optional().describe("Required for every item on write"),
+  evidence: zod.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}`;
@@ -8909,7 +9133,7 @@ function createPlanTool(stateRef, toolName, description) {
     schema: zod.z.object({
       operation: zod.z.enum(["write", "read", "update"]),
       expectedVersion: zod.z.number().int().min(0).optional(),
-      todoList: zod.z.array(zod.z.union([todoWriteItemSchema, todoUpdateItemSchema])).optional()
+      todoList: zod.z.array(todoItemWireSchema).optional()
     }),
     func: async ({ operation, expectedVersion, todoList }) => {
       const toolStateRef = manageTodo._stateRef;
@@ -8975,7 +9199,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
           };
@@ -8998,7 +9225,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
           };
@@ -14764,8 +14991,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";
@@ -14777,8 +15123,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.
@@ -14787,10 +15146,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);
   }
@@ -14805,6 +15168,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,
@@ -14920,10 +15287,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,
@@ -14953,7 +15411,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
           }
         };
@@ -15208,6 +15666,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) {
@@ -16658,6 +17158,7 @@ exports.httpSink = httpSink;
 exports.inMemoryCheckpointStore = inMemoryCheckpointStore;
 exports.inMemoryConversationStore = inMemoryConversationStore;
 exports.isHookImplemented = isHookImplemented;
+exports.isOpenAIHostedEndpoint = isOpenAIHostedEndpoint;
 exports.isSmartModel = isSmartModel;
 exports.isValidIban = isValidIban;
 exports.isValidLuhn = isValidLuhn;
@@ -16686,6 +17187,7 @@ exports.portkeyGateway = portkeyGateway;
 exports.portkeyGuardrail = portkeyGuardrail;
 exports.preopenSkills = preopenSkills;
 exports.preopenToolCallId = preopenToolCallId;
+exports.prepareStrictToolMenu = prepareStrictToolMenu;
 exports.promptInjectionGuard = promptInjectionGuard;
 exports.rateLimit = rateLimit;
 exports.readMemoryFacts = readMemoryFacts;
@@ -16705,6 +17207,7 @@ exports.resolveToolApprovalState = resolveToolApprovalState;
 exports.resolveUserQuestionState = resolveUserQuestionState;
 exports.responseCache = responseCache;
 exports.restoreSnapshot = restoreSnapshot;
+exports.restoreToolCalls = restoreToolCalls;
 exports.runSmartAgentEvalHarness = runSmartAgentEvalHarness;
 exports.scoreItemsByRelevance = scoreItemsByRelevance;
 exports.searchSkills = searchSkills;
@@ -16715,6 +17218,8 @@ exports.setTokenCounter = setTokenCounter;
 exports.startStreamingSession = startStreamingSession;
 exports.summarizeObject = summarizeObject;
 exports.textFromContent = textFromContent;
+exports.toStrictCompatible = toStrictCompatible;
+exports.toStrictToolSchema = toStrictToolSchema;
 exports.tokenize = tokenize;
 exports.toolPolicy = toolPolicy;
 exports.traceSessionToOtlp = traceSessionToOtlp;