@pikku/core 0.12.78 → 0.12.80

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

@@ -12,7 +12,11 @@ import type {
 } from './ai-agent.types.js'
 import type { AIAgentRunnerParams } from '../../services/ai-agent-runner-service.js'
 import { PikkuError } from '../../errors/error-handler.js'
-import { checkAuthPermissions, runPermissions } from '../../permissions.js'
+import {
+  checkAuthPermissions,
+  runPermissions,
+  type PermissionWire,
+} from '../../permissions.js'
 import { AIProviderNotConfiguredError } from '../../errors/errors.js'
 import { ForbiddenError } from '../../errors/errors.js'
 import { verifyScopes } from '../../scopes.js'
@@ -319,8 +323,8 @@ export async function assertAgentAuthorized(
 
   await runPermissions({
     funcPermissions: agent.permissions,
-    services: singletonServices as any,
-    wire: wire as any,
+    services: singletonServices,
+    wire: wire as PermissionWire,
     data: {},
     packageName,
     label: 'agent',
@@ -395,7 +399,7 @@ export function createScopedChannel(
           toolName: event.toolName,
           args: event.args,
           ...(event.reason !== undefined ? { reason: event.reason } : {}),
-          runId: (event as any).runId,
+          runId: event.runId,
         })
         return
       }
@@ -940,10 +944,7 @@ export async function prepareAgentRun(
 
   let messages: AIMessage[] = []
   if (storage) {
-    // A tool whose run was interrupted may still be writing its result to this
-    // thread. In voice the next turn lands within a second or two, so without
-    // this the model would load context that is missing the very thing it is
-    // about to be asked about.
+    // knowledge: decisions/internals/agent-context-waits-for-a-tool-result-still-being-written.md
     await awaitPendingInterruptNote(threadId)
     messages = await storage.getMessages(threadId, {
       lastN: memoryConfig?.lastMessages ?? 20,
@@ -959,10 +960,7 @@ export async function prepareAgentRun(
 
   const userContent: AIMessage['content'] = input.attachments?.length
     ? [
-        // Omitted when there is nothing to say. An attachment on its own is a
-        // real turn — a spoken one carries audio and no text at all — and an
-        // empty text part alongside it is a part providers are entitled to
-        // reject, for a caller who never wrote one.
+        // knowledge: decisions/internals/an-empty-text-part-is-omitted-from-an-agent-message.md
         ...(input.message
           ? [{ type: 'text' as const, text: input.message }]
           : []),

package/src/wirings/ai-agent/ai-agent-resume-authorization.test.ts

@@ -43,6 +43,7 @@ const setup = (agentName: string, resourceId = 'u1') => {
       getRun: async () => suspendedRun(agentName, resourceId),
       resolveApproval: async (toolCallId: string) => {
         resolved.push(toolCallId)
+        return true
       },
     },
   } as any)

package/src/wirings/ai-agent/ai-agent-runner.test.ts

@@ -707,7 +707,7 @@ describe('resumeAIAgentSync', () => {
           createdAt: new Date(),
           updatedAt: new Date(),
         }),
-        resolveApproval: async () => {},
+        resolveApproval: async () => true,
         updateRun: async () => {},
       },
     } as any)
@@ -784,6 +784,7 @@ describe('resumeAIAgentSync', () => {
         },
         resolveApproval: async (toolCallId: string, status: string) => {
           resolveCalls.push({ toolCallId, status })
+          return true
         },
       },
       aiStorage: {
@@ -816,6 +817,84 @@ describe('resumeAIAgentSync', () => {
     ])
   })
 
+  test('an approver that loses the claim never runs the tool', async () => {
+    addTestAgent('claim-agent')
+    pikkuState(null, 'agent', 'agentsMeta')['claim-agent'].tools = ['refund']
+    pikkuState(null, 'rpc', 'meta').refund = 'refund'
+    pikkuState(null, 'function', 'meta').refund = {
+      description: 'Refund',
+      sessionless: true,
+    }
+
+    let executions = 0
+    pikkuState(null, 'function', 'functions').set('refund', {
+      func: async () => {
+        executions++
+        return { refunded: true }
+      },
+    })
+
+    const run: AgentRunState = {
+      runId: 'run-claim',
+      agentName: 'claim-agent',
+      threadId: 'thread-claim',
+      resourceId: 'resource-claim',
+      status: 'suspended',
+      suspendReason: 'approval',
+      pendingApprovals: [
+        {
+          type: 'tool-call',
+          toolCallId: 'tc-claim',
+          toolName: 'refund',
+          args: {},
+        },
+      ],
+      usage: { inputTokens: 0, outputTokens: 0, model: 'test/test-model' },
+      createdAt: new Date(),
+      updatedAt: new Date(),
+    }
+
+    // Every concurrent approver reads the same `suspended` run with the same
+    // pending list; the store hands the claim to exactly one of them.
+    let claimsLeft = 1
+    pikkuState(null, 'package', 'singletonServices', {
+      logger: {
+        info: () => {},
+        warn: () => {},
+        error: () => {},
+        debug: () => {},
+      },
+      aiAgentRunner: {
+        run: async (): Promise<AIAgentStepResult> =>
+          makeStepResult({
+            text: 'Refunded',
+            usage: { inputTokens: 1, outputTokens: 1 },
+          }),
+      },
+      aiRunState: {
+        getRun: async () => run,
+        createRun: async () => 'unused',
+        updateRun: async () => {},
+        resolveApproval: async () => claimsLeft-- > 0,
+      },
+      aiStorage: {
+        saveMessages: async () => {},
+        getMessages: async () => [],
+      },
+    } as any)
+
+    const approvals = [{ toolCallId: 'tc-claim', approved: true }]
+    await resumeAIAgentSync('run-claim', approvals, asOwner('resource-claim'))
+    assert.equal(executions, 1, 'the winner ran the tool once')
+
+    await assert.rejects(
+      () =>
+        resumeAIAgentSync('run-claim', approvals, asOwner('resource-claim')),
+      /already resolved by another caller/
+    )
+    assert.equal(executions, 1, 'the loser did not run it a second time')
+  })
+
   test('records denied approvals and rejects agent mismatches', async () => {
     addTestAgent('resume-agent')
 
@@ -861,6 +940,7 @@ describe('resumeAIAgentSync', () => {
         updateRun: async () => {},
         resolveApproval: async (toolCallId: string, status: string) => {
           resolveCalls.push({ toolCallId, status })
+          return true
         },
       },
       aiStorage: {
@@ -959,7 +1039,7 @@ describe('resumeAIAgentSync', () => {
       },
       aiRunState: {
         getRun: async () => run,
-        resolveApproval: async () => {},
+        resolveApproval: async () => true,
         updateRun: async () => {},
       },
       aiStorage: {

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

@@ -43,6 +43,12 @@ import {
   trackToolExecution,
 } from './ai-agent-interrupt.js'
 import { pikkuState, getSingletonServices } from '../../pikku-state.js'
+import {
+  applyInputMiddleware,
+  describeApprovals,
+  notifyAfterStep,
+  toAccumulatedStep,
+} from './ai-agent-turn.js'
 import { resolveModelConfig } from './ai-agent-model-config.js'
 import { AIProviderNotConfiguredError } from '../../errors/errors.js'
 import { randomUUID } from './ai-agent-utils.js'
@@ -147,26 +153,20 @@ export async function runAIAgent(
   // One bag per run, shared by every middleware — see PikkuAIMiddlewareHooks.
   const sharedNotes: Record<string, unknown> = {}
 
-  let modifiedMessages = runnerParams.messages
-  let modifiedInstructions = runnerParams.instructions
-  for (const mw of aiMiddlewares) {
-    if (mw.modifyInput) {
-      const result = await mw.modifyInput(singletonServices, {
-        messages: modifiedMessages,
-        instructions: modifiedInstructions,
-        shared: sharedNotes,
-      })
-      modifiedMessages = result.messages
-      modifiedInstructions = result.instructions
-    }
-  }
+  const { messages: modifiedMessages, instructions: modifiedInstructions } =
+    await applyInputMiddleware(
+      aiMiddlewares,
+      singletonServices,
+      {
+        messages: runnerParams.messages,
+        instructions: runnerParams.instructions,
+      },
+      sharedNotes
+    )
   runnerParams.messages = modifiedMessages
   runnerParams.instructions = modifiedInstructions
 
-  // History records what the model was asked, which for a spoken turn is the
-  // transcript rather than the base64 audio that arrived — see the same note on
-  // the streaming path. Identity-checked, because a middleware may legitimately
-  // replace the message list with something unrelated to this turn.
+  // knowledge: decisions/internals/thread-history-records-the-transcript-not-the-audio.md
   const lastModified = modifiedMessages[modifiedMessages.length - 1]
   const persistedUserMessage =
     lastModified?.id === userMessage.id ? lastModified : userMessage
@@ -181,10 +181,7 @@ export async function runAIAgent(
     updatedAt: new Date(),
   })
 
-  // Registered on the same terms as `streamAIAgent`. A run created here is
-  // visible to `interruptAIAgent` through `aiRunState` either way, so skipping
-  // this would leave that call finding the run, passing the ownership check and
-  // then failing to stop it — reported as if it were running on another host.
+  // knowledge: decisions/internals/a-non-streaming-agent-run-registers-with-airunstate-too.md
   const interruptHandle = registerInterruptibleRun(runId)
   runnerParams.abortSignal = interruptHandle.signal
   runnerParams.tools = trackToolExecution(runnerParams.tools, interruptHandle)
@@ -216,52 +213,15 @@ export async function runAIAgent(
       totalUsage.inputTokens += stepResult.usage.inputTokens
       totalUsage.outputTokens += stepResult.usage.outputTokens
 
-      for (const mw of aiMiddlewares) {
-        if (mw.afterStep) {
-          await mw.afterStep(singletonServices, {
-            stepNumber: step,
-            text: stepResult.text,
-            toolCalls: stepResult.toolCalls,
-            toolResults: stepResult.toolResults,
-            usage: stepResult.usage,
-            finishReason: stepResult.finishReason,
-          })
-        }
-      }
+      await notifyAfterStep(aiMiddlewares, singletonServices, step, stepResult)
 
-      accumulatedSteps.push({
-        usage: stepResult.usage,
-        toolCalls: stepResult.toolCalls.map((tc) => {
-          const tr = stepResult.toolResults.find(
-            (r) => r.toolCallId === tc.toolCallId
-          )
-          return {
-            name: tc.toolName,
-            args: tc.args as Record<string, unknown>,
-            result:
-              typeof tr?.result === 'string'
-                ? tr.result
-                : JSON.stringify(tr?.result ?? ''),
-          }
-        }),
-      })
+      accumulatedSteps.push(toAccumulatedStep(stepResult))
 
       if (stepResult.toolCalls.length === 0) break
 
       const approvalsNeeded = checkForApprovals(stepResult, runnerParams.tools)
       if (approvalsNeeded.length > 0) {
-        for (const approval of approvalsNeeded) {
-          const toolDef = runnerParams.tools.find(
-            (t) => t.name === approval.toolName
-          )
-          if (toolDef?.approvalDescriptionFn && !approval.reason) {
-            try {
-              approval.reason = await toolDef.approvalDescriptionFn(
-                approval.args
-              )
-            } catch {}
-          }
-        }
+        await describeApprovals(approvalsNeeded, runnerParams.tools)
 
         const pendingApprovals = approvalsNeeded.map((a) =>
           a.agentRunId
@@ -385,10 +345,7 @@ export async function runAIAgent(
       usage: totalUsage,
     }
   } catch (error) {
-    // An interrupt is not a failure, so it skips the `onError` hooks and never
-    // becomes an `errorMessage`. Unlike the streaming path there is no partial
-    // reply to hand back — nothing was delivered — so the caller gets a typed
-    // throw it can tell apart from a provider outage instead of a result.
+    // knowledge: decisions/internals/an-agent-interrupt-is-not-a-failure.md
     const interruption = interruptHandle.interruption
     if (interruption || isAbortError(error)) {
       await aiRunState.updateRun(runId, { status: 'interrupted' })
@@ -470,11 +427,24 @@ export async function resumeAIAgentSync(
 
   const savedPendingApprovals = [...(run.pendingApprovals ?? [])]
 
+  // The read above is not a claim — concurrent resumes all see the same pending
+  // list. `resolveApproval` is the claim, and only the caller it returns true
+  // for may run the tool.
+  const claimedIds = new Set<string>()
   for (const { toolCallId, approved } of approvals) {
-    await aiRunState.resolveApproval(
+    const claimed = await aiRunState.resolveApproval(
       toolCallId,
       approved ? 'approved' : 'denied'
     )
+    if (claimed) {
+      claimedIds.add(toolCallId)
+    }
+  }
+
+  if (approvals.length > 0 && claimedIds.size === 0) {
+    throw new Error(
+      `Approvals for run ${runId} were already resolved by another caller`
+    )
   }
 
   const { tools } = await buildToolDefs(
@@ -498,6 +468,8 @@ export async function resumeAIAgentSync(
     if (pending.type !== 'tool-call') continue
 
     const toolCallId = pending.toolCallId
+    if (!claimedIds.has(toolCallId)) continue
+
     let resultStr: string
 
     if (rejectedIds.has(toolCallId)) {
@@ -623,19 +595,13 @@ async function continueAfterToolResultSync(
   // One bag per run, shared by every middleware — see PikkuAIMiddlewareHooks.
   const sharedNotes: Record<string, unknown> = {}
 
-  let modifiedMessages = trimmedMessages
-  let modifiedInstructions = instructions
-  for (const mw of aiMiddlewares) {
-    if (mw.modifyInput) {
-      const result = await mw.modifyInput(singletonServices, {
-        messages: modifiedMessages,
-        instructions: modifiedInstructions,
-        shared: sharedNotes,
-      })
-      modifiedMessages = result.messages
-      modifiedInstructions = result.instructions
-    }
-  }
+  const { messages: modifiedMessages, instructions: modifiedInstructions } =
+    await applyInputMiddleware(
+      aiMiddlewares,
+      singletonServices,
+      { messages: trimmedMessages, instructions: instructions },
+      sharedNotes
+    )
 
   const { tools: resumeTools } = await buildToolDefs(
     params,
@@ -684,52 +650,15 @@ async function continueAfterToolResultSync(
       totalUsage.inputTokens += stepResult.usage.inputTokens
       totalUsage.outputTokens += stepResult.usage.outputTokens
 
-      for (const mw of aiMiddlewares) {
-        if (mw.afterStep) {
-          await mw.afterStep(singletonServices, {
-            stepNumber: step,
-            text: stepResult.text,
-            toolCalls: stepResult.toolCalls,
-            toolResults: stepResult.toolResults,
-            usage: stepResult.usage,
-            finishReason: stepResult.finishReason,
-          })
-        }
-      }
+      await notifyAfterStep(aiMiddlewares, singletonServices, step, stepResult)
 
-      accumulatedSteps.push({
-        usage: stepResult.usage,
-        toolCalls: stepResult.toolCalls.map((tc) => {
-          const tr = stepResult.toolResults.find(
-            (r) => r.toolCallId === tc.toolCallId
-          )
-          return {
-            name: tc.toolName,
-            args: tc.args as Record<string, unknown>,
-            result:
-              typeof tr?.result === 'string'
-                ? tr.result
-                : JSON.stringify(tr?.result ?? ''),
-          }
-        }),
-      })
+      accumulatedSteps.push(toAccumulatedStep(stepResult))
 
       if (stepResult.toolCalls.length === 0) break
 
       const approvalsNeeded = checkForApprovals(stepResult, runnerParams.tools)
       if (approvalsNeeded.length > 0) {
-        for (const approval of approvalsNeeded) {
-          const toolDef = runnerParams.tools.find(
-            (t) => t.name === approval.toolName
-          )
-          if (toolDef?.approvalDescriptionFn && !approval.reason) {
-            try {
-              approval.reason = await toolDef.approvalDescriptionFn(
-                approval.args
-              )
-            } catch {}
-          }
-        }
+        await describeApprovals(approvalsNeeded, runnerParams.tools)
 
         const pendingApprovals = approvalsNeeded.map((a) =>
           a.agentRunId
@@ -832,7 +761,7 @@ async function continueAfterToolResultSync(
       run.threadId,
       run.resourceId,
       memoryConfig,
-      null as any,
+      null,
       {
         ...result,
         text: outputText,

package/src/wirings/ai-agent/ai-agent-stream.test.ts

@@ -1629,6 +1629,7 @@ describe('resumeAIAgent', () => {
         getRun: async () => remainingRun,
         resolveApproval: async (toolCallId: string, status: string) => {
           resolveCalls.push({ toolCallId, status })
+          return true
         },
         updateRun: async (_runId: string, patch: any) => {
           updates.push(patch)
@@ -1750,6 +1751,7 @@ describe('resumeAIAgent', () => {
         },
         resolveApproval: async (toolCallId: string, status: string) => {
           resolveCalls.push({ toolCallId, status })
+          return true
         },
         updateRun: async (_runId: string, patch: any) => {
           updates.push(patch)

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

@@ -10,6 +10,7 @@ import type {
   AIAgentMemoryConfig,
 } from './ai-agent.types.js'
 import { pikkuState, getSingletonServices } from '../../pikku-state.js'
+import { applyInputMiddleware } from './ai-agent-turn.js'
 import { AIProviderNotConfiguredError } from '../../errors/errors.js'
 import { randomUUID } from './ai-agent-utils.js'
 import { SPOKEN_TRANSCRIPT } from './voice-input.js'
@@ -676,38 +677,26 @@ export async function streamAIAgent(
   // One bag per run, shared by every middleware — see PikkuAIMiddlewareHooks.
   const sharedNotes: Record<string, unknown> = {}
 
-  let modifiedMessages = runnerParams.messages
-  let modifiedInstructions = runnerParams.instructions
-  for (const mw of aiMiddlewares) {
-    if (mw.modifyInput) {
-      const result = await mw.modifyInput(singletonServices, {
-        messages: modifiedMessages,
-        instructions: modifiedInstructions,
-        shared: sharedNotes,
-      })
-      modifiedMessages = result.messages
-      modifiedInstructions = result.instructions
-    }
-  }
+  const { messages: modifiedMessages, instructions: modifiedInstructions } =
+    await applyInputMiddleware(
+      aiMiddlewares,
+      singletonServices,
+      {
+        messages: runnerParams.messages,
+        instructions: runnerParams.instructions,
+      },
+      sharedNotes
+    )
   runnerParams.messages = modifiedMessages
   runnerParams.instructions = modifiedInstructions
 
-  // Sent on the raw channel, ahead of the run. A voice client sent audio and so
-  // has no idea what it said; until this arrives its own message is a blank
-  // bubble. Ahead of the run rather than alongside it because the answer starts
-  // streaming within a few hundred milliseconds, and a question that appears
-  // after its answer reads as the wrong question.
+  // knowledge: decisions/internals/the-transcript-event-is-sent-ahead-of-the-run.md
   const transcript = sharedNotes[SPOKEN_TRANSCRIPT]
   if (typeof transcript === 'string') {
     channel.send({ type: 'transcript', text: transcript })
   }
 
-  // What goes into thread history is what the model was actually asked. For a
-  // spoken turn that is not what arrived over the wire: the wire carried a
-  // base64 audio blob, and persisting it would write megabytes of unreadable
-  // data into the history while losing the only readable record of the turn.
-  // Identity-checked rather than assumed — a middleware is free to rewrite the
-  // message list into something with no relation to the turn.
+  // knowledge: decisions/internals/thread-history-records-the-transcript-not-the-audio.md
   const lastModified = modifiedMessages[modifiedMessages.length - 1]
   const persistedUserMessage =
     lastModified?.id === userMessage.id ? lastModified : userMessage
@@ -768,7 +757,7 @@ export async function streamAIAgent(
     {
       wireInheritedChannelMiddleware: meta?.channelMiddleware,
       wireChannelMiddleware: [
-        ...((agent.channelMiddleware as any[]) ?? []),
+        ...(agent.channelMiddleware ?? []),
         ...streamMiddleware,
       ],
     }
@@ -792,10 +781,7 @@ export async function streamAIAgent(
 
   const credentialFilteredChannel: AIStreamChannel = {
     ...wrappedChannel,
-    // Returns what the inner send returns. Middleware runs asynchronously, so
-    // swallowing the promise here makes every `await channel.send(...)` upstream
-    // a no-op — including the one that waits for a buffering hook to flush
-    // before the channel closes.
+    // knowledge: decisions/internals/an-agent-stream-send-must-return-the-inner-sends-promise.md
     send: (event: AIStreamEvent) => {
       if (
         event.type === 'tool-result' &&
@@ -872,11 +858,7 @@ export async function streamAIAgent(
       runId
     )
 
-    // Through the middleware rather than straight at the channel, and awaited.
-    // `done` is the only signal a stream hook gets that the reply is over, and
-    // the ones that buffer need it: `voiceOutput` speaks a trailing fragment
-    // that never reached a full stop, and waits for audio it has already paid
-    // to synthesize. Sent raw, that work is discarded by the `close()` below.
+    // knowledge: decisions/internals/the-agent-done-event-goes-through-the-middleware-and-is-awaited.md
     await outputChannel.send({ type: 'done' })
     channel.close()
     return persistingChannel.fullText
@@ -979,12 +961,7 @@ export async function interruptAIAgent(
     reason: input.reason ?? 'user',
   })
 
-  // A run still marked `running` that this process cannot abort is executing on
-  // another instance. Returning a bare `false` there is indistinguishable from
-  // "it already finished", so the one deployment shape this registry does not
-  // cover fails silently — an agent that simply refuses to shut up, with nothing
-  // in the logs. Say so instead. See `signalRunInterrupt` for the fix (fan the
-  // interrupt out over eventHub so every instance tries locally).
+  // knowledge: decisions/internals/an-agent-run-owned-by-another-instance-says-so.md
   if (!stopped && run.status === 'running') {
     logger?.warn(
       `Could not interrupt run ${input.runId}: it is running in another process. ` +
@@ -1037,10 +1014,18 @@ export async function resumeAIAgent(
 
   await assertAgentAuthorized(agent, params, packageName)
 
-  await aiRunState.resolveApproval(
+  // The read above is not a claim — concurrent resumes all see the same pending
+  // approval. `resolveApproval` is the claim, and the loser must not go on to
+  // run the tool a second time.
+  const claimed = await aiRunState.resolveApproval(
     input.toolCallId,
     input.approved ? 'approved' : 'denied'
   )
+  if (!claimed) {
+    throw new Error(
+      `Approval for toolCallId ${input.toolCallId} was already resolved by another caller`
+    )
+  }
 
   const { storage } = resolveMemoryServices(agent, singletonServices)
   const memoryConfig = agent.memory
@@ -1317,24 +1302,15 @@ async function continueAfterToolResult(
   // One bag per run, shared by every middleware — see PikkuAIMiddlewareHooks.
   const sharedNotes: Record<string, unknown> = {}
 
-  let modifiedMessages = trimmedMessages
-  let modifiedInstructions = instructions
-  for (const mw of aiMiddlewares) {
-    if (mw.modifyInput) {
-      const result = await mw.modifyInput(singletonServices, {
-        messages: modifiedMessages,
-        instructions: modifiedInstructions,
-        shared: sharedNotes,
-      })
-      modifiedMessages = result.messages
-      modifiedInstructions = result.instructions
-    }
-  }
+  const { messages: modifiedMessages, instructions: modifiedInstructions } =
+    await applyInputMiddleware(
+      aiMiddlewares,
+      singletonServices,
+      { messages: trimmedMessages, instructions: instructions },
+      sharedNotes
+    )
 
-  // Resuming is as interruptible as the first turn. It is the same person
-  // listening to the same voice, and after an approval it is where most of the
-  // reply actually gets spoken — an approved delete is followed by the agent
-  // talking about it, and that is a normal thing to talk over.
+  // knowledge: decisions/internals/a-resumed-agent-turn-is-as-interruptible-as-the-first.md
   const interruptHandle = registerInterruptibleRun(run.runId)
 
   const streamMiddleware = aiMiddlewares
@@ -1369,7 +1345,7 @@ async function continueAfterToolResult(
     {
       wireInheritedChannelMiddleware: meta?.channelMiddleware,
       wireChannelMiddleware: [
-        ...((agent.channelMiddleware as any[]) ?? []),
+        ...(agent.channelMiddleware ?? []),
         ...streamMiddleware,
       ],
     }
@@ -1467,10 +1443,7 @@ async function continueAfterToolResult(
       run.runId
     )
 
-    // Through the middleware, for the same reason as the first turn — and it
-    // matters more here. After an approval, most of what gets spoken is the
-    // agent talking about what it just did, so this is the half of the reply a
-    // dropped flush would silence.
+    // knowledge: decisions/internals/the-agent-done-event-goes-through-the-middleware-and-is-awaited.md
     await wrappedChannel.send({ type: 'done' })
     channel.close()
   } catch (err) {

package/src/wirings/ai-agent/ai-agent-thread-ownership.test.ts

@@ -114,7 +114,7 @@ const createHarness = (
         ],
         messages: [],
       }),
-      resolveApproval: async () => {},
+      resolveApproval: async () => true,
     },
   } as any)