@pikku/core 0.12.72 → 0.12.74

package/src/wirings/ai-agent/ai-agent-agui.ts

@@ -42,11 +42,6 @@ export type { AGUIEvent }
 export type AGUIChannelOptions = {
   threadId?: string
   runId?: string
-  /**
-   * Late-bound runId source, resolved when the run is opened (first event).
-   * Lets the stream path report the AIRunStateService runId on RUN_STARTED
-   * even though that id is only created after the channel is wrapped.
-   */
   getRunId?: () => string | undefined
 }
 
@@ -85,8 +80,6 @@ export function wrapChannelWithAGUI(
   let usageModel: string | undefined
   const usageTotals = { input: 0, output: 0 }
 
-  // The AG-UI client rejects any event arriving before RUN_STARTED, so the
-  // run is opened lazily with the first translated event.
   function send(event: AGUIEvent): void {
     if (!runStartedSent) {
       runStartedSent = true
@@ -141,11 +134,6 @@ export function wrapChannelWithAGUI(
     return thinkingMessageId
   }
 
-  // The AG-UI client treats RUN_FINISHED as terminal and rejects everything
-  // after it, so it is emitted exactly once — on 'done' — with the usage
-  // accumulated across all steps (per-step 'usage' events must NOT finish
-  // the run: on multi-step tool runs later steps would arrive after
-  // RUN_FINISHED and the client would drop the whole stream).
   function finishRun(): void {
     endTextMessage()
     endThinkingMessage()
@@ -177,6 +165,9 @@ export function wrapChannelWithAGUI(
     setState: (s) => inner.setState(s),
     getState: () => inner.getState(),
     clearState: () => inner.clearState(),
+    // Delegated: the wrapper is a view over the same connection, so a peer
+    // reachable from the channel underneath is reachable from here too.
+    remote: (funcName: string, data?: unknown) => inner.remote(funcName, data),
     sendBinary: (data) => inner.sendBinary(data),
     close: () => inner.close(),
 
@@ -262,9 +253,6 @@ export function wrapChannelWithAGUI(
           break
         }
 
-        // Step names must be unique among active steps on the client and
-        // sub-agents reuse step numbers on the shared channel, so each
-        // step-start closes the previous step and gets a sequential name.
         case 'step-start': {
           endTextMessage()
           endThinkingMessage()
@@ -368,9 +356,40 @@ export function wrapChannelWithAGUI(
           break
         }
 
-        case 'audio-delta':
-        case 'audio-done':
+        case 'interrupted': {
+          endTextMessage()
+          endThinkingMessage()
+          endStep()
+          send({
+            type: 'CUSTOM',
+            name: 'pikku:interrupted',
+            value: {
+              runId: event.runId,
+              text: event.text,
+              reason: event.reason,
+            },
+          })
           break
+        }
+
+        // AG-UI has no event for speech, so it travels as CUSTOM like the other
+        // pikku-specific ones. Dropping it instead — which is what this did —
+        // means a voice agent reached over HTTP is inaudible: `voiceOutput`
+        // synthesizes every sentence, the provider bills for it, and nothing
+        // gets past the mapper.
+        case 'audio-delta': {
+          send({
+            type: 'CUSTOM',
+            name: 'pikku:audio-delta',
+            value: { data: event.data, format: event.format },
+          })
+          break
+        }
+
+        case 'audio-done': {
+          send({ type: 'CUSTOM', name: 'pikku:audio-done', value: {} })
+          break
+        }
       }
     },
   }

package/src/wirings/ai-agent/ai-agent-helpers.ts

@@ -1,3 +1,5 @@
+import type { AgentInterruptResult } from './ai-agent-interrupt.js'
+
 export function agent<TAgentMap extends Record<string, { output: any }>>(
   agentName: string & keyof TAgentMap
 ): { func: (services: any, data: any, wire: any) => Promise<any> } {
@@ -49,6 +51,24 @@ export function agentResume(): {
   }
 }
 
+export function agentInterrupt(): {
+  func: (
+    services: any,
+    data: { runId: string; reason?: 'speech' | 'user' | 'timeout' },
+    wire: any
+  ) => Promise<AgentInterruptResult>
+} {
+  return {
+    func: async (
+      _services: any,
+      data: { runId: string; reason?: 'speech' | 'user' | 'timeout' },
+      { rpc }: any
+    ) => {
+      return rpc.agent.interrupt(data.runId, data.reason)
+    },
+  }
+}
+
 export function agentApprove<TAgentMap extends Record<string, { output: any }>>(
   _agentName: string & keyof TAgentMap
 ): {