Voice agents: cooperative interrupt, @pikku/voice-agents, and store-backed converse assertions - #1085

packages/core/src/wirings/http/web-request.test.ts (1)

354-369: 🎯 Functional Correctness | 🔵 Trivial | ⚡ Quick win

Cover the send branch for binary bodies.

createMockResponse does not define send. This test only validates res.arrayBuffer(body). applyWebResponse calls res.send(body) when an adapter provides it. Add a send-capable mock and assert the same byte sequence for that path.

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@packages/core/src/wirings/http/web-request.test.ts` around lines 354 - 369,
Extend the binary-body test around applyWebResponse to use a createMockResponse
variant that defines send, then assert send receives the original byte sequence
unchanged. Preserve the existing arrayBuffer assertion and verify the
adapter-provided send branch with the same binary payload.

e2e/packages/functions/src/functions/voice-demo.function.ts (2)

463-468: 🚀 Performance & Scalability | 🔵 Trivial | 💤 Low value

Encoding byte by byte adds latency to every turn.

toBase64 concatenates one character per byte on the main thread. handleTurn awaits it before the transcription request starts, so the cost lands in the gap the page is trying to keep short. Chunked conversion removes the per-byte string growth.

♻️ Proposed change

 const toBase64 = async (blob) => {
   const bytes = new Uint8Array(await blob.arrayBuffer())
   let binary = ''
-  for (let i = 0; i < bytes.length; i++) binary += String.fromCharCode(bytes[i])
+  const CHUNK = 0x8000
+  for (let i = 0; i < bytes.length; i += CHUNK) {
+    binary += String.fromCharCode.apply(null, bytes.subarray(i, i + CHUNK))
+  }
   return btoa(binary)
 }

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@e2e/packages/functions/src/functions/voice-demo.function.ts` around lines 463
- 468, Update toBase64 to avoid byte-by-byte string concatenation: convert the
Uint8Array to binary in chunks before calling btoa, preserving the same Base64
output and async behavior used by handleTurn.

---

144-148: 🚀 Performance & Scalability | 🔵 Trivial | ⚡ Quick win

Bound the audio and text inputs.

audio and text accept a string of any length. Both routes are unauthenticated and both forward the payload to a billed provider. A single large request turns into a large provider charge, and Buffer.from on a very large base64 string allocates the whole decoded buffer in memory. Add a .max() to each schema. A few seconds of Opus is a few tens of kilobytes, so the bound can be generous and still useful.

♻️ Proposed change

 export const VoiceDemoTranscribeInput = z.object({
   /** The recorded turn, base64. JSON rather than a raw body so the route needs
    *  no binary handling on either side; a few seconds of Opus is small. */
-  audio: z.string(),
+  audio: z.string().max(4_000_000),
 })

 export const VoiceDemoSpeakInput = z.object({
-  text: z.string(),
+  text: z.string().max(2_000),
 })

Also applies to: 248-250

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@e2e/packages/functions/src/functions/voice-demo.function.ts` around lines 144
- 148, Bound the unauthenticated provider inputs by adding generous
maximum-length validation to the audio field in VoiceDemoTranscribeInput and the
text field in the corresponding text-input schema. Apply the limits to the
z.string() definitions before payloads reach Buffer.from or the billed provider,
preserving the existing schema behavior for valid short inputs.

e2e/packages/functions/src/agents/voice-assistant.agent.ts (1)

120-150: 📐 Maintainability & Code Quality | 🔵 Trivial | ⚡ Quick win

Share the model ids and voice map with the demo route.

e2e/packages/functions/src/functions/voice-demo.function.ts redeclares the same values as ASR_MODEL, TTS_MODEL, and SPEAKABLE_SCRIPTS. Its comment states that these must stay in step with this agent. A copy in two files drifts silently, and drift here changes the voice the user hears or the script coverage check. Export the constants from one module and import them in both places.

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@e2e/packages/functions/src/agents/voice-assistant.agent.ts` around lines 120
- 150, Centralize the voice configuration currently passed to voiceInput and
voiceOutput in this agent, including the ASR model id, TTS model id, and
speakableScripts map, as exported constants. Update both the voice assistant
agent and voice-demo.function.ts to import and use those shared constants,
removing the duplicate declarations while preserving the existing model and
voice values.

packages/voice-agents/README.md (1)

51-58: 📐 Maintainability & Code Quality | 🔵 Trivial | ⚡ Quick win

Add the missing exports to the reference table.

The table lists four exports, but the README itself demonstrates spokenApproval and interpretConsent imported from @pikku/voice-agents (line 113), and detectSpeech is documented at length elsewhere in the package as an alternative to detectSilence. None of these three appear in the table. Add rows for them so the table remains a complete reference.

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@packages/voice-agents/README.md` around lines 51 - 58, Update the “What each
piece is for” export table to include spokenApproval, interpretConsent, and
detectSpeech, with concise purposes matching their documented behavior and the
existing README terminology.

packages/voice-agents/run-tests.sh (1)

4-4: 🩺 Stability & Availability | 🔵 Trivial | 💤 Low value

Harden the shell script per shellcheck hints.

Shellcheck flags two spots:

• Line 4: cd "$script_dir" has no failure guard (SC2164). If cd fails, the rest of the script runs from the wrong directory.
• Line 35: files=($(find src -type f -name "*.test.ts")) splits on whitespace (SC2207). A test file path containing a space breaks into multiple array elements.

Both fixes are small and improve robustness.

🛠️ Proposed fixes

-cd "$script_dir"
+cd "$script_dir" || exit 1

-files=($(find src -type f -name "*.test.ts"))
+mapfile -t files < <(find src -type f -name "*.test.ts")

Also applies to: 35-35

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@packages/voice-agents/run-tests.sh` at line 4, Harden the run-tests.sh setup
and file collection: update the cd command near script_dir to fail immediately
if changing directories fails, and replace the unquoted find-based array
assignment near files with whitespace-safe path handling so filenames containing
spaces remain single elements.

Source: Linters/SAST tools

packages/voice-agents/src/speech-detector.ts (1)

156-277: 📐 Maintainability & Code Quality | 🔵 Trivial | 🏗️ Heavy lift

Add test coverage for the two turn-detection modules. Both detectSpeech and detectSilence implement timing- and callback-sensitive logic (redemption windows, misfire/short-segment discarding, idempotent stop(), progress throttling) with no accompanying test file in this batch, while sibling modules in the same layer (audio-playback-queue.ts, spoken-approval.ts) each have one.

• packages/voice-agents/src/speech-detector.ts#L156-L277: add speech-detector.test.ts covering onSpeechStart/onSpeechEnd/onVADMisfire handling, the redemptionMs timing adjustment in endTurn, and idempotent stop(), using a mocked VadModule/VadInstance.
• packages/voice-agents/src/silence-detector.ts#L44-L118: add silence-detector.test.ts covering the audible/silent transition, onSilenceProgress throttling via PROGRESS_STEP, and idempotent stop(), using a mocked AudioContext/AudioNode/requestAnimationFrame.

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@packages/voice-agents/src/speech-detector.ts` around lines 156 - 277, Add
speech-detector.test.ts covering detectSpeech callbacks for speech starts,
speech ends, misfires, redemptionMs-adjusted timing, and idempotent stop() using
mocked VadModule/VadInstance; add silence-detector.test.ts covering
detectSilence audible-to-silent transitions, PROGRESS_STEP progress throttling,
and idempotent stop() using mocked AudioContext, AudioNode, and
requestAnimationFrame. Update only the tests; no direct production-code change
is required in either detector.

packages/voice-agents/package.json (1)

10-15: 🎯 Functional Correctness | 🔵 Trivial | ⚡ Quick win

Add a types export condition for @pikku/voice-agents.

packages/voice-agents/package.json exposes import and require entrypoints, but consumers using exports need an explicit types entrypoint to resolve the emitted declarations. Add a top-level "types" field and list "types" first under "." in exports.

📦 Proposed fix for the export map

+  "types": "./dist/esm/index.d.ts",
   "exports": {
     ".": {
+      "types": "./dist/esm/index.d.ts",
       "import": "./dist/esm/index.js",
       "require": "./dist/cjs/index.js"
     }
   },

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@packages/voice-agents/package.json` around lines 10 - 15, Add the
package-level types field pointing to the emitted declarations, and update the
"." export map in the package configuration to list a types condition first
before import and require, using the package’s existing declaration output path.

packages/voice-agents/tsconfig.cjs.json (1)

5-5: 📐 Maintainability & Code Quality | 🔵 Trivial | 💤 Low value

Replace deprecated moduleResolution: "node" in the CJS tsconfig.

TypeScript 6 marks moduleResolution: "node"/"node10" as deprecated in favor of moduleResolution: "node16"/"node18"/NodeNext. This config uses commonjs but currently sets moduleResolution: "node", so change both CJK entries to moduleResolution: "node16" and remove ignoreDeprecations: "6.0".

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@packages/voice-agents/tsconfig.cjs.json` at line 5, Update
packages/voice-agents/tsconfig.cjs.json to replace both moduleResolution: "node"
entries with moduleResolution: "node16", and remove the ignoreDeprecations:
"6.0" setting while preserving the existing CommonJS module configuration.

packages/voice-agents/src/spoken-approval.ts (1)

157-170: 🚀 Performance & Scalability | 🔵 Trivial | 💤 Low value

The ReDoS hint here is a false positive, but you can precompile the patterns.

phrases comes from the module-level GRANTS and DENIALS constants. No user input reaches new RegExp. The static analysis warning does not apply. takePhrases still builds 37 RegExp objects on every call. Build them once at module scope.

♻️ Proposed refactor

-const takePhrases = (text: string, phrases: string[]) => {
+const patternsFor = (phrases: string[]) =>
+  phrases.map((phrase) => new RegExp(`\\b${phrase}\\b`, 'g'))
+
+const GRANT_PATTERNS = patternsFor(GRANTS)
+const DENIAL_PATTERNS = patternsFor(DENIALS)
+
+const takePhrases = (text: string, patterns: RegExp[]) => {
   let found = false
   let remaining = text
-  for (const phrase of phrases) {
+  for (const pattern of patterns) {
     // Matched phrases are removed so a later pass cannot read the same words
     // again — this is what keeps "no problem" from also counting as a refusal.
-    const next = remaining.replace(new RegExp(`\\b${phrase}\\b`, 'g'), ' ')
+    pattern.lastIndex = 0
+    const next = remaining.replace(pattern, ' ')

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@packages/voice-agents/src/spoken-approval.ts` around lines 157 - 170,
Precompile the phrase-matching regular expressions for the module-level GRANTS
and DENIALS values instead of constructing them inside takePhrases on every
call. Update takePhrases to reuse the prebuilt patterns while preserving phrase
removal order and the existing found/remaining behavior.

Source: Linters/SAST tools

packages/voice-agents/src/audio-playback-queue.ts (2)

86-93: 📐 Maintainability & Code Quality | 🔵 Trivial | 💤 Low value

Document that the returned promise rejects on decode failure.

drain() handles a failed decode internally, but enqueue returns a derived promise from buffer.then(...). A caller that writes void queue.enqueue(...) gets an unhandled rejection. The test file already works around this at audio-playback-queue.test.ts Line 97. State the contract in the JSDoc, so callers know they must handle rejection.

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@packages/voice-agents/src/audio-playback-queue.ts` around lines 86 - 93,
Update the JSDoc for enqueue in the audio playback queue to explicitly document
that its returned promise resolves when decoding completes but rejects if audio
decoding fails. Keep the existing enqueue and drain behavior unchanged, and make
clear that callers must handle the rejection.

---

114-132: 🩺 Stability & Availability | 🔵 Trivial | ⚡ Quick win

An interrupt during playback leaves the play() promise pending forever.

interrupt() sets source.onended = null and calls source.stop(). The Promise created in play() then has no path to resolve. The drain() loop that awaits it stays suspended permanently and retains its closure. Each interruption during playback adds one such suspended loop.

Keep a resolver for the current utterance and settle it in interrupt().

♻️ Proposed refactor

   private current: {
     text: string
     source: AudioBufferSourceNode
     startedAt: number
     duration: number
+    done: () => void
   } | null = null

-      const { text, source, startedAt, duration } = this.current
+      const { text, source, startedAt, duration, done } = this.current
       complete = false
       source.onended = null
       try {
         source.stop()
       } catch {
         // Already stopped by the scheduler; nothing to unwind.
       }
       const elapsed = Math.max(0, this.ctx.currentTime - startedAt)
       const fraction = duration > 0 ? Math.min(1, elapsed / duration) : 0
       const cut = text.slice(0, Math.round(text.length * fraction)).trimEnd()
       if (cut) heard.push(cut)
       this.current = null
+      done()

       this.current = {
         text: pending.text,
         source,
         startedAt: this.ctx.currentTime,
         duration: pending.buffer.duration,
+        done: resolve,
       }

Also applies to: 180-200

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@packages/voice-agents/src/audio-playback-queue.ts` around lines 114 - 132,
Update the current utterance state in play() to retain its promise resolver,
then invoke that resolver from interrupt() before clearing this.current so the
interrupted playback promise settles and drain() can continue. Preserve normal
onended resolution and ensure the resolver is settled only once.

packages/voice-agents/src/use-voice-conversation.ts (1)

81-82: 📐 Maintainability & Code Quality | 🔵 Trivial | 💤 Low value

Move the optionsRef.current write into an effect.

This hook declares React 18/19 support, and mutating a ref during render can leave the ref pointing to an abandoned render in concurrent mode. Set optionsRef.current = options in useEffect, and add the necessary cleanup so start/onSpeechStart do not use stale options after unmount or dependency change.

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@packages/voice-agents/src/use-voice-conversation.ts` around lines 81 - 82,
Move the optionsRef.current assignment out of render and into a useEffect within
the voice conversation hook. Add effect cleanup that invalidates or clears the
ref on unmount and before dependency changes, ensuring start and onSpeechStart
cannot read stale options.

packages/services/ai-deepinfra/run-tests.sh (1)

31-35: 📐 Maintainability & Code Quality | 🔵 Trivial | 💤 Low value

Use a null-delimited read to collect test files.

Word splitting on find output breaks on paths that contain spaces or globbing characters. mapfile with -print0 removes that risk. Note also that shopt -s nullglob on Line 7 and the pattern variable are now only decorative, because find performs the discovery.

Static analysis reports the same concern (SC2207).

♻️ Proposed change

-# Expand the pattern into an array of files
-files=($(find src -type f -name "*.test.ts"))
+# Expand the pattern into an array of files
+files=()
+while IFS= read -r -d '' file; do
+  files+=("$file")
+done < <(find src -type f -name "*.test.ts" -print0)

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@packages/services/ai-deepinfra/run-tests.sh` around lines 31 - 35, Update the
test-file collection in the script to read null-delimited results from find
using mapfile and find -print0, preserving paths containing spaces or glob
characters. Remove the now-unused pattern variable and nullglob setting because
discovery no longer relies on shell glob expansion.

Source: Linters/SAST tools

packages/services/ai-deepinfra/src/transcription-model.ts (2)

179-183: 🗄️ Data Integrity & Integration | 🔵 Trivial | 💤 Low value

String(value) flattens object and array provider extras.

A provider extra such as { deepinfra: { diarization: { speakers: 2 } } } becomes the multipart value [object Object]. The speech model sends extras as JSON, so the two models accept different extra shapes for the same option name. Serialise non-primitive values as JSON.

♻️ Proposed change

     for (const [key, value] of Object.entries(
       providerExtras(options.providerOptions)
     )) {
-      if (value !== undefined && value !== null) body.append(key, String(value))
+      if (value === undefined || value === null) continue
+      body.append(
+        key,
+        typeof value === 'object' ? JSON.stringify(value) : String(value)
+      )
     }

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@packages/services/ai-deepinfra/src/transcription-model.ts` around lines 179 -
183, Update the provider extras loop in the transcription model to serialize
object and array values with JSON while preserving direct string conversion for
primitive values. Ensure multipart body fields receive valid JSON for
non-primitive extras, including nested objects such as diarization
configuration.

---

203-204: 🩺 Stability & Availability | 🔵 Trivial | ⚡ Quick win

Give a non-JSON success response the same model-named error as a failure.

response.json() throws a bare SyntaxError when a 200 response carries HTML or plain text, for example from a proxy or an edge cache. The failure path on Line 201 names the model, and speech-model.ts guards on content-type before it parses. This path does neither, so the caller loses the model id and the body.

♻️ Proposed change

-    const payload = (await response.json()) as DeepInfraTranscriptionResponse
+    const raw = await response.text()
+    let payload: DeepInfraTranscriptionResponse
+    try {
+      payload = JSON.parse(raw) as DeepInfraTranscriptionResponse
+    } catch {
+      throw new Error(
+        `DeepInfra transcription model '${this.modelId}' returned a non-JSON body: ${raw.slice(0, 500)}`
+      )
+    }

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@packages/services/ai-deepinfra/src/transcription-model.ts` around lines 203 -
204, Update the transcription response handling around response.json() to
validate the response content type before parsing, and handle non-JSON success
bodies with the same model-named error format as the existing failure path.
Preserve the parsed payload flow for valid JSON responses while including the
response body and model identifier when rejecting invalid success responses.

packages/services/ai-deepinfra/package.json (1)

20-25: 📐 Maintainability & Code Quality | 🔵 Trivial | 💤 Low value

Align the release script with Yarn and consider exporting types in the exports map.

Two small points:

• Line 20 uses npm run build && npm test while the rest of the monorepo uses Yarn.
• The exports map has no types condition. Consumers that resolve with node16/nodenext or bundler read exports and can miss dist/index.d.ts.

♻️ Proposed change

-    "release": "npm run build && npm test",
+    "release": "yarn build && yarn test",
     "prepublishOnly": "yarn build"
   },
   "exports": {
-    ".": "./dist/index.js"
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
   },

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@packages/services/ai-deepinfra/package.json` around lines 20 - 25, Update the
package.json release script to use the repository’s Yarn commands instead of
npm, while preserving the existing build-and-test sequence. Extend the exports
entry for "." with a types condition pointing to the generated declaration file
at dist/index.d.ts alongside the existing runtime export.

packages/services/ai-deepinfra/src/deepinfra-config.ts (2)

39-47: 🎯 Functional Correctness | 🔵 Trivial | 💤 Low value

A differently cased authorization key in settings.headers produces two header entries.

The returned object is a plain record. If a caller passes headers: { Authorization: '…' }, the record holds both authorization and Authorization. fetch then normalises both names into one field and joins the values with a comma, which yields an invalid credential rather than an override.

Normalise the key names before the merge, or document that settings.headers must use lowercase names.

♻️ Proposed change

   headers: () => {
     const apiKey = settings.apiKey ?? process.env.DEEPINFRA_API_KEY
     if (!apiKey) {
       throw new Error(
         'DeepInfra API key is missing. Pass `apiKey` to createDeepInfra(), or set DEEPINFRA_API_KEY.'
       )
     }
-    return { authorization: `Bearer ${apiKey}`, ...settings.headers }
+    const extra = Object.fromEntries(
+      Object.entries(settings.headers ?? {}).map(([key, value]) => [
+        key.toLowerCase(),
+        value,
+      ])
+    )
+    return { authorization: `Bearer ${apiKey}`, ...extra }
   },

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@packages/services/ai-deepinfra/src/deepinfra-config.ts` around lines 39 - 47,
Update the headers callback in the DeepInfra configuration so settings.headers
keys are normalised case-insensitively before merging with the generated
authorization header, ensuring any casing of authorization overrides or is
overridden without producing duplicate entries. Preserve all other custom
headers unchanged.

---

48-48: 🩺 Stability & Availability | 🔵 Trivial | ⚡ Quick win

Bind the default fetch to globalThis.

settings.fetch ?? globalThis.fetch stores a detached reference. Browsers reject detached fetch calls and throw TypeError: Illegal invocation, so the browser-facing @pikku/voice-agents path can fail. Resolve globalThis.fetch lazily and bind it.

♻️ Proposed change

-  fetch: settings.fetch ?? globalThis.fetch,
+  fetch: settings.fetch ?? ((...args) => globalThis.fetch(...args)),

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@packages/services/ai-deepinfra/src/deepinfra-config.ts` at line 48, Update
the default fetch handling in the deepinfra configuration so that when
settings.fetch is absent, globalThis.fetch is resolved lazily and bound to
globalThis before storage or invocation; preserve any explicitly supplied
settings.fetch unchanged.

packages/services/ai-deepinfra/src/transcription-model.test.ts (1)

5-22: 📐 Maintainability & Code Quality | 🔵 Trivial | 💤 Low value

stubFetch is duplicated in both test files.

speech-model.test.ts Lines 5-24 defines a near-identical helper that adds a Uint8Array branch. Extract one shared helper, for example src/test-fetch.ts, so both models test against the same stub behaviour. The tsconfig.json exclude list only removes **/*.test.ts, so name any shared helper accordingly or add it to the exclude list to keep it out of dist.

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@packages/services/ai-deepinfra/src/transcription-model.test.ts` around lines
5 - 22, Extract the duplicated stubFetch helper from transcription-model.test.ts
and speech-model.test.ts into one shared test-fetch helper, preserving the
Uint8Array, string, JSON, status, headers, and call-capture behavior used by
both tests. Import and reuse that helper in both test files, and name the shared
file appropriately or update tsconfig.json so it remains excluded from dist.

packages/services/ai-deepinfra/src/speech-model.test.ts (1)

101-143: 📐 Maintainability & Code Quality | 🔵 Trivial | 💤 Low value

Consider covering abortSignal and per-call header merging for the speech model.

transcription-model.test.ts verifies that abortSignal reaches fetch on Lines 227-239. The speech model forwards the same signal on speech-model.ts Line 78, and it merges definedHeaders(options.headers) on Line 60, but neither path has a test here. Barge-in depends on the signal, so a regression would be silent.

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@packages/services/ai-deepinfra/src/speech-model.test.ts` around lines 101 -
143, Add speech-model tests covering both per-call abortSignal propagation to
fetch and per-call header merging with the configured headers. Use the existing
stubFetch and speech model setup, assert the fetch receives the exact signal,
and verify custom defined headers are included alongside the model’s default
headers.

packages/core/src/wirings/ai-agent/ai-agent-interrupt.ts (1)

289-319: 📐 Maintainability & Code Quality | 🔵 Trivial | ⚡ Quick win

Remove the call.mutating flag or make it change state.

call.mutating is initialised to true at Line 295, and onBeginChanges at Line 303-305 sets it to true again. The collectResult getter at Line 312-314 therefore always returns true. The flag and the hook have no effect.

The conservative default is correct and is documented in beginChanges. The suppression for a tool that stops at its checkpoint already comes from the AbandonedError branch at Line 179. Drop the flag so the code states what it does.

♻️ Proposed simplification

       execute: (input: unknown) => {
         // Assumed to have changed something unless it says otherwise — the tool
         // that never declares its checkpoint is the one that cannot be assumed
         // harmless. `beginChanges()` can only ever make this more precise.
-        const call = { mutating: true }
         const scope: AbortScope = {
           get abandoned() {
             return handle.signal.aborted
           },
           get reason() {
             return handle.interruption?.reason
           },
-          onBeginChanges: () => {
-            call.mutating = true
-          },
         }
         return handle.trackTool(
           tool.name,
           randomUUID(),
-          () => runInAbortScope(scope, () => tool.execute(input)),
-          {
-            get collectResult() {
-              return call.mutating
-            },
-          }
+          () => runInAbortScope(scope, () => tool.execute(input))
         )
       },

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@packages/core/src/wirings/ai-agent/ai-agent-interrupt.ts` around lines 289 -
319, Remove the redundant call.mutating state and the onBeginChanges hook from
the execute wrapper in the tool mapping. Keep collectResult as an unconditional
true value, preserving the documented conservative default and existing
AbandonedError suppression behavior.

packages/core/src/wirings/ai-agent/voice-output.ts (1)

252-261: 📐 Maintainability & Code Quality | 🔵 Trivial | ⚡ Quick win

Do not log an aborted synthesis as an error.

On barge-in the run aborts, and synthesizeAudio rejects for every sentence still in flight. Each rejection reaches this branch and writes a logger.error line. A normal interruption then produces error-level noise proportional to the number of queued sentences. Distinguish the abort from a provider failure.

♻️ Proposed change

         state.tail = (state.tail ?? Promise.resolve()).then(async () => {
           const result = await synthesis
           if (!result.ok) {
+            // An interrupt cancels every sentence still in flight. That is the
+            // feature working, not a provider failure.
+            if (signal?.aborted) return
             // One sentence going unspoken is better than the rest of the reply
             // never arriving, so the chain carries on.
             logger?.error(
               `voiceOutput could not synthesize a sentence: ${String(result.error)}`
             )
             return
           }

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@packages/core/src/wirings/ai-agent/voice-output.ts` around lines 252 - 261,
Update the error handling around the synthesis result in the state.tail chain to
distinguish an expected run abort from a provider failure. Suppress logger.error
for abort-related rejections during barge-in, while preserving the existing
error log and chain continuation for genuine synthesis failures.

Fix all unresolved CodeRabbit comments on this PR:

• Push a commit to this branch (recommended)
• Create a new PR with the fixes