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

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

@@ -0,0 +1,85 @@
+function shown(value) {
+    if (value === undefined)
+        return "undefined";
+    const encoded = JSON.stringify(value);
+    return encoded === undefined ? String(value) : encoded;
+}
+function typeName(value) {
+    if (value === null)
+        return "null";
+    if (Array.isArray(value))
+        return "array";
+    return typeof value;
+}
+export function mapping(value, parent) {
+    if (value === null || typeof value !== "object" || Array.isArray(value)) {
+        throw new Error(`${parent}: expected object, got ${typeName(value)}`);
+    }
+    return value;
+}
+export function string(wire, key, parent) {
+    const value = wire[key];
+    if (typeof value !== "string") {
+        throw new Error(`${parent}.${key}: expected string, got ${shown(value)}`);
+    }
+    return value;
+}
+export function optionalString(wire, key, parent) {
+    const value = wire[key];
+    if (value === null || value === undefined)
+        return null;
+    if (typeof value !== "string") {
+        throw new Error(`${parent}.${key}: expected string, got ${shown(value)}`);
+    }
+    return value;
+}
+export function integer(wire, key, parent) {
+    const value = wire[key];
+    if (typeof value !== "number" || !Number.isInteger(value)) {
+        throw new Error(`${parent}.${key}: expected integer, got ${shown(value)}`);
+    }
+    return value;
+}
+export function optionalInteger(wire, key, parent) {
+    const value = wire[key];
+    if (value === null || value === undefined)
+        return null;
+    if (typeof value !== "number" || !Number.isInteger(value)) {
+        throw new Error(`${parent}.${key}: expected integer, got ${shown(value)}`);
+    }
+    return value;
+}
+export function array(wire, key, parent) {
+    const value = wire[key];
+    if (!Array.isArray(value)) {
+        throw new Error(`${parent}.${key}: expected array, got ${shown(value)}`);
+    }
+    return value;
+}
+export function optionalArray(wire, key, parent) {
+    const value = wire[key];
+    if (value === null || value === undefined)
+        return null;
+    if (!Array.isArray(value)) {
+        throw new Error(`${parent}.${key}: expected array, got ${shown(value)}`);
+    }
+    return value;
+}
+export function stringArray(wire, key, parent) {
+    const value = array(wire, key, parent);
+    for (const item of value) {
+        if (typeof item !== "string") {
+            throw new Error(`${parent}.${key}: expected array of strings, got ${shown(item)}`);
+        }
+    }
+    return value;
+}
+export function optionalMapping(wire, key, parent) {
+    const value = wire[key];
+    if (value === null || value === undefined)
+        return null;
+    if (typeof value !== "object" || Array.isArray(value)) {
+        throw new Error(`${parent}.${key}: expected object, got ${shown(value)}`);
+    }
+    return value;
+}

package/runtime/extensions/switchboard-local/node_modules/@valni/switchboard/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "@valni/switchboard",
+  "version": "0.1.0",
+  "description": "TypeScript client for Switchboard.",
+  "private": true,
+  "type": "module",
+  "license": "UNLICENSED",
+  "engines": {
+    "node": ">=22"
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "prepare": "npm run build",
+    "test": "vitest run"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Valni-Labs/switchboard-ts.git"
+  },
+  "dependencies": {
+    "@valni/switchboard-native": "git+https://github.com/Valni-Labs/SwitchboardNative.git#1343e11248ce477220b839366a5fc586aef4ce09"
+  },
+  "devDependencies": {
+    "@types/node": "^22.15.0",
+    "typescript": "^5.8.0",
+    "vitest": "^3.1.0"
+  }
+}

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

@@ -0,0 +1,29 @@
+{
+  "name": "@valni/switchboard-native",
+  "version": "0.1.0",
+  "description": "The Switchboard native wire contract: TypeScript source of truth plus generated language bindings.",
+  "type": "module",
+  "main": "src/index.ts",
+  "types": "src/index.ts",
+  "exports": {
+    ".": "./src/index.ts"
+  },
+  "files": [
+    "src"
+  ],
+  "scripts": {
+    "test": "vitest run",
+    "codegen:swift": "node codegen/generate-swift.mjs",
+    "codegen:python": "node codegen/generate-python.mjs"
+  },
+  "devDependencies": {
+    "typescript": "^6.0.3",
+    "vitest": "^2.1.9"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Valni-Labs/SwitchboardNative.git"
+  },
+  "license": "UNLICENSED",
+  "private": true
+}

package/runtime/extensions/switchboard-local/node_modules/@valni/switchboard-native/src/anthropic.ts

@@ -0,0 +1,127 @@
+export interface AnthropicCacheControl {
+  type: 'ephemeral';
+  ttl?: string;
+}
+
+export interface AnthropicImageSource {
+  type: 'base64' | 'url';
+  media_type?: string;
+  data?: string;
+  url?: string;
+}
+
+export type AnthropicContentBlock =
+  | { type: 'text'; text: string; cache_control?: AnthropicCacheControl }
+  | { type: 'image'; source: AnthropicImageSource; cache_control?: AnthropicCacheControl }
+  | { type: 'tool_use'; id: string; name: string; input: unknown; cache_control?: AnthropicCacheControl }
+  | {
+      type: 'tool_result';
+      tool_use_id: string;
+      content: string | AnthropicContentBlock[];
+      is_error?: boolean;
+      cache_control?: AnthropicCacheControl;
+    }
+  | { type: 'thinking'; thinking: string; signature: string };
+
+export interface AnthropicMessage {
+  role: 'user' | 'assistant';
+  content: string | AnthropicContentBlock[];
+}
+
+export interface AnthropicSystemBlock {
+  type: 'text';
+  text: string;
+  cache_control?: AnthropicCacheControl;
+}
+
+export type AnthropicSystem = string | AnthropicSystemBlock[];
+
+export interface AnthropicTool {
+  name: string;
+  description?: string;
+  input_schema: Record<string, unknown>;
+  cache_control?: AnthropicCacheControl;
+}
+
+export type AnthropicToolChoice =
+  | { type: 'auto' }
+  | { type: 'any' }
+  | { type: 'none' }
+  | { type: 'tool'; name: string };
+
+export type AnthropicThinking =
+  | { type: 'adaptive'; display?: 'summarized' | 'omitted' }
+  | { type: 'enabled'; budget_tokens: number }
+  | { type: 'disabled' };
+
+export type AnthropicEffort = 'low' | 'medium' | 'high' | 'xhigh' | 'max';
+
+export interface AnthropicOutputFormat {
+  type: 'json_schema';
+  schema: Record<string, unknown>;
+}
+
+export interface AnthropicOutputConfig {
+  effort?: AnthropicEffort;
+  format?: AnthropicOutputFormat;
+}
+
+export interface AnthropicMetadata {
+  user_id?: string;
+}
+
+export interface AnthropicMessagesRequest {
+  model: string;
+  messages: AnthropicMessage[];
+  max_tokens: number;
+  system?: AnthropicSystem;
+  temperature?: number;
+  top_p?: number;
+  top_k?: number;
+  stop_sequences?: string[];
+  stream?: boolean;
+  tools?: AnthropicTool[];
+  tool_choice?: AnthropicToolChoice;
+  thinking?: AnthropicThinking;
+  output_config?: AnthropicOutputConfig;
+  metadata?: AnthropicMetadata;
+}
+
+export interface AnthropicUsage {
+  input_tokens: number;
+  output_tokens: number;
+  cache_creation_input_tokens?: number;
+  cache_read_input_tokens?: number;
+}
+
+export type AnthropicResponseContentBlock =
+  | { type: 'text'; text: string }
+  | { type: 'tool_use'; id: string; name: string; input: unknown }
+  | { type: 'thinking'; thinking: string; signature: string };
+
+export interface AnthropicMessageResponse {
+  id: string;
+  type: 'message';
+  role: 'assistant';
+  model: string;
+  content: AnthropicResponseContentBlock[];
+  stop_reason: 'end_turn' | 'max_tokens' | 'stop_sequence' | 'tool_use' | 'pause_turn' | 'refusal' | null;
+  stop_sequence: string | null;
+  usage: AnthropicUsage;
+}
+
+export type AnthropicBlockDelta =
+  | { type: 'text_delta'; text: string }
+  | { type: 'input_json_delta'; partial_json: string }
+  | { type: 'thinking_delta'; thinking: string }
+  | { type: 'signature_delta'; signature: string };
+
+export type AnthropicStreamEvent =
+  | { type: 'message_start'; message: { id: string; role: 'assistant'; model: string; usage: AnthropicUsage } }
+  | { type: 'content_block_start'; index: number; content_block: AnthropicResponseContentBlock }
+  | { type: 'content_block_delta'; index: number; delta: AnthropicBlockDelta }
+  | { type: 'content_block_stop'; index: number }
+  | { type: 'message_delta'; delta: { stop_reason?: string; stop_sequence?: string | null }; usage: { output_tokens: number } }
+  | { type: 'message_stop' }
+  | { type: 'ping' }
+  | { type: 'error'; error: { type: string; message: string } };

package/runtime/extensions/switchboard-local/node_modules/@valni/switchboard-native/src/google.ts

@@ -0,0 +1,111 @@
+export interface GoogleInlineData {
+  mimeType: string;
+  data: string;
+}
+
+export interface GoogleFileData {
+  mimeType?: string;
+  fileUri: string;
+}
+
+export type GooglePart =
+  | { text: string }
+  | { inlineData: GoogleInlineData }
+  | { fileData: GoogleFileData }
+  | { functionCall: { name: string; args: Record<string, unknown> } }
+  | { functionResponse: { name: string; response: Record<string, unknown> } };
+
+export interface GoogleContent {
+  role: 'user' | 'model';
+  parts: GooglePart[];
+}
+
+export interface GoogleSystemInstruction {
+  parts: GooglePart[];
+}
+
+export interface GoogleFunctionDeclaration {
+  name: string;
+  description?: string;
+  parameters?: Record<string, unknown>;
+}
+
+export interface GoogleTool {
+  functionDeclarations?: GoogleFunctionDeclaration[];
+}
+
+export type GoogleFunctionCallingMode = 'AUTO' | 'ANY' | 'NONE';
+
+export interface GoogleFunctionCallingConfig {
+  mode?: GoogleFunctionCallingMode;
+  allowedFunctionNames?: string[];
+}
+
+export interface GoogleToolConfig {
+  functionCallingConfig?: GoogleFunctionCallingConfig;
+}
+
+export interface GoogleThinkingConfig {
+  thinkingBudget?: number;
+  includeThoughts?: boolean;
+}
+
+export interface GoogleGenerationConfig {
+  temperature?: number;
+  topP?: number;
+  topK?: number;
+  maxOutputTokens?: number;
+  stopSequences?: string[];
+  candidateCount?: number;
+  responseMimeType?: string;
+  responseSchema?: Record<string, unknown>;
+  thinkingConfig?: GoogleThinkingConfig;
+}
+
+export interface GoogleSafetySetting {
+  category: string;
+  threshold: string;
+}
+
+export interface GoogleGenerateContentRequest {
+  model: string;
+  contents: GoogleContent[];
+  systemInstruction?: GoogleSystemInstruction;
+  tools?: GoogleTool[];
+  toolConfig?: GoogleToolConfig;
+  generationConfig?: GoogleGenerationConfig;
+  safetySettings?: GoogleSafetySetting[];
+  stream?: boolean;
+}
+
+export interface GoogleUsageMetadata {
+  promptTokenCount?: number;
+  candidatesTokenCount?: number;
+  thoughtsTokenCount?: number;
+  cachedContentTokenCount?: number;
+  totalTokenCount?: number;
+}
+
+export type GoogleFinishReason =
+  | 'STOP'
+  | 'MAX_TOKENS'
+  | 'SAFETY'
+  | 'RECITATION'
+  | 'BLOCKLIST'
+  | 'PROHIBITED_CONTENT'
+  | 'SPII'
+  | 'MALFORMED_FUNCTION_CALL'
+  | 'OTHER';
+
+export interface GoogleCandidate {
+  content?: GoogleContent;
+  finishReason?: GoogleFinishReason;
+  index?: number;
+}
+
+export interface GoogleGenerateContentResponse {
+  candidates?: GoogleCandidate[];
+  usageMetadata?: GoogleUsageMetadata;
+  modelVersion?: string;
+  responseId?: string;
+}

package/runtime/extensions/switchboard-local/node_modules/@valni/switchboard-native/src/index.ts

@@ -0,0 +1,8 @@
+export * from './routing.js';
+export * from './anthropic.js';
+export * from './google.js';
+export * from './openaiGeneric.js';
+export * from './openaiPro.js';
+export * from './profile.js';
+export * from './modelRecord.js';
+export * from './validateConfig.js';

package/runtime/extensions/switchboard-local/node_modules/@valni/switchboard-native/src/modelRecord.test.ts

@@ -0,0 +1,25 @@
+import { describe, it, expect } from 'vitest';
+import type { AnthropicProfile, GoogleProfile, OpenAIGenericProfile, OpenAIProProfile } from './profile.js';
+import { profileByKind } from './modelRecord.js';
+
+const anthropicProfile: AnthropicProfile = { kind: 'anthropic', model: 'claude-test' };
+const chatProfile: OpenAIGenericProfile = { kind: 'openai_generic', model: 'chat-test' };
+const proProfile: OpenAIProProfile = { kind: 'openai_pro', model: 'pro-test' };
+const googleProfile: GoogleProfile = { kind: 'google', model: 'gemini-test' };
+
+describe('profileByKind', () => {
+  it('tags every kind with exactly its own discriminator', () => {
+    expect(profileByKind(anthropicProfile)).toEqual({ anthropic: anthropicProfile });
+    expect(profileByKind(chatProfile)).toEqual({ openai_generic: chatProfile });
+    expect(profileByKind(proProfile)).toEqual({ openai_pro: proProfile });
+    expect(profileByKind(googleProfile)).toEqual({ google: googleProfile });
+  });
+
+  it('produces a single-key wrapper whose tag matches the profile kind', () => {
+    for (const profile of [anthropicProfile, chatProfile, proProfile, googleProfile]) {
+      const tagged = profileByKind(profile);
+      const tags = Object.keys(tagged);
+      expect(tags).toEqual([profile.kind]);
+    }
+  });
+});

package/runtime/extensions/switchboard-local/node_modules/@valni/switchboard-native/src/modelRecord.ts

@@ -0,0 +1,57 @@
+import type {
+  AnthropicProfile,
+  GoogleProfile,
+  ModelProfile,
+  OpenAIGenericProfile,
+  OpenAIProProfile,
+} from './profile.js';
+
+export type ProfileByKind =
+  | { anthropic: AnthropicProfile }
+  | { openai_generic: OpenAIGenericProfile }
+  | { openai_pro: OpenAIProProfile }
+  | { google: GoogleProfile };
+
+export type ModelRecordStatus =
+  | { kind: 'live' }
+  | { kind: 'deprecated'; at: number }
+  | { kind: 'retired'; at: number }
+  | { kind: 'gone'; at: number };
+
+export interface ModelRecordPrice {
+  input_micro_cents_per_mtok: number;
+  output_micro_cents_per_mtok: number;
+  cached_input_micro_cents_per_mtok: number | null;
+  effective_at: number;
+}
+
+export interface ModelRecord {
+  id: string;
+  kind: ProfileByKind;
+}
+
+export type ModelPricesById = Record<string, ModelRecordPrice>;
+export type ModelStatusById = Record<string, ModelRecordStatus>;
+
+export interface ProviderRecordSummary {
+  id: string;
+  display_name: string;
+  model_ids: string[];
+}
+
+export function profileByKind(profile: ModelProfile): ProfileByKind {
+  switch (profile.kind) {
+    case 'anthropic':
+      return { anthropic: profile };
+    case 'openai_generic':
+      return { openai_generic: profile };
+    case 'openai_pro':
+      return { openai_pro: profile };
+    case 'google':
+      return { google: profile };
+    default: {
+      const exhaustive: never = profile;
+      return exhaustive;
+    }
+  }
+}

package/runtime/extensions/switchboard-local/node_modules/@valni/switchboard-native/src/openaiGeneric.ts

@@ -0,0 +1,103 @@
+export type OpenAIContentPart =
+  | { type: 'text'; text: string }
+  | { type: 'image_url'; image_url: { url: string; detail?: 'auto' | 'low' | 'high' } };
+
+export interface OpenAIToolCall {
+  id: string;
+  type: 'function';
+  function: { name: string; arguments: string };
+}
+
+export interface OpenAIChatMessage {
+  role: 'system' | 'developer' | 'user' | 'assistant' | 'tool';
+  content: string | OpenAIContentPart[] | null;
+  name?: string;
+  tool_calls?: OpenAIToolCall[];
+  tool_call_id?: string;
+}
+
+export interface OpenAITool {
+  type: 'function';
+  function: {
+    name: string;
+    description?: string;
+    parameters?: Record<string, unknown>;
+    strict?: boolean;
+  };
+}
+
+export type OpenAIToolChoice =
+  | 'auto'
+  | 'none'
+  | 'required'
+  | { type: 'function'; function: { name: string } };
+
+export interface OpenAIChatRequest {
+  model: string;
+  messages: OpenAIChatMessage[];
+  max_completion_tokens?: number;
+  max_tokens?: number;
+  temperature?: number;
+  top_p?: number;
+  frequency_penalty?: number;
+  presence_penalty?: number;
+  seed?: number;
+  n?: number;
+  logit_bias?: Record<string, number>;
+  stop?: string | string[];
+  stream?: boolean;
+  stream_options?: { include_usage?: boolean };
+  tools?: OpenAITool[];
+  tool_choice?: OpenAIToolChoice;
+  parallel_tool_calls?: boolean;
+  response_format?: Record<string, unknown>;
+  reasoning_effort?: 'none' | 'minimal' | 'low' | 'medium' | 'high' | 'xhigh' | 'max';
+  verbosity?: 'low' | 'medium' | 'high';
+  prompt_cache_key?: string;
+  store?: boolean;
+  metadata?: Record<string, string>;
+  user?: string;
+}
+
+export interface OpenAIUsage {
+  prompt_tokens: number;
+  completion_tokens: number;
+  total_tokens: number;
+  prompt_tokens_details?: { cached_tokens?: number; cache_write_tokens?: number; audio_tokens?: number };
+  completion_tokens_details?: {
+    reasoning_tokens?: number;
+    accepted_prediction_tokens?: number;
+    rejected_prediction_tokens?: number;
+    audio_tokens?: number;
+  };
+}
+
+export interface OpenAIChatResponseMessage {
+  role: 'assistant';
+  content: string | null;
+  tool_calls?: OpenAIToolCall[];
+}
+
+export type OpenAIFinishReason = 'stop' | 'length' | 'tool_calls' | 'content_filter' | null;
+
+export interface OpenAIChatResponse {
+  id: string;
+  object: 'chat.completion';
+  model: string;
+  choices: Array<{ index: number; message: OpenAIChatResponseMessage; finish_reason: OpenAIFinishReason }>;
+  usage: OpenAIUsage;
+}
+
+export interface OpenAIChatDelta {
+  role?: 'assistant';
+  content?: string | null;
+  tool_calls?: Array<{ index: number; id?: string; type?: 'function'; function?: { name?: string; arguments?: string } }>;
+}
+
+export interface OpenAIChatChunk {
+  id: string;
+  object: 'chat.completion.chunk';
+  model: string;
+  choices: Array<{ index: number; delta: OpenAIChatDelta; finish_reason: OpenAIFinishReason }>;
+  usage?: OpenAIUsage | null;
+}

package/runtime/extensions/switchboard-local/node_modules/@valni/switchboard-native/src/openaiPro.ts

@@ -0,0 +1,89 @@
+export type OpenAIResponsesContentPart =
+  | { type: 'input_text'; text: string }
+  | { type: 'input_image'; image_url: string; detail?: 'auto' | 'low' | 'high' }
+  | { type: 'output_text'; text: string };
+
+export type OpenAIResponsesInputItem =
+  | { type: 'message'; role: 'system' | 'developer' | 'user' | 'assistant'; content: string | OpenAIResponsesContentPart[] }
+  | { type: 'function_call'; call_id: string; name: string; arguments: string }
+  | { type: 'function_call_output'; call_id: string; output: string }
+  | { type: 'reasoning'; id: string; summary: unknown[] };
+
+export interface OpenAIResponsesTool {
+  type: 'function';
+  name: string;
+  description?: string;
+  parameters?: Record<string, unknown>;
+  strict?: boolean;
+}
+
+export type OpenAIResponsesToolChoice =
+  | 'auto'
+  | 'none'
+  | 'required'
+  | { type: 'function'; name: string };
+
+export interface OpenAIResponsesRequest {
+  model: string;
+  input: string | OpenAIResponsesInputItem[];
+  instructions?: string;
+  max_output_tokens?: number;
+  max_tool_calls?: number;
+  temperature?: number;
+  top_p?: number;
+  stream?: boolean;
+  tools?: OpenAIResponsesTool[];
+  tool_choice?: OpenAIResponsesToolChoice;
+  parallel_tool_calls?: boolean;
+  reasoning?: { effort?: 'none' | 'minimal' | 'low' | 'medium' | 'high' | 'xhigh' | 'max'; summary?: 'auto' | 'concise' | 'detailed' };
+  text?: { format?: Record<string, unknown>; verbosity?: 'low' | 'medium' | 'high' };
+  include?: string[];
+  store?: boolean;
+  previous_response_id?: string;
+  prompt_cache_key?: string;
+  metadata?: Record<string, string>;
+}
+
+export interface OpenAIResponsesUsage {
+  input_tokens: number;
+  output_tokens: number;
+  total_tokens: number;
+  input_tokens_details?: { cached_tokens?: number; cache_write_tokens?: number };
+  output_tokens_details?: { reasoning_tokens?: number };
+}
+
+export type OpenAIResponsesOutputItem =
+  | { type: 'message'; id: string; role: 'assistant'; content: Array<{ type: 'output_text'; text: string }> }
+  | { type: 'function_call'; id: string; call_id: string; name: string; arguments: string }
+  | { type: 'reasoning'; id: string; summary: unknown[] };
+
+export interface OpenAIResponsesResponse {
+  id: string;
+  object: 'response';
+  model: string;
+  status: 'completed' | 'incomplete' | 'failed' | 'in_progress';
+  output: OpenAIResponsesOutputItem[];
+  usage: OpenAIResponsesUsage;
+}
+
+export type OpenAIResponsesStreamContentPart =
+  | { type: 'output_text'; text: string }
+  | { type: 'refusal'; refusal: string }
+  | { type: 'reasoning_text'; text: string };
+
+export type OpenAIResponsesStreamEvent =
+  | { type: 'response.created'; response: { id: string } }
+  | { type: 'response.in_progress'; response: { id: string } }
+  | { type: 'response.output_item.added'; output_index: number; item: OpenAIResponsesOutputItem }
+  | { type: 'response.content_part.added'; item_id: string; output_index: number; content_index: number; part: OpenAIResponsesStreamContentPart }
+  | { type: 'response.output_text.delta'; delta: string }
+  | { type: 'response.output_text.done'; item_id: string; output_index: number; content_index: number; text: string }
+  | { type: 'response.content_part.done'; item_id: string; output_index: number; content_index: number; part: OpenAIResponsesStreamContentPart }
+  | { type: 'response.function_call_arguments.delta'; item_id: string; output_index: number; delta: string }
+  | { type: 'response.function_call_arguments.done'; item_id: string; output_index: number; name: string; arguments: string }
+  | { type: 'response.reasoning_summary_text.delta'; item_id: string; output_index: number; summary_index: number; delta: string }
+  | { type: 'response.output_item.done'; item: OpenAIResponsesOutputItem }
+  | { type: 'response.completed'; response: { status: string; usage: OpenAIResponsesUsage } }
+  | { type: 'response.incomplete'; response: { status: string; usage?: OpenAIResponsesUsage } }
+  | { type: 'response.failed'; response: { error?: { message: string } } }
+  | { type: 'error'; message: string };