@opencode-ai/ai 0.0.0-bootstrap.0 → 0.0.0-next-15618

package/dist/protocols/utils/cache.js

@@ -0,0 +1,8 @@
+// Shared helpers for provider cache-marker lowering. Anthropic and Bedrock
+// both enforce a 4-breakpoint cap per request and accept the same `5m`/`1h`
+// TTL buckets, so the counter and TTL mapping live here.
+export const newBreakpoints = (cap) => ({ remaining: cap, dropped: 0 });
+// Returns `"1h"` for any `ttlSeconds >= 3600`, otherwise `undefined` (the
+// provider default 5m). Anthropic & Bedrock both treat anything shorter than
+// an hour as 5m.
+export const ttlBucket = (ttlSeconds) => ttlSeconds !== undefined && ttlSeconds >= 3600 ? "1h" : undefined;

package/dist/protocols/utils/gemini-tool-schema.d.ts

@@ -0,0 +1,2 @@
+export declare const convert: (schema: unknown) => Record<string, unknown> | undefined;
+export * as GeminiToolSchema from "./gemini-tool-schema";

package/dist/protocols/utils/gemini-tool-schema.js

@@ -0,0 +1,83 @@
+import { isRecord } from "../../utils/record";
+// Gemini accepts a JSON Schema-like dialect for tool parameters, but rejects a
+// handful of common JSON Schema shapes. Keep this projection isolated so the
+// Gemini protocol file still reads like the other protocol modules.
+const SCHEMA_INTENT_KEYS = [
+    "type",
+    "properties",
+    "items",
+    "prefixItems",
+    "enum",
+    "const",
+    "$ref",
+    "additionalProperties",
+    "patternProperties",
+    "required",
+    "not",
+    "if",
+    "then",
+    "else",
+];
+const hasCombiner = (schema) => isRecord(schema) && (Array.isArray(schema.anyOf) || Array.isArray(schema.oneOf) || Array.isArray(schema.allOf));
+const hasSchemaIntent = (schema) => isRecord(schema) && (hasCombiner(schema) || SCHEMA_INTENT_KEYS.some((key) => key in schema));
+const sanitizeNode = (schema) => {
+    if (!isRecord(schema))
+        return Array.isArray(schema) ? schema.map(sanitizeNode) : schema;
+    const result = Object.fromEntries(Object.entries(schema).map(([key, value]) => [
+        key,
+        key === "enum" && Array.isArray(value) ? value.map(String) : sanitizeNode(value),
+    ]));
+    if (Array.isArray(result.enum) && (result.type === "integer" || result.type === "number"))
+        result.type = "string";
+    const properties = result.properties;
+    if (result.type === "object" && isRecord(properties) && Array.isArray(result.required)) {
+        result.required = result.required.filter((field) => typeof field === "string" && field in properties);
+    }
+    if (result.type === "array" && !hasCombiner(result)) {
+        result.items = result.items ?? {};
+        if (isRecord(result.items) && !hasSchemaIntent(result.items))
+            result.items = { ...result.items, type: "string" };
+    }
+    if (typeof result.type === "string" && result.type !== "object" && !hasCombiner(result)) {
+        delete result.properties;
+        delete result.required;
+    }
+    return result;
+};
+const emptyObjectSchema = (schema) => schema.type === "object" &&
+    (!isRecord(schema.properties) || Object.keys(schema.properties).length === 0) &&
+    !schema.additionalProperties;
+const projectNode = (schema) => {
+    if (!isRecord(schema))
+        return undefined;
+    if (emptyObjectSchema(schema))
+        return undefined;
+    return Object.fromEntries([
+        ["description", schema.description],
+        ["required", schema.required],
+        ["format", schema.format],
+        ["type", Array.isArray(schema.type) ? schema.type.filter((type) => type !== "null")[0] : schema.type],
+        ["nullable", Array.isArray(schema.type) && schema.type.includes("null") ? true : undefined],
+        ["enum", schema.const !== undefined ? [schema.const] : schema.enum],
+        [
+            "properties",
+            isRecord(schema.properties)
+                ? Object.fromEntries(Object.entries(schema.properties).map(([key, value]) => [key, projectNode(value)]))
+                : undefined,
+        ],
+        [
+            "items",
+            Array.isArray(schema.items)
+                ? schema.items.map(projectNode)
+                : schema.items === undefined
+                    ? undefined
+                    : projectNode(schema.items),
+        ],
+        ["allOf", Array.isArray(schema.allOf) ? schema.allOf.map(projectNode) : undefined],
+        ["anyOf", Array.isArray(schema.anyOf) ? schema.anyOf.map(projectNode) : undefined],
+        ["oneOf", Array.isArray(schema.oneOf) ? schema.oneOf.map(projectNode) : undefined],
+        ["minLength", schema.minLength],
+    ].filter((entry) => entry[1] !== undefined));
+};
+export const convert = (schema) => projectNode(sanitizeNode(schema));
+export * as GeminiToolSchema from "./gemini-tool-schema";

package/dist/protocols/utils/lifecycle.d.ts

@@ -0,0 +1,19 @@
+import { LLMEvent, type FinishReason, type ProviderMetadata, type Usage } from "../../schema";
+export interface State {
+    readonly stepStarted: boolean;
+    readonly text: ReadonlySet<string>;
+    readonly reasoning: ReadonlySet<string>;
+}
+export declare const initial: () => State;
+export declare const stepStart: (state: State, events: LLMEvent[]) => State;
+export declare const textDelta: (state: State, events: LLMEvent[], id: string, text: string) => State;
+export declare const reasoningStart: (state: State, events: LLMEvent[], id: string, providerMetadata?: ProviderMetadata) => State;
+export declare const reasoningDelta: (state: State, events: LLMEvent[], id: string, text: string, providerMetadata?: ProviderMetadata) => State;
+export declare const reasoningEnd: (state: State, events: LLMEvent[], id: string, providerMetadata?: ProviderMetadata) => State;
+export declare const textEnd: (state: State, events: LLMEvent[], id: string, providerMetadata?: ProviderMetadata) => State;
+export declare const finish: (state: State, events: LLMEvent[], input: {
+    readonly reason: FinishReason;
+    readonly usage?: Usage;
+    readonly providerMetadata?: ProviderMetadata;
+}) => State;
+export * as Lifecycle from "./lifecycle";

package/dist/protocols/utils/lifecycle.js

@@ -0,0 +1,65 @@
+import { LLMEvent } from "../../schema";
+export const initial = () => ({ stepStarted: false, text: new Set(), reasoning: new Set() });
+export const stepStart = (state, events) => {
+    if (state.stepStarted)
+        return state;
+    events.push(LLMEvent.stepStart({ index: 0 }));
+    return { ...state, stepStarted: true };
+};
+export const textDelta = (state, events, id, text) => {
+    const stepped = stepStart(state, events);
+    if (stepped.text.has(id)) {
+        events.push(LLMEvent.textDelta({ id, text }));
+        return stepped;
+    }
+    events.push(LLMEvent.textStart({ id }), LLMEvent.textDelta({ id, text }));
+    return { ...stepped, text: new Set([...stepped.text, id]) };
+};
+export const reasoningStart = (state, events, id, providerMetadata) => {
+    if (state.reasoning.has(id))
+        return state;
+    const stepped = stepStart(state, events);
+    events.push(LLMEvent.reasoningStart({ id, providerMetadata }));
+    return { ...stepped, reasoning: new Set([...stepped.reasoning, id]) };
+};
+export const reasoningDelta = (state, events, id, text, providerMetadata) => {
+    const started = reasoningStart(state, events, id, providerMetadata);
+    events.push(LLMEvent.reasoningDelta({ id, text }));
+    return started;
+};
+export const reasoningEnd = (state, events, id, providerMetadata) => {
+    if (!state.reasoning.has(id))
+        return state;
+    const stepped = stepStart(state, events);
+    events.push(LLMEvent.reasoningEnd({ id, providerMetadata }));
+    const reasoning = new Set(stepped.reasoning);
+    reasoning.delete(id);
+    return { ...stepped, reasoning };
+};
+export const textEnd = (state, events, id, providerMetadata) => {
+    if (!state.text.has(id))
+        return state;
+    const stepped = stepStart(state, events);
+    events.push(LLMEvent.textEnd({ id, providerMetadata }));
+    const text = new Set(stepped.text);
+    text.delete(id);
+    return { ...stepped, text };
+};
+const closeOpenBlocks = (state, events) => {
+    for (const id of state.reasoning)
+        events.push(LLMEvent.reasoningEnd({ id }));
+    for (const id of state.text)
+        events.push(LLMEvent.textEnd({ id }));
+    return { ...state, text: new Set(), reasoning: new Set() };
+};
+export const finish = (state, events, input) => {
+    const stepped = closeOpenBlocks(stepStart(state, events), events);
+    events.push(LLMEvent.stepFinish({
+        index: 0,
+        reason: input.reason,
+        usage: input.usage,
+        providerMetadata: input.providerMetadata,
+    }), LLMEvent.finish(input));
+    return { ...stepped, stepStarted: false };
+};
+export * as Lifecycle from "./lifecycle";

package/dist/protocols/utils/openai-options.d.ts

@@ -0,0 +1,22 @@
+import { Schema } from "effect";
+import type { LLMRequest } from "../../schema";
+export declare const OpenAIReasoningEfforts: readonly ["none", "minimal", "low", "medium", "high", "xhigh", "max"];
+export type OpenAIReasoningEffort = string;
+export declare const OpenAIResponseIncludables: readonly ["file_search_call.results", "web_search_call.results", "web_search_call.action.sources", "message.input_image.image_url", "computer_call_output.output.image_url", "code_interpreter_call.outputs", "reasoning.encrypted_content", "message.output_text.logprobs"];
+export type OpenAIResponseIncludable = (typeof OpenAIResponseIncludables)[number];
+export declare const OpenAIServiceTiers: readonly ["auto", "default", "flex", "priority"];
+export type OpenAIServiceTier = (typeof OpenAIServiceTiers)[number];
+export declare const OpenAIReasoningEffort: Schema.String;
+export declare const OpenAITextVerbosity: Schema.Literals<readonly ["low", "medium", "high"]>;
+export declare const OpenAIResponseIncludable: Schema.Literals<readonly ["file_search_call.results", "web_search_call.results", "web_search_call.action.sources", "message.input_image.image_url", "computer_call_output.output.image_url", "code_interpreter_call.outputs", "reasoning.encrypted_content", "message.output_text.logprobs"]>;
+export declare const OpenAIServiceTier: Schema.Literals<readonly ["auto", "default", "flex", "priority"]>;
+export declare const isReasoningEffort: (effort: unknown) => effort is OpenAIReasoningEffort;
+export declare const store: (request: LLMRequest) => boolean | undefined;
+export declare const reasoningEffort: (request: LLMRequest) => string | undefined;
+export declare const reasoningSummary: (request: LLMRequest) => "auto" | undefined;
+export declare const include: (request: LLMRequest) => ReadonlyArray<OpenAIResponseIncludable> | undefined;
+export declare const promptCacheKey: (request: LLMRequest) => string | undefined;
+export declare const textVerbosity: (request: LLMRequest) => "low" | "medium" | "high" | undefined;
+export declare const serviceTier: (request: LLMRequest) => "auto" | "default" | "flex" | "priority" | undefined;
+export declare const instructions: (request: LLMRequest) => string | undefined;
+export * as OpenAIOptions from "./openai-options";

package/dist/protocols/utils/openai-options.js

@@ -0,0 +1,64 @@
+import { Schema } from "effect";
+import { ReasoningEfforts, TextVerbosity } from "../../schema";
+export const OpenAIReasoningEfforts = ReasoningEfforts;
+// Mirrors OpenAI's `ResponseIncludable` union from the official SDK. Keep this
+// in lockstep with `openai-node/src/resources/responses/responses.ts`.
+export const OpenAIResponseIncludables = [
+    "file_search_call.results",
+    "web_search_call.results",
+    "web_search_call.action.sources",
+    "message.input_image.image_url",
+    "computer_call_output.output.image_url",
+    "code_interpreter_call.outputs",
+    "reasoning.encrypted_content",
+    "message.output_text.logprobs",
+];
+export const OpenAIServiceTiers = ["auto", "default", "flex", "priority"];
+const TEXT_VERBOSITY = new Set(["low", "medium", "high"]);
+const INCLUDABLES = new Set(OpenAIResponseIncludables);
+const SERVICE_TIERS = new Set(OpenAIServiceTiers);
+export const OpenAIReasoningEffort = Schema.String;
+export const OpenAITextVerbosity = TextVerbosity;
+export const OpenAIResponseIncludable = Schema.Literals(OpenAIResponseIncludables);
+export const OpenAIServiceTier = Schema.Literals(OpenAIServiceTiers);
+export const isReasoningEffort = (effort) => typeof effort === "string";
+const isTextVerbosity = (value) => typeof value === "string" && TEXT_VERBOSITY.has(value);
+const options = (request) => request.providerOptions?.openai;
+export const store = (request) => {
+    const value = options(request)?.store;
+    return typeof value === "boolean" ? value : undefined;
+};
+export const reasoningEffort = (request) => {
+    const value = options(request)?.reasoningEffort;
+    return typeof value === "string" ? value : undefined;
+};
+export const reasoningSummary = (request) => options(request)?.reasoningSummary === "auto" ? "auto" : undefined;
+// Resolve the OpenAI Responses `include` field. Filters out unknown
+// includable values defensively so a typo in upstream config drops the
+// invalid entry instead of poisoning the wire body. An empty array (either
+// passed directly or produced by filtering) is treated as "no include" and
+// returns undefined so the request body omits the field entirely.
+export const include = (request) => {
+    const value = options(request)?.include;
+    if (!Array.isArray(value))
+        return undefined;
+    const filtered = value.filter((entry) => INCLUDABLES.has(entry));
+    return filtered.length > 0 ? filtered : undefined;
+};
+export const promptCacheKey = (request) => {
+    const value = options(request)?.promptCacheKey;
+    return typeof value === "string" ? value : undefined;
+};
+export const textVerbosity = (request) => {
+    const value = options(request)?.textVerbosity;
+    return isTextVerbosity(value) ? value : undefined;
+};
+export const serviceTier = (request) => {
+    const value = options(request)?.serviceTier;
+    return typeof value === "string" && SERVICE_TIERS.has(value) ? value : undefined;
+};
+export const instructions = (request) => {
+    const value = options(request)?.instructions;
+    return typeof value === "string" ? value : undefined;
+};
+export * as OpenAIOptions from "./openai-options";

package/dist/protocols/utils/tool-schema.d.ts

@@ -0,0 +1,7 @@
+import type { JsonSchema, ModelToolSchemaCompatibility } from "../../schema";
+export declare const ToolSchemaProjection: {
+    readonly gemini: (schema: JsonSchema) => JsonSchema;
+    readonly modelCompatibility: (schema: JsonSchema, compatibility: ModelToolSchemaCompatibility | undefined) => JsonSchema;
+    readonly moonshot: (schema: JsonSchema) => JsonSchema;
+    readonly openAI: (schema: JsonSchema) => JsonSchema;
+};

package/dist/protocols/utils/tool-schema.js

@@ -0,0 +1,79 @@
+import { isRecord } from "../../utils/record";
+import { GeminiToolSchema } from "./gemini-tool-schema";
+const removeNullSchemas = (value) => {
+    if (Array.isArray(value))
+        return value.map(removeNullSchemas);
+    if (!isRecord(value))
+        return value;
+    const fields = Object.fromEntries(Object.entries(value)
+        .filter(([key]) => key !== "anyOf")
+        .map(([key, field]) => [key, removeNullSchemas(field)]));
+    if (!Array.isArray(value.anyOf))
+        return fields;
+    const variants = value.anyOf.filter((variant) => !isRecord(variant) || variant.type !== "null").map(removeNullSchemas);
+    if (variants.length === 1 && isRecord(variants[0]))
+        return { ...fields, ...variants[0] };
+    return { ...fields, anyOf: variants };
+};
+const tupleItemsSchema = (items) => {
+    const projected = items.map(moonshotNode);
+    if (projected.length === 0)
+        return {};
+    if (projected.length === 1)
+        return projected[0];
+    return { anyOf: projected };
+};
+const moonshotNode = (schema) => {
+    if (Array.isArray(schema))
+        return schema.map(moonshotNode);
+    if (!isRecord(schema))
+        return schema;
+    if (typeof schema.$ref === "string")
+        return { $ref: schema.$ref };
+    return Object.fromEntries(Object.entries(schema).flatMap(([key, value]) => {
+        if (key === "items" && Array.isArray(value))
+            return [[key, tupleItemsSchema(value)]];
+        if (key === "prefixItems") {
+            if ("items" in schema)
+                return [];
+            return [["items", tupleItemsSchema(Array.isArray(value) ? value : [])]];
+        }
+        if (key === "unevaluatedItems")
+            return [];
+        return [[key, moonshotNode(value)]];
+    }));
+};
+const moonshot = (schema) => {
+    const projected = moonshotNode(schema);
+    return isRecord(projected) ? projected : {};
+};
+const openAI = (schema) => {
+    const variants = Array.isArray(schema.anyOf) ? schema.anyOf.filter(isRecord) : [];
+    const flattened = variants.length === 0
+        ? { ...schema, type: "object" }
+        : {
+            ...Object.fromEntries(Object.entries(schema).filter(([key]) => key !== "anyOf")),
+            type: "object",
+            properties: variants.reduce((properties, variant) => ({ ...(isRecord(variant.properties) ? variant.properties : {}), ...properties }), {}),
+            additionalProperties: false,
+        };
+    const normalized = removeNullSchemas(flattened);
+    return isRecord(normalized) ? normalized : { type: "object" };
+};
+const gemini = (schema) => GeminiToolSchema.convert(schema) ?? {};
+const modelCompatibility = (schema, compatibility) => {
+    if (compatibility === undefined)
+        return schema;
+    switch (compatibility) {
+        case "gemini":
+            return gemini(schema);
+        case "moonshot":
+            return moonshot(schema);
+    }
+};
+export const ToolSchemaProjection = {
+    gemini,
+    modelCompatibility,
+    moonshot,
+    openAI,
+};

package/dist/protocols/utils/tool-stream.d.ts

@@ -0,0 +1,155 @@
+import { Effect } from "effect";
+import { LLMError, LLMEvent, type ProviderMetadata } from "../../schema";
+import { type ToolAccumulator } from "../shared";
+type StreamKey = string | number;
+/**
+ * One pending streamed tool call. Providers emit the tool identity and JSON
+ * argument text across separate chunks; `input` is the raw JSON string collected
+ * so far, not the parsed object.
+ */
+export interface PendingTool extends ToolAccumulator {
+    readonly providerExecuted?: boolean;
+    readonly providerMetadata?: ProviderMetadata;
+}
+/**
+ * Sparse parser state keyed by the provider's stream-local tool identifier.
+ *
+ * This key is not the final tool-call id (`call_...`). It is the id/index the
+ * provider uses while streaming a partial call: OpenAI Chat / Anthropic /
+ * Bedrock use numeric content indexes, while OpenAI Responses uses string
+ * `item_id`s. The generic keeps each protocol internally consistent.
+ */
+export type State<K extends StreamKey> = Partial<Record<K, PendingTool>>;
+/**
+ * Result of adding argument text to one pending tool call. It returns both the
+ * next `tools` state and the updated `tool` because parsers often need the
+ * current id/name immediately. `events` contains lifecycle and delta events
+ * produced by the append; metadata-only deltas update identity without output.
+ */
+export interface AppendOutcome<K extends StreamKey> {
+    readonly tools: State<K>;
+    readonly tool: PendingTool;
+    readonly events: ReadonlyArray<LLMEvent>;
+}
+/** Create empty accumulator state for one provider stream. */
+export declare const empty: <K extends StreamKey>() => State<K>;
+export declare const isError: <K extends StreamKey>(result: AppendOutcome<K> | LLMError) => result is LLMError;
+/**
+ * Register a tool call whose start event arrived before any argument deltas.
+ * Used by Anthropic `content_block_start`, Bedrock `contentBlockStart`, and
+ * OpenAI Responses `response.output_item.added`.
+ */
+export declare const start: <K extends StreamKey>(tools: State<K>, key: K, tool: Omit<PendingTool, "input"> & {
+    readonly input?: string;
+}) => Partial<Record<K, PendingTool>>;
+/**
+ * Append a streamed argument delta, starting the tool if this provider encodes
+ * identity on the first delta instead of a separate start event. OpenAI Chat has
+ * this shape: `tool_calls[].index` is the stream key, and `id` / `name` may only
+ * appear on the first delta for that index.
+ */
+export declare const appendOrStart: <K extends StreamKey>(route: string, tools: State<K>, key: K, delta: {
+    readonly id?: string;
+    readonly name?: string;
+    readonly text: string;
+}, missingToolMessage: string) => AppendOutcome<K> | LLMError;
+/**
+ * Append argument text to a tool that must already have been started. This keeps
+ * protocols honest when their stream grammar promises a start event before any
+ * argument delta.
+ */
+export declare const appendExisting: <K extends StreamKey>(route: string, tools: State<K>, key: K, text: string, missingToolMessage: string) => AppendOutcome<K> | LLMError;
+/**
+ * Finalize one pending tool call: parse the accumulated raw JSON, remove it
+ * from state, and return the optional public `tool-call` event. Missing keys are
+ * a no-op because some providers emit stop events for non-tool content blocks.
+ */
+export declare const finish: <K extends StreamKey>(route: string, tools: State<K>, key: K) => Effect.Effect<{
+    tools: Partial<Record<K, PendingTool>>;
+    events?: undefined;
+} | {
+    tools: Partial<Record<K, PendingTool>>;
+    events: ({
+        readonly type: "tool-input-end";
+        readonly id: string;
+        readonly name: string;
+        readonly providerMetadata?: {
+            readonly [x: string]: {
+                readonly [x: string]: unknown;
+            };
+        } | undefined;
+    } | {
+        readonly type: "tool-call";
+        readonly id: string;
+        readonly name: string;
+        readonly input: unknown;
+        readonly providerExecuted?: boolean | undefined;
+        readonly providerMetadata?: {
+            readonly [x: string]: {
+                readonly [x: string]: unknown;
+            };
+        } | undefined;
+    })[];
+}, LLMError, never>;
+/**
+ * Finalize one pending tool call with an authoritative final input string.
+ * OpenAI Responses can send accumulated deltas and then repeat the completed
+ * arguments on `response.output_item.done`; the final value wins.
+ */
+export declare const finishWithInput: <K extends StreamKey>(route: string, tools: State<K>, key: K, input: string) => Effect.Effect<{
+    tools: Partial<Record<K, PendingTool>>;
+    events?: undefined;
+} | {
+    tools: Partial<Record<K, PendingTool>>;
+    events: ({
+        readonly type: "tool-input-end";
+        readonly id: string;
+        readonly name: string;
+        readonly providerMetadata?: {
+            readonly [x: string]: {
+                readonly [x: string]: unknown;
+            };
+        } | undefined;
+    } | {
+        readonly type: "tool-call";
+        readonly id: string;
+        readonly name: string;
+        readonly input: unknown;
+        readonly providerExecuted?: boolean | undefined;
+        readonly providerMetadata?: {
+            readonly [x: string]: {
+                readonly [x: string]: unknown;
+            };
+        } | undefined;
+    })[];
+}, LLMError, never>;
+/**
+ * Finalize every pending tool call at once. OpenAI Chat has this shape: it does
+ * not emit per-tool stop events, so all accumulated calls finish when the choice
+ * receives a terminal `finish_reason`.
+ */
+export declare const finishAll: <K extends StreamKey>(route: string, tools: State<K>) => Effect.Effect<{
+    tools: Partial<Record<K, PendingTool>>;
+    events: ({
+        readonly type: "tool-input-end";
+        readonly id: string;
+        readonly name: string;
+        readonly providerMetadata?: {
+            readonly [x: string]: {
+                readonly [x: string]: unknown;
+            };
+        } | undefined;
+    } | {
+        readonly type: "tool-call";
+        readonly id: string;
+        readonly name: string;
+        readonly input: unknown;
+        readonly providerExecuted?: boolean | undefined;
+        readonly providerMetadata?: {
+            readonly [x: string]: {
+                readonly [x: string]: unknown;
+            };
+        } | undefined;
+    })[];
+}, LLMError, never>;
+export * as ToolStream from "./tool-stream";

package/dist/protocols/utils/tool-stream.js

@@ -0,0 +1,136 @@
+import { Effect } from "effect";
+import { LLMError, LLMEvent } from "../../schema";
+import { eventError, parseToolInput } from "../shared";
+/** Create empty accumulator state for one provider stream. */
+export const empty = () => ({});
+const withTool = (tools, key, tool) => {
+    return { ...tools, [key]: tool };
+};
+const withoutTool = (tools, key) => {
+    const next = { ...tools };
+    delete next[key];
+    return next;
+};
+const inputStart = (tool) => LLMEvent.toolInputStart({
+    id: tool.id,
+    name: tool.name,
+    providerMetadata: tool.providerMetadata,
+});
+const inputDelta = (tool, text) => LLMEvent.toolInputDelta({
+    id: tool.id,
+    name: tool.name,
+    text,
+});
+const toolCall = (route, tool, inputOverride) => parseToolInput(route, tool.name, inputOverride ?? tool.input).pipe(Effect.map((input) => LLMEvent.toolCall({
+    id: tool.id,
+    name: tool.name,
+    input,
+    providerExecuted: tool.providerExecuted ? true : undefined,
+    providerMetadata: tool.providerMetadata,
+})));
+/** Store the updated tool and produce the optional public delta event. */
+const appendTool = (tools, key, tool, text) => {
+    const events = [];
+    if (!tools[key])
+        events.push(inputStart(tool));
+    if (text.length > 0)
+        events.push(inputDelta(tool, text));
+    return {
+        tools: withTool(tools, key, tool),
+        tool,
+        events,
+    };
+};
+export const isError = (result) => result instanceof LLMError;
+/**
+ * Register a tool call whose start event arrived before any argument deltas.
+ * Used by Anthropic `content_block_start`, Bedrock `contentBlockStart`, and
+ * OpenAI Responses `response.output_item.added`.
+ */
+export const start = (tools, key, tool) => withTool(tools, key, { ...tool, input: tool.input ?? "" });
+/**
+ * Append a streamed argument delta, starting the tool if this provider encodes
+ * identity on the first delta instead of a separate start event. OpenAI Chat has
+ * this shape: `tool_calls[].index` is the stream key, and `id` / `name` may only
+ * appear on the first delta for that index.
+ */
+export const appendOrStart = (route, tools, key, delta, missingToolMessage) => {
+    const current = tools[key];
+    const id = delta.id ?? current?.id;
+    const name = delta.name ?? current?.name;
+    if (!id || !name)
+        return eventError(route, missingToolMessage);
+    const tool = {
+        id,
+        name,
+        input: `${current?.input ?? ""}${delta.text}`,
+        providerExecuted: current?.providerExecuted,
+        providerMetadata: current?.providerMetadata,
+    };
+    if (current && delta.text.length === 0 && current.id === id && current.name === name)
+        return { tools, tool: current, events: [] };
+    return appendTool(tools, key, tool, delta.text);
+};
+/**
+ * Append argument text to a tool that must already have been started. This keeps
+ * protocols honest when their stream grammar promises a start event before any
+ * argument delta.
+ */
+export const appendExisting = (route, tools, key, text, missingToolMessage) => {
+    const current = tools[key];
+    if (!current)
+        return eventError(route, missingToolMessage);
+    if (text.length === 0)
+        return { tools, tool: current, events: [] };
+    return appendTool(tools, key, { ...current, input: `${current.input}${text}` }, text);
+};
+/**
+ * Finalize one pending tool call: parse the accumulated raw JSON, remove it
+ * from state, and return the optional public `tool-call` event. Missing keys are
+ * a no-op because some providers emit stop events for non-tool content blocks.
+ */
+export const finish = (route, tools, key) => Effect.gen(function* () {
+    const tool = tools[key];
+    if (!tool)
+        return { tools };
+    return {
+        tools: withoutTool(tools, key),
+        events: [
+            LLMEvent.toolInputEnd({ id: tool.id, name: tool.name, providerMetadata: tool.providerMetadata }),
+            yield* toolCall(route, tool),
+        ],
+    };
+});
+/**
+ * Finalize one pending tool call with an authoritative final input string.
+ * OpenAI Responses can send accumulated deltas and then repeat the completed
+ * arguments on `response.output_item.done`; the final value wins.
+ */
+export const finishWithInput = (route, tools, key, input) => Effect.gen(function* () {
+    const tool = tools[key];
+    if (!tool)
+        return { tools };
+    return {
+        tools: withoutTool(tools, key),
+        events: [
+            LLMEvent.toolInputEnd({ id: tool.id, name: tool.name, providerMetadata: tool.providerMetadata }),
+            yield* toolCall(route, tool, input),
+        ],
+    };
+});
+/**
+ * Finalize every pending tool call at once. OpenAI Chat has this shape: it does
+ * not emit per-tool stop events, so all accumulated calls finish when the choice
+ * receives a terminal `finish_reason`.
+ */
+export const finishAll = (route, tools) => Effect.gen(function* () {
+    const pending = Object.values(tools).filter((tool) => tool !== undefined);
+    return {
+        tools: empty(),
+        events: yield* Effect.forEach(pending, (tool) => toolCall(route, tool).pipe(Effect.map((call) => [
+            LLMEvent.toolInputEnd({ id: tool.id, name: tool.name, providerMetadata: tool.providerMetadata }),
+            call,
+        ]))).pipe(Effect.map((events) => events.flat())),
+    };
+});
+export * as ToolStream from "./tool-stream";

package/dist/protocols.d.ts

@@ -0,0 +1 @@
+export * from "./protocols/index";

package/dist/protocols.js

@@ -0,0 +1 @@
+export * from "./protocols/index";