gemi 0.60.0 → 0.61.0

package/dist/ai/live/harness.d.ts

@@ -0,0 +1,137 @@
+/**
+ * The plumbing the live suite needs, kept out of the suite so the tests read as
+ * claims about the API rather than as setup.
+ *
+ * NOTHING IN THIS DIRECTORY READS A KEY BY VALUE. The providers pull
+ * `OPENAI_API_KEY` / `AZURE_OPENAI_API_KEY` out of `process.env` themselves —
+ * see `AgentProvider.endpoint()` — so the only thing this file does with a
+ * credential is ask whether one is set. That is deliberate: a harness that
+ * carried the key around would eventually put it in a failure message, and a
+ * failure message is the one place a secret is guaranteed to be printed.
+ */
+import type { AgentProvider, ProviderEvent, ProviderStream, ProviderStreamParams } from "../AgentProvider";
+import type { AgentMessage, AgentStreamFrame, Usage } from "../types";
+/**
+ * The model the suite is written against. `gpt-5.4` is not incidental: it is
+ * the generation where tool search exists (see `providers/capabilities.ts`),
+ * and the deferred-namespace test is the whole reason this suite exists.
+ *
+ * Overridable so a resource whose deployment is called something else can still
+ * run — Azure lets whoever ran the template name it anything.
+ */
+export declare const LIVE_MODEL: string;
+export declare const LIVE_AZURE_DEPLOYMENT: string;
+/**
+ * A key alone is not enough for Azure: the provider also needs to know which
+ * resource, and there are three spellings of that. Checking for all three is
+ * what stops the suite from running and failing with a 404 for a contributor
+ * who exported the key and nothing else.
+ */
+export declare const AZURE_RESOURCE_VARS: readonly ["AZURE_OPENAI_ENDPOINT", "AZURE_OPENAI_RESOURCE_NAME", "AZURE_RESOURCE_NAME"];
+export declare const openaiConfigured: boolean;
+export declare const azureConfigured: boolean;
+/**
+ * A provider that records what went through it and caps what it costs.
+ *
+ * Two jobs, and both are load-bearing rather than convenience:
+ *
+ * `calls` is evidence. The memoization claim in the escalation test — that a
+ * sub-run which finished on turn one is replayed from the transcript rather
+ * than run again — is not observable from the transcript, because a replayed
+ * run and a re-run one produce the same messages. The only difference is
+ * whether a request was made, so the test counts requests.
+ *
+ * `maxOutputTokens` is a cap `Agent` has no way to set: `AgentStreamParams`
+ * carries no token budget, deliberately, and `ProviderStreamParams` does. So
+ * the cap goes on the seam between them. Without it a reasoning model asked a
+ * puzzle can spend thousands of tokens deciding how to say "nine".
+ */
+export declare class RecordingProvider implements AgentProvider {
+    private readonly inner;
+    private readonly maxOutputTokens;
+    readonly model: string;
+    readonly capabilities: AgentProvider["capabilities"];
+    /** One entry per model call, in order. */
+    readonly requests: ProviderStreamParams[];
+    /** Every `ProviderEvent` the parser produced, flattened across calls — this
+     *  is where the tool-search and namespace assertions read from, because
+     *  `AgentStreamEvent` carries only half of what the parser knows. */
+    readonly events: ProviderEvent[];
+    constructor(inner: AgentProvider, maxOutputTokens: number);
+    get calls(): number;
+    /**
+     * What the provider itself reported spending, summed over every call.
+     *
+     * Deliberately a second implementation of `Agent`'s `addUsage` rather than a
+     * call to it: the claim being checked is that the run's total is the sum of
+     * what the provider billed, and asking the accumulator whether it accumulated
+     * would check nothing. The optional members follow the same rule the real one
+     * does — present as soon as any call reported them, so a run whose provider
+     * never mentions reasoning tokens keeps the smaller shape.
+     */
+    spent(): Usage;
+    stream(params: ProviderStreamParams): ProviderStream;
+    upload(file: File): Promise<string>;
+    normalizeError(error: unknown): import("../types").AgentError;
+}
+export type LiveTarget = {
+    /** Appears in every suite name, so `vitest -t openai` selects one provider. */
+    label: "openai" | "azure";
+    provider: (maxOutputTokens?: number) => RecordingProvider;
+};
+export declare const TARGETS: LiveTarget[];
+export declare const configuredFor: (label: LiveTarget["label"]) => boolean;
+export declare const textOf: (message: AgentMessage | undefined) => string;
+export declare const partsOf: (messages: AgentMessage[], type: string) => any[];
+export declare const lastOf: <T>(items: T[]) => T;
+/** Every text part in the run, joined — what the user ends up reading. */
+export declare const transcriptText: (messages: AgentMessage[]) => string;
+/**
+ * The same text with digit grouping removed, for the assertions that look for a
+ * number the tool produced.
+ *
+ * A model writes 7413 as "7,413" about half the time, and on a French system
+ * prompt it would write "7 413". Stripping the separators is not a weaker
+ * assertion — it is the same number — and the alternative, telling the model
+ * how to format its digits, would make the test pass by changing what is being
+ * measured.
+ */
+export declare const withoutDigitGrouping: (text: string) => string;
+/**
+ * Drains a run's numbered frames while it is still going, twice over.
+ *
+ * `frames()` rather than the plain async iterator because half the claims in
+ * this suite are about `seq` — that nested events are numbered in the parent's
+ * sequence, and that a client replaying them lands on the same transcript.
+ *
+ * WHY TWO ARRAYS, AND WHY THIS IS NOT PEDANTRY. A `tool-call` frame carries the
+ * `ToolCallPart` BY REFERENCE, and the part goes on being written to after the
+ * frame is emitted: `nestedRunner` hangs `nested` on it, and the sub-run's
+ * transcript grows there for the rest of the call. In process, that means a
+ * frame collected at the top of a run has a *different* value by the end of it.
+ *
+ * `AgentRunImpl.toResponse` does `JSON.stringify(frame.event)` at yield time,
+ * so a browser watching live receives the part as it was when the frame went
+ * out — which is what `wire` is: a clone taken the instant the frame arrived.
+ * That is the only honest input for a test of the client reducer. Feeding the
+ * live objects instead would hand the reducer a nested transcript it never had
+ * to build, and a reducer that dropped `nested-event` entirely would still
+ * pass. (It did. That is how this was found.)
+ *
+ * `live` is kept because the other shape is real too: a client that calls
+ * `/attach?from=0` after the run has finished gets the buffered frames
+ * serialized *then*, nested transcript already on the part, and then every
+ * `nested-event` again on top of it. Converging from there is a claim worth
+ * making rather than an accident worth relying on.
+ */
+export declare function collectFrames(run: {
+    frames(from?: number): AsyncIterable<AgentStreamFrame>;
+}): {
+    wire: AgentStreamFrame[];
+    live: AgentStreamFrame[];
+    done: Promise<void>;
+};
+/** The request that has no user in it: these tests call `Agent.stream` directly
+ *  rather than through the controller, and no tool here reads the request. */
+export declare const req: any;
+//# sourceMappingURL=harness.d.ts.map

package/dist/ai/live/harness.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"harness.d.ts","sourceRoot":"","sources":["../../../ai/live/harness.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,OAAO,KAAK,EACV,aAAa,EACb,aAAa,EACb,cAAc,EACd,oBAAoB,EACrB,MAAM,kBAAkB,CAAC;AAE1B,OAAO,KAAK,EAAE,YAAY,EAAE,gBAAgB,EAAE,KAAK,EAAE,MAAM,UAAU,CAAC;AAEtE;;;;;;;GAOG;AACH,eAAO,MAAM,UAAU,QAAyC,CAAC;AACjE,eAAO,MAAM,qBAAqB,QAC8C,CAAC;AAEjF;;;;;GAKG;AACH,eAAO,MAAM,mBAAmB,yFAItB,CAAC;AAEX,eAAO,MAAM,gBAAgB,SAAsC,CAAC;AACpE,eAAO,MAAM,eAAe,SAEoC,CAAC;AAEjE;;;;;;;;;;;;;;;GAeG;AACH,qBAAa,iBAAkB,YAAW,aAAa;IAWnD,OAAO,CAAC,QAAQ,CAAC,KAAK;IACtB,OAAO,CAAC,QAAQ,CAAC,eAAe;IAXlC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,YAAY,EAAE,aAAa,CAAC,cAAc,CAAC,CAAC;IACrD,0CAA0C;IAC1C,QAAQ,CAAC,QAAQ,EAAE,oBAAoB,EAAE,CAAM;IAC/C;;yEAEqE;IACrE,QAAQ,CAAC,MAAM,EAAE,aAAa,EAAE,CAAM;gBAGnB,KAAK,EAAE,aAAa,EACpB,eAAe,EAAE,MAAM;IAM1C,IAAI,KAAK,IAAI,MAAM,CAElB;IAED;;;;;;;;;OASG;IACH,KAAK,IAAI,KAAK;IAkBd,MAAM,CAAC,MAAM,EAAE,oBAAoB,GAAG,cAAc;IAYpD,MAAM,CAAC,IAAI,EAAE,IAAI,GAAG,OAAO,CAAC,MAAM,CAAC;IAInC,cAAc,CAAC,KAAK,EAAE,OAAO;CAG9B;AAMD,MAAM,MAAM,UAAU,GAAG;IACvB,+EAA+E;IAC/E,KAAK,EAAE,QAAQ,GAAG,OAAO,CAAC;IAC1B,QAAQ,EAAE,CAAC,eAAe,CAAC,EAAE,MAAM,KAAK,iBAAiB,CAAC;CAC3D,CAAC;AAEF,eAAO,MAAM,OAAO,EAAE,UAAU,EAW/B,CAAC;AAEF,eAAO,MAAM,aAAa,GAAI,OAAO,UAAU,CAAC,OAAO,CAAC,YACC,CAAC;AAI1D,eAAO,MAAM,MAAM,GAAI,SAAS,YAAY,GAAG,SAAS,KAAG,MAI9C,CAAC;AAEd,eAAO,MAAM,OAAO,GAAI,UAAU,YAAY,EAAE,EAAE,MAAM,MAAM,KAAG,GAAG,EAC0B,CAAC;AAE/F,eAAO,MAAM,MAAM,GAAI,CAAC,EAAE,OAAO,CAAC,EAAE,KAAG,CAA4B,CAAC;AAEpE,0EAA0E;AAC1E,eAAO,MAAM,cAAc,GAAI,UAAU,YAAY,EAAE,WAAoC,CAAC;AAE5F;;;;;;;;;GASG;AACH,eAAO,MAAM,oBAAoB,GAAI,MAAM,MAAM,WACG,CAAC;AAErD;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAgB,aAAa,CAAC,GAAG,EAAE;IAAE,MAAM,CAAC,IAAI,CAAC,EAAE,MAAM,GAAG,aAAa,CAAC,gBAAgB,CAAC,CAAA;CAAE;;;;EAU5F;AAED;8EAC8E;AAC9E,eAAO,MAAM,GAAG,EAAS,GAAG,CAAC"}

package/dist/ai/providers/call.d.ts

@@ -0,0 +1,42 @@
+import type { ProviderEvent } from "../AgentProvider";
+import { type FetchLike } from "./http";
+import type { ResponsesRequest } from "./request";
+/**
+ * The parts of a call that differ between OpenAI and Azure, and nothing else.
+ *
+ * Two classes, one request path: the differences are a URL, a header and when
+ * the credential is read, so those are what gets passed in. Everything below
+ * this line — retries, decoding, event translation, what an error looks like —
+ * is identical, and duplicating it into the Azure class is how the two would
+ * start behaving differently by accident.
+ */
+export type ResponsesEndpoint = {
+    responsesUrl: string;
+    filesUrl: string;
+    /** Async because Entra tokens expire mid-conversation, so the credential has
+     *  to be read per request rather than per provider. */
+    headers: () => Promise<Record<string, string>>;
+    timeoutMs: number;
+    maxRetries: number;
+    fetchImpl?: FetchLike;
+};
+/**
+ * Errors reach the consumer as events, not exceptions.
+ *
+ * A `ProviderStream` that threw would make every caller wrap its `for await`,
+ * and would lose the deltas already yielded — the agent needs the text it got
+ * before the socket died, because the user has already read it.
+ */
+export declare function streamResponses(endpoint: ResponsesEndpoint, body: ResponsesRequest, params: {
+    signal?: AbortSignal;
+    structuredOutput: boolean;
+}): AsyncGenerator<ProviderEvent>;
+/**
+ * Uploads an attachment and returns the id a `FilePart` carries.
+ *
+ * `user_data` rather than `assistants`: this is a file a person attached to a
+ * message, not a corpus for a retrieval store, and the purpose is what decides
+ * which of the two the file can be used for.
+ */
+export declare function uploadFile(endpoint: ResponsesEndpoint, file: File): Promise<string>;
+//# sourceMappingURL=call.d.ts.map

package/dist/ai/providers/call.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"call.d.ts","sourceRoot":"","sources":["../../../ai/providers/call.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAEtD,OAAO,EAAoB,KAAK,SAAS,EAAE,MAAM,QAAQ,CAAC;AAC1D,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,WAAW,CAAC;AAGlD;;;;;;;;GAQG;AACH,MAAM,MAAM,iBAAiB,GAAG;IAC9B,YAAY,EAAE,MAAM,CAAC;IACrB,QAAQ,EAAE,MAAM,CAAC;IACjB;2DACuD;IACvD,OAAO,EAAE,MAAM,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;IAC/C,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,CAAC,EAAE,SAAS,CAAC;CACvB,CAAC;AAEF;;;;;;GAMG;AACH,wBAAuB,eAAe,CACpC,QAAQ,EAAE,iBAAiB,EAC3B,IAAI,EAAE,gBAAgB,EACtB,MAAM,EAAE;IAAE,MAAM,CAAC,EAAE,WAAW,CAAC;IAAC,gBAAgB,EAAE,OAAO,CAAA;CAAE,GAC1D,cAAc,CAAC,aAAa,CAAC,CA4C/B;AAED;;;;;;GAMG;AACH,wBAAsB,UAAU,CAAC,QAAQ,EAAE,iBAAiB,EAAE,IAAI,EAAE,IAAI,GAAG,OAAO,CAAC,MAAM,CAAC,CAyBzF"}

package/dist/ai/providers/capabilities.d.ts

@@ -0,0 +1,50 @@
+import type { ProviderCapabilities } from "../AgentProvider";
+/**
+ * What a model can do, read off its id.
+ *
+ * Hardcoding `true` was never an option — `reasoning: { effort }` is a 400 on
+ * gpt-4o, and `defer_loading` is a 400 on anything that predates tool search —
+ * but neither is a table lookup that only answers for ids we shipped knowing
+ * about.
+ *
+ * SO AN UNKNOWN ID GETS EVERY CAPABILITY. That is the whole point: a model
+ * released next Tuesday must be usable by writing its name, not by waiting for
+ * a gemi release. The default is chosen for how it fails, not for how often it
+ * is right. Guessing high fails loudly and once — the API rejects the request
+ * and names the parameter it disliked, and the fix is one line of config.
+ * Guessing low fails silently and forever: reasoning is dropped, every deferred
+ * schema is inlined, and the only symptom is a bigger bill and a worse answer.
+ * Unknown ids also skew new rather than old, because nobody invents the name of
+ * a model that already shipped.
+ *
+ * The named families below exist to make the *known-old* cases right, which is
+ * the only place a guess can be wrong in the quiet direction.
+ *
+ * Note what an answer of `false` does and does not buy. `reasoning: false` and
+ * `toolSearch: false` change the request, because both are optimizations and
+ * the run is identical without them. `structuredOutput: false` does not: it is
+ * reported honestly for a caller that wants to branch on it, but the request
+ * builder still sends the schema, because an agent that declared an `output`
+ * has an app waiting on a typed result and dropping the parameter would answer
+ * prose forever with nothing to branch on. See `request.ts`.
+ */
+export declare function capabilitiesForModel(model: string): ProviderCapabilities;
+export type Family = {
+    kind: "gpt" | "o";
+    major: number;
+    minor: number;
+};
+/**
+ * Reads the generation out of `gpt-5.4-mini-2025-01-01` or `o3-mini`.
+ *
+ * The minor number is read as well as the major, and it is load-bearing: tool
+ * search arrived at gpt-5.2, so `gpt-5` and `gpt-5.4` are two different answers
+ * to the same question and a major-only reading gets one of them wrong. An id
+ * with no minor — `gpt-5`, `gpt-4o`, `o3` — is minor 0, which is what it is.
+ *
+ * Exported for its own test: the classification is what the guards below are
+ * really about, and it is the only place they are observable — two ids can
+ * classify differently and still land on the same capability answer today.
+ */
+export declare function parseFamily(id: string): Family | null;
+//# sourceMappingURL=capabilities.d.ts.map

package/dist/ai/providers/capabilities.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"capabilities.d.ts","sourceRoot":"","sources":["../../../ai/providers/capabilities.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,kBAAkB,CAAC;AAE7D;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,MAAM,GAAG,oBAAoB,CAgDxE;AA4CD,MAAM,MAAM,MAAM,GAAG;IAAE,IAAI,EAAE,KAAK,GAAG,GAAG,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAAC;AAEzE;;;;;;;;;;;GAWG;AACH,wBAAgB,WAAW,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAcrD"}

package/dist/ai/providers/errors.d.ts

@@ -0,0 +1,37 @@
+import type { AgentError } from "../types";
+/**
+ * A non-2xx response, carried as an exception so the retry loop and
+ * `normalizeError` can both read it.
+ *
+ * The body is kept parsed-if-possible and raw-if-not: OpenAI and Azure both
+ * answer `{ error: { message, type, code } }` on a good day, and an HTML error
+ * page from a proxy on a bad one, and the bad day is exactly when the text
+ * matters.
+ */
+export declare class ProviderHttpError extends Error {
+    readonly status: number;
+    readonly body: unknown;
+    readonly requestId?: string;
+    constructor(status: number, body: unknown, requestId?: string);
+}
+/**
+ * The request ran out of time. Its own class because it must not read as a
+ * user abort: `stop()` means the person is done, and a timeout means the
+ * network was, and only one of those is worth trying again.
+ */
+export declare class ProviderTimeoutError extends Error {
+    readonly timeoutMs: number;
+    constructor(timeoutMs: number);
+}
+/**
+ * Provider failures onto `AgentErrorCode`.
+ *
+ * The contract an app is buying here is that it can branch on `rate_limited`
+ * without knowing whose rate limit it was, and on `retryable` without knowing
+ * which of the two APIs answered. So `retryable` is set from what is actually
+ * true of the failure — a 429 from a spent quota is not retryable no matter
+ * what its status code says, and neither is a request that will be too long
+ * again next time.
+ */
+export declare function normalizeProviderError(error: unknown): AgentError;
+//# sourceMappingURL=errors.d.ts.map

package/dist/ai/providers/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../../ai/providers/errors.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,UAAU,CAAC;AAE3C;;;;;;;;GAQG;AACH,qBAAa,iBAAkB,SAAQ,KAAK;IAC1C,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;IACvB,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;gBAEhB,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,EAAE,SAAS,CAAC,EAAE,MAAM;CAO9D;AAED;;;;GAIG;AACH,qBAAa,oBAAqB,SAAQ,KAAK;IAC7C,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;gBAEf,SAAS,EAAE,MAAM;CAK9B;AAyBD;;;;;;;;;GASG;AACH,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,OAAO,GAAG,UAAU,CA4BjE"}

package/dist/ai/providers/fakeProvider.d.ts

@@ -0,0 +1,35 @@
+import type { AgentProvider, ProviderEvent, ProviderStreamParams } from "../AgentProvider";
+/**
+ * Scripted `ProviderEvent`s, one script per model call.
+ *
+ * The real provider is written against the same interface elsewhere; depending
+ * on it in a test would make that test a test of two things at once, and would
+ * need a network.
+ *
+ * It lives in source rather than in a test file for the same reason
+ * `store/stubAgentRun.ts` does: both the `Agent` tests and the controller tests
+ * need it, and a test file that imports another test file gets that file's
+ * suites collected twice.
+ */
+export declare class FakeProvider {
+    private scripts;
+    readonly model = "fake";
+    readonly capabilities: {
+        reasoning: boolean;
+        structuredOutput: boolean;
+        fileInput: boolean;
+        parallelToolCalls: boolean;
+        toolSearch: boolean;
+    };
+    readonly calls: ProviderStreamParams[];
+    constructor(scripts: ProviderEvent[][]);
+    stream(params: ProviderStreamParams): AsyncGenerator<ProviderEvent, void, unknown>;
+    upload(): Promise<string>;
+    normalizeError(error: unknown): {
+        code: "provider_error";
+        message: string;
+        retryable: boolean;
+    };
+}
+export declare function fakeProvider(...scripts: ProviderEvent[][]): AgentProvider & FakeProvider;
+//# sourceMappingURL=fakeProvider.d.ts.map

package/dist/ai/providers/fakeProvider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fakeProvider.d.ts","sourceRoot":"","sources":["../../../ai/providers/fakeProvider.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,aAAa,EAAE,oBAAoB,EAAE,MAAM,kBAAkB,CAAC;AAE3F;;;;;;;;;;;GAWG;AACH,qBAAa,YAAY;IAWX,OAAO,CAAC,OAAO;IAV3B,QAAQ,CAAC,KAAK,UAAU;IACxB,QAAQ,CAAC,YAAY;;;;;;MAMnB;IACF,QAAQ,CAAC,KAAK,EAAE,oBAAoB,EAAE,CAAM;gBAExB,OAAO,EAAE,aAAa,EAAE,EAAE;IAE9C,MAAM,CAAC,MAAM,EAAE,oBAAoB;IAc7B,MAAM;IAIZ,cAAc,CAAC,KAAK,EAAE,OAAO;;;;;CAO9B;AAED,wBAAgB,YAAY,CAAC,GAAG,OAAO,EAAE,aAAa,EAAE,EAAE,GACT,aAAa,GAAG,YAAY,CAC5E"}

package/dist/ai/providers/http.d.ts

@@ -0,0 +1,46 @@
+export type FetchLike = (input: string, init: RequestInit) => Promise<Response>;
+export type RequestOptions = {
+    maxRetries: number;
+    timeoutMs: number;
+    signal?: AbortSignal;
+    /** Injected by the tests. Nothing here should ever need a real socket to be
+     *  exercised, and a retry policy that is only tested against a live API is
+     *  one that gets tested during an outage. */
+    fetchImpl?: FetchLike;
+    /** Takes the caller's signal so the default can clear its timer rather than
+     *  hold the process open for a backoff nobody is waiting for any more. An
+     *  injected sleep may ignore it: the wait is raced against the abort either
+     *  way. */
+    sleep?: (ms: number, signal?: AbortSignal) => Promise<void>;
+    random?: () => number;
+    now?: () => number;
+};
+export declare const MAX_DELAY_MS = 20000;
+/**
+ * `Retry-After` in either of its two legal forms: seconds, or an HTTP date.
+ *
+ * Honoured rather than ignored because the server knows when its window
+ * reopens and we are guessing. A value in the past clamps to zero; a garbage
+ * value falls back to the computed backoff, since a header we cannot read is
+ * not a reason to give up on the request.
+ *
+ * Parsed here, bounded at the call site: this returns what the server said.
+ */
+export declare function parseRetryAfter(value: string | null | undefined, now: number): number | undefined;
+/**
+ * Exponential backoff with full jitter. The jitter is the point: without it,
+ * every request that got rate limited at the same moment retries at the same
+ * moment, and the second wave is the same size as the first.
+ */
+export declare function backoffDelayMs(attempt: number, random: () => number): number;
+/**
+ * One HTTP call, retried.
+ *
+ * The timeout covers getting a response, not consuming one. A streamed answer
+ * legitimately takes minutes, and a timeout that kept running would cut off
+ * long completions at exactly the point where they were most expensive to
+ * abandon — so the timer is cleared once the headers land, and only the
+ * caller's own signal can end the body.
+ */
+export declare function requestWithRetry(url: string, init: RequestInit, options: RequestOptions): Promise<Response>;
+//# sourceMappingURL=http.d.ts.map

package/dist/ai/providers/http.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"http.d.ts","sourceRoot":"","sources":["../../../ai/providers/http.ts"],"names":[],"mappings":"AAEA,MAAM,MAAM,SAAS,GAAG,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,WAAW,KAAK,OAAO,CAAC,QAAQ,CAAC,CAAC;AAEhF,MAAM,MAAM,cAAc,GAAG;IAC3B,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,CAAC,EAAE,WAAW,CAAC;IACrB;;iDAE6C;IAC7C,SAAS,CAAC,EAAE,SAAS,CAAC;IACtB;;;eAGW;IACX,KAAK,CAAC,EAAE,CAAC,EAAE,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,WAAW,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IAC5D,MAAM,CAAC,EAAE,MAAM,MAAM,CAAC;IACtB,GAAG,CAAC,EAAE,MAAM,MAAM,CAAC;CACpB,CAAC;AAMF,eAAO,MAAM,YAAY,QAAS,CAAC;AAEnC;;;;;;;;;GASG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAOjG;AAED;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,MAAM,GAAG,MAAM,CAG5E;AA6CD;;;;;;;;GAQG;AACH,wBAAsB,gBAAgB,CACpC,GAAG,EAAE,MAAM,EACX,IAAI,EAAE,WAAW,EACjB,OAAO,EAAE,cAAc,GACtB,OAAO,CAAC,QAAQ,CAAC,CAqGnB"}

package/dist/ai/providers/request.d.ts

@@ -0,0 +1,69 @@
+import type { ProviderCapabilities, ProviderStreamParams, ProviderToolNamespace, ProviderToolSpec } from "../AgentProvider";
+import type { AgentMessage, ToolResultPart } from "../types";
+/**
+ * Building the request body is a pure function, on purpose.
+ *
+ * Everything hard about this provider is in here — item ordering, tool-call
+ * pairing, what a denied call looks like on the wire — and none of it needs a
+ * socket to be wrong. So it is separated from the class that posts it, and the
+ * tests assert the object rather than mocking `fetch` and reading a string.
+ */
+export type ResponsesInputItem = Record<string, unknown>;
+export type ResponsesTool = Record<string, unknown>;
+export type ResponsesRequest = {
+    model: string;
+    input: ResponsesInputItem[];
+    stream: true;
+    instructions?: string;
+    tools?: ResponsesTool[];
+    parallel_tool_calls?: boolean;
+    text?: {
+        format: Record<string, unknown>;
+    };
+    reasoning?: {
+        effort: string;
+        summary: "auto";
+    };
+    temperature?: number;
+    max_output_tokens?: number;
+};
+export declare function buildResponsesRequest(params: ProviderStreamParams, ctx: {
+    model: string;
+    capabilities: ProviderCapabilities;
+}): ResponsesRequest;
+/**
+ * `AgentMessage[]` to Responses input items.
+ *
+ * Order is preserved *within* a message, not just between messages: a message
+ * that holds reasoning, then a tool call, then its result has to arrive in that
+ * order, because the API validates the pairing positionally. So text and file
+ * parts are buffered into one message item and that buffer is flushed the
+ * moment a non-message item appears, rather than emitting all the text first
+ * and all the calls after.
+ */
+export declare function toResponsesInput(messages: AgentMessage[], capabilities: ProviderCapabilities): ResponsesInputItem[];
+/**
+ * Every tool call gets an output, including the ones that never ran.
+ *
+ * The API rejects a history containing a `function_call` with no matching
+ * `function_call_output`, so a denial cannot be expressed by omission — and a
+ * conversation where the user said no has to stay continuable, which is the
+ * whole reason `denied` exists in the first place.
+ *
+ * What is sent is prose rather than a status enum, because the reader is a
+ * language model: it has to be able to tell "the user refused this" from "this
+ * blew up", and those two lead to genuinely different next moves — apologize
+ * and ask, versus try another way.
+ */
+export declare function toolResultOutput(part: ToolResultPart): string;
+/**
+ * Tools and namespaces onto the Responses `tools` array.
+ *
+ * Without tool search the grouping has nothing to do — a namespace exists to be
+ * searched — so it is flattened away and every schema is sent inline with
+ * `deferred` ignored. That is the promise `capabilities.toolSearch` makes:
+ * deferral is a token optimization, and an optimization that changed which
+ * tools the model can reach would not be one.
+ */
+export declare function toResponsesTools(tools: (ProviderToolSpec | ProviderToolNamespace)[] | undefined, capabilities: ProviderCapabilities): ResponsesTool[];
+//# sourceMappingURL=request.d.ts.map

package/dist/ai/providers/request.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"request.d.ts","sourceRoot":"","sources":["../../../ai/providers/request.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,oBAAoB,EACpB,oBAAoB,EACpB,qBAAqB,EACrB,gBAAgB,EACjB,MAAM,kBAAkB,CAAC;AAC1B,OAAO,KAAK,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,UAAU,CAAC;AAE7D;;;;;;;GAOG;AAKH,MAAM,MAAM,kBAAkB,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AACzD,MAAM,MAAM,aAAa,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AAEpD,MAAM,MAAM,gBAAgB,GAAG;IAC7B,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,kBAAkB,EAAE,CAAC;IAC5B,MAAM,EAAE,IAAI,CAAC;IACb,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,KAAK,CAAC,EAAE,aAAa,EAAE,CAAC;IACxB,mBAAmB,CAAC,EAAE,OAAO,CAAC;IAC9B,IAAI,CAAC,EAAE;QAAE,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;KAAE,CAAC;IAC3C,SAAS,CAAC,EAAE;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,CAAC;IAChD,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,iBAAiB,CAAC,EAAE,MAAM,CAAC;CAC5B,CAAC;AAEF,wBAAgB,qBAAqB,CACnC,MAAM,EAAE,oBAAoB,EAC5B,GAAG,EAAE;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,YAAY,EAAE,oBAAoB,CAAA;CAAE,GACzD,gBAAgB,CAiDlB;AAID;;;;;;;;;GASG;AACH,wBAAgB,gBAAgB,CAC9B,QAAQ,EAAE,YAAY,EAAE,EACxB,YAAY,EAAE,oBAAoB,GACjC,kBAAkB,EAAE,CA0EtB;AA0FD;;;;;;;;;;;;GAYG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,cAAc,GAAG,MAAM,CAgB7D;AAUD;;;;;;;;GAQG;AACH,wBAAgB,gBAAgB,CAC9B,KAAK,EAAE,CAAC,gBAAgB,GAAG,qBAAqB,CAAC,EAAE,GAAG,SAAS,EAC/D,YAAY,EAAE,oBAAoB,GACjC,aAAa,EAAE,CA2CjB"}

package/dist/ai/providers/stream.d.ts

@@ -0,0 +1,42 @@
+import type { ProviderEvent } from "../AgentProvider";
+import type { Usage } from "../types";
+/**
+ * The Responses SSE stream to `ProviderEvent`.
+ *
+ * Also a pure function over chunks, for the same reason the request builder is:
+ * everything that breaks here breaks on a byte boundary or a malformed frame,
+ * and neither needs a network to reproduce. The tests drive it with recorded
+ * fixture strings, including one fed a byte at a time.
+ */
+export type SSEMessage = {
+    event: string;
+    data: string;
+    id?: string;
+};
+/**
+ * Chunks to SSE messages.
+ *
+ * Written out rather than reached for as a one-liner because every shortcut
+ * here is a bug that only shows up under load. A frame split across two chunks
+ * is the normal case, not the edge case — TCP has no idea what an event is.
+ * Multi-line `data:` is spec, comment lines beginning with `:` are what
+ * keepalives look like, and a `\r\n` stream is what you get through some
+ * proxies.
+ */
+export declare function sseMessages(chunks: AsyncIterable<string> | Iterable<string>): AsyncGenerator<SSEMessage>;
+type ParseOptions = {
+    /**
+     * Set when the agent declared an `output` schema. The same
+     * `response.output_text.delta` carries prose in one case and the JSON of the
+     * final answer in the other, and only the caller knows which it asked for.
+     */
+    structuredOutput?: boolean;
+};
+export declare function parseResponsesStream(chunks: AsyncIterable<string> | Iterable<string>, options?: ParseOptions): AsyncGenerator<ProviderEvent>;
+export declare function emptyUsage(): Usage;
+export declare function toUsage(raw: any): Usage;
+/** A `ReadableStream` of bytes to the string chunks the parser wants. Split out
+ *  so the parser never has to know it came from a socket. */
+export declare function decodeChunks(body: ReadableStream<Uint8Array> | null): AsyncGenerator<string>;
+export {};
+//# sourceMappingURL=stream.d.ts.map

package/dist/ai/providers/stream.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stream.d.ts","sourceRoot":"","sources":["../../../ai/providers/stream.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AACtD,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,UAAU,CAAC;AAEtC;;;;;;;GAOG;AAEH,MAAM,MAAM,UAAU,GAAG;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,EAAE,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC;AAEtE;;;;;;;;;GASG;AACH,wBAAuB,WAAW,CAChC,MAAM,EAAE,aAAa,CAAC,MAAM,CAAC,GAAG,QAAQ,CAAC,MAAM,CAAC,GAC/C,cAAc,CAAC,UAAU,CAAC,CAwD5B;AAED,KAAK,YAAY,GAAG;IAClB;;;;OAIG;IACH,gBAAgB,CAAC,EAAE,OAAO,CAAC;CAC5B,CAAC;AAIF,wBAAuB,oBAAoB,CACzC,MAAM,EAAE,aAAa,CAAC,MAAM,CAAC,GAAG,QAAQ,CAAC,MAAM,CAAC,EAChD,OAAO,GAAE,YAAiB,GACzB,cAAc,CAAC,aAAa,CAAC,CA4P/B;AA+HD,wBAAgB,UAAU,IAAI,KAAK,CAElC;AAED,wBAAgB,OAAO,CAAC,GAAG,EAAE,GAAG,GAAG,KAAK,CAcvC;AAED;6DAC6D;AAC7D,wBAAuB,YAAY,CACjC,IAAI,EAAE,cAAc,CAAC,UAAU,CAAC,GAAG,IAAI,GACtC,cAAc,CAAC,MAAM,CAAC,CAiBxB"}