@framers/agentos 0.10.23 → 0.10.25

package/dist/core/llm/providers/implementations/OpenAIProvider.d.ts

@@ -74,7 +74,8 @@ export declare function modelRequiresMaxCompletionTokens(modelId: string): boole
  * family prefix alone does not decide the size: `gpt-5.4` is a 1.05M model
  * while its `-mini` and `-nano` siblings are 400K.
  *
- *   - 1,050,000: the GPT-6 family, the GPT-5.6 family except `gpt-5.6-cyber`,
+ *   - 1,050,000: the GPT-6 family (`gpt-6.1-sol` included, per the
+ *     2026-09-29 changelog), the GPT-5.6 family except `gpt-5.6-cyber`,
  *     `gpt-5.5`, `gpt-5.5-pro`, `gpt-5.4` and `gpt-5.4-pro` (max input
  *     922,000 on GPT-6).
  *   - 400,000: `gpt-5.6-cyber`, `gpt-5.4-mini` / `-nano`, `gpt-5.3-codex`,
@@ -86,28 +87,88 @@ export declare function modelRequiresMaxCompletionTokens(modelId: string): boole
  * @returns Context window in tokens.
  */
 export declare function openAiReasoningContextWindow(modelId: string): number;
+/**
+ * Prompt size, in input tokens, above which OpenAI bills a call on a
+ * long-context model at the long-context rates. The pricing page splits its
+ * flagship table into "<=272K" and ">272K" input tokens, and the comparison is
+ * strict: a prompt of exactly 272,000 tokens bills at the standard rates. The
+ * count includes cached tokens, and output size never triggers the tier.
+ */
+export declare const OPENAI_LONG_CONTEXT_THRESHOLD_TOKENS = 272000;
+/**
+ * Factor OpenAI applies to the input rate of a long-context call. The cached
+ * input and cache write rates double as well.
+ */
+export declare const OPENAI_LONG_CONTEXT_INPUT_MULTIPLIER = 2;
+/** Factor OpenAI applies to the output rate of a long-context call. */
+export declare const OPENAI_LONG_CONTEXT_OUTPUT_MULTIPLIER = 1.5;
+/**
+ * Whether OpenAI bills `modelId` at the long-context rates when a prompt
+ * exceeds {@link OPENAI_LONG_CONTEXT_THRESHOLD_TOKENS} input tokens. Such a
+ * call bills its whole input at {@link OPENAI_LONG_CONTEXT_INPUT_MULTIPLIER}
+ * times the input rate and its whole output at
+ * {@link OPENAI_LONG_CONTEXT_OUTPUT_MULTIPLIER} times the output rate.
+ *
+ * OpenAI states the rule for its models with a 1.05M context window, so this
+ * reuses {@link openAiReasoningContextWindow}. That covers the GPT-6 family
+ * (`gpt-6.1-sol` included), the GPT-5.6 family except `gpt-5.6-cyber`,
+ * `gpt-5.5`, `gpt-5.5-pro`, `gpt-5.4` and `gpt-5.4-pro`, bare or dated.
+ * Everything else bills flat at every prompt size: the GPT-5 models with a
+ * smaller window (`gpt-5.6-cyber`, which the pricing page lists without a
+ * long-context rate, `gpt-5.4-mini` / `-nano`, `gpt-5.3` and older, and the
+ * chat-latest snapshots), the o-series, and the pre-GPT-5 models, `gpt-4.1`
+ * included despite its 1M window. Checked against
+ * developers.openai.com/api/docs/pricing and the model pages on 2026-09-30.
+ *
+ * @param modelId Model id as requested or as echoed by the API.
+ * @returns `true` when a prompt above the threshold bills at the long-context rates.
+ */
+export declare function openAiHasLongContextPricing(modelId: string): boolean;
 /**
  * Whether OpenAI serves `modelId` only through the Responses API. OpenAI lists
  * the `-pro` tiers, the codex models, `gpt-5.6-cyber` and the deep-research
- * models as Responses-only. OpenAIProvider sends a request to /v1/responses
- * only when it is a non-streamed GPT-5 or GPT-6 call carrying function tools
- * and an effort, and to /v1/chat/completions otherwise, where these ids fail.
+ * models as Responses-only; on /v1/chat/completions they fail (gpt-5.3-codex
+ * answers 404). OpenAIProvider sends every call to these ids to /v1/responses
+ * (see {@link openAiRequiresResponsesApi}).
+ *
+ * Only OpenAI's own families (`gpt-`, the o-series, `codex-`) qualify. Groq,
+ * xAI, Together and Mistral delegate to this class with their own model ids,
+ * and an id such as `grok-4-pro` on one of those endpoints is served by its
+ * Chat Completions route.
  *
  * @param modelId Provider-side model identifier.
  * @returns `true` when the model has no Chat Completions endpoint.
  */
 export declare function isOpenAIResponsesOnlyModel(modelId: string): boolean;
+/**
+ * Whether a call to `modelId` can be served only by `/v1/responses`:
+ *
+ *   - any call to a Responses-only model ({@link isOpenAIResponsesOnlyModel});
+ *   - a GPT-6 call carrying function tools. Chat Completions does not serve
+ *     it: `gpt-6-astra` rejects tool calls there with or without a
+ *     `reasoning_effort` (probed 2026-09-10 and 2026-09-30), the `gpt-6.1-sol` model page lists
+ *     tool calling on Responses only, and the `gpt-6-sol` / `gpt-6-luna`
+ *     pages allow chat tool calls only with `reasoning_effort: 'none'`. A
+ *     2026-09-30 probe of a GPT-6 tool call with no `reasoning_effort` on
+ *     /v1/chat/completions returned HTTP 400.
+ *
+ * {@link shouldRouteToOpenAiResponsesApi} applies this rule to streamed and
+ * non-streamed calls alike.
+ *
+ * @param modelId Provider-side model identifier.
+ * @param options The request's tools.
+ * @returns `true` when the call has no Chat Completions route.
+ */
+export declare function openAiRequiresResponsesApi(modelId: string, options: Pick<ModelCompletionOptions, 'tools'>): boolean;
 /**
  * ModelInfo capabilities for a GPT-5, GPT-6 or o-series id, limited to what
  * OpenAIProvider can serve.
  *
  *   - Responses-only models ({@link isOpenAIResponsesOnlyModel}) list as
- *     `chat` only. This provider reaches them only on its narrow Responses
- *     path, and the refresh leaves the Responses-only o-series ids out.
- *   - GPT-6 omits `tool_use`. OpenAI requires the Responses API for GPT-6
- *     Astra tool calls and `reasoning_effort: "none"` for Sol and Luna tool
- *     calls on Chat Completions, and this provider routes a tool call to
- *     Responses only when it carries an effort and is not streamed.
+ *     `chat` only. Tool and streaming support vary from model to model on
+ *     that tier, and the refresh leaves the Responses-only o-series ids out.
+ *   - GPT-6 lists `tool_use`: every GPT-6 tool call, streamed or not, goes to
+ *     `/v1/responses` ({@link openAiRequiresResponsesApi}).
  *   - `o1-mini` and `o1-preview` have no function calling or structured
  *     outputs. They and `o3-mini` take text only, and every other id takes
  *     images (per model input modalities, checked 2026-09-29).
@@ -142,32 +203,30 @@ export declare function openAiReasoningCapabilities(modelId: string): string[];
  */
 export declare function isOpenAIReasoningModel(modelId: string): boolean;
 /**
- * Whether OpenAI rejects `reasoning_effort` sent ALONGSIDE function tools on
- * the `/v1/chat/completions` endpoint for `modelId`. The GPT-5 family enforces
- * this — "Function tools with reasoning_effort are not supported for gpt-5.5
- * in /v1/chat/completions. Please use /v1/responses instead." (live-observed
- * 2026-07-08 when the codegen frontier fallback chain routed a tool-carrying,
- * effort:xhigh orchestrator turn to gpt-5.5, hard-erroring the whole build).
- *
- * Such a call is routed to `/v1/responses` when it qualifies (see
- * {@link shouldRouteToOpenAiResponsesApi}, which preserves BOTH effort and
- * tools); otherwise it stays on chat/completions and must DROP
- * `reasoning_effort` (the model then reasons at its default depth) rather than
- * 400 the entire request. Scoped to the GPT-5 and GPT-6 families: the o-series
- * (o1/o3/o4) still accepts `reasoning_effort` + tools on chat/completions, so
- * dropping it there would be a needless reasoning-depth regression. Widen this
- * predicate if a future o-series enforces the same Responses-API requirement.
- *
- * GPT-6 enforces the SAME restriction — live-probed 2026-09-10
- * (chat.completions, `gpt-6-astra`, `reasoning_effort: 'xhigh'` + one function
- * tool): HTTP 400 `invalid_request_error` — "Function tools with
- * reasoning_effort are not supported for gpt-6-astra in /v1/chat/completions.
- * To use function tools, use /v1/responses or set reasoning_effort to 'none'."
- * The suggested `'none'` escape hatch does NOT exist on this family: the same
- * probe with `reasoning_effort: 'none'` returns HTTP 400 `unsupported_value`
- * ("Supported values are: 'low', 'medium', 'high', and 'xhigh'"). Dropping the
- * param entirely (or routing to `/v1/responses`) is therefore the only viable
- * path, which is exactly what the two call sites below already do.
+ * Whether OpenAI rejects `reasoning_effort` sent alongside function tools on
+ * the `/v1/chat/completions` endpoint for `modelId`. The GPT-5 family does:
+ * "Function tools with reasoning_effort are not supported for gpt-5.5 in
+ * /v1/chat/completions. Please use /v1/responses instead." (live-observed
+ * 2026-07-08, when the codegen frontier fallback chain sent a tool-carrying,
+ * effort:xhigh orchestrator turn to gpt-5.5 and the whole build failed).
+ *
+ * GPT-6 does as well. Live-probed 2026-09-10 (chat.completions,
+ * `gpt-6-astra`, `reasoning_effort: 'xhigh'` and one function tool): HTTP 400
+ * `invalid_request_error`, "Function tools with reasoning_effort are not
+ * supported for gpt-6-astra in /v1/chat/completions. To use function tools,
+ * use /v1/responses or set reasoning_effort to 'none'." The 2026-09-30 probe
+ * found that `gpt-6-sol` and `gpt-6-luna` accept `'none'` there while
+ * `gpt-6-astra` rejects it, and that a GPT-6 tool call with no
+ * `reasoning_effort` also returns 400, so every GPT-6 tool call goes to
+ * `/v1/responses` ({@link openAiRequiresResponsesApi}).
+ *
+ * {@link shouldRouteToOpenAiResponsesApi} sends a GPT-5 tool call that
+ * carries an effort to `/v1/responses`, which keeps both the effort and the
+ * tools. A call whose message content Responses cannot carry stays on
+ * chat/completions, where the chat builder drops `reasoning_effort` so the
+ * call succeeds at the model's default depth. The o-series (o1/o3/o4) accepts
+ * `reasoning_effort` with tools on chat/completions, so it stays outside this
+ * predicate; widen it if a future o-series model enforces the same rule.
  *
  * @param modelId Provider-side model identifier (e.g. `'gpt-5.5'`, `'gpt-6-astra'`).
  */
@@ -206,27 +265,43 @@ export declare function isResponsesMappableContent(content: ChatMessage['content
  */
 export declare function flattenResponsesTextContent(content: ChatMessage['content']): string;
 /**
- * Whether a NON-streaming call must use `/v1/responses` instead of
- * `/v1/chat/completions`: a gpt-5/gpt-6 reasoning model carrying function tools
- * AND a requested effort — the ONLY combination chat/completions 400s on
- * ("Function tools with reasoning_effort are not supported … Please use
- * /v1/responses instead") and the only case where the Responses path buys
- * anything (preserved reasoning depth). Excludes, per the 2026-07-08 Codex
- * review, requests that carry a `responseFormat` (the Responses path maps no
- * structured output — those stay on chat/completions where R4 drops effort) or
- * message content the input mapper cannot carry (see
- * {@link isResponsesMappableContent}). Every excluded case stays on
- * chat/completions; R4's effort-drop remains the defense-in-depth floor there.
- *
- * Content gating is delegated to {@link isResponsesMappableContent} rather
- * than tested inline. It previously required EVERY message's content to be a
- * plain string, which silently excluded Anthropic-style cache-marked system
- * blocks (`systemBlocks` / `SystemContentBlock[]`, which reach the provider as
- * an all-text content array). Callers that set `systemBlocks` to fix a cold
- * prompt cache therefore lost Responses routing and hard-400ed on
- * chat/completions — the exact failure this router exists to prevent. All-text
- * arrays now route and are flattened losslessly; true multimodal content is
- * still excluded, because the mapper still cannot represent it.
+ * Whether the `/v1/responses` builder can carry message `m` without losing
+ * content. Text-only content ({@link isResponsesMappableContent}) maps on
+ * every role. User and tool messages may also carry image parts: a user turn
+ * sends them as `input_image`, and a tool result becomes a
+ * `function_call_output` whose output is an `input_text` / `input_image`
+ * array (the form OpenAI's function-calling reference gives for it). Any other
+ * part, such as audio, a file or an Anthropic `tool_result` block, has no
+ * mapping.
+ *
+ * @param m A request message.
+ * @returns `true` when the message maps onto Responses input losslessly.
+ */
+export declare function isResponsesMappableMessage(m: ChatMessage): boolean;
+/**
+ * Whether a call goes to `/v1/responses` instead of `/v1/chat/completions`.
+ * Streamed and non-streamed calls follow this one rule.
+ *
+ *   - Every call {@link openAiRequiresResponsesApi} names: Responses-only
+ *     models and GPT-6 tool calls.
+ *   - A GPT-5 or GPT-6 call that carries function tools and an effort, when
+ *     every message maps ({@link isResponsesMappableMessage}). Chat
+ *     Completions rejects `reasoning_effort` alongside function tools for
+ *     these families ("Function tools with reasoning_effort are not supported
+ *     ... Please use /v1/responses instead"); Responses keeps both, and a
+ *     `responseFormat` travels as `text.format`.
+ *
+ * Content gating goes through {@link isResponsesMappableMessage}, which
+ * accepts Anthropic-style cache-marked system blocks (`systemBlocks` reach the
+ * provider as an all-text content array) and flattens them without loss. A
+ * GPT-5 tool call whose content does not map stays on chat/completions, where
+ * the chat builder drops the effort (see
+ * {@link openAiRejectsReasoningEffortWithTools}).
+ *
+ * @param modelId Provider-side model identifier.
+ * @param messages The request messages.
+ * @param options The request's tools, effort and response format.
+ * @returns `true` when the call goes to `/v1/responses`.
  */
 export declare function shouldRouteToOpenAiResponsesApi(modelId: string, messages: ChatMessage[], options: Pick<ModelCompletionOptions, 'tools' | 'effort' | 'responseFormat'>): boolean;
 export declare class OpenAIProvider implements IProvider {
@@ -278,6 +353,54 @@ export declare class OpenAIProvider implements IProvider {
     generateCompletion(modelId: string, messages: ChatMessage[], options: ModelCompletionOptions): Promise<ModelCompletionResponse>;
     /** @inheritdoc */
     generateCompletionStream(modelId: string, messages: ChatMessage[], options: ModelCompletionOptions): AsyncGenerator<ModelCompletionResponse, void, undefined>;
+    /**
+     * The terminal chunk a stream yields when the caller's signal aborts it.
+     * @private
+     */
+    private abortedStreamChunk;
+    /**
+     * Maps a `/v1/chat/completions` SSE stream onto
+     * {@link ModelCompletionResponse} chunks, accumulating streamed tool calls
+     * by index. A caller abort ends the stream with the abort chunk.
+     * @private
+     */
+    private mapChatStream;
+    /**
+     * Maps a `/v1/responses` SSE stream onto the {@link ModelCompletionResponse}
+     * chunks the chat stream produces.
+     *
+     *   - `response.output_text.delta` yields a text chunk.
+     *   - A `function_call` item yields a tool-call delta with its id and name
+     *     (`response.output_item.added`), then its argument fragments
+     *     (`response.function_call_arguments.delta`). Tool-call indexes are
+     *     dense in order of appearance, so a reasoning item ahead of the calls
+     *     leaves no gap.
+     *   - The item's final form (`response.function_call_arguments.done`,
+     *     `response.output_item.done`) and the terminal response are
+     *     authoritative. Text, a call id or name, or an argument suffix that the
+     *     deltas did not carry goes out as one more delta, exactly once, before
+     *     the final chunk. A consumer that rebuilds the turn from deltas
+     *     (StreamingReconstructor) and one that reads the final chunk
+     *     (streamText, GMI) therefore see the same text and calls, including
+     *     when a proxy strips the delta events.
+     *   - `response.completed` and `response.incomplete` yield exactly one final
+     *     chunk with the finish reason, tool calls and usage.
+     *   - Before any text or tool call has gone out, `response.failed`, an
+     *     `error` event, and a body that ends or fails to read before a terminal
+     *     event throw an {@link OpenAIProviderError}, as a failed HTTP request
+     *     does: the status of a retryable error code
+     *     ({@link RESPONSES_RETRYABLE_ERROR_STATUS}) or `NETWORK_ERROR` for the
+     *     cut-off or failed body, and a failed response's billed usage in
+     *     `details.usage`. Callers can then fail over and meter the attempt.
+     *   - After output, those failures and a caller abort each yield one final
+     *     chunk carrying an error instead, so the partial answer stays with the
+     *     caller.
+     *
+     * Reasoning summaries, content-part events and refusals carry nothing this
+     * mapping surfaces and are skipped.
+     * @private
+     */
+    private mapResponsesStream;
     /** @inheritdoc */
     generateEmbeddings(modelId: string, texts: string[], options?: ProviderEmbeddingOptions): Promise<ProviderEmbeddingResponse>;
     /** @inheritdoc */
@@ -319,17 +442,31 @@ export declare class OpenAIProvider implements IProvider {
      */
     private applyCacheAndTierParams;
     /**
-     * Build a `/v1/responses` request body for a gpt-5/gpt-6 reasoning +
-     * function-tool call (the only case
-     * {@link shouldRouteToOpenAiResponsesApi} routes here).
-     * Preserves BOTH `reasoning.effort` and `tools`, which chat/completions
-     * rejects together. No structured output by construction (the router
-     * excludes responseFormat). Message content arrives as either a plain
-     * string or an all-text block array — {@link flattenResponsesTextContent}
-     * joins the latter, so cache-marked `systemBlocks` survive intact instead of
-     * collapsing to an empty prompt. True multimodal content never reaches here
-     * (the router excludes it via {@link isResponsesMappableContent}).
+     * Build a `/v1/responses` request body for a call
+     * {@link shouldRouteToOpenAiResponsesApi} sends there: a Responses-only
+     * model, a GPT-6 tool call, or a GPT-5/GPT-6 tool call that carries an
+     * effort.
+     *
+     *   - System, assistant and text-only turns carry flattened text
+     *     ({@link flattenResponsesTextContent}), so cache-marked `systemBlocks`
+     *     arrive joined instead of empty. A user turn with images carries
+     *     `input_text` / `input_image` parts, and a tool result with images
+     *     becomes a `function_call_output` whose output is that part array.
+     *   - `tools`, `reasoning` and `text.format` appear only when the call has
+     *     function tools, an effort the model maps, or an OpenAI-shaped
+     *     `responseFormat`. `stream: true` marks a streamed call; Responses has
+     *     no `stream_options.include_usage` and reports usage on the terminal
+     *     event.
+     *   - A chat-style `reasoning_effort` in `customModelParams` moves to
+     *     `reasoning.effort`, because Responses rejects the top-level key.
+     *
      * Live-probed 2026-07-08; block-content path live-probed 2026-09-12.
+     *
+     * @throws {OpenAIProviderError} `RESPONSES_UNMAPPABLE_CONTENT` when a
+     *   message carries a part Responses cannot represent (audio, a file, an
+     *   Anthropic `tool_result` block). Only a call with no Chat Completions
+     *   route reaches here with such content; the error is not retryable, like
+     *   the 400 or 404 Chat Completions would return for it.
      * @private
      */
     private buildResponsesPayload;
@@ -353,6 +490,25 @@ export declare class OpenAIProvider implements IProvider {
      * @private
      */
     private mapResponsesToCompletionResponse;
+    /**
+     * Logs a `/v1/responses` turn that holds output items but no message and
+     * no function call: reasoning-only output. It is returned as an empty turn
+     * carrying the real finish reason (`length` when max_output_tokens capped
+     * it), so the caller can retry with a larger budget. Reasoning tokens come
+     * out of the same output budget as the visible answer, so a reasoning model
+     * needs a materially larger maxTokens than a non-reasoning one to leave
+     * room for a reply.
+     * @private
+     */
+    private warnReasoningOnlyOutput;
+    /**
+     * Token usage and cost for a `/v1/responses` result. The Responses API
+     * spells the counts `input_tokens` / `output_tokens` and the cached detail
+     * `input_tokens_details`; they are re-keyed to the chat spelling so both
+     * endpoints meter through {@link calculateUsage}.
+     * @private
+     */
+    private mapResponsesUsage;
     /**
      * Maps the raw OpenAI API Chat Completion response to the standard ModelCompletionResponse.
      * @private
@@ -387,7 +543,20 @@ export declare class OpenAIProvider implements IProvider {
      */
     private resolvePricing;
     /**
-     * Calculates the estimated cost of an API call.
+     * Estimated USD cost of one API call, from the per-1K rates in
+     * `modelPricing`. When the model has long-context pricing
+     * ({@link openAiHasLongContextPricing}) and the prompt exceeds
+     * {@link OPENAI_LONG_CONTEXT_THRESHOLD_TOKENS} input tokens, the whole call
+     * bills at the long-context rates: every input token at 2x and every output
+     * token at 1.5x.
+     *
+     * @param promptTokens Input tokens, cached tokens included. OpenAI compares
+     *   this same count against the long-context threshold.
+     * @param completionTokens Output tokens, reasoning tokens included.
+     * @param modelId Model id as echoed by the API; a dated snapshot without its
+     *   own row resolves to its base row.
+     * @param isEmbedding Prices `promptTokens` alone at the embedding rate.
+     * @returns Cost in USD, or undefined when the model has no price row.
      * @private
      */
     private calculateCost;
@@ -400,12 +569,28 @@ export declare class OpenAIProvider implements IProvider {
      * @param {string} apiKey - The API key to use.
      * @param {Record<string, unknown>} [body] - The request body for POST requests.
      * @param {boolean} [expectStream] - Whether the response is expected to be a stream.
+     * @param {number} [requestTimeoutOverride] - Per-call timeout in ms, over the configured default.
+     * @param {AbortSignal} [abortSignal] - Caller's signal. It aborts the fetch in flight, and once
+     *   it has fired no further attempt is sent.
      * @returns {Promise<T | ReadableStream<Uint8Array>>} The API response or stream.
-     * @throws {OpenAIProviderError} If the request fails after retries or for non-retryable errors.
+     * @throws {OpenAIProviderError} If the request fails after retries or for non-retryable errors;
+     *   `REQUEST_ABORTED` when the caller's signal ends it.
      */
     private makeApiRequest;
     /**
-     * Parses an SSE (Server-Sent Events) stream.
+     * {@link parseSseStream} for the /v1/responses mapper: a read that fails
+     * mid-body (parseSseStream's `STREAM_PARSING_ERROR`) ends the stream and is
+     * recorded on `reading.failure` instead of propagating, so the mapper
+     * handles it like a body cut off before its terminal event.
+     * @private
+     */
+    private readResponsesSse;
+    /**
+     * Parses an SSE (Server-Sent Events) stream and yields each `data:` payload.
+     *
+     * When `abortSignal` fires, the reader is cancelled at once, which settles
+     * a read that is waiting on the network, and the generator ends without
+     * yielding more; the caller then emits its abort chunk.
      * @private
      */
     private parseSseStream;

package/dist/core/llm/providers/implementations/OpenAIProvider.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"OpenAIProvider.d.ts","sourceRoot":"","sources":["../../../../../src/core/llm/providers/implementations/OpenAIProvider.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"OpenAIProvider.d.ts","sourceRoot":"","sources":["../../../../../src/core/llm/providers/implementations/OpenAIProvider.ts"],"names":[],"mappings":"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"}