@absolutejs/voice 0.0.22-beta.5 → 0.0.22-beta.6

package/dist/index.d.ts

@@ -3,7 +3,7 @@ export { createVoiceAssistant, createVoiceExperiment, summarizeVoiceAssistantRun
 export { createVoiceAgent, createVoiceAgentSquad, createVoiceAgentTool } from './agent';
 export { createStoredVoiceCallReviewArtifact, createStoredVoiceExternalObjectMap, createStoredVoiceIntegrationEvent, createStoredVoiceOpsTask, createVoiceFileExternalObjectMapStore, createVoiceFileAssistantMemoryStore, createVoiceFileIntegrationEventStore, createVoiceFileReviewStore, createVoiceFileRuntimeStorage, createVoiceFileSessionStore, createVoiceFileTaskStore, createVoiceFileTraceSinkDeliveryStore, createVoiceFileTraceEventStore } from './fileStore';
 export { createVoiceAssistantMemoryHandle, createVoiceAssistantMemoryRecord, createVoiceMemoryAssistantMemoryStore, resolveVoiceAssistantMemoryNamespace } from './assistantMemory';
-export { createJSONVoiceAssistantModel, createOpenAIVoiceAssistantModel } from './modelAdapters';
+export { createAnthropicVoiceAssistantModel, createGeminiVoiceAssistantModel, createJSONVoiceAssistantModel, createOpenAIVoiceAssistantModel } from './modelAdapters';
 export { buildVoiceTraceReplay, createVoiceMemoryTraceSinkDeliveryStore, createVoiceTraceHTTPSink, createVoiceMemoryTraceEventStore, createVoiceTraceSinkDeliveryId, createVoiceTraceSinkDeliveryRecord, createVoiceTraceSinkStore, createVoiceTraceEvent, createVoiceTraceEventId, deliverVoiceTraceEventsToSinks, evaluateVoiceTrace, exportVoiceTrace, filterVoiceTraceEvents, pruneVoiceTraceEvents, redactVoiceTraceEvent, redactVoiceTraceEvents, redactVoiceTraceText, renderVoiceTraceHTML, renderVoiceTraceMarkdown, resolveVoiceTraceRedactionOptions, selectVoiceTraceEventsForPrune, summarizeVoiceTrace } from './trace';
 export { createVoiceSQLiteExternalObjectMapStore, createVoiceSQLiteIntegrationEventStore, createVoiceSQLiteReviewStore, createVoiceSQLiteRuntimeStorage, createVoiceSQLiteSessionStore, createVoiceSQLiteTaskStore, createVoiceSQLiteTraceSinkDeliveryStore, createVoiceSQLiteTraceEventStore } from './sqliteStore';
 export { createVoicePostgresExternalObjectMapStore, createVoicePostgresIntegrationEventStore, createVoicePostgresReviewStore, createVoicePostgresRuntimeStorage, createVoicePostgresSessionStore, createVoicePostgresTaskStore, createVoicePostgresTraceSinkDeliveryStore, createVoicePostgresTraceEventStore } from './postgresStore';
@@ -26,7 +26,7 @@ export { resolveTurnDetectionConfig, TURN_PROFILE_DEFAULTS } from './turnProfile
 export { createVoiceCallReviewFromLiveTelephonyReport, createVoiceCallReviewRecorder, renderVoiceCallReviewHTML, renderVoiceCallReviewMarkdown } from './testing/review';
 export type { VoiceAssistant, VoiceAssistantArtifactPlan, VoiceAssistantExperiment, VoiceAssistantExperimentOptions, VoiceAssistantGuardrailInput, VoiceAssistantGuardrails, VoiceAssistantMemoryLifecycle, VoiceAssistantMemoryLifecycleInput, VoiceAssistantOptions, VoiceAssistantOutputGuardrailInput, VoiceAssistantPreset, VoiceAssistantRunsSummary, VoiceAssistantRunSummary, VoiceAssistantVariant } from './assistant';
 export type { VoiceAssistantMemoryBinding, VoiceAssistantMemoryHandle, VoiceAssistantMemoryOptions, VoiceAssistantMemoryRecord, VoiceAssistantMemoryStore } from './assistantMemory';
-export type { OpenAIVoiceAssistantModelOptions, VoiceJSONAssistantModelHandler, VoiceJSONAssistantModelOptions } from './modelAdapters';
+export type { AnthropicVoiceAssistantModelOptions, GeminiVoiceAssistantModelOptions, OpenAIVoiceAssistantModelOptions, VoiceJSONAssistantModelHandler, VoiceJSONAssistantModelOptions } from './modelAdapters';
 export type { VoiceAgent, VoiceAgentMessage, VoiceAgentMessageRole, VoiceAgentModel, VoiceAgentModelInput, VoiceAgentModelOutput, VoiceAgentOptions, VoiceAgentRunResult, VoiceAgentSquadOptions, VoiceAgentTool, VoiceAgentToolCall, VoiceAgentToolResult } from './agent';
 export type { VoiceOpsRuntime, VoiceOpsRuntimeConfig, VoiceOpsRuntimeSummary, VoiceOpsRuntimeSinkWorkerConfig, VoiceOpsRuntimeTaskWorkerConfig, VoiceOpsRuntimeTickResult, VoiceOpsRuntimeWebhookWorkerConfig } from './opsRuntime';
 export type { VoiceOpsPresetName, VoiceOpsPresetOverrides, VoiceResolvedOpsPreset } from './opsPresets';

package/dist/index.js

@@ -5150,6 +5150,17 @@ var createVoiceAgent = (options) => {
       if (output.assistantText?.trim()) {
         messages.push({
           content: output.assistantText,
+          metadata: output.toolCalls?.length ? {
+            toolCalls: output.toolCalls
+          } : undefined,
+          role: "assistant"
+        });
+      } else if (output.toolCalls?.length) {
+        messages.push({
+          content: "",
+          metadata: {
+            toolCalls: output.toolCalls
+          },
           role: "assistant"
         });
       }
@@ -7141,6 +7152,7 @@ var OUTPUT_SCHEMA = {
   },
   type: "object"
 };
+var ROUTE_RESULT_INSTRUCTION = "Return a JSON object with assistantText, complete, transfer, escalate, voicemail, noAnswer, and result when you are not calling tools.";
 var parseJSON = (value) => {
   try {
     const parsed = JSON.parse(value);
@@ -7151,6 +7163,18 @@ var parseJSON = (value) => {
     };
   }
 };
+var parseJSONValue = (value) => {
+  try {
+    return JSON.parse(value);
+  } catch {
+    return value;
+  }
+};
+var getMessageToolCalls = (message) => {
+  const toolCalls = message.metadata?.toolCalls;
+  return Array.isArray(toolCalls) ? toolCalls.filter((toolCall) => toolCall && typeof toolCall === "object" && typeof toolCall.name === "string") : [];
+};
+var createHTTPError = (provider, response) => new Error(`${provider} voice assistant model failed: HTTP ${response.status}`);
 var normalizeRouteOutput = (output) => {
   const result = {};
   if (typeof output.assistantText === "string") {
@@ -7217,6 +7241,124 @@ var messageToOpenAIInput = (message) => {
     role: message.role === "system" ? "developer" : message.role
   };
 };
+var messageToAnthropicMessage = (message) => {
+  if (message.role === "system") {
+    return;
+  }
+  if (message.role === "tool") {
+    if (!message.toolCallId) {
+      return {
+        content: `Tool result from ${message.name ?? "tool"}: ${message.content}`,
+        role: "user"
+      };
+    }
+    return {
+      content: [
+        {
+          content: message.content,
+          tool_use_id: message.toolCallId,
+          type: "tool_result"
+        }
+      ],
+      role: "user"
+    };
+  }
+  const toolCalls = getMessageToolCalls(message);
+  if (message.role === "assistant" && toolCalls.length) {
+    return {
+      content: [
+        ...message.content ? [
+          {
+            text: message.content,
+            type: "text"
+          }
+        ] : [],
+        ...toolCalls.map((toolCall) => ({
+          id: toolCall.id ?? crypto.randomUUID(),
+          input: toolCall.args,
+          name: toolCall.name,
+          type: "tool_use"
+        }))
+      ],
+      role: "assistant"
+    };
+  }
+  return {
+    content: message.content,
+    role: message.role
+  };
+};
+var toGeminiSchema = (schema) => {
+  const next = {};
+  for (const [key, value] of Object.entries(schema)) {
+    if (key === "additionalProperties") {
+      continue;
+    }
+    if (key === "type" && typeof value === "string") {
+      next[key] = value.toUpperCase();
+      continue;
+    }
+    if (Array.isArray(value)) {
+      next[key] = value.map((item) => item && typeof item === "object" ? toGeminiSchema(item) : item);
+      continue;
+    }
+    if (value && typeof value === "object") {
+      next[key] = toGeminiSchema(value);
+      continue;
+    }
+    next[key] = value;
+  }
+  return next;
+};
+var messageToGeminiContent = (message) => {
+  if (message.role === "system") {
+    return;
+  }
+  if (message.role === "tool") {
+    return {
+      parts: [
+        {
+          functionResponse: {
+            id: message.toolCallId,
+            name: message.name ?? "tool",
+            response: {
+              result: parseJSONValue(message.content)
+            }
+          }
+        }
+      ],
+      role: "user"
+    };
+  }
+  const toolCalls = getMessageToolCalls(message);
+  if (message.role === "assistant" && toolCalls.length) {
+    return {
+      parts: [
+        ...message.content ? [
+          {
+            text: message.content
+          }
+        ] : [],
+        ...toolCalls.map((toolCall) => ({
+          functionCall: {
+            args: toolCall.args,
+            id: toolCall.id,
+            name: toolCall.name
+          }
+        }))
+      ],
+      role: "model"
+    };
+  }
+  return {
+    parts: [
+      {
+        text: message.content
+      }
+    ],
+    role: message.role === "assistant" ? "model" : "user"
+  };
+};
 var extractText = (response) => {
   if (typeof response.output_text === "string") {
     return response.output_text;
@@ -7305,7 +7447,7 @@ var createOpenAIVoiceAssistantModel = (options) => {
         method: "POST"
       });
       if (!response.ok) {
-        throw new Error(`OpenAI voice assistant model failed: HTTP ${response.status}`);
+        throw createHTTPError("OpenAI", response);
       }
       const body = await response.json();
       if (body.usage && typeof body.usage === "object") {
@@ -7321,6 +7463,178 @@ var createOpenAIVoiceAssistantModel = (options) => {
     }
   };
 };
+var extractAnthropicText = (response) => {
+  const content = Array.isArray(response.content) ? response.content : [];
+  return content.map((item) => item && typeof item === "object" && item.type === "text" && typeof item.text === "string" ? item.text : "").filter(Boolean).join(`
+`);
+};
+var extractAnthropicToolCalls = (response) => {
+  const content = Array.isArray(response.content) ? response.content : [];
+  const toolCalls = [];
+  for (const item of content) {
+    if (!item || typeof item !== "object") {
+      continue;
+    }
+    const record = item;
+    if (record.type !== "tool_use" || typeof record.name !== "string") {
+      continue;
+    }
+    toolCalls.push({
+      args: record.input && typeof record.input === "object" ? record.input : {},
+      id: typeof record.id === "string" ? record.id : undefined,
+      name: record.name
+    });
+  }
+  return toolCalls;
+};
+var createAnthropicVoiceAssistantModel = (options) => {
+  const fetchImpl = options.fetch ?? globalThis.fetch;
+  const baseUrl = options.baseUrl ?? "https://api.anthropic.com/v1";
+  const model = options.model ?? "claude-sonnet-4-5";
+  return {
+    generate: async (input) => {
+      const response = await fetchImpl(`${baseUrl.replace(/\/$/, "")}/messages`, {
+        body: JSON.stringify({
+          max_tokens: options.maxOutputTokens ?? 1024,
+          messages: input.messages.map(messageToAnthropicMessage).filter(Boolean),
+          model,
+          system: [input.system, ROUTE_RESULT_INSTRUCTION].filter(Boolean).join(`
+
+`),
+          temperature: options.temperature,
+          tool_choice: input.tools.length ? { type: "auto" } : { type: "none" },
+          tools: input.tools.map((tool) => ({
+            description: tool.description,
+            input_schema: tool.parameters ?? {
+              additionalProperties: true,
+              type: "object"
+            },
+            name: tool.name
+          }))
+        }),
+        headers: {
+          "anthropic-version": options.version ?? "2023-06-01",
+          "content-type": "application/json",
+          "x-api-key": options.apiKey
+        },
+        method: "POST"
+      });
+      if (!response.ok) {
+        throw createHTTPError("Anthropic", response);
+      }
+      const body = await response.json();
+      if (body.usage && typeof body.usage === "object") {
+        await options.onUsage?.(body.usage);
+      }
+      const toolCalls = extractAnthropicToolCalls(body);
+      if (toolCalls.length) {
+        return {
+          assistantText: extractAnthropicText(body) || undefined,
+          toolCalls
+        };
+      }
+      return normalizeRouteOutput(parseJSON(extractAnthropicText(body)));
+    }
+  };
+};
+var extractGeminiCandidateParts = (response) => {
+  const candidates = Array.isArray(response.candidates) ? response.candidates : [];
+  const first = candidates[0];
+  if (!first || typeof first !== "object") {
+    return [];
+  }
+  const content = first.content;
+  if (!content || typeof content !== "object") {
+    return [];
+  }
+  const parts = content.parts;
+  return Array.isArray(parts) ? parts : [];
+};
+var extractGeminiText = (response) => extractGeminiCandidateParts(response).map((part) => part && typeof part === "object" && typeof part.text === "string" ? part.text : "").filter(Boolean).join(`
+`);
+var extractGeminiToolCalls = (response) => {
+  const toolCalls = [];
+  for (const part of extractGeminiCandidateParts(response)) {
+    if (!part || typeof part !== "object") {
+      continue;
+    }
+    const functionCall = part.functionCall;
+    if (!functionCall || typeof functionCall !== "object") {
+      continue;
+    }
+    const record = functionCall;
+    if (typeof record.name !== "string") {
+      continue;
+    }
+    toolCalls.push({
+      args: record.args && typeof record.args === "object" ? record.args : {},
+      id: typeof record.id === "string" ? record.id : undefined,
+      name: record.name
+    });
+  }
+  return toolCalls;
+};
+var createGeminiVoiceAssistantModel = (options) => {
+  const fetchImpl = options.fetch ?? globalThis.fetch;
+  const baseUrl = options.baseUrl ?? "https://generativelanguage.googleapis.com/v1beta";
+  const model = options.model ?? "gemini-2.5-flash";
+  return {
+    generate: async (input) => {
+      const endpoint = `${baseUrl.replace(/\/$/, "")}/models/${encodeURIComponent(model)}:generateContent?key=${encodeURIComponent(options.apiKey)}`;
+      const response = await fetchImpl(endpoint, {
+        body: JSON.stringify({
+          contents: input.messages.map(messageToGeminiContent).filter(Boolean),
+          generationConfig: {
+            maxOutputTokens: options.maxOutputTokens,
+            responseMimeType: "application/json",
+            responseSchema: toGeminiSchema(OUTPUT_SCHEMA),
+            temperature: options.temperature
+          },
+          systemInstruction: {
+            parts: [
+              {
+                text: [input.system, ROUTE_RESULT_INSTRUCTION].filter(Boolean).join(`
+
+`)
+              }
+            ]
+          },
+          tools: input.tools.length ? [
+            {
+              functionDeclarations: input.tools.map((tool) => ({
+                description: tool.description,
+                name: tool.name,
+                parameters: toGeminiSchema(tool.parameters ?? {
+                  additionalProperties: true,
+                  type: "object"
+                })
+              }))
+            }
+          ] : undefined
+        }),
+        headers: {
+          "content-type": "application/json"
+        },
+        method: "POST"
+      });
+      if (!response.ok) {
+        throw createHTTPError("Gemini", response);
+      }
+      const body = await response.json();
+      if (body.usageMetadata && typeof body.usageMetadata === "object") {
+        await options.onUsage?.(body.usageMetadata);
+      }
+      const toolCalls = extractGeminiToolCalls(body);
+      if (toolCalls.length) {
+        return {
+          assistantText: extractGeminiText(body) || undefined,
+          toolCalls
+        };
+      }
+      return normalizeRouteOutput(parseJSON(extractGeminiText(body)));
+    }
+  };
+};
 // src/sqliteStore.ts
 import { Database } from "bun:sqlite";
 var normalizeTableNameSegment = (value) => value.trim().replace(/[^a-zA-Z0-9_]+/g, "_").replace(/^_+|_+$/g, "") || "voice";
@@ -9909,8 +10223,10 @@ export {
   createOpenAIVoiceAssistantModel,
   createJSONVoiceAssistantModel,
   createId,
+  createGeminiVoiceAssistantModel,
   createDomainPhraseHints,
   createDomainLexicon,
+  createAnthropicVoiceAssistantModel,
   conditionAudioChunk,
   completeVoiceOpsTask,
   claimVoiceOpsTask,

package/dist/modelAdapters.d.ts

@@ -14,5 +14,26 @@ export type OpenAIVoiceAssistantModelOptions = {
     onUsage?: (usage: Record<string, unknown>) => Promise<void> | void;
     temperature?: number;
 };
+export type AnthropicVoiceAssistantModelOptions = {
+    apiKey: string;
+    baseUrl?: string;
+    fetch?: typeof fetch;
+    maxOutputTokens?: number;
+    model?: string;
+    onUsage?: (usage: Record<string, unknown>) => Promise<void> | void;
+    temperature?: number;
+    version?: string;
+};
+export type GeminiVoiceAssistantModelOptions = {
+    apiKey: string;
+    baseUrl?: string;
+    fetch?: typeof fetch;
+    maxOutputTokens?: number;
+    model?: string;
+    onUsage?: (usage: Record<string, unknown>) => Promise<void> | void;
+    temperature?: number;
+};
 export declare const createJSONVoiceAssistantModel: <TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown>(options: VoiceJSONAssistantModelOptions<TContext, TSession, TResult>) => VoiceAgentModel<TContext, TSession, TResult>;
 export declare const createOpenAIVoiceAssistantModel: <TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown>(options: OpenAIVoiceAssistantModelOptions) => VoiceAgentModel<TContext, TSession, TResult>;
+export declare const createAnthropicVoiceAssistantModel: <TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown>(options: AnthropicVoiceAssistantModelOptions) => VoiceAgentModel<TContext, TSession, TResult>;
+export declare const createGeminiVoiceAssistantModel: <TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown>(options: GeminiVoiceAssistantModelOptions) => VoiceAgentModel<TContext, TSession, TResult>;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@absolutejs/voice",
-	"version": "0.0.22-beta.5",
+	"version": "0.0.22-beta.6",
 	"description": "Voice primitives and Elysia plugin for AbsoluteJS",
 	"repository": {
 		"type": "git",