@alexkroman1/aai 1.8.1 → 1.8.2

package/.turbo/turbo-build.log

@@ -1,5 +1,5 @@
 
-> @alexkroman1/aai@1.8.1 build /home/runner/work/agent/agent/packages/aai
+> @alexkroman1/aai@1.8.2 build /home/runner/work/agent/agent/packages/aai
 > tsdown && tsc -p tsconfig.build.json
 
 ℹ tsdown v0.21.7 powered by rolldown v1.0.0-rc.12
@@ -8,7 +8,7 @@
 ℹ target: node22
 ℹ tsconfig: tsconfig.json
 ℹ Build start
-ℹ dist/host/runtime-barrel.js          109.52 kB │ gzip: 30.12 kB
+ℹ dist/host/runtime-barrel.js          110.46 kB │ gzip: 30.38 kB
 ℹ dist/sdk/protocol.js                   5.70 kB │ gzip:  1.92 kB
 ℹ dist/index.js                          2.88 kB │ gzip:  1.24 kB
 ℹ dist/sdk/manifest-barrel.js            0.36 kB │ gzip:  0.20 kB
@@ -18,7 +18,7 @@
 ℹ dist/sdk/providers/tts-barrel.js       0.25 kB │ gzip:  0.16 kB
 ℹ dist/sdk/providers/vector-barrel.js    0.22 kB │ gzip:  0.15 kB
 ℹ dist/sdk/providers/s2s-barrel.js       0.15 kB │ gzip:  0.12 kB
-ℹ dist/_internal-types-CfOAbK6V.js       5.45 kB │ gzip:  1.87 kB
+ℹ dist/_internal-types-8v1qAa4A.js       6.04 kB │ gzip:  2.15 kB
 ℹ dist/types-DOWVZhb9.js                 5.39 kB │ gzip:  2.27 kB
 ℹ dist/soniox-BQdL0mB5.js                2.03 kB │ gzip:  0.54 kB
 ℹ dist/constants-y68COEGj.js             1.70 kB │ gzip:  0.76 kB
@@ -28,5 +28,5 @@
 ℹ dist/s3-BtCMvCod.js                    0.76 kB │ gzip:  0.29 kB
 ℹ dist/pinecone-CeJ69aRs.js              0.48 kB │ gzip:  0.24 kB
 ℹ dist/openai-realtime-cjPAHMMx.js       0.27 kB │ gzip:  0.19 kB
-ℹ 20 files, total: 139.45 kB
-✔ Build complete in 62ms
+ℹ 20 files, total: 140.98 kB
+✔ Build complete in 42ms

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # @alexkroman1/aai
 
+## 1.8.2
+
+### Patch Changes
+
+- bb06b4e: Fix S2S tool calls arriving with empty args. Strip the $schema keyword from Zod-generated JSON Schema for tool parameters — some S2S providers ship the dialect URI to the underlying model and emit tool calls with empty args even when required params are listed. Also accept both 'arguments' and 'args' field names on the wire. Pipeline transport now surfaces tool-result stream parts as tool_call_done so the client UI flips pending → done.
+
 ## 1.8.1
 
 ### Patch Changes

package/dist/{_internal-types-CfOAbK6V.js → _internal-types-8v1qAa4A.js}

@@ -128,13 +128,25 @@ const ToolSchemaSchema = z.object({
 	parameters: z.record(z.string(), z.unknown())
 });
 const EMPTY_PARAMS = z.object({});
+/**
+* Convert a Zod schema to the JSON Schema shape that S2S providers expect.
+* Strips the `$schema` keyword: `z.toJSONSchema` (Zod v4) tags output with
+* the JSON Schema 2020-12 dialect URI, and some Realtime/S2S providers
+* either reject the field outright or ship it through to the underlying
+* model with a malformed function spec — observed empirically as tool
+* calls that arrive with `args: {}` even when required params are listed.
+*/
+function toToolJsonSchema(zodSchema) {
+	const { $schema: _omit, ...rest } = z.toJSONSchema(zodSchema);
+	return rest;
+}
 function agentToolsToSchemas(tools) {
 	return Object.entries(tools).map(([name, def]) => ({
 		type: "function",
 		name,
 		description: def.description,
-		parameters: z.toJSONSchema(def.parameters ?? EMPTY_PARAMS)
+		parameters: toToolJsonSchema(def.parameters ?? EMPTY_PARAMS)
 	}));
 }
 //#endregion
-export { toAgentConfig as a, makeSttError as c, agentToolsToSchemas as i, makeTtsError as l, EMPTY_PARAMS as n, ProviderDescriptorSchema as o, ToolSchemaSchema as r, assertProviderTriple as s, AgentConfigSchema as t };
+export { toAgentConfig as a, assertProviderTriple as c, agentToolsToSchemas as i, makeSttError as l, EMPTY_PARAMS as n, toToolJsonSchema as o, ToolSchemaSchema as r, ProviderDescriptorSchema as s, AgentConfigSchema as t, makeTtsError as u };

package/dist/host/runtime-barrel.js

@@ -1,8 +1,8 @@
 import { r as DEFAULT_SYSTEM_PROMPT } from "../types-DOWVZhb9.js";
-import { _ as TOOL_EXECUTION_TIMEOUT_MS, a as DEFAULT_SHUTDOWN_TIMEOUT_MS, c as FETCH_TIMEOUT_MS, d as MAX_PAGE_CHARS, g as RUN_CODE_TIMEOUT_MS, h as PIPELINE_FLUSH_TIMEOUT_MS, l as MAX_HTML_BYTES, m as MAX_WS_PAYLOAD_BYTES, o as DEFAULT_STT_SAMPLE_RATE, p as MAX_VALUE_SIZE, s as DEFAULT_TTS_SAMPLE_RATE, t as AGENT_CSP } from "../constants-y68COEGj.js";
+import { _ as TOOL_EXECUTION_TIMEOUT_MS, a as DEFAULT_SHUTDOWN_TIMEOUT_MS, c as FETCH_TIMEOUT_MS, d as MAX_PAGE_CHARS, f as MAX_TOOL_RESULT_CHARS, g as RUN_CODE_TIMEOUT_MS, h as PIPELINE_FLUSH_TIMEOUT_MS, l as MAX_HTML_BYTES, m as MAX_WS_PAYLOAD_BYTES, o as DEFAULT_STT_SAMPLE_RATE, p as MAX_VALUE_SIZE, s as DEFAULT_TTS_SAMPLE_RATE, t as AGENT_CSP } from "../constants-y68COEGj.js";
 import { i as toolError, n as errorDetail, r as errorMessage, t as parseWsUpgradeParams } from "../ws-upgrade-CG8-by1n.js";
 import { ClientMessageSchema, VectorRequestSchema, buildReadyConfig, lenientParse } from "../sdk/protocol.js";
-import { a as toAgentConfig, c as makeSttError, i as agentToolsToSchemas, l as makeTtsError, n as EMPTY_PARAMS, s as assertProviderTriple } from "../_internal-types-CfOAbK6V.js";
+import { a as toAgentConfig, c as assertProviderTriple, i as agentToolsToSchemas, l as makeSttError, n as EMPTY_PARAMS, o as toToolJsonSchema, u as makeTtsError } from "../_internal-types-8v1qAa4A.js";
 import { a as MISTRAL_KIND, d as ANTHROPIC_KIND, l as GOOGLE_KIND, r as OPENAI_KIND, s as GROQ_KIND } from "../xai-BDI61Y2M.js";
 import { a as DEEPGRAM_KIND, r as ELEVENLABS_KIND, s as ASSEMBLYAI_KIND, t as SONIOX_KIND } from "../soniox-BQdL0mB5.js";
 import { a as CARTESIA_KIND, n as RIME_KIND } from "../rime-58p9mDR8.js";
@@ -311,7 +311,7 @@ function resolveAllBuiltins(names, opts) {
 			type: "function",
 			name: toolName,
 			description: def.description,
-			parameters: z.toJSONSchema(def.parameters ?? EMPTY_PARAMS)
+			parameters: toToolJsonSchema(def.parameters ?? EMPTY_PARAMS)
 		});
 		if (def.guidance) guidance.push(def.guidance);
 	}
@@ -2141,6 +2141,14 @@ function createPipelineTransport(opts) {
 			onDelta(out);
 			ttsSession?.sendText(out);
 		}
+		function emitToolResult(part) {
+			const callId = part.toolCallId ?? "";
+			if (!callId) return;
+			const raw = part.output ?? part.result ?? "";
+			const str = typeof raw === "string" ? raw : JSON.stringify(raw);
+			const truncated = str.length > 4e3 ? str.slice(0, MAX_TOOL_RESULT_CHARS) : str;
+			callbacks.onToolCallDone?.(callId, truncated);
+		}
 		return function handlePart(part) {
 			switch (part.type) {
 				case "text-delta":
@@ -2154,6 +2162,9 @@ function createPipelineTransport(opts) {
 					callbacks.onToolCall(part.toolCallId ?? "", part.toolName ?? "", input);
 					return;
 				}
+				case "tool-result":
+					emitToolResult(part);
+					return;
 				case "error": {
 					const msg = errorMessage(part.error);
 					log.error("LLM stream error", {
@@ -2396,8 +2407,14 @@ const S2sMessageSchema = z.discriminatedUnion("type", [
 		type: z.literal("tool.call"),
 		call_id: z.string(),
 		name: z.string(),
-		args: z.record(z.string(), z.unknown()).optional().default({})
-	}),
+		arguments: z.record(z.string(), z.unknown()).optional(),
+		args: z.record(z.string(), z.unknown()).optional()
+	}).transform((m) => ({
+		type: m.type,
+		call_id: m.call_id,
+		name: m.name,
+		args: m.arguments ?? m.args ?? {}
+	})),
 	z.object({
 		type: z.literal("reply.done"),
 		status: z.string().optional()
@@ -2545,6 +2562,20 @@ function connectS2s(opts) {
 			if (type === "reply.audio" || type === "input.audio" || type === "reply.done" || type === "session.error") return;
 			log.info(`S2S << ${type}`);
 		}
+		function handleObject(obj, raw) {
+			logIncoming(obj.type);
+			if (obj.type === "tool.call") log.info("S2S << tool.call payload", { payload: JSON.stringify(obj) });
+			if (obj.type === "reply.audio" && typeof obj.data === "string") {
+				callbacks.onAudio(base64ToUint8(obj.data));
+				return;
+			}
+			const parsed = parseS2sMessage(obj);
+			if (!parsed) {
+				log.warn(`S2S << unrecognised message type: ${obj.type ?? JSON.stringify(raw).slice(0, 200)}`);
+				return;
+			}
+			dispatchS2sMessage(callbacks, parsed, dispatchState, dispatchCtx);
+		}
 		ws.addEventListener("message", (ev) => {
 			let raw;
 			try {
@@ -2557,18 +2588,7 @@ function connectS2s(opts) {
 				log.warn("S2S << non-object JSON message", { type: typeof raw });
 				return;
 			}
-			const obj = raw;
-			logIncoming(obj.type);
-			if (obj.type === "reply.audio" && typeof obj.data === "string") {
-				callbacks.onAudio(base64ToUint8(obj.data));
-				return;
-			}
-			const parsed = parseS2sMessage(obj);
-			if (!parsed) {
-				log.warn(`S2S << unrecognised message type: ${obj.type ?? JSON.stringify(raw).slice(0, 200)}`);
-				return;
-			}
-			dispatchS2sMessage(callbacks, parsed, dispatchState, dispatchCtx);
+			handleObject(raw, raw);
 		});
 		ws.addEventListener("close", (ev) => {
 			const code = ev.code ?? 0;
@@ -3200,6 +3220,11 @@ function createRuntime(opts) {
 					toolName: name,
 					args
 				}) : (id, name, args) => bindCore().onToolCall(id, name, args),
+				...isPipeline ? { onToolCallDone: (id, result) => sessionOpts.client.event({
+					type: "tool_call_done",
+					toolCallId: id,
+					result
+				}) } : {},
 				onError: (code, message) => bindCore().onError(code, message),
 				onSpeechStarted: () => bindCore().onSpeechStarted(),
 				onSpeechStopped: () => bindCore().onSpeechStopped()

package/dist/host/transports/types.d.ts

@@ -13,6 +13,13 @@ export type TransportCallbacks = {
     onUserTranscript(text: string): void;
     onAgentTranscript(text: string, interrupted: boolean): void;
     onToolCall(callId: string, name: string, args: Record<string, unknown>): void;
+    /**
+     * Tool execution finished. Pipeline mode invokes this from the
+     * `tool-result` stream part so the client UI can mark the call done.
+     * S2S transports leave this unset — SessionCore.onToolCall emits the
+     * `tool_call_done` event itself after dispatching the tool.
+     */
+    onToolCallDone?(callId: string, result: string): void;
     onError(code: SessionErrorCode, message: string): void;
     onSpeechStarted(): void;
     onSpeechStopped(): void;

package/dist/sdk/_internal-types.d.ts

@@ -85,4 +85,13 @@ export type ToolSchema = {
     parameters: JSONSchema7;
 };
 export declare const EMPTY_PARAMS: z.ZodObject<{}, z.core.$strip>;
+/**
+ * Convert a Zod schema to the JSON Schema shape that S2S providers expect.
+ * Strips the `$schema` keyword: `z.toJSONSchema` (Zod v4) tags output with
+ * the JSON Schema 2020-12 dialect URI, and some Realtime/S2S providers
+ * either reject the field outright or ship it through to the underlying
+ * model with a malformed function spec — observed empirically as tool
+ * calls that arrive with `args: {}` even when required params are listed.
+ */
+export declare function toToolJsonSchema(zodSchema: z.ZodTypeAny): JSONSchema7;
 export declare function agentToolsToSchemas(tools: Readonly<Record<string, ToolDef>>): ToolSchema[];

package/dist/sdk/manifest-barrel.js

@@ -1,2 +1,2 @@
-import { a as toAgentConfig, i as agentToolsToSchemas, n as EMPTY_PARAMS, o as ProviderDescriptorSchema, r as ToolSchemaSchema, s as assertProviderTriple, t as AgentConfigSchema } from "../_internal-types-CfOAbK6V.js";
+import { a as toAgentConfig, c as assertProviderTriple, i as agentToolsToSchemas, n as EMPTY_PARAMS, r as ToolSchemaSchema, s as ProviderDescriptorSchema, t as AgentConfigSchema } from "../_internal-types-8v1qAa4A.js";
 export { AgentConfigSchema, EMPTY_PARAMS, ProviderDescriptorSchema, ToolSchemaSchema, agentToolsToSchemas, assertProviderTriple, toAgentConfig };

package/host/builtin-tools.ts

@@ -9,7 +9,7 @@
 
 import { convert } from "html-to-text";
 import { z } from "zod";
-import { EMPTY_PARAMS, type ToolSchema } from "../sdk/_internal-types.ts";
+import { EMPTY_PARAMS, type ToolSchema, toToolJsonSchema } from "../sdk/_internal-types.ts";
 import { FETCH_TIMEOUT_MS, MAX_HTML_BYTES, MAX_PAGE_CHARS } from "../sdk/constants.ts";
 import type { ToolDef } from "../sdk/types.ts";
 import { createRunCode } from "./_run-code.ts";
@@ -242,7 +242,7 @@ export function resolveAllBuiltins(
         type: "function",
         name: toolName,
         description: def.description,
-        parameters: z.toJSONSchema(def.parameters ?? EMPTY_PARAMS) as ToolSchema["parameters"],
+        parameters: toToolJsonSchema(def.parameters ?? EMPTY_PARAMS) as ToolSchema["parameters"],
       });
       if (def.guidance) guidance.push(def.guidance);
     }

package/host/runtime.ts

@@ -513,6 +513,15 @@ export function createRuntime(opts: RuntimeOptions): Runtime {
         ? (id, name, args) =>
             sessionOpts.client.event({ type: "tool_call", toolCallId: id, toolName: name, args })
         : (id, name, args) => bindCore().onToolCall(id, name, args),
+      // Pipeline: emit `tool_call_done` when streamText surfaces the
+      // `tool-result` part so the UI can flip status from pending → done.
+      // S2S transports never set this; SessionCore.onToolCall emits done itself.
+      ...(isPipeline
+        ? {
+            onToolCallDone: (id: string, result: string) =>
+              sessionOpts.client.event({ type: "tool_call_done", toolCallId: id, result }),
+          }
+        : {}),
       onError: (code, message) => bindCore().onError(code, message),
       onSpeechStarted: () => bindCore().onSpeechStarted(),
       onSpeechStopped: () => bindCore().onSpeechStopped(),

package/host/s2s.ts

@@ -55,12 +55,23 @@ const S2sMessageSchema = z.discriminatedUnion("type", [
     item_id: z.string().optional().default(""),
     interrupted: z.boolean().optional().default(false),
   }),
-  z.object({
-    type: z.literal("tool.call"),
-    call_id: z.string(),
-    name: z.string(),
-    args: z.record(z.string(), z.unknown()).optional().default({}),
-  }),
+  // AssemblyAI's S2S protocol delivers tool args under `arguments`; older
+  // implementations and our internal tests use `args`. Accept either, with
+  // `arguments` taking precedence so the live wire format wins.
+  z
+    .object({
+      type: z.literal("tool.call"),
+      call_id: z.string(),
+      name: z.string(),
+      arguments: z.record(z.string(), z.unknown()).optional(),
+      args: z.record(z.string(), z.unknown()).optional(),
+    })
+    .transform((m) => ({
+      type: m.type,
+      call_id: m.call_id,
+      name: m.name,
+      args: m.arguments ?? m.args ?? {},
+    })),
   z.object({ type: z.literal("reply.done"), status: z.string().optional() }),
   z.object({ type: z.literal("session.error"), code: z.string(), message: z.string() }),
   z.object({ type: z.literal("error"), message: z.string() }),
@@ -303,27 +314,20 @@ export function connectS2s(opts: ConnectS2sOptions): Promise<S2sHandle> {
       log.info(`S2S << ${type}`);
     }
 
-    ws.addEventListener("message", (ev) => {
-      let raw: unknown;
-      try {
-        raw = JSON.parse(String(ev.data));
-      } catch {
-        log.warn("S2S << invalid JSON", { data: String(ev.data).slice(0, 200) });
-        return;
-      }
-
-      if (typeof raw !== "object" || raw === null || Array.isArray(raw)) {
-        log.warn("S2S << non-object JSON message", { type: typeof raw });
-        return;
-      }
-      const obj = raw as Record<string, unknown>;
+    function handleObject(obj: Record<string, unknown>, raw: unknown): void {
       logIncoming(obj.type);
-
+      // Log the full tool.call payload so we can diagnose provider-side
+      // empty-args problems — the underlying LLM emitting a function call
+      // without populating its required parameters. Without the full
+      // payload we cannot tell apart "field-name mismatch" from
+      // "model emitted no args."
+      if (obj.type === "tool.call") {
+        log.info("S2S << tool.call payload", { payload: JSON.stringify(obj) });
+      }
       if (obj.type === "reply.audio" && typeof obj.data === "string") {
         callbacks.onAudio(base64ToUint8(obj.data));
         return;
       }
-
       const parsed = parseS2sMessage(obj);
       if (!parsed) {
         log.warn(
@@ -332,6 +336,21 @@ export function connectS2s(opts: ConnectS2sOptions): Promise<S2sHandle> {
         return;
       }
       dispatchS2sMessage(callbacks, parsed, dispatchState, dispatchCtx);
+    }
+
+    ws.addEventListener("message", (ev) => {
+      let raw: unknown;
+      try {
+        raw = JSON.parse(String(ev.data));
+      } catch {
+        log.warn("S2S << invalid JSON", { data: String(ev.data).slice(0, 200) });
+        return;
+      }
+      if (typeof raw !== "object" || raw === null || Array.isArray(raw)) {
+        log.warn("S2S << non-object JSON message", { type: typeof raw });
+        return;
+      }
+      handleObject(raw as Record<string, unknown>, raw);
     });
 
     ws.addEventListener("close", (ev) => {

package/host/transports/pipeline-transport.ts

@@ -14,6 +14,7 @@ import {
   DEFAULT_MAX_HISTORY,
   DEFAULT_STT_SAMPLE_RATE,
   DEFAULT_TTS_SAMPLE_RATE,
+  MAX_TOOL_RESULT_CHARS,
   PIPELINE_FLUSH_TIMEOUT_MS,
 } from "../../sdk/constants.ts";
 import type { SessionErrorCode } from "../../sdk/protocol.ts";
@@ -235,6 +236,25 @@ export function createPipelineTransport(opts: PipelineTransportOptions): Transpo
       ttsSession?.sendText(out);
     }
 
+    function emitToolResult(part: {
+      readonly toolCallId?: string;
+      readonly output?: unknown;
+    }): void {
+      // Inline execution finished — surface completion so the client UI can
+      // flip the tool-call from "pending" to "done". Schema requires a
+      // string result capped at MAX_TOOL_RESULT_CHARS.
+      const callId = part.toolCallId ?? "";
+      if (!callId) return;
+      const raw =
+        (part as { output?: unknown; result?: unknown }).output ??
+        (part as { result?: unknown }).result ??
+        "";
+      const str = typeof raw === "string" ? raw : JSON.stringify(raw);
+      const truncated =
+        str.length > MAX_TOOL_RESULT_CHARS ? str.slice(0, MAX_TOOL_RESULT_CHARS) : str;
+      callbacks.onToolCallDone?.(callId, truncated);
+    }
+
     return function handlePart(part: {
       readonly type: string;
       readonly text?: string;
@@ -257,6 +277,9 @@ export function createPipelineTransport(opts: PipelineTransportOptions): Transpo
           callbacks.onToolCall(part.toolCallId ?? "", part.toolName ?? "", input);
           return;
         }
+        case "tool-result":
+          emitToolResult(part);
+          return;
         case "error": {
           const msg = errorMessage(part.error);
           log.error("LLM stream error", { message: msg, sid: opts.sid });

package/host/transports/types.ts

@@ -17,6 +17,13 @@ export type TransportCallbacks = {
   onUserTranscript(text: string): void;
   onAgentTranscript(text: string, interrupted: boolean): void;
   onToolCall(callId: string, name: string, args: Record<string, unknown>): void;
+  /**
+   * Tool execution finished. Pipeline mode invokes this from the
+   * `tool-result` stream part so the client UI can mark the call done.
+   * S2S transports leave this unset — SessionCore.onToolCall emits the
+   * `tool_call_done` event itself after dispatching the tool.
+   */
+  onToolCallDone?(callId: string, result: string): void;
   onError(code: SessionErrorCode, message: string): void;
   onSpeechStarted(): void;
   onSpeechStopped(): void;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@alexkroman1/aai",
-  "version": "1.8.1",
+  "version": "1.8.2",
   "type": "module",
   "exports": {
     ".": {

package/sdk/_internal-types.ts

@@ -118,11 +118,24 @@ export type ToolSchema = {
 
 export const EMPTY_PARAMS = z.object({});
 
+/**
+ * Convert a Zod schema to the JSON Schema shape that S2S providers expect.
+ * Strips the `$schema` keyword: `z.toJSONSchema` (Zod v4) tags output with
+ * the JSON Schema 2020-12 dialect URI, and some Realtime/S2S providers
+ * either reject the field outright or ship it through to the underlying
+ * model with a malformed function spec — observed empirically as tool
+ * calls that arrive with `args: {}` even when required params are listed.
+ */
+export function toToolJsonSchema(zodSchema: z.ZodTypeAny): JSONSchema7 {
+  const { $schema: _omit, ...rest } = z.toJSONSchema(zodSchema) as Record<string, unknown>;
+  return rest as JSONSchema7;
+}
+
 export function agentToolsToSchemas(tools: Readonly<Record<string, ToolDef>>): ToolSchema[] {
   return Object.entries(tools).map(([name, def]) => ({
     type: "function",
     name,
     description: def.description,
-    parameters: z.toJSONSchema(def.parameters ?? EMPTY_PARAMS) as JSONSchema7,
+    parameters: toToolJsonSchema(def.parameters ?? EMPTY_PARAMS),
   }));
 }