@pikku/core 0.12.79 → 0.12.80

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)
 

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

@@ -0,0 +1,121 @@
+import type { CoreSingletonServices } from '../../types/core.types.js'
+import type { PikkuAIMiddlewareHooks } from './ai-agent.types.js'
+
+/** Exactly what `modifyInput` accepts and returns, taken from the hook itself. */
+type TurnInput = Pick<
+  Parameters<NonNullable<PikkuAIMiddlewareHooks['modifyInput']>>[1],
+  'messages' | 'instructions'
+>
+
+/**
+ * Run every `modifyInput` hook in order, threading each result into the next.
+ *
+ * Shared by the four places a turn starts — first turn and resume, on both the
+ * streaming and non-streaming paths. `sharedNotes` is one bag per run that the
+ * caller keeps, because hooks use it to pass things forward (`voiceInput`
+ * leaves the transcript there for `voiceOutput`).
+ */
+export const applyInputMiddleware = async (
+  aiMiddlewares: PikkuAIMiddlewareHooks[],
+  singletonServices: CoreSingletonServices,
+  input: TurnInput,
+  sharedNotes: Record<string, unknown>
+): Promise<TurnInput> => {
+  let { messages, instructions } = input
+  for (const mw of aiMiddlewares) {
+    if (!mw.modifyInput) continue
+    const result = await mw.modifyInput(singletonServices, {
+      messages,
+      instructions,
+      shared: sharedNotes,
+    })
+    messages = result.messages
+    instructions = result.instructions
+  }
+  return { messages, instructions }
+}
+
+/** The step fields both agent paths hand to `afterStep`, taken from the hook. */
+type StepResult = Omit<
+  Parameters<NonNullable<PikkuAIMiddlewareHooks['afterStep']>>[1],
+  'stepNumber'
+>
+
+/**
+ * Notify every `afterStep` hook. The payload is the step verbatim plus its
+ * ordinal — a hook that wants the run's totals accumulates them itself.
+ */
+export const notifyAfterStep = async (
+  aiMiddlewares: PikkuAIMiddlewareHooks[],
+  singletonServices: CoreSingletonServices,
+  stepNumber: number,
+  stepResult: StepResult
+): Promise<void> => {
+  for (const mw of aiMiddlewares) {
+    if (!mw.afterStep) continue
+    await mw.afterStep(singletonServices, {
+      stepNumber,
+      text: stepResult.text,
+      toolCalls: stepResult.toolCalls,
+      toolResults: stepResult.toolResults,
+      usage: stepResult.usage,
+      finishReason: stepResult.finishReason,
+    })
+  }
+}
+
+/**
+ * The step shape kept on the run: each tool call paired with its result.
+ *
+ * A result is stringified unless it already is a string, because this is what
+ * gets persisted and read back as history — an object there is unreadable.
+ */
+export const toAccumulatedStep = (stepResult: StepResult) => ({
+  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 ?? ''),
+    }
+  }),
+})
+
+type PendingApproval = {
+  toolName: string
+  args: unknown
+  reason?: string
+}
+
+type ToolDef = {
+  name: string
+  approvalDescriptionFn?: (args: any) => Promise<string> | string
+}
+
+/**
+ * Fill in each approval's human-readable reason from the tool's own
+ * `approvalDescriptionFn`, where it did not supply one.
+ *
+ * A description that throws is swallowed: the approval still has to be raised,
+ * and a gate that disappears because its label failed to render is the worst
+ * available outcome.
+ */
+export const describeApprovals = async (
+  approvals: PendingApproval[],
+  tools: ToolDef[]
+): Promise<void> => {
+  for (const approval of approvals) {
+    if (approval.reason) continue
+    const toolDef = tools.find((t) => t.name === approval.toolName)
+    if (!toolDef?.approvalDescriptionFn) continue
+    try {
+      approval.reason = await toolDef.approvalDescriptionFn(approval.args)
+    } catch {}
+  }
+}

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

@@ -413,7 +413,7 @@ export type AIStreamEvent =
       toolName: string
       args: unknown
       reason?: string
-      runId?: string
+      runId: string
       agent?: string
       session?: string
     }

package/src/wirings/ai-agent/voice-input.ts

@@ -164,12 +164,7 @@ export const voiceInput = (config?: {
       // to send, and a message with no content is not a question.
       if (updatedContent.length === 0) throw new NoSpeechDetectedError()
 
-      // Only when something was actually heard. A turn can carry audio that all
-      // reads as non-speech and still have content — an image with a silent
-      // caption clip — which leaves nothing above to throw. Recording `''` here
-      // would send a transcript event saying the user said nothing, and a client
-      // that tells "not transcribed yet" from "transcribed" by the key being
-      // absent would render the turn as an empty bubble rather than a pending one.
+      // knowledge: decisions/internals/an-empty-transcript-is-not-recorded.md
       if (heard.length > 0) {
         shared[SPOKEN_TRANSCRIPT] = heard.join(' ')
       }

package/src/wirings/ai-agent/voice-output.ts

@@ -206,11 +206,7 @@ export const voiceOutput = (config?: {
       }
       if (!aiAgentRunner?.generateSpeech) return event
 
-      // Only an explicit `false` silences the reply. `voiceInput` sets this on
-      // every turn it handles, so `false` means a real user really typed; the
-      // key being absent means nothing reported either way — no voice input is
-      // wired — and that caller's replies are spoken exactly as they were before
-      // this option existed.
+      // knowledge: decisions/internals/voice-output-speaks-unless-voice-input-explicitly-says-otherwise.md
       if (!config?.always && shared[SPOKEN_TURN] === false) return event
 
       /**
@@ -228,13 +224,7 @@ export const voiceOutput = (config?: {
           )
         }
 
-        // Checked per sentence but announced once per reply: a bilingual answer
-        // should still speak the half it can, and repeating the notice for
-        // every sentence of a long one would bury the reply itself.
-        //
-        // Per sentence is also what makes the voice right. A reply that answers
-        // in English and then quotes a Chinese title is two sentences in two
-        // scripts, and each is synthesized in the voice its own script needs.
+        // knowledge: decisions/internals/speech-synthesis-picks-a-voice-per-sentence-and-warns-once.md
         let voice = config.voice
         if (config.speakableScripts) {
           const unspeakable = unspeakableScripts(text, config.speakableScripts)

package/src/wirings/channel/channel-common.ts

@@ -1,3 +1,4 @@
+import type { CorePikkuChannelMiddleware } from './channel.types.js'
 import type {
   CoreSingletonServices,
   CorePikkuMiddleware,
@@ -61,7 +62,9 @@ export const runChannelLifecycleWithMiddleware = async ({
     `${channelConfig.name}:${lifecycleType}:cm`,
     {
       wireInheritedChannelMiddleware: channelMiddlewareMeta,
-      wireChannelMiddleware: channelConfig.channelMiddleware as any,
+      // knowledge: questions/channel-middleware-accepts-bare-factories-that-nothing-resolves.md
+      wireChannelMiddleware:
+        channelConfig.channelMiddleware as CorePikkuChannelMiddleware[],
     }
   )
 
@@ -76,7 +79,7 @@ export const runChannelLifecycleWithMiddleware = async ({
   const runLifecycle = async () => {
     return await runPikkuFunc('channel', channelConfig.name, meta.pikkuFuncId, {
       singletonServices: services,
-      data: () => data as any,
+      data: () => data,
       wire,
       sessionService: userSession,
       tags: meta.tags ?? [],

package/src/wirings/channel/channel-handler-shapes.test.ts

@@ -0,0 +1,72 @@
+import { describe, test } from 'node:test'
+import assert from 'node:assert/strict'
+
+import { pikkuState, resetPikkuState } from '../../pikku-state.js'
+import { wireChannel } from './channel-runner.js'
+
+const registeredFunc = (funcId: string) =>
+  pikkuState(null, 'function', 'functions').get(funcId)
+
+const wire = (channel: any) => {
+  resetPikkuState()
+  pikkuState(null, 'channel', 'meta', {
+    shapes: {
+      name: 'shapes',
+      route: '/shapes',
+      input: null,
+      connect: { pikkuFuncId: 'shapes__connect' },
+      disconnect: { pikkuFuncId: 'shapes__disconnect' },
+      message: { pikkuFuncId: 'shapes__message' },
+      messageWirings: {},
+    },
+  } as any)
+  wireChannel({ name: 'shapes', route: '/shapes', ...channel })
+}
+
+/**
+ * knowledge: decisions/internals/channel-message-handlers-accept-three-config-shapes.md
+ */
+describe('every channel handler shape registers a callable function config', () => {
+  const handler = async () => undefined
+
+  test('a direct function config registers as-is', () => {
+    wire({ onConnect: { func: handler } })
+
+    assert.equal(typeof registeredFunc('shapes__connect')?.func, 'function')
+  })
+
+  test('a wrapper around a function config registers the inner config', () => {
+    wire({ onConnect: { func: { func: handler }, middleware: [] } })
+
+    // Registering the wrapper itself leaves `.func` an object, and the function
+    // runner calls `.func(...)` — that is a TypeError at connect time.
+    assert.equal(
+      typeof registeredFunc('shapes__connect')?.func,
+      'function',
+      'the wrapper was registered instead of the config it wraps'
+    )
+  })
+
+  test('onDisconnect unwraps the same way', () => {
+    wire({ onDisconnect: { func: { func: handler }, middleware: [] } })
+
+    assert.equal(typeof registeredFunc('shapes__disconnect')?.func, 'function')
+  })
+
+  test('onMessage unwraps the same way', () => {
+    wire({ onMessage: { func: { func: handler } } })
+
+    assert.equal(typeof registeredFunc('shapes__message')?.func, 'function')
+  })
+
+  test('a simple wrapper — a function plus sibling middleware — stays whole', () => {
+    wire({ onConnect: { func: handler, middleware: [] } })
+
+    const registered = registeredFunc('shapes__connect')
+    assert.equal(typeof registered?.func, 'function')
+    assert.ok(
+      'middleware' in (registered as object),
+      'the sibling middleware must survive registration'
+    )
+  })
+})

package/src/wirings/channel/channel-handler.ts

@@ -4,6 +4,7 @@ import type {
   CoreUserSession,
 } from '../../types/core.types.js'
 import type {
+  CorePikkuChannelMiddleware,
   BinaryData,
   ChannelMessageMeta,
   CoreChannel,
@@ -94,7 +95,7 @@ export const processMessageHandlers = (
       logger.error(
         `Channel ${channelConfig.name} with id ${channelHandler.getChannel().channelId} requires a session for ${routeMessage}. No session is attached to this websocket connection. Ensure auth middleware establishes a session during websocket upgrade, and configure sessionStore when the runtime needs persisted sessions.`
       )
-      // TODO: Send error message back breaks typescript, but should be implemented somehow
+      // knowledge: questions/unauthorized-channel-replies-escape-the-declared-out-type.md
       channelHandler.getChannel().send(`Unauthorized for ${routeMessage}`)
       return
     }
@@ -111,10 +112,7 @@ export const processMessageHandlers = (
     // Get wire middleware: channel-level middleware + message-specific middleware
     const channelWireMiddleware = channelConfig.middleware || []
 
-    // Check if onMessage is a wrapper object vs direct function config:
-    // - Direct config: onMessage.func is a plain Function
-    // - Wrapper: onMessage.func is a CorePikkuFunctionConfig (has onMessage.func.func)
-    // - Simple wrapper: onMessage has both func (plain Function) and middleware properties
+    // knowledge: decisions/internals/channel-message-handlers-accept-three-config-shapes.md
     const isWrapper =
       onMessage &&
       typeof onMessage === 'object' &&
@@ -145,7 +143,9 @@ export const processMessageHandlers = (
       inheritedMiddleware,
       wireMiddleware,
       inheritedChannelMiddleware: channelMeta?.channelMiddleware,
-      wireChannelMiddleware: wireChannelMiddleware as any,
+      // knowledge: questions/channel-middleware-accepts-bare-factories-that-nothing-resolves.md
+      wireChannelMiddleware:
+        wireChannelMiddleware as CorePikkuChannelMiddleware[],
       coerceDataFromSchema: true,
       tags: channelConfig.tags,
       sessionService: userSession,
@@ -191,7 +191,7 @@ export const processMessageHandlers = (
 
             processed = true
             const routeResult = await processMessage(
-              data as any,
+              data,
               routes[routerValue],
               routingProperty,
               routerValue

package/src/wirings/channel/channel-rpc-service.ts

@@ -10,20 +10,6 @@ import {
   type ChannelRPCValidator,
 } from './channel-rpc.types.js'
 
-/**
- * `remote` for channels that only ever flow one way — a server-sent stream, an
- * agent's output, a local CLI. Nothing is listening for a request on them, so
- * the call is refused rather than waiting out a timeout.
- */
-export const unsupportedChannelRemote = async (
-  funcName: string
-): Promise<never> => {
-  throw new ChannelRPCError(
-    `Cannot call "${funcName}" remotely: this channel has no peer that answers`,
-    'unsupported'
-  )
-}
-
 /**
  * A `DeploymentService` whose transport is an open channel rather than an
  * address, so a server-side function can call back into a peer that has no

package/src/wirings/channel/channel-rpc.test.ts

@@ -109,21 +109,42 @@ describe('ChannelRPCRegistry', () => {
     })
   })
 
-  test('times out instead of hanging forever', async () => {
+  /**
+   * The registry unrefs its timeout timer so an in-flight call can never hold
+   * a process open. That makes the timeout unawaitable in a test: when the
+   * pending call is the only thing left, the loop drains before the timer
+   * fires, and node:test cancels the file — taking every later test with it.
+   *
+   * Driving the clock by hand removes the dependency on real time entirely.
+   * `t.mock.timers` is scoped to the test and resets itself, so the tests that
+   * do want a real clock are unaffected.
+   *
+   * knowledge: decisions/internals/an-unref-d-timer-cannot-be-awaited-under-node-test.md
+   */
+  test('times out instead of hanging forever', async (t) => {
+    t.mock.timers.enable({ apis: ['setTimeout'] })
+
     const registry = new ChannelRPCRegistry(10)
     const call = registry.register()
 
-    await assert.rejects(call.promise, (e: ChannelRPCError) => {
+    const rejected = assert.rejects(call.promise, (e: ChannelRPCError) => {
       assert.equal(e.reason, 'timeout')
       return true
     })
+    t.mock.timers.tick(10)
+    await rejected
+
     assert.equal(registry.inFlight, 0, 'a timed out call is not leaked')
   })
 
-  test('drops a late response for an already-timed-out call', async () => {
+  test('drops a late response for an already-timed-out call', async (t) => {
+    t.mock.timers.enable({ apis: ['setTimeout'] })
+
     const registry = new ChannelRPCRegistry(10)
     const call = registry.register()
-    await assert.rejects(call.promise)
+    const rejected = assert.rejects(call.promise)
+    t.mock.timers.tick(10)
+    await rejected
 
     const settled = registry.settle({
       action: CHANNEL_RPC_RESPONSE,

package/src/wirings/channel/channel-rpc.types.ts

@@ -148,3 +148,17 @@ export type ChannelRPCValidator = (
   funcName: string,
   value: unknown
 ) => Promise<void> | void
+
+/**
+ * `remote` for wires with no peer that answers — a server-sent stream, an
+ * agent's output, a local CLI. Nothing is listening for a request on them, so
+ * the call is refused rather than waiting out a timeout.
+ */
+export const unsupportedChannelRemote = async (
+  funcName: string
+): Promise<never> => {
+  throw new ChannelRPCError(
+    `Cannot call "${funcName}" remotely: this channel has no peer that answers`,
+    'unsupported'
+  )
+}