@buoy-gg/agent-core 7.0.35 → 7.0.38

package/lib/typescript/engine/tokenCalibration.d.ts

@@ -0,0 +1,46 @@
+/**
+ * How many characters make a token — measured, not assumed.
+ *
+ * Every budget in this engine is kept in characters because that is what a
+ * string has, but every LIMIT that matters is in tokens: the provider's
+ * context window, the reply room, the cost. The conversion was a constant
+ * (4) everywhere. English prose does run near 4; the tool results this agent
+ * actually sends are JSON, which tokenizes nearer 3 — so a request the budget
+ * called 100k tokens could be 130k, on a gateway whose window is 128k. The
+ * proactive budget was optimistic in exactly the sessions it exists for.
+ *
+ * The provider tells us the truth after every request: its usage report
+ * carries the prompt's token count, and the engine knows how many characters
+ * it sent. One division gives the ratio for THIS conversation on THIS
+ * tokenizer; an exponential average smooths a single odd request (a round
+ * that was all prose, or all ids). Strands' design 0008 does the same in
+ * reverse — a known token baseline plus an estimate of the delta — and its
+ * decision record says why: public limits should be in LLM-native units.
+ *
+ * Clamped, because a wrong sample must not be able to blow the budget wide
+ * open (a gateway that reports nonsense usage) or shrink it to nothing.
+ */
+import type { TokenUsage } from "../providers/types";
+export declare const DEFAULT_CHARS_PER_TOKEN = 4;
+export declare class TokenCalibration {
+    private ratio;
+    private samples;
+    /** Characters per token, as currently believed. */
+    get charsPerToken(): number;
+    get sampleCount(): number;
+    /** Fold in one request: what was sent, and what the provider counted. */
+    observe(requestChars: number, promptTokens: number): void;
+    /** Characters a token budget allows, at the believed ratio. */
+    chars(tokens: number): number;
+    reset(): void;
+}
+/**
+ * The whole prompt's token count from a usage report.
+ *
+ * Anthropic reports the cached and freshly-written prefix SEPARATELY from
+ * `input`; OpenAI-shaped providers fold `cached_tokens` INTO `prompt_tokens`.
+ * See TokenUsage. Adding on the wrong protocol double-counts the cache and
+ * halves the believed ratio.
+ */
+export declare function promptTokensOf(usage: TokenUsage, protocol: "anthropic" | "openai"): number;
+//# sourceMappingURL=tokenCalibration.d.ts.map

package/lib/typescript/engine/tokenCalibration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tokenCalibration.d.ts","sourceRoot":"","sources":["../../../src/engine/tokenCalibration.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAErD,eAAO,MAAM,uBAAuB,IAAI,CAAC;AAQzC,qBAAa,gBAAgB;IAC3B,OAAO,CAAC,KAAK,CAA2B;IACxC,OAAO,CAAC,OAAO,CAAK;IAEpB,mDAAmD;IACnD,IAAI,aAAa,IAAI,MAAM,CAE1B;IAED,IAAI,WAAW,IAAI,MAAM,CAExB;IAED,yEAAyE;IACzE,OAAO,CAAC,YAAY,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,GAAG,IAAI;IAOzD,+DAA+D;IAC/D,KAAK,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM;IAI7B,KAAK,IAAI,IAAI;CAId;AAED;;;;;;;GAOG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,UAAU,EAAE,QAAQ,EAAE,WAAW,GAAG,QAAQ,GAAG,MAAM,CAG1F"}

package/lib/typescript/engine/verify.d.ts

@@ -0,0 +1,67 @@
+/**
+ * Outcome verification: after a write lands, check that what the user asked
+ * for actually happened — not just that the adapter said ok.
+ *
+ * "Install override → `{ok:true}`" was reported as done. But installed ≠ a
+ * request has used it ≠ the cart shows it, and each step can succeed while
+ * the outcome fails: the app had the old response cached, the screen kept
+ * saying In Stock, and the reply said "the item is now sold out". Strands'
+ * GoalLoop frames this as a completion criterion with bounded correction; the
+ * criterion borrowed here is DETERMINISTIC — a read-back the engine performs
+ * with the same tools the model has — not a second model judging the reply.
+ *
+ * Three outcomes, each honest about what it is:
+ *
+ * - `verified`   — the read-back shows the requested state.
+ * - `unverified` — the write landed but the read-back cannot yet show the
+ *                  outcome (an override is installed but no request has
+ *                  matched it). Reported as exactly that, never as proof.
+ * - `failed`     — the read-back contradicts the write. The model is told
+ *                  what was found and asked for ONE correction through the
+ *                  same policy and ledger path; never to repeat the write.
+ *
+ * Bounded by construction: each verifier makes a few reads, polls for at most
+ * `waitMs` (small, per action), and stops on the turn's abort signal. It never
+ * dispatches a write, and its reads are not stashed as evidence. Undefined
+ * means "no opinion" — nothing is appended, which is what every action
+ * without a verifier gets.
+ */
+import type { DispatchFn } from "../types";
+export type VerificationStatus = "verified" | "unverified" | "failed";
+export interface Verification {
+    status: VerificationStatus;
+    /** One plain sentence for the row and the model. */
+    detail: string;
+}
+export interface VerifyInput {
+    toolId: string;
+    action: string;
+    params: Record<string, unknown>;
+    result: unknown;
+    dispatch: DispatchFn;
+    signal?: AbortSignal;
+    /**
+     * The store / cache read the engine already took after the write for the
+     * receipt (`captureStoreState`), so the zustand and query verifiers do not
+     * read the same thing twice. Absent → the verifier reads it itself.
+     */
+    after?: unknown;
+}
+type Verifier = (input: VerifyInput) => Promise<Verification | undefined>;
+/** Every key in `want` present in `have` with an equal (deep) value. Arrays compare whole. */
+export declare function isSubset(want: unknown, have: unknown): boolean;
+/**
+ * The adapters' path grammar — dotted keys, `[0]`, and the id-addressed
+ * `[field=value]` the prompt recommends for list edits ("lines[lineId=seed-1].qty").
+ * A mirror of shared/sync/valuePath.ts, kept here because agent-core imports
+ * nothing. The first live run wrote exactly that form and this resolver, then
+ * dotted-only, reported a landed edit as "did not take".
+ */
+export declare function atPath(root: unknown, path: string): unknown;
+export declare const VERIFIERS: Readonly<Record<string, Verifier>>;
+/** Run the verifier for this action, if there is one. Never throws: a read that blows up is "no opinion". */
+export declare function verifyOutcome(input: VerifyInput): Promise<Verification | undefined>;
+/** The trailer the model reads. Kept in the `[Buoy] ` trailer form the bench's parser splits on. */
+export declare function verificationTrailer(v: Verification): string;
+export {};
+//# sourceMappingURL=verify.d.ts.map

package/lib/typescript/engine/verify.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"verify.d.ts","sourceRoot":"","sources":["../../../src/engine/verify.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,UAAU,CAAC;AAE3C,MAAM,MAAM,kBAAkB,GAAG,UAAU,GAAG,YAAY,GAAG,QAAQ,CAAC;AAEtE,MAAM,WAAW,YAAY;IAC3B,MAAM,EAAE,kBAAkB,CAAC;IAC3B,oDAAoD;IACpD,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,WAAW;IAC1B,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAChC,MAAM,EAAE,OAAO,CAAC;IAChB,QAAQ,EAAE,UAAU,CAAC;IACrB,MAAM,CAAC,EAAE,WAAW,CAAC;IACrB;;;;OAIG;IACH,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB;AAED,KAAK,QAAQ,GAAG,CAAC,KAAK,EAAE,WAAW,KAAK,OAAO,CAAC,YAAY,GAAG,SAAS,CAAC,CAAC;AA6B1E,8FAA8F;AAC9F,wBAAgB,QAAQ,CAAC,IAAI,EAAE,OAAO,EAAE,IAAI,EAAE,OAAO,GAAG,OAAO,CAS9D;AAED;;;;;;GAMG;AACH,wBAAgB,MAAM,CAAC,IAAI,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAqB3D;AAiFD,eAAO,MAAM,SAAS,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC,CAMxD,CAAC;AAEF,6GAA6G;AAC7G,wBAAsB,aAAa,CAAC,KAAK,EAAE,WAAW,GAAG,OAAO,CAAC,YAAY,GAAG,SAAS,CAAC,CAQzF;AAED,oGAAoG;AACpG,wBAAgB,mBAAmB,CAAC,CAAC,EAAE,YAAY,GAAG,MAAM,CAS3D"}

package/lib/typescript/index.d.ts

@@ -9,15 +9,19 @@
  */
 export type { ActionDescriptor, ActionEffect, DispatchFn, JsonSchema, ReleaseBehavior, SnapshotFn, ToolDescriptor, UndoSpec, } from "./types";
 export { CATALOG, CATALOG_ACTION_COUNT, CATALOG_TOOL_COUNT } from "./catalog/catalog.g";
+export { CATALOG_ACTIONS, type CatalogAction, type CatalogActionMap, type CatalogToolId, } from "./catalog/catalog.types.g";
 export { fromProviderToolName, toProviderToolName, toProviderTools, type ProviderTool, type ToProviderToolsOptions, } from "./catalog/toProviderTools";
 export { applyDefaults, validateParams, type ValidationResult, } from "./catalog/validateParams";
 export { projectSnapshot, SNAPSHOT_ACTION } from "./catalog/snapshotReads";
+export { normalizeParams, aliasNote, hashQueryKey } from "./catalog/normalizeParams";
 export { createAnthropicProvider } from "./providers/anthropic";
 export { createOpenAIProvider } from "./providers/openai";
 export type { AgentMessage, Provider, ProviderConfig, ProviderRequest, StreamEvent, ThinkingBlock, TokenUsage, ToolCall, ToolResult, } from "./providers/types";
-export { runAgentTurn, runGatedAction, type GatedActionInput, type GatedActionOutcome, type RunTurnInput, type TurnEvent, } from "./engine/runAgentTurn";
-export { buildSystemPrompt, type ContextPack, type SystemPromptInput, } from "./engine/systemPrompt";
-export { buildContextDigest, type BuildContextInput } from "./context/buildContextPack";
+export { runAgentTurn, runGatedAction, readTargetDigest, digestOf, type GatedActionInput, type GatedActionOutcome, type RunTurnInput, type TurnEvent, type ApprovalAnswer, type StopReason, } from "./engine/runAgentTurn";
+export { EvidenceStore, type EvidenceEntry } from "./engine/evidence";
+export { TokenCalibration } from "./engine/tokenCalibration";
+export { buildLiveBlock, buildSystemPrompt, type ContextPack, type Procedure, type SystemPromptInput, } from "./engine/systemPrompt";
+export { buildContextDigest, buildLiveContext, type BuildContextInput, } from "./context/buildContextPack";
 export { EffectLedger, isReversible, type AppliedEffect, type LedgerEntry, type RevertOutcome, } from "./effects/ledger";
 export { humanise, titleCall, toolTitle } from "./policy/labels";
 export * from "./blocks/types";

package/lib/typescript/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,YAAY,EACV,gBAAgB,EAChB,YAAY,EACZ,UAAU,EACV,UAAU,EACV,eAAe,EACf,UAAU,EACV,cAAc,EACd,QAAQ,GACT,MAAM,SAAS,CAAC;AAEjB,OAAO,EAAE,OAAO,EAAE,oBAAoB,EAAE,kBAAkB,EAAE,MAAM,qBAAqB,CAAC;AACxF,OAAO,EACL,oBAAoB,EACpB,kBAAkB,EAClB,eAAe,EACf,KAAK,YAAY,EACjB,KAAK,sBAAsB,GAC5B,MAAM,2BAA2B,CAAC;AACnC,OAAO,EACL,aAAa,EACb,cAAc,EACd,KAAK,gBAAgB,GACtB,MAAM,0BAA0B,CAAC;AAClC,OAAO,EAAE,eAAe,EAAE,eAAe,EAAE,MAAM,yBAAyB,CAAC;AAE3E,OAAO,EAAE,uBAAuB,EAAE,MAAM,uBAAuB,CAAC;AAChE,OAAO,EAAE,oBAAoB,EAAE,MAAM,oBAAoB,CAAC;AAC1D,YAAY,EACV,YAAY,EACZ,QAAQ,EACR,cAAc,EACd,eAAe,EACf,WAAW,EACX,aAAa,EACb,UAAU,EACV,QAAQ,EACR,UAAU,GACX,MAAM,mBAAmB,CAAC;AAE3B,OAAO,EACL,YAAY,EACZ,cAAc,EACd,KAAK,gBAAgB,EACrB,KAAK,kBAAkB,EACvB,KAAK,YAAY,EACjB,KAAK,SAAS,GACf,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EACL,iBAAiB,EACjB,KAAK,WAAW,EAChB,KAAK,iBAAiB,GACvB,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EAAE,kBAAkB,EAAE,KAAK,iBAAiB,EAAE,MAAM,4BAA4B,CAAC;AAExF,OAAO,EACL,YAAY,EACZ,YAAY,EACZ,KAAK,aAAa,EAClB,KAAK,WAAW,EAChB,KAAK,aAAa,GACnB,MAAM,kBAAkB,CAAC;AAE1B,OAAO,EAAE,QAAQ,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AACjE,cAAc,gBAAgB,CAAC;AAC/B,OAAO,EAAE,YAAY,EAAE,SAAS,EAAE,cAAc,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AACxF,OAAO,EAAE,cAAc,EAAE,WAAW,EAAE,KAAK,YAAY,EAAE,MAAM,mBAAmB,CAAC;AACnF,OAAO,EACL,MAAM,EACN,YAAY,EACZ,wBAAwB,EACxB,sBAAsB,EACtB,KAAK,SAAS,EACd,KAAK,aAAa,EAClB,KAAK,QAAQ,GACd,MAAM,iBAAiB,CAAC;AACzB,OAAO,EACL,MAAM,EACN,oBAAoB,EACpB,aAAa,EACb,gBAAgB,GACjB,MAAM,iBAAiB,CAAC;AAEzB,OAAO,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,gBAAgB,CAAC;AACnD,OAAO,EACL,oBAAoB,EACpB,gBAAgB,EAChB,KAAK,cAAc,EACnB,KAAK,oBAAoB,GAC1B,MAAM,WAAW,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,YAAY,EACV,gBAAgB,EAChB,YAAY,EACZ,UAAU,EACV,UAAU,EACV,eAAe,EACf,UAAU,EACV,cAAc,EACd,QAAQ,GACT,MAAM,SAAS,CAAC;AAEjB,OAAO,EAAE,OAAO,EAAE,oBAAoB,EAAE,kBAAkB,EAAE,MAAM,qBAAqB,CAAC;AACxF,OAAO,EACL,eAAe,EACf,KAAK,aAAa,EAClB,KAAK,gBAAgB,EACrB,KAAK,aAAa,GACnB,MAAM,2BAA2B,CAAC;AACnC,OAAO,EACL,oBAAoB,EACpB,kBAAkB,EAClB,eAAe,EACf,KAAK,YAAY,EACjB,KAAK,sBAAsB,GAC5B,MAAM,2BAA2B,CAAC;AACnC,OAAO,EACL,aAAa,EACb,cAAc,EACd,KAAK,gBAAgB,GACtB,MAAM,0BAA0B,CAAC;AAClC,OAAO,EAAE,eAAe,EAAE,eAAe,EAAE,MAAM,yBAAyB,CAAC;AAC3E,OAAO,EAAE,eAAe,EAAE,SAAS,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AAErF,OAAO,EAAE,uBAAuB,EAAE,MAAM,uBAAuB,CAAC;AAChE,OAAO,EAAE,oBAAoB,EAAE,MAAM,oBAAoB,CAAC;AAC1D,YAAY,EACV,YAAY,EACZ,QAAQ,EACR,cAAc,EACd,eAAe,EACf,WAAW,EACX,aAAa,EACb,UAAU,EACV,QAAQ,EACR,UAAU,GACX,MAAM,mBAAmB,CAAC;AAE3B,OAAO,EACL,YAAY,EACZ,cAAc,EACd,gBAAgB,EAChB,QAAQ,EACR,KAAK,gBAAgB,EACrB,KAAK,kBAAkB,EACvB,KAAK,YAAY,EACjB,KAAK,SAAS,EACd,KAAK,cAAc,EACnB,KAAK,UAAU,GAChB,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EAAE,aAAa,EAAE,KAAK,aAAa,EAAE,MAAM,mBAAmB,CAAC;AACtE,OAAO,EAAE,gBAAgB,EAAE,MAAM,2BAA2B,CAAC;AAC7D,OAAO,EACL,cAAc,EACd,iBAAiB,EACjB,KAAK,WAAW,EAChB,KAAK,SAAS,EACd,KAAK,iBAAiB,GACvB,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EACL,kBAAkB,EAClB,gBAAgB,EAChB,KAAK,iBAAiB,GACvB,MAAM,4BAA4B,CAAC;AAEpC,OAAO,EACL,YAAY,EACZ,YAAY,EACZ,KAAK,aAAa,EAClB,KAAK,WAAW,EAChB,KAAK,aAAa,GACnB,MAAM,kBAAkB,CAAC;AAE1B,OAAO,EAAE,QAAQ,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AACjE,cAAc,gBAAgB,CAAC;AAC/B,OAAO,EAAE,YAAY,EAAE,SAAS,EAAE,cAAc,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AACxF,OAAO,EAAE,cAAc,EAAE,WAAW,EAAE,KAAK,YAAY,EAAE,MAAM,mBAAmB,CAAC;AACnF,OAAO,EACL,MAAM,EACN,YAAY,EACZ,wBAAwB,EACxB,sBAAsB,EACtB,KAAK,SAAS,EACd,KAAK,aAAa,EAClB,KAAK,QAAQ,GACd,MAAM,iBAAiB,CAAC;AACzB,OAAO,EACL,MAAM,EACN,oBAAoB,EACpB,aAAa,EACb,gBAAgB,GACjB,MAAM,iBAAiB,CAAC;AAEzB,OAAO,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,gBAAgB,CAAC;AACnD,OAAO,EACL,oBAAoB,EACpB,gBAAgB,EAChB,KAAK,cAAc,EACnB,KAAK,oBAAoB,GAC1B,MAAM,WAAW,CAAC"}

package/lib/typescript/policy/labels.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"labels.d.ts","sourceRoot":"","sources":["../../../src/policy/labels.ts"],"names":[],"mappings":"AA+MA,sEAAsE;AACtE,wBAAgB,SAAS,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAEhD;AAgCD,yEAAyE;AACzE,wBAAgB,QAAQ,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAO/C;AAaD;;;GAGG;AACH,wBAAgB,SAAS,CACvB,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC9B,MAAM,CAoBR"}
+{"version":3,"file":"labels.d.ts","sourceRoot":"","sources":["../../../src/policy/labels.ts"],"names":[],"mappings":"AAwNA,sEAAsE;AACtE,wBAAgB,SAAS,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAEhD;AAuCD,yEAAyE;AACzE,wBAAgB,QAAQ,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAO/C;AAaD;;;GAGG;AACH,wBAAgB,SAAS,CACvB,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC9B,MAAM,CAoBR"}

package/lib/typescript/policy/policy.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"policy.d.ts","sourceRoot":"","sources":["../../../src/policy/policy.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AACH,OAAO,KAAK,EAAE,gBAAgB,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AAG/D;;;;;;GAMG;AACH,MAAM,WAAW,SAAS;IACxB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,YAAY,CAAC;CACvB;AAED,MAAM,WAAW,aAAa;IAC5B;;;;OAIG;IACH,eAAe,CAAC,EAAE,YAAY,EAAE,CAAC;IACjC;;;;OAIG;IACH,kBAAkB,CAAC,EAAE;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,MAAM,CAAC,EAAE,MAAM,CAAA;KAAE,EAAE,CAAC;IAC3D;;;;OAIG;IACH,KAAK,CAAC,EAAE,SAAS,EAAE,CAAC;IACpB,0DAA0D;IAC1D,IAAI,CAAC,EAAE;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,MAAM,CAAC,EAAE,MAAM,CAAA;KAAE,EAAE,CAAC;IAC7C,0DAA0D;IAC1D,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB;;;;;OAKG;IACH,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,yDAAyD;IACzD,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,wGAAwG;AACxG,eAAO,MAAM,wBAAwB,EAAE,YAAY,EAAoB,CAAC;AAExE,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,aAAa,GAAG,YAAY,EAAE,CAE5E;AAED,MAAM,MAAM,QAAQ,GAChB;IAAE,OAAO,EAAE,OAAO,CAAA;CAAE,GACpB;IAAE,OAAO,EAAE,gBAAgB,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,GAC7C;IAAE,OAAO,EAAE,QAAQ,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC;AAE1C,MAAM,WAAW,WAAW;IAC1B,UAAU,EAAE,gBAAgB,CAAC;IAC7B,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,aAAa,CAAC;IACtB,2CAA2C;IAC3C,SAAS,EAAE,OAAO,CAAC;CACpB;AAKD,wBAAgB,MAAM,CAAC,EACrB,UAAU,EACV,MAAM,EACN,MAAM,EACN,SAAS,GACV,EAAE,WAAW,GAAG,QAAQ,CAuExB;AAoBD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,YAAY,CAC1B,MAAM,EAAE,MAAM,EACd,UAAU,EAAE,gBAAgB,EAC5B,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC9B,MAAM,CAER"}
+{"version":3,"file":"policy.d.ts","sourceRoot":"","sources":["../../../src/policy/policy.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AACH,OAAO,KAAK,EAAE,gBAAgB,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AAG/D;;;;;;GAMG;AACH,MAAM,WAAW,SAAS;IACxB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,YAAY,CAAC;CACvB;AAED,MAAM,WAAW,aAAa;IAC5B;;;;OAIG;IACH,eAAe,CAAC,EAAE,YAAY,EAAE,CAAC;IACjC;;;;OAIG;IACH,kBAAkB,CAAC,EAAE;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,MAAM,CAAC,EAAE,MAAM,CAAA;KAAE,EAAE,CAAC;IAC3D;;;;OAIG;IACH,KAAK,CAAC,EAAE,SAAS,EAAE,CAAC;IACpB,0DAA0D;IAC1D,IAAI,CAAC,EAAE;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,MAAM,CAAC,EAAE,MAAM,CAAA;KAAE,EAAE,CAAC;IAC7C,0DAA0D;IAC1D,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB;;;;;OAKG;IACH,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,yDAAyD;IACzD,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,wGAAwG;AACxG,eAAO,MAAM,wBAAwB,EAAE,YAAY,EAAoB,CAAC;AAExE,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,aAAa,GAAG,YAAY,EAAE,CAE5E;AAED,MAAM,MAAM,QAAQ,GAChB;IAAE,OAAO,EAAE,OAAO,CAAA;CAAE,GACpB;IAAE,OAAO,EAAE,gBAAgB,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,GAC7C;IAAE,OAAO,EAAE,QAAQ,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC;AAE1C,MAAM,WAAW,WAAW;IAC1B,UAAU,EAAE,gBAAgB,CAAC;IAC7B,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,aAAa,CAAC;IACtB,2CAA2C;IAC3C,SAAS,EAAE,OAAO,CAAC;CACpB;AAKD,wBAAgB,MAAM,CAAC,EACrB,UAAU,EACV,MAAM,EACN,MAAM,EACN,SAAS,GACV,EAAE,WAAW,GAAG,QAAQ,CA2ExB;AAoBD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,YAAY,CAC1B,MAAM,EAAE,MAAM,EACd,UAAU,EAAE,gBAAgB,EAC5B,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC9B,MAAM,CAER"}

package/lib/typescript/policy/redact.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"redact.d.ts","sourceRoot":"","sources":["../../../src/policy/redact.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAqDH;;;;GAIG;AACH,wBAAgB,MAAM,CAAC,KAAK,EAAE,OAAO,EAAE,KAAK,SAAI,GAAG,OAAO,CAazD;AAQD,wBAAgB,oBAAoB,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,CAQ3D;AAED,wBAAgB,aAAa,CAAC,GAAG,EAAE,OAAO,GAAG,OAAO,CAOnD;AAQD;;;;;;;;;;GAUG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,OAAO,EAAE,KAAK,SAAI,GAAG,OAAO,CAYnE"}
+{"version":3,"file":"redact.d.ts","sourceRoot":"","sources":["../../../src/policy/redact.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAoEH;;;;GAIG;AACH,wBAAgB,MAAM,CAAC,KAAK,EAAE,OAAO,EAAE,KAAK,SAAI,GAAG,OAAO,CAazD;AAuBD,wBAAgB,oBAAoB,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,CAgB3D;AAED,wBAAgB,aAAa,CAAC,GAAG,EAAE,OAAO,GAAG,OAAO,CAOnD;AAQD;;;;;;;;;;GAUG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,OAAO,EAAE,KAAK,SAAI,GAAG,OAAO,CAYnE"}

package/lib/typescript/providers/anthropic.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"anthropic.d.ts","sourceRoot":"","sources":["../../../src/providers/anthropic.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,OAAO,KAAK,EAEV,QAAQ,EACR,cAAc,EAMf,MAAM,SAAS,CAAC;AAyCjB,wBAAgB,uBAAuB,CAAC,MAAM,EAAE,cAAc,GAAG,QAAQ,CA0MxE"}
+{"version":3,"file":"anthropic.d.ts","sourceRoot":"","sources":["../../../src/providers/anthropic.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,OAAO,KAAK,EAEV,QAAQ,EACR,cAAc,EAMf,MAAM,SAAS,CAAC;AA2EjB,wBAAgB,uBAAuB,CAAC,MAAM,EAAE,cAAc,GAAG,QAAQ,CAySxE"}

package/lib/typescript/providers/openai.d.ts

@@ -1,19 +1,3 @@
-/**
- * OpenAI chat-completions protocol.
- *
- * The differences from Anthropic that actually matter to the code:
- * - Tool results are their own `{role:"tool", tool_call_id, content}` MESSAGE,
- *   not blocks inside a user message.
- * - Tool arguments arrive as a JSON STRING, streamed in fragments, and are
- *   keyed by an `index` that is stable across deltas while `id`/`name` only
- *   appear on the first fragment.
- * - The stream DOES have a `data: [DONE]` sentinel, unlike Anthropic's.
- *
- * This adapter also serves Azure and any OpenAI-compatible org gateway, which
- * is the common shape for an internal LLM proxy. Note Anthropic's own
- * OpenAI-compatibility endpoint is explicitly not production-ready and silently
- * ignores several fields — use the native Anthropic adapter for Anthropic.
- */
 import type { Provider, ProviderConfig } from "./types";
 export declare function createOpenAIProvider(config: ProviderConfig): Provider;
 //# sourceMappingURL=openai.d.ts.map

package/lib/typescript/providers/openai.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"openai.d.ts","sourceRoot":"","sources":["../../../src/providers/openai.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AACH,OAAO,KAAK,EAEV,QAAQ,EACR,cAAc,EAGf,MAAM,SAAS,CAAC;AA2CjB,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,cAAc,GAAG,QAAQ,CA+GrE"}
+{"version":3,"file":"openai.d.ts","sourceRoot":"","sources":["../../../src/providers/openai.ts"],"names":[],"mappings":"AA8BA,OAAO,KAAK,EAEV,QAAQ,EACR,cAAc,EAIf,MAAM,SAAS,CAAC;AA8DjB,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,cAAc,GAAG,QAAQ,CAkNrE"}

package/lib/typescript/providers/problem.d.ts

@@ -0,0 +1,50 @@
+/**
+ * What kind of failure a provider reported — decided once, from the status,
+ * the error type and the message, so the engine can act on the KIND rather
+ * than grep a string.
+ *
+ * Only two kinds are acted on, and both only when nothing has been generated:
+ *
+ * - `throttled` — 429 / 529 / 503, a `rate_limit_error` or `overloaded_error`
+ *   frame, or a body that says so. Waiting and asking again is the right move;
+ *   the request never reached a model.
+ * - `overflow` — the provider refused the request as too big. Trimming older
+ *   history and asking once more is the right move; the proactive budget is
+ *   an estimate (chars ÷ 4) and JSON tokenizes worse than prose.
+ *
+ * Everything else — auth, a bad schema, an unknown model, a mid-answer
+ * `api_error` — is reported and NOT retried. The phrase lists are the union
+ * observed across provider responses by the Strands SDK (harness-sdk
+ * `381ab48`, `models/anthropic.ts` + `models/openai/errors.ts`, Apache-2.0),
+ * matched case-insensitively on the lowered message.
+ */
+export type ProblemKind = "throttled" | "overflow" | "auth" | "other";
+export interface StreamProblem {
+    kind: ProblemKind;
+    /** HTTP status, when the failure was an HTTP response. */
+    status?: number;
+    /** A `Retry-After` the endpoint sent, in ms — honoured over the backoff. */
+    retryAfterMs?: number;
+}
+export interface ClassifyInput {
+    status?: number;
+    /** The provider's error `type` (or OpenAI `code`), when the body was parsed. */
+    type?: string;
+    message: string;
+    /** Raw `Retry-After` header value — seconds, or an HTTP date. */
+    retryAfter?: string | null;
+}
+export declare function classifyProblem(input: ClassifyInput): StreamProblem;
+/**
+ * `Retry-After` is either delay-seconds or an HTTP-date. Anything unparseable
+ * or in the past is undefined, so the caller falls back to its own backoff.
+ */
+export declare function parseRetryAfter(value: string | null | undefined): number | undefined;
+/**
+ * Pull the provider's error `type` out of an error body, for the HTTP path
+ * where the body is JSON like `{"error":{"type":"overloaded_error",…}}` or
+ * `{"error":{"code":"context_length_exceeded",…}}`. Returns undefined for
+ * anything that is not that shape; the message phrases still apply.
+ */
+export declare function errorTypeOf(body: string): string | undefined;
+//# sourceMappingURL=problem.d.ts.map

package/lib/typescript/providers/problem.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"problem.d.ts","sourceRoot":"","sources":["../../../src/providers/problem.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,MAAM,MAAM,WAAW,GAAG,WAAW,GAAG,UAAU,GAAG,MAAM,GAAG,OAAO,CAAC;AAEtE,MAAM,WAAW,aAAa;IAC5B,IAAI,EAAE,WAAW,CAAC;IAClB,0DAA0D;IAC1D,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,4EAA4E;IAC5E,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AA8BD,MAAM,WAAW,aAAa;IAC5B,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,gFAAgF;IAChF,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,MAAM,CAAC;IAChB,iEAAiE;IACjE,UAAU,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CAC5B;AAED,wBAAgB,eAAe,CAAC,KAAK,EAAE,aAAa,GAAG,aAAa,CAoBnE;AAED;;;GAGG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GAAG,MAAM,GAAG,SAAS,CAQpF;AAED;;;;;GAKG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAS5D"}

package/lib/typescript/providers/sse.d.ts

@@ -7,12 +7,96 @@
  * TV-CLI lanes never had it. So `readSse` degrades to reading the whole body
  * and replaying it as events rather than failing: a non-streaming answer is a
  * slower chat, while a hard failure is no chat at all.
+ *
+ * THE TWO PATHS MUST AGREE. They did not. The buffered path appended "\n\n" to
+ * the body before parsing, which turns an unterminated final frame — the exact
+ * signature of a cut connection — into a well-formed event. The streaming path
+ * discarded that same frame, as the SSE spec requires. So one lane invented a
+ * complete answer where the other saw a broken one. Now both discard it and
+ * both RECORD it (`SseReadStatus.truncated`), because "was this reply whole?"
+ * is a question the engine has to answer before it runs anything.
  */
 export interface SseEvent {
     event?: string;
     data: string;
 }
-export declare function readSse(response: Response): AsyncGenerator<SseEvent, void, void>;
-/** Body text for a failed response, trimmed to something a user can read. */
+export interface SseReadStatus {
+    /**
+     * Non-blank bytes were left over at EOF: the stream stopped mid-frame.
+     *
+     * Discarding the partial frame is correct (SSE spec); pretending the stream
+     * ended cleanly is not. Providers pair this with their own terminal-marker
+     * check — a clean frame boundary with no `message_stop`/`[DONE]` is equally
+     * truncated, just tidier about it.
+     */
+    truncated: boolean;
+}
+export interface SseReadOptions {
+    status?: SseReadStatus;
+    /**
+     * Aborts the READ itself, not just the request.
+     *
+     * Normally redundant: a real `fetch` errors its response body when its
+     * signal aborts, so `reader.read()` rejects on its own. But Ask Buoy takes a
+     * host-supplied `fetch` (`ProviderConfig.fetch`), and a wrapper that returns
+     * a body it built itself — an interceptor, a replay harness, a polyfill —
+     * severs that link. Without this the idle timeout fires, aborts a signal
+     * nothing is listening to, and the turn parks on a read that never settles:
+     * exactly the hang the clock was added to end.
+     */
+    signal?: AbortSignal;
+    /**
+     * Called once per COMPLETE frame, including ones that yield nothing.
+     *
+     * The idle timeout hangs off this. A comment-only frame — `: OPENROUTER
+     * PROCESSING`, which is exactly what arrives during a long silence — is
+     * skipped by the parser and would otherwise look identical to a dead socket.
+     */
+    onFrame?: () => void;
+}
+/**
+ * Turn a stream of TEXT chunks into SSE frames.
+ *
+ * The one place framing happens, whatever produced the bytes: a `fetch` body
+ * reader, an `XMLHttpRequest` progress slice, or a whole body read at once on
+ * a runtime that cannot stream. Splitting it out is what lets the XHR
+ * transport exist without a second parser to keep in step with this one.
+ */
+export declare function framesFrom(chunks: AsyncIterable<string>, options?: SseReadOptions): AsyncGenerator<SseEvent, void, void>;
+export declare function readSse(response: Response, options?: SseReadOptions): AsyncGenerator<SseEvent, void, void>;
+/**
+ * A 200 that is not a stream at all.
+ *
+ * Gateways in front of a model do this: an auth proxy that has lost its
+ * upstream serves an HTML error page, a misrouted path serves an SPA shell,
+ * and a gateway that ignored `stream: true` serves one JSON object. Every one
+ * of those parses to zero SSE frames, so the old code read it as a model that
+ * had nothing to say and ended the turn with a blank bubble.
+ *
+ * Returns a message when the body should be treated as an error, and undefined
+ * when it looks like something the SSE reader can work with. Consumes the body
+ * only in the failing case.
+ */
+export declare function nonStreamProblem(response: Response): Promise<string | undefined>;
+/**
+ * Body text for a failed response, trimmed to something a user can read.
+ * The detail alone — the transport prefixes the status and classifies it.
+ */
 export declare function errorBody(response: Response): Promise<string>;
+/**
+ * The message for a stream that stopped before the provider said it was done.
+ *
+ * `truncated` distinguishes the two shapes: cut mid-frame (a dropped
+ * connection) versus a clean frame boundary with no terminal marker (a gateway
+ * that closes the socket instead of sending one). The second is a
+ * compatibility problem worth naming, because retrying it will not help.
+ */
+export declare function truncatedMessage(truncated: boolean): string;
+/**
+ * The message for arguments that would not parse, with enough in it to act on.
+ * `stopReason` "length" is the common cause — a reasoning model spends its
+ * budget thinking and the tool call is truncated mid-JSON — and the tail of
+ * the raw arguments says immediately whether that is what happened.
+ */
+export declare function unparseableMessage(name: string, args: string, stopReason?: string): string;
 //# sourceMappingURL=sse.d.ts.map

package/lib/typescript/providers/sse.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sse.d.ts","sourceRoot":"","sources":["../../../src/providers/sse.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,MAAM,WAAW,QAAQ;IACvB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;CACd;AAsBD,wBAAuB,OAAO,CAC5B,QAAQ,EAAE,QAAQ,GACjB,cAAc,CAAC,QAAQ,EAAE,IAAI,EAAE,IAAI,CAAC,CAkDtC;AAED,6EAA6E;AAC7E,wBAAsB,SAAS,CAAC,QAAQ,EAAE,QAAQ,GAAG,OAAO,CAAC,MAAM,CAAC,CAQnE"}
+{"version":3,"file":"sse.d.ts","sourceRoot":"","sources":["../../../src/providers/sse.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,MAAM,WAAW,QAAQ;IACvB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;CACd;AAED,MAAM,WAAW,aAAa;IAC5B;;;;;;;OAOG;IACH,SAAS,EAAE,OAAO,CAAC;CACpB;AAED,MAAM,WAAW,cAAc;IAC7B,MAAM,CAAC,EAAE,aAAa,CAAC;IACvB;;;;;;;;;;OAUG;IACH,MAAM,CAAC,EAAE,WAAW,CAAC;IACrB;;;;;;OAMG;IACH,OAAO,CAAC,EAAE,MAAM,IAAI,CAAC;CACtB;AA6CD;;;;;;;GAOG;AACH,wBAAuB,UAAU,CAC/B,MAAM,EAAE,aAAa,CAAC,MAAM,CAAC,EAC7B,OAAO,GAAE,cAAmB,GAC3B,cAAc,CAAC,QAAQ,EAAE,IAAI,EAAE,IAAI,CAAC,CAUtC;AAED,wBAAuB,OAAO,CAC5B,QAAQ,EAAE,QAAQ,EAClB,OAAO,GAAE,cAAmB,GAC3B,cAAc,CAAC,QAAQ,EAAE,IAAI,EAAE,IAAI,CAAC,CA6EtC;AAED;;;;;;;;;;;;GAYG;AACH,wBAAsB,gBAAgB,CAAC,QAAQ,EAAE,QAAQ,GAAG,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CAYtF;AAED;;;GAGG;AACH,wBAAsB,SAAS,CAAC,QAAQ,EAAE,QAAQ,GAAG,OAAO,CAAC,MAAM,CAAC,CAMnE;AAED;;;;;;;GAOG;AACH,wBAAgB,gBAAgB,CAAC,SAAS,EAAE,OAAO,GAAG,MAAM,CAI3D;AAED;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,UAAU,CAAC,EAAE,MAAM,GAAG,MAAM,CAQ1F"}

package/lib/typescript/providers/streamTimer.d.ts

@@ -0,0 +1,59 @@
+/**
+ * The clock on a model request.
+ *
+ * There was none. A gateway that accepted the socket and then said nothing —
+ * an overloaded proxy, a dropped VPN, a laptop that slept mid-answer — left
+ * the turn running with the thinking strip animating until a person pressed
+ * Stop. The 180s turn deadline did not help: it is read at the TOP of a step
+ * (`runAgentTurn`), and a step parked inside `await fetch(...)` never reaches
+ * the next one.
+ *
+ * Two clocks, because the two silences mean different things:
+ *
+ * - CONNECT covers "no headers yet". Nothing has been generated, so nothing is
+ *   lost by giving up; 30s is already long for a gateway to acknowledge a POST.
+ * - IDLE covers "headers arrived, then nothing". This one has to be generous.
+ *   Anthropic sends `ping` frames, but an OpenAI-protocol reasoning model can
+ *   legitimately emit nothing for a long stretch while it thinks, and cutting
+ *   that off would look like a broken product. Any frame at all — a keepalive
+ *   comment included — resets it, so only total silence trips it.
+ *
+ * A timeout is NOT a retry. Nothing is re-sent: the request may have reached
+ * the model, and a duplicate turn is a duplicate bill and possibly duplicate
+ * writes. The turn ends with an honest notice and a Continue button.
+ */
+export declare const DEFAULT_CONNECT_TIMEOUT_MS = 30000;
+export declare const DEFAULT_IDLE_TIMEOUT_MS = 90000;
+export interface StreamTimerOptions {
+    connectTimeoutMs?: number;
+    idleTimeoutMs?: number;
+}
+export interface StreamTimer {
+    /**
+     * The signal to hand to `fetch`. Aborts when the caller's signal aborts OR
+     * when either clock runs out, so one signal covers all three.
+     */
+    readonly signal: AbortSignal | undefined;
+    /** Headers arrived: stop the connect clock, start the idle one. */
+    connected(): void;
+    /** A frame arrived: restart the idle clock. */
+    activity(): void;
+    /**
+     * Which clock fired, if either. Read in the provider's catch: an abort with
+     * a reason here is a timeout, an abort without one is the user's Stop.
+     */
+    readonly expired: "connect" | "idle" | undefined;
+    /** Message for the expired clock, or undefined if neither fired. */
+    message(): string | undefined;
+    /** Always call this — a live timer keeps the JS runtime awake. */
+    dispose(): void;
+}
+/**
+ * A timer over an optional caller signal.
+ *
+ * When no `AbortController` exists (a runtime old enough to lack it) this
+ * degrades to passing the caller's signal straight through with no clocks,
+ * rather than failing to send anything at all.
+ */
+export declare function createStreamTimer(callerSignal: AbortSignal | undefined, options?: StreamTimerOptions): StreamTimer;
+//# sourceMappingURL=streamTimer.d.ts.map

package/lib/typescript/providers/streamTimer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"streamTimer.d.ts","sourceRoot":"","sources":["../../../src/providers/streamTimer.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH,eAAO,MAAM,0BAA0B,QAAS,CAAC;AACjD,eAAO,MAAM,uBAAuB,QAAS,CAAC;AAE9C,MAAM,WAAW,kBAAkB;IACjC,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AAED,MAAM,WAAW,WAAW;IAC1B;;;OAGG;IACH,QAAQ,CAAC,MAAM,EAAE,WAAW,GAAG,SAAS,CAAC;IACzC,mEAAmE;IACnE,SAAS,IAAI,IAAI,CAAC;IAClB,+CAA+C;IAC/C,QAAQ,IAAI,IAAI,CAAC;IACjB;;;OAGG;IACH,QAAQ,CAAC,OAAO,EAAE,SAAS,GAAG,MAAM,GAAG,SAAS,CAAC;IACjD,oEAAoE;IACpE,OAAO,IAAI,MAAM,GAAG,SAAS,CAAC;IAC9B,kEAAkE;IAClE,OAAO,IAAI,IAAI,CAAC;CACjB;AAED;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAC/B,YAAY,EAAE,WAAW,GAAG,SAAS,EACrC,OAAO,GAAE,kBAAuB,GAC/B,WAAW,CAyFb"}

package/lib/typescript/providers/transport.d.ts

@@ -0,0 +1,48 @@
+/**
+ * How a request is SENT, decided before it is sent.
+ *
+ * The obvious place to add XHR was inside `readSse`, once a missing
+ * `response.body` had already proved that `fetch` could not stream. That is
+ * the wrong boundary and would have been a real bug: the POST has already
+ * happened by then, the reader has neither the URL nor the headers nor the
+ * body to repeat it, and issuing a second one would ask the model to generate
+ * the same answer twice — billed twice, and for a turn that writes, acted on
+ * twice. Transport is chosen up front; a response that has started is consumed
+ * exactly once, whatever it turns out to be.
+ *
+ * `auto` therefore learns rather than probes. The first request goes through
+ * `fetch`; if that response has no reader, the answer is buffered (as it
+ * always was on that runtime) and the SESSION remembers, so every later
+ * request uses XHR and streams. One buffered reply at the start of a bare-RN
+ * session, and nothing to configure.
+ */
+import type { ProviderConfig } from "./types";
+import { type SseEvent, type SseReadOptions } from "./sse";
+import { type StreamProblem } from "./problem";
+export type TransportKind = "fetch" | "xhr" | "auto";
+export interface OpenStreamRequest {
+    headers: Record<string, string>;
+    body: string;
+    signal?: AbortSignal;
+}
+export interface OpenStreamResult {
+    /** A message when the request failed or is not a stream; frames are empty. */
+    problem?: string;
+    /**
+     * The failure, classified — see providers/problem.ts. Present whenever
+     * `problem` is an HTTP failure; a not-a-stream body is `other`. The engine
+     * retries `throttled` and `overflow` when nothing was generated, and this
+     * is the only place the status and `Retry-After` header are still in hand.
+     */
+    problemInfo?: StreamProblem;
+    frames(options?: SseReadOptions): AsyncGenerator<SseEvent, void, void>;
+}
+export interface Transport {
+    open(req: OpenStreamRequest): Promise<OpenStreamResult>;
+}
+/**
+ * One transport per provider instance, because the `auto` decision is worth
+ * remembering: re-learning it would buffer the first reply of every turn.
+ */
+export declare function createTransport(config: ProviderConfig): Transport;
+//# sourceMappingURL=transport.d.ts.map

package/lib/typescript/providers/transport.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transport.d.ts","sourceRoot":"","sources":["../../../src/providers/transport.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AACH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAC9C,OAAO,EAIL,KAAK,QAAQ,EACb,KAAK,cAAc,EACpB,MAAM,OAAO,CAAC;AAEf,OAAO,EAAgC,KAAK,aAAa,EAAE,MAAM,WAAW,CAAC;AAE7E,MAAM,MAAM,aAAa,GAAG,OAAO,GAAG,KAAK,GAAG,MAAM,CAAC;AAErD,MAAM,WAAW,iBAAiB;IAChC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAChC,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,CAAC,EAAE,WAAW,CAAC;CACtB;AAED,MAAM,WAAW,gBAAgB;IAC/B,8EAA8E;IAC9E,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB;;;;;OAKG;IACH,WAAW,CAAC,EAAE,aAAa,CAAC;IAC5B,MAAM,CAAC,OAAO,CAAC,EAAE,cAAc,GAAG,cAAc,CAAC,QAAQ,EAAE,IAAI,EAAE,IAAI,CAAC,CAAC;CACxE;AAED,MAAM,WAAW,SAAS;IACxB,IAAI,CAAC,GAAG,EAAE,iBAAiB,GAAG,OAAO,CAAC,gBAAgB,CAAC,CAAC;CACzD;AAID;;;GAGG;AACH,wBAAgB,eAAe,CAAC,MAAM,EAAE,cAAc,GAAG,SAAS,CAmFjE"}