@cognipeer/agent-sdk 0.10.4 → 0.10.5

package/dist/index.d.cts

@@ -3874,6 +3874,37 @@ type OpenAIProviderConfig = {
      * where it matters most: a self-hosted model is named by whoever served it.
      */
     responsesApi?: "auto" | "never" | "always";
+    /**
+     * Models that go to the Responses API, named explicitly. Opt-in; unset by
+     * default, and nothing here is inferred from a model name.
+     *
+     * A string matches the request's model (or `defaultModel`) exactly; a RegExp
+     * is tested against it. A match routes the request to Responses whether or
+     * not it carries `reasoning` — the case this exists for is a model that
+     * reasons by default and rejects function tools on Chat Completions, where
+     * sending no reasoning field does not help. `responsesApi: "never"` still
+     * wins; under `"always"` the routing is unchanged.
+     *
+     * Requests for a matched model also get, on the Responses body only:
+     *  - Chat Completions spellings arriving through `extra`, which /responses
+     *    rejects with a 400, re-spelled with their values unchanged:
+     *    `reasoning_effort` → `reasoning.effort` (a request `reasoning` effort
+     *    still wins), `max_tokens` / `max_completion_tokens` →
+     *    `max_output_tokens`, `response_format` → `text.format`, and
+     *    `stream_options.include_usage` dropped.
+     *  - real SSE streaming, when `responsesStreaming` is also true.
+     *
+     * Honoured by `OpenAIProvider` itself only; `AzureProvider` and
+     * `OpenAICompatibleProvider` ignore it.
+     */
+    responsesApiModels?: Array<string | RegExp>;
+    /**
+     * Stream Responses API output as it arrives (text and tool-call argument
+     * deltas) for models in `responsesApiModels`. Default false, which keeps the
+     * existing behaviour: one non-streaming Responses call, emitted as a single
+     * chunk. Has no effect on any other request.
+     */
+    responsesStreaming?: boolean;
 };
 type AnthropicProviderConfig = {
     provider: "anthropic";
@@ -5509,7 +5540,11 @@ declare class OpenAIProvider extends BaseProvider {
     protected readonly defaultModel: string;
     protected readonly defaultHeaders: Record<string, string>;
     protected readonly responsesApi: "auto" | "never" | "always";
+    private readonly responsesApiModels;
+    private readonly responsesStreaming;
     constructor(config: OpenAIProviderConfig);
+    /** True when the caller listed this request's model in `responsesApiModels`. */
+    private isResponsesApiModel;
     /** 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.
@@ -5518,12 +5553,23 @@ declare class OpenAIProvider 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. */
     protected useResponsesApi(request: ChatCompletionRequest): boolean;
     complete(request: ChatCompletionRequest): Promise<ChatCompletionResponse>;
     completeStream(request: ChatCompletionRequest): AsyncGenerator<ChatCompletionChunk, void, unknown>;
     protected buildRequestBody(request: ChatCompletionRequest, stream: boolean): Record<string, any>;
     protected completeResponses(request: ChatCompletionRequest): Promise<ChatCompletionResponse>;
+    /** 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). */
+    private streamResponses;
     protected buildResponsesBody(request: ChatCompletionRequest): Record<string, any>;
     /** Maps a unified message to a Responses API `input` item. */
     protected toResponsesInput(m: UnifiedMessage): Record<string, any>;

package/dist/index.d.ts

@@ -3874,6 +3874,37 @@ type OpenAIProviderConfig = {
      * where it matters most: a self-hosted model is named by whoever served it.
      */
     responsesApi?: "auto" | "never" | "always";
+    /**
+     * Models that go to the Responses API, named explicitly. Opt-in; unset by
+     * default, and nothing here is inferred from a model name.
+     *
+     * A string matches the request's model (or `defaultModel`) exactly; a RegExp
+     * is tested against it. A match routes the request to Responses whether or
+     * not it carries `reasoning` — the case this exists for is a model that
+     * reasons by default and rejects function tools on Chat Completions, where
+     * sending no reasoning field does not help. `responsesApi: "never"` still
+     * wins; under `"always"` the routing is unchanged.
+     *
+     * Requests for a matched model also get, on the Responses body only:
+     *  - Chat Completions spellings arriving through `extra`, which /responses
+     *    rejects with a 400, re-spelled with their values unchanged:
+     *    `reasoning_effort` → `reasoning.effort` (a request `reasoning` effort
+     *    still wins), `max_tokens` / `max_completion_tokens` →
+     *    `max_output_tokens`, `response_format` → `text.format`, and
+     *    `stream_options.include_usage` dropped.
+     *  - real SSE streaming, when `responsesStreaming` is also true.
+     *
+     * Honoured by `OpenAIProvider` itself only; `AzureProvider` and
+     * `OpenAICompatibleProvider` ignore it.
+     */
+    responsesApiModels?: Array<string | RegExp>;
+    /**
+     * Stream Responses API output as it arrives (text and tool-call argument
+     * deltas) for models in `responsesApiModels`. Default false, which keeps the
+     * existing behaviour: one non-streaming Responses call, emitted as a single
+     * chunk. Has no effect on any other request.
+     */
+    responsesStreaming?: boolean;
 };
 type AnthropicProviderConfig = {
     provider: "anthropic";
@@ -5509,7 +5540,11 @@ declare class OpenAIProvider extends BaseProvider {
     protected readonly defaultModel: string;
     protected readonly defaultHeaders: Record<string, string>;
     protected readonly responsesApi: "auto" | "never" | "always";
+    private readonly responsesApiModels;
+    private readonly responsesStreaming;
     constructor(config: OpenAIProviderConfig);
+    /** True when the caller listed this request's model in `responsesApiModels`. */
+    private isResponsesApiModel;
     /** 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.
@@ -5518,12 +5553,23 @@ declare class OpenAIProvider 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. */
     protected useResponsesApi(request: ChatCompletionRequest): boolean;
     complete(request: ChatCompletionRequest): Promise<ChatCompletionResponse>;
     completeStream(request: ChatCompletionRequest): AsyncGenerator<ChatCompletionChunk, void, unknown>;
     protected buildRequestBody(request: ChatCompletionRequest, stream: boolean): Record<string, any>;
     protected completeResponses(request: ChatCompletionRequest): Promise<ChatCompletionResponse>;
+    /** 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). */
+    private streamResponses;
     protected buildResponsesBody(request: ChatCompletionRequest): Record<string, any>;
     /** Maps a unified message to a Responses API `input` item. */
     protected toResponsesInput(m: UnifiedMessage): Record<string, any>;

package/dist/index.mjs

@@ -14981,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";
@@ -14994,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.
@@ -15004,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);
   }
@@ -15022,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,
@@ -15137,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,
@@ -15170,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
           }
         };
@@ -15425,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) {