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

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

@@ -0,0 +1,95 @@
+export class SwitchboardError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = new.target.name;
+    }
+}
+export class ServerError extends SwitchboardError {
+    status;
+    code;
+    serverMessage;
+    context;
+    constructor(status, code, message, context = null) {
+        super(code !== null ? `Switchboard ${status} ${code}: ${message}` : `Switchboard ${status}: ${message}`);
+        this.status = status;
+        this.code = code;
+        this.serverMessage = message;
+        this.context = context;
+    }
+}
+export class AuthenticationError extends ServerError {
+}
+export class InsufficientBalanceError extends ServerError {
+}
+export class RateLimitError extends ServerError {
+}
+export class SpendLimitError extends ServerError {
+}
+export class ModelNotPermittedError extends ServerError {
+}
+const AUTHENTICATION_CODES = new Set(["SWB-1001", "SWB-1002", "SWB-1006", "SWB-1013", "SWB-1014"]);
+const INSUFFICIENT_BALANCE_CODES = new Set(["SWB-1007"]);
+const RATE_LIMIT_CODES = new Set(["SWB-1003", "SWB-1004", "SWB-1008"]);
+const SPEND_LIMIT_CODES = new Set(["SWB-1005", "SWB-1009", "SWB-1011"]);
+const MODEL_NOT_PERMITTED_CODES = new Set(["SWB-1010", "SWB-1012"]);
+export function serverErrorFor(status, code, message, context = null) {
+    if (code !== null) {
+        if (AUTHENTICATION_CODES.has(code))
+            return new AuthenticationError(status, code, message, context);
+        if (INSUFFICIENT_BALANCE_CODES.has(code))
+            return new InsufficientBalanceError(status, code, message, context);
+        if (RATE_LIMIT_CODES.has(code))
+            return new RateLimitError(status, code, message, context);
+        if (SPEND_LIMIT_CODES.has(code))
+            return new SpendLimitError(status, code, message, context);
+        if (MODEL_NOT_PERMITTED_CODES.has(code))
+            return new ModelNotPermittedError(status, code, message, context);
+    }
+    return new ServerError(status, code, message, context);
+}
+export class DecodingFailedError extends SwitchboardError {
+    underlying;
+    constructor(underlying) {
+        super(`Switchboard response decode failed: ${underlying instanceof Error ? underlying.message : String(underlying)}`);
+        this.underlying = underlying;
+    }
+}
+export class EncodingFailedError extends SwitchboardError {
+    underlying;
+    constructor(underlying) {
+        super(`Switchboard request body encode failed: ${underlying instanceof Error ? underlying.message : String(underlying)}`);
+        this.underlying = underlying;
+    }
+}
+export class TransportError extends SwitchboardError {
+    underlying;
+    constructor(underlying) {
+        super(`Switchboard request failed: ${underlying instanceof Error ? underlying.message : String(underlying)}`);
+        this.underlying = underlying;
+    }
+}
+export class MissingAPIKeyError extends SwitchboardError {
+    constructor() {
+        super("Client was constructed with an empty API key.");
+    }
+}
+export class StreamError extends SwitchboardError {
+    code;
+    streamMessage;
+    detail;
+    constructor(code, message, detail = null) {
+        super(detail !== null
+            ? `Switchboard stream error ${code}: ${message} (${detail})`
+            : `Switchboard stream error ${code}: ${message}`);
+        this.code = code;
+        this.streamMessage = message;
+        this.detail = detail;
+    }
+}
+export class DeviceAuthError extends SwitchboardError {
+    reason;
+    constructor(reason, message) {
+        super(message);
+        this.reason = reason;
+    }
+}

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

@@ -0,0 +1,8 @@
+export * as messages from "./messages.js";
+export * as native from "./native.js";
+export { Client, DEFAULT_BASE_URL, DEFAULT_TIMEOUT_MILLISECONDS, } from "./client.js";
+export { BalancePage, ErrorEnvelope, MICRO_CENTS_PER_USD, ModelsPage, PickerModel, UsagePage, UsageRecord, usdFromMicroCents, } from "./apiTypes.js";
+export { AuthenticationError, DecodingFailedError, DeviceAuthError, EncodingFailedError, InsufficientBalanceError, MissingAPIKeyError, ModelNotPermittedError, RateLimitError, ServerError, SpendLimitError, StreamError, SwitchboardError, TransportError, serverErrorFor, } from "./errors.js";
+export { DEFAULT_AUTH_BASE_URL, deviceLogin, deviceRefresh, } from "./deviceAuth.js";
+export { WireFormat, kindForWireFormat } from "./models.js";
+export { SwitchboardRouter, } from "./native.js";

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

@@ -0,0 +1,253 @@
+import * as wire from "./wire.js";
+const KNOWN_PROPERTY_TYPES = new Set(["string", "number", "integer", "boolean", "object", "array", "null"]);
+const DATA_URL_PREVIEW_LENGTH = 64;
+const DATA_URL_PREFIX = "data:";
+const BASE64_ENCODING_LABEL = "base64";
+export const Role = {
+    SYSTEM: "system",
+    USER: "user",
+    ASSISTANT: "assistant",
+    TOOL: "tool",
+};
+const ROLES = new Set(Object.values(Role));
+function decodeRole(value) {
+    if (!ROLES.has(value)) {
+        throw new Error(`unknown role ${JSON.stringify(value)}`);
+    }
+    return value;
+}
+export class ImageData {
+    mediaType;
+    base64;
+    constructor(mediaType, base64) {
+        this.mediaType = mediaType;
+        this.base64 = base64;
+    }
+    get dataUrl() {
+        return `${DATA_URL_PREFIX}${this.mediaType};${BASE64_ENCODING_LABEL},${this.base64}`;
+    }
+    static fromDataUrl(dataUrl) {
+        const parsed = parseDataUrl(dataUrl);
+        if (parsed === null) {
+            const preview = dataUrl.slice(0, DATA_URL_PREVIEW_LENGTH);
+            const suffix = dataUrl.length > DATA_URL_PREVIEW_LENGTH ? `… (${dataUrl.length} chars total)` : "";
+            throw new Error(`Expected a \`data:\` image URL, got ${preview}${suffix}`);
+        }
+        return parsed;
+    }
+}
+function parseDataUrl(dataUrl) {
+    if (!dataUrl.startsWith(DATA_URL_PREFIX))
+        return null;
+    const body = dataUrl.slice(DATA_URL_PREFIX.length);
+    const semicolon = body.indexOf(";");
+    const comma = body.indexOf(",");
+    if (semicolon === -1 || comma === -1 || semicolon >= comma)
+        return null;
+    if (body.slice(semicolon + 1, comma) !== BASE64_ENCODING_LABEL)
+        return null;
+    return new ImageData(body.slice(0, semicolon), body.slice(comma + 1));
+}
+export class TextPart {
+    text;
+    constructor(text) {
+        this.text = text;
+    }
+}
+export class ImagePart {
+    image;
+    constructor(image) {
+        this.image = image;
+    }
+}
+function encodeContent(content) {
+    if (typeof content === "string")
+        return content;
+    return content.map(encodePart);
+}
+function encodePart(part) {
+    if (part instanceof TextPart) {
+        return { type: "text", text: part.text };
+    }
+    return { type: "image_url", image_url: { url: part.image.dataUrl } };
+}
+function decodeContent(value) {
+    if (typeof value === "string")
+        return value;
+    if (Array.isArray(value))
+        return value.map(decodePart);
+    throw new Error(`message.content: expected string or array of parts, got ${value === null ? "null" : typeof value}`);
+}
+function decodePart(value) {
+    const fields = wire.mapping(value, "content part");
+    const partType = wire.string(fields, "type", "content part");
+    if (partType === "text") {
+        return new TextPart(wire.string(fields, "text", "content part"));
+    }
+    if (partType === "image_url") {
+        const payload = wire.mapping(fields["image_url"], "content part.image_url");
+        return new ImagePart(ImageData.fromDataUrl(wire.string(payload, "url", "content part.image_url")));
+    }
+    throw new Error(`Unknown content part type: ${partType}`);
+}
+export function contentText(content) {
+    if (typeof content === "string")
+        return content;
+    return content
+        .filter((part) => part instanceof TextPart)
+        .map((part) => part.text)
+        .join("");
+}
+export class ToolCallFunction {
+    name;
+    arguments;
+    constructor(name, argumentsText) {
+        this.name = name;
+        this.arguments = argumentsText;
+    }
+    static fromWire(value) {
+        const fields = wire.mapping(value, "tool_call.function");
+        return new ToolCallFunction(wire.string(fields, "name", "tool_call.function"), wire.string(fields, "arguments", "tool_call.function"));
+    }
+}
+export class ToolCall {
+    id;
+    function;
+    type;
+    constructor(id, functionCall, type = "function") {
+        this.id = id;
+        this.function = functionCall;
+        this.type = type;
+    }
+    toWire() {
+        return {
+            id: this.id,
+            type: this.type,
+            function: { name: this.function.name, arguments: this.function.arguments },
+        };
+    }
+    static fromWire(value) {
+        const fields = wire.mapping(value, "tool_call");
+        return new ToolCall(wire.string(fields, "id", "tool_call"), ToolCallFunction.fromWire(fields["function"]), wire.string(fields, "type", "tool_call"));
+    }
+}
+export class Message {
+    role;
+    content;
+    toolCallId;
+    toolCalls;
+    constructor(role, content, options = {}) {
+        this.role = role;
+        this.content = content;
+        this.toolCallId = options.toolCallId ?? null;
+        this.toolCalls = options.toolCalls ?? null;
+    }
+    static system(text) {
+        return new Message(Role.SYSTEM, text);
+    }
+    static user(text) {
+        return new Message(Role.USER, text);
+    }
+    static assistant(text) {
+        return new Message(Role.ASSISTANT, text);
+    }
+    static userParts(parts) {
+        return new Message(Role.USER, parts);
+    }
+    static tool(callId, result) {
+        return new Message(Role.TOOL, result, { toolCallId: callId });
+    }
+    get text() {
+        return contentText(this.content);
+    }
+    toWire() {
+        if (this.role === Role.TOOL && this.toolCallId === null) {
+            throw new Error("`toolCallId` is required when role is tool");
+        }
+        if (this.toolCallId !== null && this.role !== Role.TOOL) {
+            throw new Error("`toolCallId` is only valid when role is tool");
+        }
+        if (this.toolCalls !== null && this.role !== Role.ASSISTANT) {
+            throw new Error("`toolCalls` is only valid when role is assistant");
+        }
+        const encoded = { role: this.role, content: encodeContent(this.content) };
+        if (this.toolCallId !== null) {
+            encoded["tool_call_id"] = this.toolCallId;
+        }
+        if (this.toolCalls !== null) {
+            encoded["tool_calls"] = this.toolCalls.map((toolCall) => toolCall.toWire());
+        }
+        return encoded;
+    }
+    static fromWire(value) {
+        const fields = wire.mapping(value, "message");
+        const role = decodeRole(wire.string(fields, "role", "message"));
+        const contentWire = fields["content"];
+        let content;
+        if (contentWire === null || contentWire === undefined) {
+            if (role !== Role.ASSISTANT) {
+                throw new Error(`message.content is required for role ${role}`);
+            }
+            content = "";
+        }
+        else {
+            content = decodeContent(contentWire);
+        }
+        const toolCallsWire = wire.optionalArray(fields, "tool_calls", "message");
+        const toolCalls = toolCallsWire === null ? null : toolCallsWire.map((item) => ToolCall.fromWire(item));
+        return new Message(role, content, {
+            toolCallId: wire.optionalString(fields, "tool_call_id", "message"),
+            toolCalls,
+        });
+    }
+}
+export class PropertySchema {
+    type;
+    description;
+    constructor(type, description) {
+        const lowered = type.toLowerCase();
+        this.type = KNOWN_PROPERTY_TYPES.has(lowered) ? lowered : type;
+        this.description = description;
+    }
+}
+export class ToolParameters {
+    properties;
+    required;
+    constructor(properties, required = []) {
+        this.properties = properties;
+        this.required = required;
+    }
+    toWire() {
+        const encoded = {
+            type: "object",
+            properties: Object.fromEntries(Object.entries(this.properties).map(([name, schema]) => [
+                name,
+                { type: schema.type, description: schema.description },
+            ])),
+        };
+        if (this.required.length > 0) {
+            encoded["required"] = [...this.required];
+        }
+        return encoded;
+    }
+}
+export class Tool {
+    name;
+    description;
+    parameters;
+    constructor(name, description, parameters) {
+        this.name = name;
+        this.description = description;
+        this.parameters = parameters;
+    }
+    toWire() {
+        return {
+            type: "function",
+            function: {
+                name: this.name,
+                description: this.description,
+                parameters: this.parameters.toWire(),
+            },
+        };
+    }
+}

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

@@ -0,0 +1,19 @@
+import { SwitchboardError } from "./errors.js";
+import { KIND_ANTHROPIC, KIND_OPENAI_GENERIC, KIND_OPENAI_PRO } from "./native.js";
+export const WireFormat = {
+    ANTHROPIC_MESSAGES: "anthropic-messages",
+    OPENAI_COMPATIBLE: "openai-compat",
+    OPENAI_RESPONSES: "openai-responses",
+};
+const WIRE_FORMAT_TO_KIND = {
+    [WireFormat.ANTHROPIC_MESSAGES]: KIND_ANTHROPIC,
+    [WireFormat.OPENAI_COMPATIBLE]: KIND_OPENAI_GENERIC,
+    [WireFormat.OPENAI_RESPONSES]: KIND_OPENAI_PRO,
+};
+export function kindForWireFormat(wireFormat) {
+    const kind = WIRE_FORMAT_TO_KIND[wireFormat];
+    if (kind === undefined) {
+        throw new SwitchboardError(`Unknown wire format: ${wireFormat}`);
+    }
+    return kind;
+}