open-agents-ai 0.137.0 → 0.138.1

package/dist/index.js

@@ -21583,8 +21583,55 @@ If you're stuck, try a completely different approach. Do NOT repeat what failed
                 break;
               }
               if (/does not support tools|HTTP 400.*tools/i.test(errMsg)) {
-                this.emit({ type: "error", content: `Model does not support tool calling. Use /model to select a model with tool support (e.g., qwen3.5, nemotron).`, timestamp: (/* @__PURE__ */ new Date()).toISOString() });
-                break;
+                this.emit({
+                  type: "status",
+                  content: `Model lacks native tool support \u2014 switching to prompt-injected tool mode`,
+                  timestamp: (/* @__PURE__ */ new Date()).toISOString()
+                });
+                const toolDescriptions = Array.from(this.tools.values()).map((t) => `- ${t.name}: ${t.description}`).join("\n");
+                const toolInjectMsg = [
+                  "\n\n[TOOL MODE \u2014 PROMPT INJECTION]",
+                  "This model does not have native tool-calling. To use tools, output a JSON block:",
+                  "```json",
+                  '{"tool": "tool_name", "args": {"param": "value"}}',
+                  "```",
+                  "\nAvailable tools:",
+                  toolDescriptions,
+                  "\nOutput EXACTLY ONE tool call per response in the JSON format above.",
+                  "After seeing the tool result, continue or call another tool.",
+                  'When done, output: {"tool": "task_complete", "args": {"summary": "what you did"}}'
+                ].join("\n");
+                messages.push({ role: "system", content: toolInjectMsg });
+                chatRequest.tools = [];
+                try {
+                  response = this.options.streamEnabled && this.hasStreamingSupport() ? await this.streamingRequest(chatRequest, turn) : await this.backend.chatCompletion(chatRequest);
+                  const content = response.choices?.[0]?.message?.content ?? "";
+                  const jsonMatch = content.match(/```json\s*\n?([\s\S]*?)```/);
+                  if (jsonMatch) {
+                    try {
+                      const parsed = JSON.parse(jsonMatch[1]);
+                      if (parsed.tool && this.tools.has(parsed.tool)) {
+                        const tool = this.tools.get(parsed.tool);
+                        const result = await tool.execute(parsed.args ?? {});
+                        messages.push({ role: "assistant", content });
+                        messages.push({ role: "user", content: `Tool result (${parsed.tool}): ${result.output.slice(0, 2e3)}` });
+                        if (parsed.tool === "task_complete") {
+                          completed = true;
+                          summary = String(parsed.args?.summary ?? content);
+                        }
+                        toolCallCount++;
+                        continue;
+                      }
+                    } catch {
+                    }
+                  }
+                  messages.push({ role: "assistant", content });
+                  continue;
+                } catch (retryErr2) {
+                  const msg2 = retryErr2 instanceof Error ? retryErr2.message : String(retryErr2);
+                  this.emit({ type: "error", content: `Prompt-injected tool mode also failed: ${msg2}`, timestamp: (/* @__PURE__ */ new Date()).toISOString() });
+                  break;
+                }
               }
               messages.push({ role: "user", content: "[System: backend request failed, retrying on next turn. The previous request was lost.]" });
               continue;
@@ -38718,20 +38765,21 @@ var init_voice = __esm({
       speak(text, emotion) {
         const pitchBias = emotion ? emotionToPitchBias(emotion, this.starkMode, this.autistMode) : 0;
         const speedFactor = emotion ? emotionToSpeedFactor(emotion, this.starkMode, this.autistMode) : 1;
-        this.enqueueSpeech(text, 1, 1 + pitchBias, speedFactor);
+        this.enqueueSpeech(text, 1, 1 + pitchBias, speedFactor, 0.6);
       }
       /**
-       * Speak text at reduced volume with pitch shift to indicate
+       * Speak text at reduced volume with narrow stereo placement to indicate
        * subordinate/secondary output (sub-agent activity, tool narration, etc.).
-       * Volume: 55% of primary. Base pitch: 0.92x (lower).
-       * Emotion further modulates pitch and speed on top of the subordinate base.
+       * Volume: 55% of primary. Stereo delay: 0.15ms (narrow — "recessed/behind").
+       * No pitch shift — depth is conveyed by stereo narrowness + lower volume.
+       * Emotion still modulates pitch and speed on top.
        */
       speakSubordinate(text, emotion) {
         const pitchBias = emotion ? emotionToPitchBias(emotion, this.starkMode, this.autistMode) : 0;
         const speedFactor = emotion ? emotionToSpeedFactor(emotion, this.starkMode, this.autistMode) : 1;
-        this.enqueueSpeech(text, 0.55, 0.92 + pitchBias, speedFactor);
+        this.enqueueSpeech(text, 0.55, 1 + pitchBias, speedFactor, 0.15);
       }
-      enqueueSpeech(text, volume, pitchFactor, speedFactor = 1) {
+      enqueueSpeech(text, volume, pitchFactor, speedFactor = 1, stereoDelayMs = 0.6) {
         if (!this.enabled || !this.ready)
           return;
         const chunks = this.chunkText(text);
@@ -38739,7 +38787,7 @@ var init_voice = __esm({
           this.speakQueue.length = 0;
         }
         for (const chunk of chunks) {
-          this.speakQueue.push({ text: chunk, volume, pitchFactor, speedFactor });
+          this.speakQueue.push({ text: chunk, volume, pitchFactor, speedFactor, stereoDelayMs });
         }
         if (!this.speaking) {
           this.drainQueue().catch(() => {
@@ -38919,7 +38967,7 @@ var init_voice = __esm({
           }
           isFirst = false;
           try {
-            await this.synthesizeAndPlay(item.text, item.volume, item.pitchFactor, item.speedFactor);
+            await this.synthesizeAndPlay(item.text, item.volume, item.pitchFactor, item.speedFactor, item.stereoDelayMs);
           } catch {
           }
         }
@@ -38931,9 +38979,9 @@ var init_voice = __esm({
       // -------------------------------------------------------------------------
       // Synthesis pipeline
       // -------------------------------------------------------------------------
-      async synthesizeAndPlay(text, volume = 1, pitchFactor = 1, speedFactor = 1) {
+      async synthesizeAndPlay(text, volume = 1, pitchFactor = 1, speedFactor = 1, stereoDelayMs = 0.6) {
         if (this.luxttsActive) {
-          await this.synthesizeWithLuxtts(text, volume, pitchFactor, speedFactor);
+          await this.synthesizeWithLuxtts(text, volume, pitchFactor, speedFactor, stereoDelayMs);
           return;
         }
         if (this.mlxActive) {
@@ -38979,6 +39027,7 @@ var init_voice = __esm({
         if (pitchFactor !== 1) {
           audioData = this.resamplePitch(audioData, pitchFactor);
         }
+        const stereo = this.applyStereoDelay(audioData, sampleRate, stereoDelayMs);
         if (this.onPCMOutput) {
           const int16 = new Int16Array(audioData.length);
           for (let i = 0; i < audioData.length; i++) {
@@ -38988,7 +39037,7 @@ var init_voice = __esm({
           this.onPCMOutput(Buffer.from(int16.buffer), sampleRate);
         }
         const wavPath = join50(tmpdir9(), `oa-voice-${Date.now()}.wav`);
-        this.writeWav(audioData, sampleRate, wavPath);
+        this.writeStereoWav(stereo.left, stereo.right, sampleRate, wavPath);
         await this.playWav(wavPath);
         try {
           unlinkSync8(wavPath);
@@ -39049,6 +39098,63 @@ var init_voice = __esm({
         }
         return out;
       }
+      /**
+       * Apply interaural time delay (ITD) to create stereo depth from mono audio.
+       *
+       * The right channel is delayed by `delayMs` milliseconds relative to the left.
+       * This creates a perceived spatial position — wider delay = more "present/forward",
+       * narrower delay = more "recessed/behind". Based on Blauert's duplex theory:
+       * ITDs below ~1.5ms produce lateralization without audible echo.
+       *
+       * Typical values:
+       *   0.6ms — primary voice, wide stereo presence ("speaking to you")
+       *   0.15ms — secondary voice, narrow/centered ("background, recessed")
+       */
+      applyStereoDelay(mono, sampleRate, delayMs) {
+        const delaySamples = Math.round(delayMs / 1e3 * sampleRate);
+        const outLen = mono.length + delaySamples;
+        const left = new Float32Array(outLen);
+        const right = new Float32Array(outLen);
+        left.set(mono, 0);
+        right.set(mono, delaySamples);
+        return { left, right };
+      }
+      /**
+       * Write a stereo (2-channel interleaved) WAV file from left/right Float32 channels.
+       * PCM 16-bit, same sample rate as the model output.
+       */
+      writeStereoWav(left, right, sampleRate, path) {
+        const numChannels = 2;
+        const bitsPerSample = 16;
+        const numSamples = Math.min(left.length, right.length);
+        const byteRate = sampleRate * numChannels * (bitsPerSample / 8);
+        const blockAlign = numChannels * (bitsPerSample / 8);
+        const dataSize = numSamples * numChannels * (bitsPerSample / 8);
+        const buffer = Buffer.alloc(44 + dataSize);
+        buffer.write("RIFF", 0);
+        buffer.writeUInt32LE(36 + dataSize, 4);
+        buffer.write("WAVE", 8);
+        buffer.write("fmt ", 12);
+        buffer.writeUInt32LE(16, 16);
+        buffer.writeUInt16LE(1, 20);
+        buffer.writeUInt16LE(numChannels, 22);
+        buffer.writeUInt32LE(sampleRate, 24);
+        buffer.writeUInt32LE(byteRate, 28);
+        buffer.writeUInt16LE(blockAlign, 32);
+        buffer.writeUInt16LE(bitsPerSample, 34);
+        buffer.write("data", 36);
+        buffer.writeUInt32LE(dataSize, 40);
+        let pos = 44;
+        for (let i = 0; i < numSamples; i++) {
+          const lSample = Math.max(-1, Math.min(1, left[i]));
+          const rSample = Math.max(-1, Math.min(1, right[i]));
+          buffer.writeInt16LE(lSample < 0 ? lSample * 32768 : lSample * 32767, pos);
+          pos += 2;
+          buffer.writeInt16LE(rSample < 0 ? rSample * 32768 : rSample * 32767, pos);
+          pos += 2;
+        }
+        writeFileSync14(path, buffer);
+      }
       // -------------------------------------------------------------------------
       // Phonemization
       // -------------------------------------------------------------------------
@@ -39743,9 +39849,9 @@ if __name__ == '__main__':
       /**
        * Synthesize and play audio using LuxTTS voice cloning.
        * Speed is passed natively to LuxTTS. Pitch is post-processed via resampling.
-       * Volume is applied via WAV sample scaling.
+       * Volume is applied via WAV sample scaling. Stereo ITD applied for depth.
        */
-      async synthesizeWithLuxtts(text, volume = 1, pitchFactor = 1, speedFactor = 1) {
+      async synthesizeWithLuxtts(text, volume = 1, pitchFactor = 1, speedFactor = 1, stereoDelayMs = 0.6) {
         if (!this.luxttsCloneRef || !existsSync35(this.luxttsCloneRef)) {
           return;
         }
@@ -39810,6 +39916,25 @@ if __name__ == '__main__':
           } catch {
           }
         }
+        if (stereoDelayMs > 0) {
+          try {
+            const wavData = readFileSync24(wavPath);
+            if (wavData.length > 44) {
+              const sampleRate = wavData.readUInt32LE(24);
+              const numChannels = wavData.readUInt16LE(22);
+              if (numChannels === 1) {
+                const int16 = new Int16Array(wavData.buffer, wavData.byteOffset + 44, (wavData.length - 44) / 2);
+                const float32 = new Float32Array(int16.length);
+                for (let i = 0; i < int16.length; i++) {
+                  float32[i] = int16[i] / 32768;
+                }
+                const stereo = this.applyStereoDelay(float32, sampleRate, stereoDelayMs);
+                this.writeStereoWav(stereo.left, stereo.right, sampleRate, wavPath);
+              }
+            }
+          } catch {
+          }
+        }
         await this.playWav(wavPath);
         try {
           unlinkSync8(wavPath);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "open-agents-ai",
-  "version": "0.137.0",
+  "version": "0.138.1",
   "description": "AI coding agent powered by open-source models (Ollama/vLLM) — interactive TUI with agentic tool-calling loop",
   "type": "module",
   "main": "./dist/index.js",