@valni/cli-darwin-x64 0.0.0-stage → 0.1.3

package/runtime/extensions/switchboard-local/node_modules/@valni/switchboard/dist/native.js

@@ -0,0 +1,886 @@
+import * as wire from "./wire.js";
+import * as messages from "./messages.js";
+import { EncodingFailedError } from "./errors.js";
+export const KIND_ANTHROPIC = "anthropic";
+export const KIND_OPENAI_PRO = "openai_pro";
+export const KIND_OPENAI_GENERIC = "openai_generic";
+export const KIND_GOOGLE = "google";
+export const DONE_SENTINEL = "[DONE]";
+export class AnthropicMessage {
+    role;
+    content;
+    constructor(role, content) {
+        this.role = role;
+        this.content = content;
+    }
+    static user(content) {
+        return new AnthropicMessage("user", content);
+    }
+    static assistant(content) {
+        return new AnthropicMessage("assistant", content);
+    }
+    toWire() {
+        return { role: this.role, content: this.content };
+    }
+}
+export class AnthropicMessagesRequest {
+    model;
+    messages;
+    max_tokens;
+    system;
+    temperature;
+    top_p;
+    top_k;
+    stop_sequences;
+    stream;
+    tools;
+    tool_choice;
+    thinking;
+    output_config;
+    metadata;
+    constructor(options) {
+        this.model = options.model;
+        this.messages = options.messages;
+        this.max_tokens = options.max_tokens;
+        this.system = options.system ?? null;
+        this.temperature = options.temperature ?? null;
+        this.top_p = options.top_p ?? null;
+        this.top_k = options.top_k ?? null;
+        this.stop_sequences = options.stop_sequences ?? null;
+        this.stream = options.stream ?? null;
+        this.tools = options.tools ?? null;
+        this.tool_choice = options.tool_choice ?? null;
+        this.thinking = options.thinking ?? null;
+        this.output_config = options.output_config ?? null;
+        this.metadata = options.metadata ?? null;
+    }
+    streaming() {
+        return new AnthropicMessagesRequest({ ...this, stream: true });
+    }
+    toWire() {
+        const encoded = {
+            model: this.model,
+            messages: this.messages.map((message) => message.toWire()),
+            max_tokens: this.max_tokens,
+        };
+        if (this.system !== null)
+            encoded["system"] = this.system;
+        if (this.temperature !== null)
+            encoded["temperature"] = this.temperature;
+        if (this.top_p !== null)
+            encoded["top_p"] = this.top_p;
+        if (this.top_k !== null)
+            encoded["top_k"] = this.top_k;
+        if (this.stop_sequences !== null)
+            encoded["stop_sequences"] = [...this.stop_sequences];
+        if (this.stream !== null)
+            encoded["stream"] = this.stream;
+        if (this.tools !== null)
+            encoded["tools"] = [...this.tools];
+        if (this.tool_choice !== null)
+            encoded["tool_choice"] = this.tool_choice;
+        if (this.thinking !== null)
+            encoded["thinking"] = this.thinking;
+        if (this.output_config !== null)
+            encoded["output_config"] = this.output_config;
+        if (this.metadata !== null)
+            encoded["metadata"] = this.metadata;
+        return encoded;
+    }
+}
+export class OpenAIResponsesRequest {
+    model;
+    input;
+    instructions;
+    max_output_tokens;
+    max_tool_calls;
+    temperature;
+    top_p;
+    stream;
+    tools;
+    tool_choice;
+    parallel_tool_calls;
+    reasoning;
+    text;
+    include;
+    store;
+    previous_response_id;
+    prompt_cache_key;
+    metadata;
+    constructor(options) {
+        this.model = options.model;
+        this.input = options.input;
+        this.instructions = options.instructions ?? null;
+        this.max_output_tokens = options.max_output_tokens ?? null;
+        this.max_tool_calls = options.max_tool_calls ?? null;
+        this.temperature = options.temperature ?? null;
+        this.top_p = options.top_p ?? null;
+        this.stream = options.stream ?? null;
+        this.tools = options.tools ?? null;
+        this.tool_choice = options.tool_choice ?? null;
+        this.parallel_tool_calls = options.parallel_tool_calls ?? null;
+        this.reasoning = options.reasoning ?? null;
+        this.text = options.text ?? null;
+        this.include = options.include ?? null;
+        this.store = options.store ?? null;
+        this.previous_response_id = options.previous_response_id ?? null;
+        this.prompt_cache_key = options.prompt_cache_key ?? null;
+        this.metadata = options.metadata ?? null;
+    }
+    streaming() {
+        return new OpenAIResponsesRequest({ ...this, stream: true });
+    }
+    toWire() {
+        const encoded = {
+            model: this.model,
+            input: this.input,
+        };
+        if (this.instructions !== null)
+            encoded["instructions"] = this.instructions;
+        if (this.max_output_tokens !== null)
+            encoded["max_output_tokens"] = this.max_output_tokens;
+        if (this.max_tool_calls !== null)
+            encoded["max_tool_calls"] = this.max_tool_calls;
+        if (this.temperature !== null)
+            encoded["temperature"] = this.temperature;
+        if (this.top_p !== null)
+            encoded["top_p"] = this.top_p;
+        if (this.stream !== null)
+            encoded["stream"] = this.stream;
+        if (this.tools !== null)
+            encoded["tools"] = [...this.tools];
+        if (this.tool_choice !== null)
+            encoded["tool_choice"] = this.tool_choice;
+        if (this.parallel_tool_calls !== null)
+            encoded["parallel_tool_calls"] = this.parallel_tool_calls;
+        if (this.reasoning !== null)
+            encoded["reasoning"] = this.reasoning;
+        if (this.text !== null)
+            encoded["text"] = this.text;
+        if (this.include !== null)
+            encoded["include"] = [...this.include];
+        if (this.store !== null)
+            encoded["store"] = this.store;
+        if (this.previous_response_id !== null)
+            encoded["previous_response_id"] = this.previous_response_id;
+        if (this.prompt_cache_key !== null)
+            encoded["prompt_cache_key"] = this.prompt_cache_key;
+        if (this.metadata !== null)
+            encoded["metadata"] = this.metadata;
+        return encoded;
+    }
+}
+export class OpenAIChatRequest {
+    model;
+    messages;
+    max_completion_tokens;
+    max_tokens;
+    temperature;
+    top_p;
+    frequency_penalty;
+    presence_penalty;
+    seed;
+    n;
+    logit_bias;
+    stop;
+    stream;
+    stream_options;
+    tools;
+    tool_choice;
+    parallel_tool_calls;
+    response_format;
+    reasoning_effort;
+    verbosity;
+    prompt_cache_key;
+    store;
+    metadata;
+    user;
+    constructor(options) {
+        this.model = options.model;
+        this.messages = options.messages;
+        this.max_completion_tokens = options.max_completion_tokens ?? null;
+        this.max_tokens = options.max_tokens ?? null;
+        this.temperature = options.temperature ?? null;
+        this.top_p = options.top_p ?? null;
+        this.frequency_penalty = options.frequency_penalty ?? null;
+        this.presence_penalty = options.presence_penalty ?? null;
+        this.seed = options.seed ?? null;
+        this.n = options.n ?? null;
+        this.logit_bias = options.logit_bias ?? null;
+        this.stop = options.stop ?? null;
+        this.stream = options.stream ?? null;
+        this.stream_options = options.stream_options ?? null;
+        this.tools = options.tools ?? null;
+        this.tool_choice = options.tool_choice ?? null;
+        this.parallel_tool_calls = options.parallel_tool_calls ?? null;
+        this.response_format = options.response_format ?? null;
+        this.reasoning_effort = options.reasoning_effort ?? null;
+        this.verbosity = options.verbosity ?? null;
+        this.prompt_cache_key = options.prompt_cache_key ?? null;
+        this.store = options.store ?? null;
+        this.metadata = options.metadata ?? null;
+        this.user = options.user ?? null;
+    }
+    streaming() {
+        return new OpenAIChatRequest({
+            ...this,
+            stream: true,
+            stream_options: this.stream_options ?? { include_usage: true },
+        });
+    }
+    toWire() {
+        const encoded = {
+            model: this.model,
+            messages: this.messages.map((message) => message.toWire()),
+        };
+        if (this.max_completion_tokens !== null)
+            encoded["max_completion_tokens"] = this.max_completion_tokens;
+        if (this.max_tokens !== null)
+            encoded["max_tokens"] = this.max_tokens;
+        if (this.temperature !== null)
+            encoded["temperature"] = this.temperature;
+        if (this.top_p !== null)
+            encoded["top_p"] = this.top_p;
+        if (this.frequency_penalty !== null)
+            encoded["frequency_penalty"] = this.frequency_penalty;
+        if (this.presence_penalty !== null)
+            encoded["presence_penalty"] = this.presence_penalty;
+        if (this.seed !== null)
+            encoded["seed"] = this.seed;
+        if (this.n !== null)
+            encoded["n"] = this.n;
+        if (this.logit_bias !== null)
+            encoded["logit_bias"] = this.logit_bias;
+        if (this.stop !== null)
+            encoded["stop"] = this.stop;
+        if (this.stream !== null)
+            encoded["stream"] = this.stream;
+        if (this.stream_options !== null)
+            encoded["stream_options"] = this.stream_options;
+        if (this.tools !== null)
+            encoded["tools"] = this.tools.map((tool) => tool.toWire());
+        if (this.tool_choice !== null)
+            encoded["tool_choice"] = this.tool_choice;
+        if (this.parallel_tool_calls !== null)
+            encoded["parallel_tool_calls"] = this.parallel_tool_calls;
+        if (this.response_format !== null)
+            encoded["response_format"] = this.response_format;
+        if (this.reasoning_effort !== null)
+            encoded["reasoning_effort"] = this.reasoning_effort;
+        if (this.verbosity !== null)
+            encoded["verbosity"] = this.verbosity;
+        if (this.prompt_cache_key !== null)
+            encoded["prompt_cache_key"] = this.prompt_cache_key;
+        if (this.store !== null)
+            encoded["store"] = this.store;
+        if (this.metadata !== null)
+            encoded["metadata"] = this.metadata;
+        if (this.user !== null)
+            encoded["user"] = this.user;
+        return encoded;
+    }
+}
+export class GoogleGenerateContentRequest {
+    model;
+    contents;
+    systemInstruction;
+    tools;
+    toolConfig;
+    generationConfig;
+    safetySettings;
+    stream;
+    constructor(options) {
+        this.model = options.model;
+        this.contents = options.contents;
+        this.systemInstruction = options.systemInstruction ?? null;
+        this.tools = options.tools ?? null;
+        this.toolConfig = options.toolConfig ?? null;
+        this.generationConfig = options.generationConfig ?? null;
+        this.safetySettings = options.safetySettings ?? null;
+        this.stream = options.stream ?? null;
+    }
+    streaming() {
+        return new GoogleGenerateContentRequest({ ...this, stream: true });
+    }
+    toWire() {
+        const encoded = {
+            model: this.model,
+            contents: [...this.contents],
+        };
+        if (this.systemInstruction !== null)
+            encoded["systemInstruction"] = this.systemInstruction;
+        if (this.tools !== null)
+            encoded["tools"] = [...this.tools];
+        if (this.toolConfig !== null)
+            encoded["toolConfig"] = this.toolConfig;
+        if (this.generationConfig !== null)
+            encoded["generationConfig"] = this.generationConfig;
+        if (this.safetySettings !== null)
+            encoded["safetySettings"] = [...this.safetySettings];
+        if (this.stream !== null)
+            encoded["stream"] = this.stream;
+        return encoded;
+    }
+}
+export function kindTag(body) {
+    if (body instanceof AnthropicMessagesRequest)
+        return KIND_ANTHROPIC;
+    if (body instanceof OpenAIResponsesRequest)
+        return KIND_OPENAI_PRO;
+    if (body instanceof OpenAIChatRequest)
+        return KIND_OPENAI_GENERIC;
+    if (body instanceof GoogleGenerateContentRequest)
+        return KIND_GOOGLE;
+    throw new EncodingFailedError(new TypeError("unsupported router body type"));
+}
+export class SwitchboardRouter {
+    user_id;
+    time;
+    idempotency_key;
+    kind;
+    constructor(options) {
+        this.user_id = options.user_id;
+        this.time = options.time;
+        this.idempotency_key = options.idempotency_key;
+        this.kind = options.kind;
+    }
+    static create(userId, kind) {
+        return new SwitchboardRouter({
+            user_id: userId,
+            time: new Date().toISOString(),
+            idempotency_key: crypto.randomUUID(),
+            kind,
+        });
+    }
+    streaming() {
+        return new SwitchboardRouter({ ...this, kind: this.kind.streaming() });
+    }
+    toWire() {
+        return {
+            user_id: this.user_id,
+            time: this.time,
+            idempotency_key: this.idempotency_key,
+            kind: { [kindTag(this.kind)]: this.kind.toWire() },
+        };
+    }
+}
+export class AnthropicUsage {
+    input_tokens;
+    output_tokens;
+    cache_creation_input_tokens;
+    cache_read_input_tokens;
+    constructor(inputTokens, outputTokens, cacheCreationInputTokens = null, cacheReadInputTokens = null) {
+        this.input_tokens = inputTokens;
+        this.output_tokens = outputTokens;
+        this.cache_creation_input_tokens = cacheCreationInputTokens;
+        this.cache_read_input_tokens = cacheReadInputTokens;
+    }
+    static fromWire(value) {
+        const fields = wire.mapping(value, "usage");
+        return new AnthropicUsage(wire.integer(fields, "input_tokens", "usage"), wire.integer(fields, "output_tokens", "usage"), wire.optionalInteger(fields, "cache_creation_input_tokens", "usage"), wire.optionalInteger(fields, "cache_read_input_tokens", "usage"));
+    }
+}
+export class AnthropicMessageResponse {
+    id;
+    role;
+    model;
+    content;
+    stop_reason;
+    stop_sequence;
+    usage;
+    constructor(id, role, model, content, stopReason, stopSequence, usage) {
+        this.id = id;
+        this.role = role;
+        this.model = model;
+        this.content = content;
+        this.stop_reason = stopReason;
+        this.stop_sequence = stopSequence;
+        this.usage = usage;
+    }
+    get text() {
+        return this.content
+            .filter((block) => block !== null &&
+            typeof block === "object" &&
+            block["type"] === "text" &&
+            typeof block["text"] === "string")
+            .map((block) => block.text)
+            .join("");
+    }
+    static fromWire(value) {
+        const fields = wire.mapping(value, "message");
+        return new AnthropicMessageResponse(wire.string(fields, "id", "message"), wire.string(fields, "role", "message"), wire.string(fields, "model", "message"), wire.array(fields, "content", "message"), wire.optionalString(fields, "stop_reason", "message"), wire.optionalString(fields, "stop_sequence", "message"), AnthropicUsage.fromWire(fields["usage"]));
+    }
+}
+export class OpenAIUsage {
+    prompt_tokens;
+    completion_tokens;
+    total_tokens;
+    prompt_tokens_details;
+    completion_tokens_details;
+    constructor(promptTokens, completionTokens, totalTokens, promptTokensDetails = null, completionTokensDetails = null) {
+        this.prompt_tokens = promptTokens;
+        this.completion_tokens = completionTokens;
+        this.total_tokens = totalTokens;
+        this.prompt_tokens_details = promptTokensDetails;
+        this.completion_tokens_details = completionTokensDetails;
+    }
+    static fromWire(value) {
+        const fields = wire.mapping(value, "usage");
+        return new OpenAIUsage(wire.integer(fields, "prompt_tokens", "usage"), wire.integer(fields, "completion_tokens", "usage"), wire.integer(fields, "total_tokens", "usage"), wire.optionalMapping(fields, "prompt_tokens_details", "usage"), wire.optionalMapping(fields, "completion_tokens_details", "usage"));
+    }
+}
+export class OpenAIChatResponseMessage {
+    role;
+    content;
+    tool_calls;
+    constructor(role, content = null, toolCalls = null) {
+        this.role = role;
+        this.content = content;
+        this.tool_calls = toolCalls;
+    }
+    static fromWire(value) {
+        const fields = wire.mapping(value, "choice.message");
+        return new OpenAIChatResponseMessage(wire.string(fields, "role", "choice.message"), wire.optionalString(fields, "content", "choice.message"), wire.optionalArray(fields, "tool_calls", "choice.message"));
+    }
+}
+export class OpenAIChatChoice {
+    index;
+    message;
+    finish_reason;
+    constructor(index, message, finishReason = null) {
+        this.index = index;
+        this.message = message;
+        this.finish_reason = finishReason;
+    }
+    static fromWire(value) {
+        const fields = wire.mapping(value, "choice");
+        return new OpenAIChatChoice(wire.integer(fields, "index", "choice"), OpenAIChatResponseMessage.fromWire(fields["message"]), wire.optionalString(fields, "finish_reason", "choice"));
+    }
+}
+export class OpenAIChatResponse {
+    id;
+    model;
+    choices;
+    usage;
+    constructor(id, model, choices, usage) {
+        this.id = id;
+        this.model = model;
+        this.choices = choices;
+        this.usage = usage;
+    }
+    static fromWire(value) {
+        const fields = wire.mapping(value, "response");
+        return new OpenAIChatResponse(wire.string(fields, "id", "response"), wire.string(fields, "model", "response"), wire.array(fields, "choices", "response").map((item) => OpenAIChatChoice.fromWire(item)), OpenAIUsage.fromWire(fields["usage"]));
+    }
+}
+export class OpenAIResponsesUsage {
+    input_tokens;
+    output_tokens;
+    total_tokens;
+    input_tokens_details;
+    output_tokens_details;
+    constructor(inputTokens, outputTokens, totalTokens, inputTokensDetails = null, outputTokensDetails = null) {
+        this.input_tokens = inputTokens;
+        this.output_tokens = outputTokens;
+        this.total_tokens = totalTokens;
+        this.input_tokens_details = inputTokensDetails;
+        this.output_tokens_details = outputTokensDetails;
+    }
+    static fromWire(value) {
+        const fields = wire.mapping(value, "usage");
+        return new OpenAIResponsesUsage(wire.integer(fields, "input_tokens", "usage"), wire.integer(fields, "output_tokens", "usage"), wire.integer(fields, "total_tokens", "usage"), wire.optionalMapping(fields, "input_tokens_details", "usage"), wire.optionalMapping(fields, "output_tokens_details", "usage"));
+    }
+}
+export class OpenAIResponsesResponse {
+    id;
+    model;
+    status;
+    output;
+    usage;
+    constructor(id, model, status, output, usage) {
+        this.id = id;
+        this.model = model;
+        this.status = status;
+        this.output = output;
+        this.usage = usage;
+    }
+    get outputText() {
+        const collected = [];
+        for (const item of this.output) {
+            if (item === null || typeof item !== "object")
+                continue;
+            const itemFields = item;
+            if (itemFields["type"] !== "message")
+                continue;
+            const content = itemFields["content"];
+            if (!Array.isArray(content))
+                continue;
+            for (const part of content) {
+                if (part === null || typeof part !== "object")
+                    continue;
+                const partFields = part;
+                if (partFields["type"] === "output_text" && typeof partFields["text"] === "string") {
+                    collected.push(partFields["text"]);
+                }
+            }
+        }
+        return collected.join("");
+    }
+    static fromWire(value) {
+        const fields = wire.mapping(value, "response");
+        return new OpenAIResponsesResponse(wire.string(fields, "id", "response"), wire.string(fields, "model", "response"), wire.string(fields, "status", "response"), wire.array(fields, "output", "response"), OpenAIResponsesUsage.fromWire(fields["usage"]));
+    }
+}
+export class GoogleUsageMetadata {
+    promptTokenCount;
+    candidatesTokenCount;
+    thoughtsTokenCount;
+    cachedContentTokenCount;
+    totalTokenCount;
+    constructor(promptTokenCount = null, candidatesTokenCount = null, thoughtsTokenCount = null, cachedContentTokenCount = null, totalTokenCount = null) {
+        this.promptTokenCount = promptTokenCount;
+        this.candidatesTokenCount = candidatesTokenCount;
+        this.thoughtsTokenCount = thoughtsTokenCount;
+        this.cachedContentTokenCount = cachedContentTokenCount;
+        this.totalTokenCount = totalTokenCount;
+    }
+    static fromWire(value) {
+        const fields = wire.mapping(value, "usage");
+        return new GoogleUsageMetadata(wire.optionalInteger(fields, "promptTokenCount", "usage"), wire.optionalInteger(fields, "candidatesTokenCount", "usage"), wire.optionalInteger(fields, "thoughtsTokenCount", "usage"), wire.optionalInteger(fields, "cachedContentTokenCount", "usage"), wire.optionalInteger(fields, "totalTokenCount", "usage"));
+    }
+}
+export class GoogleGenerateContentResponse {
+    candidates;
+    usageMetadata;
+    modelVersion;
+    responseId;
+    constructor(candidates = null, usageMetadata = null, modelVersion = null, responseId = null) {
+        this.candidates = candidates;
+        this.usageMetadata = usageMetadata;
+        this.modelVersion = modelVersion;
+        this.responseId = responseId;
+    }
+    static fromWire(value) {
+        const fields = wire.mapping(value, "response");
+        const usageMetadataWire = fields["usageMetadata"];
+        return new GoogleGenerateContentResponse(wire.optionalArray(fields, "candidates", "response"), usageMetadataWire === null || usageMetadataWire === undefined
+            ? null
+            : GoogleUsageMetadata.fromWire(usageMetadataWire), wire.optionalString(fields, "modelVersion", "response"), wire.optionalString(fields, "responseId", "response"));
+    }
+}
+export var AnthropicStream;
+(function (AnthropicStream) {
+    class MessageStart {
+        message;
+        constructor(message) {
+            this.message = message;
+        }
+    }
+    AnthropicStream.MessageStart = MessageStart;
+    class ContentBlockStart {
+        index;
+        content_block;
+        constructor(index, contentBlock) {
+            this.index = index;
+            this.content_block = contentBlock;
+        }
+    }
+    AnthropicStream.ContentBlockStart = ContentBlockStart;
+    class ContentBlockDelta {
+        index;
+        delta;
+        constructor(index, delta) {
+            this.index = index;
+            this.delta = delta;
+        }
+    }
+    AnthropicStream.ContentBlockDelta = ContentBlockDelta;
+    class ContentBlockStop {
+        index;
+        constructor(index) {
+            this.index = index;
+        }
+    }
+    AnthropicStream.ContentBlockStop = ContentBlockStop;
+    class MessageDelta {
+        delta;
+        usage;
+        constructor(delta, usage) {
+            this.delta = delta;
+            this.usage = usage;
+        }
+    }
+    AnthropicStream.MessageDelta = MessageDelta;
+    class MessageStop {
+    }
+    AnthropicStream.MessageStop = MessageStop;
+    class Ping {
+    }
+    AnthropicStream.Ping = Ping;
+    class Error {
+        error_type;
+        message;
+        constructor(errorType, message) {
+            this.error_type = errorType;
+            this.message = message;
+        }
+    }
+    AnthropicStream.Error = Error;
+    function parse(value) {
+        const fields = wire.mapping(value, "anthropic event");
+        const eventType = wire.string(fields, "type", "anthropic event");
+        if (eventType === "message_start") {
+            return new MessageStart(wire.mapping(fields["message"], "message_start.message"));
+        }
+        if (eventType === "content_block_start") {
+            return new ContentBlockStart(wire.integer(fields, "index", "content_block_start"), wire.mapping(fields["content_block"], "content_block_start.content_block"));
+        }
+        if (eventType === "content_block_delta") {
+            return new ContentBlockDelta(wire.integer(fields, "index", "content_block_delta"), wire.mapping(fields["delta"], "content_block_delta.delta"));
+        }
+        if (eventType === "content_block_stop") {
+            return new ContentBlockStop(wire.integer(fields, "index", "content_block_stop"));
+        }
+        if (eventType === "message_delta") {
+            return new MessageDelta(wire.mapping(fields["delta"], "message_delta.delta"), wire.mapping(fields["usage"], "message_delta.usage"));
+        }
+        if (eventType === "message_stop") {
+            return new MessageStop();
+        }
+        if (eventType === "ping") {
+            return new Ping();
+        }
+        if (eventType === "error") {
+            const errorFields = wire.mapping(fields["error"], "error.error");
+            return new Error(wire.string(errorFields, "type", "error.error"), wire.string(errorFields, "message", "error.error"));
+        }
+        return null;
+    }
+    AnthropicStream.parse = parse;
+})(AnthropicStream || (AnthropicStream = {}));
+export class OpenAIChatChunkChoice {
+    index;
+    delta;
+    finish_reason;
+    constructor(index, delta, finishReason = null) {
+        this.index = index;
+        this.delta = delta;
+        this.finish_reason = finishReason;
+    }
+    static fromWire(value) {
+        const fields = wire.mapping(value, "chunk.choice");
+        return new OpenAIChatChunkChoice(wire.integer(fields, "index", "chunk.choice"), wire.mapping(fields["delta"], "chunk.choice.delta"), wire.optionalString(fields, "finish_reason", "chunk.choice"));
+    }
+}
+export class OpenAIChatChunk {
+    id;
+    model;
+    choices;
+    usage;
+    constructor(id, model, choices, usage = null) {
+        this.id = id;
+        this.model = model;
+        this.choices = choices;
+        this.usage = usage;
+    }
+    static fromWire(value) {
+        const fields = wire.mapping(value, "chunk");
+        const usageWire = fields["usage"];
+        return new OpenAIChatChunk(wire.string(fields, "id", "chunk"), wire.string(fields, "model", "chunk"), wire.array(fields, "choices", "chunk").map((item) => OpenAIChatChunkChoice.fromWire(item)), usageWire === null || usageWire === undefined ? null : OpenAIUsage.fromWire(usageWire));
+    }
+}
+export var OpenAIResponsesStream;
+(function (OpenAIResponsesStream) {
+    class ResponseCreated {
+        response;
+        constructor(response) {
+            this.response = response;
+        }
+    }
+    OpenAIResponsesStream.ResponseCreated = ResponseCreated;
+    class ResponseInProgress {
+        response;
+        constructor(response) {
+            this.response = response;
+        }
+    }
+    OpenAIResponsesStream.ResponseInProgress = ResponseInProgress;
+    class OutputItemAdded {
+        output_index;
+        item;
+        constructor(outputIndex, item) {
+            this.output_index = outputIndex;
+            this.item = item;
+        }
+    }
+    OpenAIResponsesStream.OutputItemAdded = OutputItemAdded;
+    class ContentPartAdded {
+        item_id;
+        output_index;
+        content_index;
+        part;
+        constructor(itemId, outputIndex, contentIndex, part) {
+            this.item_id = itemId;
+            this.output_index = outputIndex;
+            this.content_index = contentIndex;
+            this.part = part;
+        }
+    }
+    OpenAIResponsesStream.ContentPartAdded = ContentPartAdded;
+    class OutputTextDelta {
+        delta;
+        constructor(delta) {
+            this.delta = delta;
+        }
+    }
+    OpenAIResponsesStream.OutputTextDelta = OutputTextDelta;
+    class OutputTextDone {
+        item_id;
+        output_index;
+        content_index;
+        text;
+        constructor(itemId, outputIndex, contentIndex, text) {
+            this.item_id = itemId;
+            this.output_index = outputIndex;
+            this.content_index = contentIndex;
+            this.text = text;
+        }
+    }
+    OpenAIResponsesStream.OutputTextDone = OutputTextDone;
+    class ContentPartDone {
+        item_id;
+        output_index;
+        content_index;
+        part;
+        constructor(itemId, outputIndex, contentIndex, part) {
+            this.item_id = itemId;
+            this.output_index = outputIndex;
+            this.content_index = contentIndex;
+            this.part = part;
+        }
+    }
+    OpenAIResponsesStream.ContentPartDone = ContentPartDone;
+    class FunctionCallArgumentsDelta {
+        item_id;
+        output_index;
+        delta;
+        constructor(itemId, outputIndex, delta) {
+            this.item_id = itemId;
+            this.output_index = outputIndex;
+            this.delta = delta;
+        }
+    }
+    OpenAIResponsesStream.FunctionCallArgumentsDelta = FunctionCallArgumentsDelta;
+    class FunctionCallArgumentsDone {
+        item_id;
+        output_index;
+        name;
+        arguments;
+        constructor(itemId, outputIndex, name, argumentsText) {
+            this.item_id = itemId;
+            this.output_index = outputIndex;
+            this.name = name;
+            this.arguments = argumentsText;
+        }
+    }
+    OpenAIResponsesStream.FunctionCallArgumentsDone = FunctionCallArgumentsDone;
+    class ReasoningSummaryTextDelta {
+        item_id;
+        output_index;
+        summary_index;
+        delta;
+        constructor(itemId, outputIndex, summaryIndex, delta) {
+            this.item_id = itemId;
+            this.output_index = outputIndex;
+            this.summary_index = summaryIndex;
+            this.delta = delta;
+        }
+    }
+    OpenAIResponsesStream.ReasoningSummaryTextDelta = ReasoningSummaryTextDelta;
+    class OutputItemDone {
+        item;
+        constructor(item) {
+            this.item = item;
+        }
+    }
+    OpenAIResponsesStream.OutputItemDone = OutputItemDone;
+    class ResponseCompleted {
+        response;
+        constructor(response) {
+            this.response = response;
+        }
+    }
+    OpenAIResponsesStream.ResponseCompleted = ResponseCompleted;
+    class ResponseIncomplete {
+        response;
+        constructor(response) {
+            this.response = response;
+        }
+    }
+    OpenAIResponsesStream.ResponseIncomplete = ResponseIncomplete;
+    class ResponseFailed {
+        response;
+        constructor(response) {
+            this.response = response;
+        }
+    }
+    OpenAIResponsesStream.ResponseFailed = ResponseFailed;
+    class Error {
+        message;
+        constructor(message) {
+            this.message = message;
+        }
+    }
+    OpenAIResponsesStream.Error = Error;
+    function parse(value) {
+        const fields = wire.mapping(value, "responses event");
+        const eventType = wire.string(fields, "type", "responses event");
+        if (eventType === "response.created") {
+            return new ResponseCreated(wire.mapping(fields["response"], "response.created.response"));
+        }
+        if (eventType === "response.in_progress") {
+            return new ResponseInProgress(wire.mapping(fields["response"], "response.in_progress.response"));
+        }
+        if (eventType === "response.output_item.added") {
+            return new OutputItemAdded(wire.integer(fields, "output_index", "response.output_item.added"), wire.mapping(fields["item"], "response.output_item.added.item"));
+        }
+        if (eventType === "response.content_part.added") {
+            return new ContentPartAdded(wire.string(fields, "item_id", "response.content_part.added"), wire.integer(fields, "output_index", "response.content_part.added"), wire.integer(fields, "content_index", "response.content_part.added"), wire.mapping(fields["part"], "response.content_part.added.part"));
+        }
+        if (eventType === "response.output_text.delta") {
+            return new OutputTextDelta(wire.string(fields, "delta", "response.output_text.delta"));
+        }
+        if (eventType === "response.output_text.done") {
+            return new OutputTextDone(wire.string(fields, "item_id", "response.output_text.done"), wire.integer(fields, "output_index", "response.output_text.done"), wire.integer(fields, "content_index", "response.output_text.done"), wire.string(fields, "text", "response.output_text.done"));
+        }
+        if (eventType === "response.content_part.done") {
+            return new ContentPartDone(wire.string(fields, "item_id", "response.content_part.done"), wire.integer(fields, "output_index", "response.content_part.done"), wire.integer(fields, "content_index", "response.content_part.done"), wire.mapping(fields["part"], "response.content_part.done.part"));
+        }
+        if (eventType === "response.function_call_arguments.delta") {
+            return new FunctionCallArgumentsDelta(wire.string(fields, "item_id", "response.function_call_arguments.delta"), wire.integer(fields, "output_index", "response.function_call_arguments.delta"), wire.string(fields, "delta", "response.function_call_arguments.delta"));
+        }
+        if (eventType === "response.function_call_arguments.done") {
+            return new FunctionCallArgumentsDone(wire.string(fields, "item_id", "response.function_call_arguments.done"), wire.integer(fields, "output_index", "response.function_call_arguments.done"), wire.string(fields, "name", "response.function_call_arguments.done"), wire.string(fields, "arguments", "response.function_call_arguments.done"));
+        }
+        if (eventType === "response.reasoning_summary_text.delta") {
+            return new ReasoningSummaryTextDelta(wire.string(fields, "item_id", "response.reasoning_summary_text.delta"), wire.integer(fields, "output_index", "response.reasoning_summary_text.delta"), wire.integer(fields, "summary_index", "response.reasoning_summary_text.delta"), wire.string(fields, "delta", "response.reasoning_summary_text.delta"));
+        }
+        if (eventType === "response.output_item.done") {
+            return new OutputItemDone(wire.mapping(fields["item"], "response.output_item.done.item"));
+        }
+        if (eventType === "response.completed") {
+            return new ResponseCompleted(wire.mapping(fields["response"], "response.completed.response"));
+        }
+        if (eventType === "response.incomplete") {
+            return new ResponseIncomplete(wire.mapping(fields["response"], "response.incomplete.response"));
+        }
+        if (eventType === "response.failed") {
+            return new ResponseFailed(wire.mapping(fields["response"], "response.failed.response"));
+        }
+        if (eventType === "error") {
+            return new Error(wire.string(fields, "message", "error"));
+        }
+        return null;
+    }
+    OpenAIResponsesStream.parse = parse;
+})(OpenAIResponsesStream || (OpenAIResponsesStream = {}));