getpatter 0.6.6 → 0.6.8

package/dist/{chunk-BO227NTF.mjs → chunk-I56S5MDJ.mjs}

@@ -498,8 +498,9 @@ var OpenAIRealtimeAdapter = class {
       } else if (t === "response.audio_transcript.delta") {
         dispatch("transcript_output", data.delta);
       } else if (t === "response.content_part.added" || t === "response.output_item.added") {
+        const itemType = data.item?.type;
         const itemId = data.item?.id ?? data.item_id ?? null;
-        if (itemId) {
+        if (itemId && (itemType === void 0 || itemType === "message")) {
           this.currentResponseItemId = itemId;
           this.currentResponseAudioMs = 0;
           this.currentResponseFirstAudioAt = null;
@@ -683,6 +684,50 @@ var OpenAIRealtimeAdapter = class {
     }));
     this.ws?.send(JSON.stringify({ type: "response.create" }));
   }
+  /**
+   * Build the partial `session` body for a mid-session swap.
+   *
+   * v1-beta wire shape: flat `{ instructions, tools }`. The GA adapter
+   * overrides this to add the mandatory `"type": "realtime"` envelope.
+   * OpenAI merges partial `session.update` payloads server-side, so only the
+   * swapped fields are sent — audio formats, VAD tuning, and voice are
+   * untouched. Mirrors Python `_build_session_update_patch`.
+   */
+  buildSessionUpdatePatch(instructions, tools) {
+    const session = {};
+    if (instructions !== void 0) session.instructions = instructions;
+    if (tools !== void 0) {
+      session.tools = tools.map((t) => {
+        const def = {
+          type: "function",
+          name: t.name,
+          description: t.description,
+          parameters: t.parameters
+        };
+        if (t.strict === true) def.strict = true;
+        return def;
+      });
+    }
+    return session;
+  }
+  /**
+   * Apply a mid-session `instructions` / `tools` swap (multi-agent handoff).
+   *
+   * Sends a partial `session.update` carrying only the supplied fields and
+   * records them on the adapter so reconnect/warmup paths rebuild the
+   * session with the post-handoff config. Voice is intentionally NOT
+   * updatable here — OpenAI Realtime rejects a voice change once the session
+   * has produced audio, so the session keeps the voice established at call
+   * start (documented limitation). Mirrors Python
+   * `OpenAIRealtimeAdapter.update_session`.
+   */
+  async updateSession(update) {
+    if (update.instructions !== void 0) this.instructions = update.instructions;
+    if (update.tools !== void 0) this.tools = update.tools;
+    const session = this.buildSessionUpdatePatch(update.instructions, update.tools);
+    if (Object.keys(session).length === 0 || !this.ws) return;
+    this.ws.send(JSON.stringify({ type: "session.update", session }));
+  }
   /** Stop the heartbeat, drop listeners, and close the Realtime WebSocket. */
   close() {
     if (this.heartbeat) {
@@ -801,10 +846,18 @@ var StatefulResampler = class {
   firHistory = new Int16Array(2);
   // [s_{-2}, s_{-1}]
   firHistoryValid = false;
+  /**
+   * Samples after the last emitted FIR center, carried to the next chunk
+   * (1–2 samples: the next center and/or its missing lookahead). Replaces
+   * the old single ``firPendingSample`` — that design wrote the pending
+   * sample into history too (processed twice, true s-2 lost) and edge-
+   * replicated the +2 tap at every chunk end, producing audible crackle at
+   * chunk boundaries.
+   */
+  firCarry = new Int16Array(0);
   // Pending sample carried from odd-count chunks (not the byte carry —
   // this is a complete Int16 sample that becomes the first input for the
   // next call).
-  firPendingSample = null;
   // 8k→16k: last input sample deferred across chunk boundaries.
   upsampleLast = 0;
   upsampleHasHistory = false;
@@ -863,13 +916,17 @@ var StatefulResampler = class {
         "[patter] StatefulResampler.flush: trailing odd byte discarded \u2014 upstream produced odd-length PCM stream"
       );
     }
-    if (this.srcRate === 16e3 && this.dstRate === 8e3 && this.firPendingSample !== null) {
-      const s = this.firPendingSample;
-      const tmp = Buffer.alloc(4);
-      tmp.writeInt16LE(s, 0);
-      tmp.writeInt16LE(s, 2);
-      const out = this._downsample16kTo8k(tmp);
-      this.firPendingSample = null;
+    if (this.srcRate === 16e3 && this.dstRate === 8e3 && this.firCarry.length > 0) {
+      const carry = this.firCarry;
+      this.firCarry = new Int16Array(0);
+      const s0 = carry[0];
+      const sP1 = carry.length > 1 ? carry[1] : s0;
+      const sP2 = sP1;
+      const sM2 = this.firHistoryValid ? this.firHistory[0] : 0;
+      const sM1 = this.firHistoryValid ? this.firHistory[1] : 0;
+      const filtered = sM2 + 4 * sM1 + 6 * s0 + 4 * sP1 + sP2 + 8 >> 4;
+      const out = Buffer.alloc(2);
+      out.writeInt16LE(Math.max(-32768, Math.min(32767, filtered)), 0);
       return out;
     }
     if (this.srcRate === 8e3 && this.dstRate === 16e3 && this.upsampleHasHistory) {
@@ -886,7 +943,7 @@ var StatefulResampler = class {
   reset() {
     this.firHistory = new Int16Array(2);
     this.firHistoryValid = false;
-    this.firPendingSample = null;
+    this.firCarry = new Int16Array(0);
     this.upsampleLast = 0;
     this.upsampleHasHistory = false;
     this.resample24Last = 0;
@@ -915,48 +972,37 @@ var StatefulResampler = class {
    */
   _downsample16kTo8k(buf) {
     const newSampleCount = buf.length >> 1;
-    const hasPending = this.firPendingSample !== null;
-    const totalInput = newSampleCount + (hasPending ? 1 : 0);
-    const input = new Int16Array(totalInput);
-    if (hasPending) {
-      input[0] = this.firPendingSample;
-      for (let j = 0; j < newSampleCount; j++) input[j + 1] = buf.readInt16LE(j * 2);
-    } else {
-      for (let j = 0; j < newSampleCount; j++) input[j] = buf.readInt16LE(j * 2);
+    const carried = this.firCarry;
+    const total = carried.length + newSampleCount;
+    const all = new Int16Array(total);
+    all.set(carried, 0);
+    for (let j = 0; j < newSampleCount; j++) {
+      all[carried.length + j] = buf.readInt16LE(j * 2);
     }
-    this.firPendingSample = null;
-    if (totalInput === 0) return Buffer.alloc(0);
+    if (total === 0) return Buffer.alloc(0);
     if (!this.firHistoryValid) {
       this.firHistory[0] = 0;
       this.firHistory[1] = 0;
       this.firHistoryValid = true;
     }
-    const extended = new Int16Array(totalInput + 2);
-    extended[0] = this.firHistory[0];
-    extended[1] = this.firHistory[1];
-    for (let j = 0; j < totalInput; j++) extended[j + 2] = input[j];
-    const outSamples = totalInput >> 1;
-    const out = Buffer.alloc(outSamples * 2);
-    for (let i = 0; i < outSamples; i++) {
-      const c = 2 + i * 2;
-      const sM2 = extended[c - 2];
-      const sM1 = extended[c - 1];
-      const s0 = extended[c];
-      const sP1 = c + 1 < extended.length ? extended[c + 1] : extended[extended.length - 1];
-      const sP2 = c + 2 < extended.length ? extended[c + 2] : extended[extended.length - 1];
+    const nOut = total >= 3 ? (total - 3 >> 1) + 1 : 0;
+    const out = Buffer.alloc(nOut * 2);
+    for (let i = 0; i < nOut; i++) {
+      const c = i * 2;
+      const sM2 = c >= 2 ? all[c - 2] : this.firHistory[0];
+      const sM1 = c >= 1 ? all[c - 1] : this.firHistory[1];
+      const s0 = all[c];
+      const sP1 = all[c + 1];
+      const sP2 = all[c + 2];
       const filtered = sM2 + 4 * sM1 + 6 * s0 + 4 * sP1 + sP2 + 8 >> 4;
       out.writeInt16LE(Math.max(-32768, Math.min(32767, filtered)), i * 2);
     }
-    if (totalInput % 2 === 1) {
-      this.firPendingSample = input[totalInput - 1];
-    }
-    if (totalInput >= 2) {
-      this.firHistory[0] = input[totalInput - 2];
-      this.firHistory[1] = input[totalInput - 1];
-    } else {
-      this.firHistory[0] = this.firHistory[1];
-      this.firHistory[1] = input[0];
+    const nextCenter = nOut * 2;
+    if (nextCenter >= 2) {
+      this.firHistory[0] = all[nextCenter - 2];
+      this.firHistory[1] = all[nextCenter - 1];
     }
+    this.firCarry = all.slice(nextCenter);
     return out;
   }
   // ---------------------------------------------------------------------------
@@ -1194,7 +1240,11 @@ var OpenAIRealtime2Adapter = class extends OpenAIRealtimeAdapter {
       },
       instructions: this.instructions || "You are a helpful voice assistant. Be concise."
     };
-    if (opts.temperature !== void 0) config.temperature = opts.temperature;
+    if (opts.temperature !== void 0) {
+      getLogger().warn(
+        `OpenAI Realtime GA does not accept 'temperature' \u2014 ignoring ${opts.temperature}`
+      );
+    }
     if (opts.maxResponseOutputTokens !== void 0) {
       config.max_output_tokens = opts.maxResponseOutputTokens;
     }
@@ -1216,6 +1266,20 @@ var OpenAIRealtime2Adapter = class extends OpenAIRealtimeAdapter {
     }
     return config;
   }
+  /**
+   * GA-shape partial `session.update` body for a mid-session swap.
+   *
+   * Identical to the base v1 patch plus the mandatory `"type": "realtime"`
+   * discriminator — the GA endpoint rejects a `session.update` without it.
+   * Used by {@link OpenAIRealtimeAdapter.updateSession} (inherited unchanged)
+   * for the multi-agent `handoff_to` flow. Mirrors the Python
+   * `OpenAIRealtime2Adapter._build_session_update_patch`.
+   */
+  buildSessionUpdatePatch(instructions, tools) {
+    const session = super.buildSessionUpdatePatch(instructions, tools);
+    if (Object.keys(session).length > 0) session.type = "realtime";
+    return session;
+  }
   /**
    * Open the Realtime WebSocket against the GA endpoint and apply the GA
    * session configuration. Header `OpenAI-Beta: realtime=v1` is OMITTED
@@ -1229,6 +1293,18 @@ var OpenAIRealtime2Adapter = class extends OpenAIRealtimeAdapter {
     });
     const wsRef = this.ws;
     const originalOn = wsRef.on.bind(this.ws);
+    const originalOff = wsRef.off.bind(this.ws);
+    const wrappedByHandler = /* @__PURE__ */ new Map();
+    wsRef.off = (event, handler) => {
+      if (event === "message") {
+        const wrapped = wrappedByHandler.get(handler);
+        if (wrapped) {
+          wrappedByHandler.delete(handler);
+          return originalOff(event, wrapped);
+        }
+      }
+      return originalOff(event, handler);
+    };
     wsRef.on = (event, handler) => {
       if (event !== "message") return originalOn(event, handler);
       const wrapped = (raw, ...rest) => {
@@ -1250,6 +1326,7 @@ var OpenAIRealtime2Adapter = class extends OpenAIRealtimeAdapter {
         }
         handler(raw, ...rest);
       };
+      wrappedByHandler.set(handler, wrapped);
       return originalOn(event, wrapped);
     };
     await new Promise((resolve, reject) => {
@@ -1257,6 +1334,7 @@ var OpenAIRealtime2Adapter = class extends OpenAIRealtimeAdapter {
       let settled = false;
       const ws = this.ws;
       const onSetupMessage = (raw) => {
+        if (settled) return;
         let msg;
         try {
           msg = JSON.parse(raw.toString());

package/dist/chunk-OV252D2V.mjs

@@ -0,0 +1,198 @@
+import {
+  LLMLoop
+} from "./chunk-YJ4HKJL6.mjs";
+import {
+  getLogger
+} from "./chunk-MVOQFAEO.mjs";
+import {
+  init_esm_shims
+} from "./chunk-N565J3CF.mjs";
+
+// src/test-mode.ts
+init_esm_shims();
+import { createInterface } from "readline";
+var TestSession = class {
+  /** Run a REPL-style session that loops user input through the agent's LLM/onMessage handler. */
+  async run(opts) {
+    const { agent, openaiKey, onMessage, onCallStart, onCallEnd } = opts;
+    const callId = `test_${Date.now().toString(36)}${Math.random().toString(36).slice(2, 8)}`;
+    const caller = "+15550000001";
+    const callee = "+15550000002";
+    const conversationHistory = [];
+    const log = getLogger();
+    log.info("");
+    log.info("=".repeat(60));
+    log.info("  PATTER TEST MODE");
+    log.info("=".repeat(60));
+    log.info(`  Agent: ${agent.model || "default"} / ${agent.voice || "default"}`);
+    log.info(`  Provider: ${agent.provider || "openai_realtime"}`);
+    log.info(`  Call ID: ${callId}`);
+    log.info(`  Caller: ${caller}  ->  Callee: ${callee}`);
+    log.info("-".repeat(60));
+    log.info("  Commands: /quit  /transfer <number>  /hangup  /history");
+    log.info("=".repeat(60));
+    log.info("");
+    if (onCallStart) {
+      await onCallStart({
+        call_id: callId,
+        caller,
+        callee,
+        direction: "test"
+      });
+    }
+    if (agent.firstMessage) {
+      log.info(`  Agent: ${agent.firstMessage}`);
+      log.info("");
+      conversationHistory.push({
+        role: "assistant",
+        text: agent.firstMessage,
+        timestamp: Date.now()
+      });
+    }
+    let llmLoop = null;
+    if (!onMessage && openaiKey) {
+      let llmModel = agent.model || "gpt-4o-mini";
+      if (llmModel.includes("realtime")) llmModel = "gpt-4o-mini";
+      let resolvedPrompt = agent.systemPrompt;
+      if (agent.variables) {
+        for (const [k, v] of Object.entries(agent.variables)) {
+          resolvedPrompt = resolvedPrompt.replaceAll(`{${k}}`, v);
+        }
+      }
+      llmLoop = new LLMLoop(
+        openaiKey,
+        llmModel,
+        resolvedPrompt,
+        agent.tools,
+        void 0,
+        agent.disablePhonePreamble ?? false
+      );
+    }
+    let ended = false;
+    const _callControl = {
+      callId,
+      caller,
+      callee,
+      transfer: async (number) => {
+        ended = true;
+        log.info(`  [Transfer -> ${number}]`);
+      },
+      hangup: async () => {
+        ended = true;
+        log.info("  [Call ended by agent]");
+      },
+      sendDtmf: async (digits, _opts) => {
+        log.info(`  [DTMF -> ${digits}]`);
+      }
+    };
+    void _callControl;
+    const rl = createInterface({
+      input: process.stdin,
+      output: process.stdout
+    });
+    const askQuestion = (prompt) => new Promise((resolve) => rl.question(prompt, resolve));
+    try {
+      while (!ended) {
+        let userInput;
+        try {
+          userInput = await askQuestion("  You: ");
+        } catch {
+          log.info("\n  [Session ended]");
+          break;
+        }
+        userInput = userInput.trim();
+        if (!userInput) continue;
+        if (userInput === "/quit") {
+          log.info("  [Session ended]");
+          break;
+        } else if (userInput === "/hangup") {
+          log.info("  [You hung up]");
+          break;
+        } else if (userInput.startsWith("/transfer ")) {
+          const number = userInput.slice(10).trim();
+          log.info(`  [Transfer -> ${number}]`);
+          break;
+        } else if (userInput === "/history") {
+          for (const entry of conversationHistory) {
+            const role = entry.role.charAt(0).toUpperCase() + entry.role.slice(1);
+            log.info(`    ${role}: ${entry.text}`);
+          }
+          continue;
+        }
+        if (onMessage) {
+          conversationHistory.push({
+            role: "user",
+            text: userInput,
+            timestamp: Date.now()
+          });
+          try {
+            const responseText = await onMessage({
+              text: userInput,
+              call_id: callId,
+              caller,
+              history: [...conversationHistory]
+            });
+            if (responseText) {
+              log.info(`  Agent: ${responseText}`);
+              conversationHistory.push({
+                role: "assistant",
+                text: responseText,
+                timestamp: Date.now()
+              });
+              log.info("");
+            }
+          } catch (e) {
+            log.error(`  [Error: ${String(e)}]`);
+          }
+        } else if (llmLoop) {
+          const callCtx = { call_id: callId, caller, callee };
+          const parts = [];
+          process.stdout.write("  Agent: ");
+          try {
+            for await (const token of llmLoop.run(userInput, conversationHistory, callCtx)) {
+              parts.push(token);
+              process.stdout.write(token);
+            }
+          } catch (err) {
+            log.info("");
+            log.error(`LLM error: ${String(err)}`);
+            continue;
+          }
+          log.info("");
+          const responseText = parts.join("");
+          conversationHistory.push({
+            role: "user",
+            text: userInput,
+            timestamp: Date.now()
+          });
+          if (responseText) {
+            conversationHistory.push({
+              role: "assistant",
+              text: responseText,
+              timestamp: Date.now()
+            });
+          }
+          log.info("");
+        } else {
+          log.info("  [No onMessage handler or LLM loop configured]");
+        }
+        if (ended) break;
+      }
+    } finally {
+      rl.close();
+    }
+    if (onCallEnd) {
+      await onCallEnd({
+        call_id: callId,
+        caller,
+        callee,
+        direction: "test",
+        transcript: conversationHistory
+      });
+    }
+  }
+};
+
+export {
+  TestSession
+};