@pikku/core 0.12.84 → 0.12.88

package/dist/wirings/addon/wire-addon.js

@@ -0,0 +1,120 @@
+import { pikkuState } from '../../pikku-state.js';
+import { getTagGroups } from '../../utils.js';
+export const wireAddon = (config) => {
+    pikkuState(null, 'addons', 'packages').set(config.name, {
+        package: config.package,
+        rpcEndpoint: config.rpcEndpoint,
+        auth: config.auth,
+        tags: config.tags,
+        ...(config.scopes ? { scopes: config.scopes } : {}),
+        ...(config.secretOverrides
+            ? { secretOverrides: config.secretOverrides }
+            : {}),
+        ...(config.variableOverrides
+            ? { variableOverrides: config.variableOverrides }
+            : {}),
+        ...(config.credentialOverrides
+            ? { credentialOverrides: config.credentialOverrides }
+            : {}),
+        ...(config.secretGrants ? { secretGrants: config.secretGrants } : {}),
+        ...(config.credentialGrants
+            ? { credentialGrants: config.credentialGrants }
+            : {}),
+        ...(config.globalSecrets ? { globalSecrets: config.globalSecrets } : {}),
+        ...(config.globalCredentials
+            ? { globalCredentials: config.globalCredentials }
+            : {}),
+    });
+};
+/**
+ * The addon configs a running function is governed by: the named instance when
+ * the caller resolved one, every instance of the package otherwise.
+ *
+ * knowledge: decisions/security/addon-scopes-are-resolved-where-the-function-runs.md
+ */
+const governingAddonConfigs = (packageName, namespace) => {
+    if (!packageName) {
+        return [];
+    }
+    const addons = pikkuState(null, 'addons', 'packages');
+    if (!addons) {
+        return [];
+    }
+    if (namespace) {
+        const config = addons.get(namespace);
+        if (config?.package === packageName) {
+            return [config];
+        }
+    }
+    return [...addons.values()].filter((config) => config?.package === packageName);
+};
+const unionOf = (packageName, namespace, field) => {
+    const values = new Set();
+    for (const config of governingAddonConfigs(packageName, namespace)) {
+        for (const value of config[field] ?? []) {
+            values.add(value);
+        }
+    }
+    return [...values];
+};
+/**
+ * knowledge: decisions/security/addon-scopes-are-resolved-where-the-function-runs.md
+ */
+export const resolveAddonScopes = (packageName, namespace) => unionOf(packageName, namespace, 'scopes');
+/**
+ * knowledge: decisions/security/addon-auth-and-tags-only-tighten.md
+ */
+export const resolveAddonTags = (packageName, namespace) => unionOf(packageName, namespace, 'tags');
+/**
+ * True when any governing instance requires a session. `auth: false` is not
+ * honoured here — on a direct wiring it would weaken the wiring's own gate.
+ *
+ * knowledge: decisions/security/addon-auth-and-tags-only-tighten.md
+ */
+export const resolveAddonAuth = (packageName, namespace) => governingAddonConfigs(packageName, namespace).some((config) => config.auth === true);
+/**
+ * The package a namespaced function id belongs to, and the name that package
+ * publishes it under.
+ *
+ * A wiring that points at an addon function through `ref('ns:fn')` records
+ * `ns:fn` as its own function id — the same id every other wire type records —
+ * but the addon publishes its metadata under the bare `fn`, in its own package
+ * state. Without this the wire finds the function it registered and no metadata
+ * to run it by.
+ *
+ * The wiring itself stays the consuming app's, so `packageName` is the package
+ * the *wire* runs in, not the target's: it is null for a `ref()` the app wired,
+ * and only narrows the lookup when a wire really does run inside the addon.
+ */
+export const resolveAddonFunctionTarget = (funcName, packageName) => {
+    const separator = funcName.indexOf(':');
+    if (separator === -1) {
+        return null;
+    }
+    const namespace = funcName.slice(0, separator);
+    const config = pikkuState(null, 'addons', 'packages').get(namespace);
+    if (!config) {
+        return null;
+    }
+    if (packageName && config.package !== packageName) {
+        return null;
+    }
+    return {
+        packageName: config.package,
+        localName: funcName.slice(separator + 1),
+    };
+};
+/**
+ * Addon tags name middleware the *consuming app* registered, so they resolve
+ * against the root tag groups rather than the addon package's own.
+ *
+ * knowledge: decisions/security/addon-auth-and-tags-only-tighten.md
+ */
+export const resolveAddonTagMiddleware = (packageName, namespace) => {
+    const tags = resolveAddonTags(packageName, namespace);
+    if (tags.length === 0) {
+        return [];
+    }
+    const tagGroups = pikkuState(null, 'middleware', 'tagGroup');
+    return tags.flatMap((tag) => getTagGroups(tagGroups, tag).flat());
+};

package/dist/wirings/addon/wire-remote-addon.d.ts

@@ -0,0 +1,22 @@
+import type { CoreServices, PikkuWire } from '../../types/core.types.js';
+/** Sent as `Authorization: Bearer <token>`; a non-default header is declared by the addon. */
+export type RemoteAddonAuth = {
+    credentialId: string;
+} | {
+    secretId: string;
+} | {
+    resolve: (services: CoreServices, wire: PikkuWire) => string | Promise<string>;
+};
+export type WireRemoteAddonConfig = {
+    /** Consumer-facing namespace, e.g. `registry` → `rpc('registry:getOpenApi')` */
+    name: string;
+    /** Must be installed as a devDependency — `pikku verify` enforces this. */
+    package: string;
+    serverUrl: string | ((services: CoreServices) => string | Promise<string>);
+    /** Omit when the addon declares its remote surface public. */
+    auth?: RemoteAddonAuth;
+    /** Map a consumer-facing fn name → the remote fn name, when they differ (rare). */
+    remoteName?: (fn: string) => string;
+    tags?: string[];
+};
+export declare const wireRemoteAddon: (config: WireRemoteAddonConfig) => void;

package/dist/wirings/addon/wire-remote-addon.js

@@ -0,0 +1,11 @@
+import { pikkuState } from '../../pikku-state.js';
+export const wireRemoteAddon = (config) => {
+    pikkuState(null, 'addons', 'packages').set(config.name, {
+        package: config.package,
+        tags: config.tags,
+        remote: true,
+        serverUrl: config.serverUrl,
+        ...(config.auth ? { remoteAuth: config.auth } : {}),
+        ...(config.remoteName ? { remoteName: config.remoteName } : {}),
+    });
+};

package/dist/wirings/agent/agent-memory.d.ts

@@ -8,6 +8,17 @@ export declare function resolveMemoryServices(agent: CoreAgent, singletonService
     storage: AgentStorageService | undefined;
 };
 export declare function isWorkingMemoryEnabled(memoryConfig: AgentMemoryConfig | undefined, storage: AgentStorageService | undefined): boolean;
+/**
+ * Merges a model-emitted working memory update into the stored state.
+ *
+ * Objects merge key by key, and `null` deletes a key. Arrays are replaced
+ * wholesale — deliberately, not as a side effect of the object guard below.
+ * The full state is echoed back to the model every turn by
+ * {@link buildWorkingMemoryPrompt}, so it can always re-emit an array in full,
+ * and appending instead would duplicate every item each time it did.
+ * `buildWorkingMemoryPrompt` states this contract to the model; the two must
+ * stay in agreement.
+ */
 export declare function deepMergeWorkingMemory(existing: Record<string, unknown>, updates: Record<string, unknown>): Record<string, unknown>;
 export declare function buildWorkingMemoryPrompt(currentState: Record<string, unknown> | null, jsonSchema?: Record<string, unknown>): string;
 export declare function loadContextMessages(memoryConfig: AgentMemoryConfig | undefined, storage: AgentStorageService | undefined, input: AgentInput, workingMemoryJsonSchema?: Record<string, unknown>): Promise<AgentMessage[]>;

package/dist/wirings/agent/agent-memory.js

@@ -11,6 +11,17 @@ export function resolveMemoryServices(agent, singletonServices) {
 export function isWorkingMemoryEnabled(memoryConfig, storage) {
     return !!memoryConfig?.workingMemory && !!storage;
 }
+/**
+ * Merges a model-emitted working memory update into the stored state.
+ *
+ * Objects merge key by key, and `null` deletes a key. Arrays are replaced
+ * wholesale — deliberately, not as a side effect of the object guard below.
+ * The full state is echoed back to the model every turn by
+ * {@link buildWorkingMemoryPrompt}, so it can always re-emit an array in full,
+ * and appending instead would duplicate every item each time it did.
+ * `buildWorkingMemoryPrompt` states this contract to the model; the two must
+ * stay in agreement.
+ */
 export function deepMergeWorkingMemory(existing, updates) {
     const result = { ...existing };
     for (const key of Object.keys(updates)) {
@@ -21,8 +32,10 @@ export function deepMergeWorkingMemory(existing, updates) {
         if (value === null) {
             delete result[key];
         }
+        else if (Array.isArray(value)) {
+            result[key] = value;
+        }
         else if (typeof value === 'object' &&
-            !Array.isArray(value) &&
             typeof result[key] === 'object' &&
             result[key] !== null &&
             !Array.isArray(result[key])) {
@@ -56,7 +69,9 @@ export function buildWorkingMemoryPrompt(currentState, jsonSchema) {
     parts.push('When you learn new information, output a partial JSON update in <working_memory> tags. ' +
         'Only include durable facts you have actually derived or the user has confirmed. ' +
         'Do not output templates, placeholders, or narration. ' +
-        'Only include changed fields. Leave unknown fields untouched. Set a field to null to delete it.');
+        'Only include changed fields. Leave unknown fields untouched. Set a field to null to delete it. ' +
+        'Arrays are replaced, not merged: to change one, repeat every item you want to keep alongside the new ones, ' +
+        'because any item you leave out is deleted.');
     return parts.join('\n\n');
 }
 export async function loadContextMessages(memoryConfig, storage, input, workingMemoryJsonSchema) {

package/dist/wirings/agent/agent-prepare.d.ts

@@ -1,4 +1,4 @@
-import type { CoreUserSession } from '../../types/core.types.js';
+import type { CoreUserSession, GetCredential } from '../../types/core.types.js';
 import type { CoreAgent, AgentInput, AgentToolDef, AgentMessage, AgentStreamChannel, PikkuAgentMiddlewareHooks, SessionScope } from './agent.types.js';
 import type { AgentRunnerParams } from '../../services/agent-runner-service.js';
 import { PikkuError } from '../../errors/error-handler.js';
@@ -6,7 +6,7 @@ import type { SessionService } from '../../services/user-session-service.js';
 export type RunAgentParams = {
     sessionService?: SessionService<CoreUserSession>;
     /** Credential accessor for the current request — used to read per-user overrides (e.g. AI_API_KEY). */
-    getCredential?: <T = unknown>(name: string) => T | null | Promise<T | null>;
+    getCredential?: GetCredential;
     /** Ephemeral owner identity minted for a sessionless request; never client-supplied, never reused across requests. */
     anonymousOwnerResourceId?: string;
 };
@@ -105,7 +105,7 @@ export declare function prepareAgentRun(agentName: string, input: AgentInput, pa
     packageName: string | null;
     resolvedName: string;
     agentRunner: import("../../services/agent-runner-service.js").AgentRunnerService;
-    storage: import("../../index.js").AgentStorageService | undefined;
+    storage: import("../../services/agent-storage-service.js").AgentStorageService | undefined;
     memoryConfig: import("./agent.types.js").AgentMemoryConfig | undefined;
     threadId: string;
     userMessage: AgentMessage;

package/dist/wirings/agent/agent-prepare.js

@@ -10,7 +10,7 @@ import { awaitPendingInterruptNote } from './agent-interrupt.js';
 import { streamAgent } from './agent-stream.js';
 import { runAgent } from './agent-runner.js';
 import { resolveNamespace, ContextAwareRPCService, } from '../../wirings/rpc/rpc-runner.js';
-import { getOrCreatePackageSingletonServices } from '../../wirings/rpc/addon-runner.js';
+import { getOrCreatePackageSingletonServices } from '../../wirings/addon/addon-runner.js';
 import { resolveMemoryServices, loadContextMessages, trimMessages, } from './agent-memory.js';
 import { resolveModelConfig } from './agent-model-config.js';
 export function resolveSessionPrincipal(params, sessionScope) {

package/dist/wirings/agent/agent-runner.js

@@ -7,7 +7,7 @@ import { applyInputMiddleware, describeApprovals, notifyAfterStep, toAccumulated
 import { applyOutputMiddleware, finalizeAgentRun, lastUserMessageText, } from './agent-finalize.js';
 import { resolveModelConfig } from './agent-model-config.js';
 import { AIProviderNotConfiguredError } from '../../errors/errors.js';
-import { randomUUID } from './agent-utils.js';
+import { deniedToolResult, randomUUID } from './agent-utils.js';
 function stripNulls(obj) {
     if (obj === null)
         return undefined;
@@ -306,8 +306,7 @@ export async function resumeAgentSync(runId, approvals, params, expectedAgentNam
         let resultStr;
         let toolError;
         if (rejectedIds.has(toolCallId)) {
-            resultStr =
-                'The user explicitly declined this action. Inform them that it was declined and do not retry.';
+            resultStr = deniedToolResult();
         }
         else if (approvedIds.has(toolCallId)) {
             const matchingTool = tools.find((t) => t.name === pending.toolName);

package/dist/wirings/agent/agent-stream.js

@@ -2,7 +2,7 @@ import { finalizeAgentRun, lastUserMessageText } from './agent-finalize.js';
 import { pikkuState, getSingletonServices } from '../../pikku-state.js';
 import { applyInputMiddleware } from './agent-turn.js';
 import { AIProviderNotConfiguredError } from '../../errors/errors.js';
-import { randomUUID } from './agent-utils.js';
+import { deniedToolResult, randomUUID } from './agent-utils.js';
 import { SPOKEN_TRANSCRIPT } from './voice-input.js';
 import { combineChannelMiddleware, wrapChannelWithMiddleware, } from '../channel/channel-middleware-runner.js';
 import { resolveMemoryServices, loadContextMessages, trimMessages, getWorkingMemoryMiddleware, } from './agent-memory.js';
@@ -203,6 +203,51 @@ async function postStreamCleanup(persistingChannel, agentRunState, runId, run) {
         usage: persistingChannel.totalUsage,
     });
 }
+/**
+ * Adapts `modifyOutputStream` hooks to channel middleware, one closure per
+ * hook so each keeps its own `state` and event log for the whole run.
+ */
+const toChannelStreamMiddleware = (hooks, sharedNotes, signal) => hooks
+    .filter((mw) => mw.modifyOutputStream)
+    .map((mw) => {
+    const state = {};
+    const allEvents = [];
+    return async (services, event, next) => {
+        allEvents.push(event);
+        const result = await mw.modifyOutputStream(services, {
+            event,
+            allEvents,
+            state,
+            shared: sharedNotes,
+            // Sends downstream directly, so a hook can hand back the fast event
+            // now and push the slow one when it is ready.
+            emit: next,
+            signal,
+        });
+        if (result == null)
+            return;
+        if (Array.isArray(result)) {
+            for (const r of result)
+                await next(r);
+        }
+        else {
+            await next(result);
+        }
+    };
+});
+/**
+ * The branch a delegating parent's own spoken text is routed down once it has
+ * handed off: the same working-memory hook instances as the main chain, so the
+ * in-band `<working_memory>` blocks are still collected, ending in a sink so
+ * neither the client, the thread history, nor user channel middleware sees
+ * text the parent was supposed to keep to itself.
+ *
+ * Routing at ingress rather than dropping further down the chain keeps the
+ * decision synchronous with the send: the working-memory hook is async, so a
+ * hand-off landing mid-flight would otherwise retroactively suppress text the
+ * parent spoke before it.
+ */
+const createWorkingMemoryOnlyChannel = (channel, services, workingMemoryMiddleware) => wrapChannelWithMiddleware({ channel: { ...channel, send: () => { } } }, services, workingMemoryMiddleware).channel;
 async function runStreamStepLoop(params) {
     const { agent, runnerParams, maxSteps, agentRunner, streamChannel, channel, agentMiddlewares, } = params;
     const singletonServices = getSingletonServices();
@@ -446,13 +491,14 @@ export async function streamAgent(agentName, input, channel, params, agentSessio
         channel.send({ type: 'done' });
         return '';
     }
+    const workingMemoryMiddleware = getWorkingMemoryMiddleware(memoryConfig, storage, {
+        threadId,
+        workingMemorySchemaName,
+        logger: singletonServices.logger,
+        schemaService: singletonServices.schema,
+    });
     const agentMiddlewares = [
-        ...getWorkingMemoryMiddleware(memoryConfig, storage, {
-            threadId,
-            workingMemorySchemaName,
-            logger: singletonServices.logger,
-            schemaService: singletonServices.schema,
-        }),
+        ...workingMemoryMiddleware,
         ...(agent.agentMiddleware ?? []),
     ];
     // One bag per run, shared by every middleware — see PikkuAgentMiddlewareHooks.
@@ -491,43 +537,25 @@ export async function streamAgent(agentName, input, channel, params, agentSessio
         await storage.saveMessages(threadId, [persistedUserMessage]);
     }
     warnUnstreamedOutputHooks(agentName, agentMiddlewares, singletonServices.logger);
-    const streamMiddleware = agentMiddlewares
-        .filter((mw) => mw.modifyOutputStream)
-        .map((mw) => {
-        const state = {};
-        const allEvents = [];
-        return async (services, event, next) => {
-            allEvents.push(event);
-            const result = await mw.modifyOutputStream(services, {
-                event,
-                allEvents,
-                state,
-                shared: sharedNotes,
-                // Sends downstream directly, so a hook can hand back the fast event
-                // now and push the slow one when it is ready.
-                emit: next,
-                signal: interruptHandle.signal,
-            });
-            if (result == null)
-                return;
-            if (Array.isArray(result)) {
-                for (const r of result)
-                    await next(r);
-            }
-            else {
-                await next(result);
-            }
-        };
-    });
+    const workingMemoryStreamMiddleware = toChannelStreamMiddleware(workingMemoryMiddleware, sharedNotes, interruptHandle.signal);
+    const streamMiddleware = toChannelStreamMiddleware(agent.agentMiddleware ?? [], sharedNotes, interruptHandle.signal);
     const agentsMeta = pikkuState(packageName, 'agent', 'agentsMeta');
     const meta = agentsMeta[resolvedName];
-    const allChannelMiddleware = combineChannelMiddleware('agent', `stream:${agentName}`, {
-        wireInheritedChannelMiddleware: meta?.channelMiddleware,
-        wireChannelMiddleware: [
-            ...(agent.channelMiddleware ?? []),
-            ...streamMiddleware,
-        ],
-    });
+    const isDelegateMode = agent.agentMode !== 'supervise' && meta?.agents?.length;
+    const delegateState = { delegated: false };
+    if (isDelegateMode) {
+        streamContext.delegateState = delegateState;
+    }
+    const allChannelMiddleware = [
+        ...workingMemoryStreamMiddleware,
+        ...combineChannelMiddleware('agent', `stream:${agentName}`, {
+            wireInheritedChannelMiddleware: meta?.channelMiddleware,
+            wireChannelMiddleware: [
+                ...(agent.channelMiddleware ?? []),
+                ...streamMiddleware,
+            ],
+        }),
+    ];
     const persistingChannel = createPersistingChannel(channel, storage, threadId, singletonServices.logger);
     const wrappedChannel = allChannelMiddleware.length > 0
         ? wrapChannelWithMiddleware({ channel: persistingChannel }, singletonServices, allChannelMiddleware).channel
@@ -545,21 +573,19 @@ export async function streamAgent(agentName, input, channel, params, agentSessio
             return wrappedChannel.send(event);
         },
     };
-    const isDelegateMode = agent.agentMode !== 'supervise' && meta?.agents?.length;
-    const delegateState = { delegated: false };
-    if (isDelegateMode) {
-        streamContext.delegateState = delegateState;
-    }
+    const workingMemoryOnlyChannel = isDelegateMode && workingMemoryStreamMiddleware.length > 0
+        ? createWorkingMemoryOnlyChannel(channel, singletonServices, workingMemoryStreamMiddleware)
+        : undefined;
     const outputChannel = isDelegateMode
         ? {
             ...credentialFilteredChannel,
             send: (event) => {
                 if (delegateState.delegated &&
-                    (event.type === 'text-delta' || event.type === 'reasoning-delta'))
-                    return;
+                    (event.type === 'text-delta' || event.type === 'reasoning-delta')) {
+                    return workingMemoryOnlyChannel?.send(event);
+                }
                 return credentialFilteredChannel.send(event);
             },
-            delegateState,
         }
         : credentialFilteredChannel;
     try {
@@ -717,7 +743,7 @@ export async function resumeAgent(input, channel, params, options) {
         if (pending.type === 'agent-call') {
             await agentRunState.updateRun(pending.agentRunId, { status: 'failed' });
         }
-        const denialResult = 'The user explicitly declined this action. Inform them that it was declined and do not retry.';
+        const denialResult = deniedToolResult();
         if (storage) {
             await storage.saveMessages(run.threadId, [
                 {
@@ -880,13 +906,14 @@ async function continueAfterToolResult(run, agent, packageName, resolvedName, st
     const allMessages = [...contextMessages, ...messages];
     const trimmedMessages = trimMessages(allMessages);
     const instructions = await buildInstructions(resolvedName, packageName);
+    const workingMemoryMiddleware = getWorkingMemoryMiddleware(memoryConfig, storage, {
+        threadId: run.threadId,
+        workingMemorySchemaName,
+        logger: singletonServices.logger,
+        schemaService: singletonServices.schema,
+    });
     const agentMiddlewares = [
-        ...getWorkingMemoryMiddleware(memoryConfig, storage, {
-            threadId: run.threadId,
-            workingMemorySchemaName,
-            logger: singletonServices.logger,
-            schemaService: singletonServices.schema,
-        }),
+        ...workingMemoryMiddleware,
         ...(agent.agentMiddleware ?? []),
     ];
     // One bag per run, shared by every middleware — see PikkuAgentMiddlewareHooks.
@@ -895,46 +922,43 @@ async function continueAfterToolResult(run, agent, packageName, resolvedName, st
     // knowledge: decisions/internals/a-resumed-agent-turn-is-as-interruptible-as-the-first.md
     const interruptHandle = registerInterruptibleRun(run.runId);
     warnUnstreamedOutputHooks(run.agentName, agentMiddlewares, singletonServices.logger);
-    const streamMiddleware = agentMiddlewares
-        .filter((mw) => mw.modifyOutputStream)
-        .map((mw) => {
-        const state = {};
-        const allEvents = [];
-        return async (services, event, next) => {
-            allEvents.push(event);
-            const result = await mw.modifyOutputStream(services, {
-                event,
-                allEvents,
-                state,
-                shared: sharedNotes,
-                // Sends downstream directly, so a hook can hand back the fast event
-                // now and push the slow one when it is ready.
-                emit: next,
-                signal: interruptHandle.signal,
-            });
-            if (result == null)
-                return;
-            if (Array.isArray(result)) {
-                for (const r of result)
-                    await next(r);
-            }
-            else {
-                await next(result);
-            }
-        };
-    });
-    const allChannelMiddleware = combineChannelMiddleware('agent', `stream:${run.agentName}`, {
-        wireInheritedChannelMiddleware: meta?.channelMiddleware,
-        wireChannelMiddleware: [
-            ...(agent.channelMiddleware ?? []),
-            ...streamMiddleware,
-        ],
-    });
+    const workingMemoryStreamMiddleware = toChannelStreamMiddleware(workingMemoryMiddleware, sharedNotes, interruptHandle.signal);
+    const streamMiddleware = toChannelStreamMiddleware(agent.agentMiddleware ?? [], sharedNotes, interruptHandle.signal);
+    const allChannelMiddleware = [
+        ...workingMemoryStreamMiddleware,
+        ...combineChannelMiddleware('agent', `stream:${run.agentName}`, {
+            wireInheritedChannelMiddleware: meta?.channelMiddleware,
+            wireChannelMiddleware: [
+                ...(agent.channelMiddleware ?? []),
+                ...streamMiddleware,
+            ],
+        }),
+    ];
     const persistingChannel = createPersistingChannel(channel, storage, run.threadId, singletonServices.logger);
     const wrappedChannel = allChannelMiddleware.length > 0
         ? wrapChannelWithMiddleware({ channel: persistingChannel }, singletonServices, allChannelMiddleware).channel
         : persistingChannel;
+    const isDelegateMode = agent.agentMode !== 'supervise' && meta?.agents?.length;
+    const delegateState = { delegated: false };
     const streamContext = { channel, options };
+    if (isDelegateMode) {
+        streamContext.delegateState = delegateState;
+    }
+    const workingMemoryOnlyChannel = isDelegateMode && workingMemoryStreamMiddleware.length > 0
+        ? createWorkingMemoryOnlyChannel(channel, singletonServices, workingMemoryStreamMiddleware)
+        : undefined;
+    const outputChannel = isDelegateMode
+        ? {
+            ...wrappedChannel,
+            send: (event) => {
+                if (delegateState.delegated &&
+                    (event.type === 'text-delta' || event.type === 'reasoning-delta')) {
+                    return workingMemoryOnlyChannel?.send(event);
+                }
+                return wrappedChannel.send(event);
+            },
+        }
+        : wrappedChannel;
     const resumeTools = (await buildToolDefs(params, new Map(), run.resourceId, resolvedName, packageName, streamContext, agentMiddlewares)).tools;
     const resolved = resolveModelConfig(resolvedName, agent);
     const maxSteps = resolved.maxSteps ?? 10;
@@ -959,7 +983,7 @@ async function continueAfterToolResult(run, agent, packageName, resolvedName, st
             runnerParams,
             maxSteps,
             agentRunner,
-            streamChannel: wrappedChannel,
+            streamChannel: outputChannel,
             persistingChannel,
             channel,
             agentMiddlewares,

package/dist/wirings/agent/agent-utils.d.ts

@@ -1 +1,14 @@
 export declare const randomUUID: () => string;
+/**
+ * The tool result stored and streamed when a user denies an approval.
+ *
+ * Two readers, one string. The model needs the sentence — it has to tell the
+ * user the action was declined and not retry it. A client needs to know a
+ * denial when it sees one, so it can render the call as denied rather than as
+ * a successful call that happened to return prose; that is what `approved`
+ * carries, and it is the same flag a client sets optimistically the moment the
+ * deny button is clicked. Emitting only the sentence made the two disagree:
+ * live the call showed denied, and on any re-render from storage the same call
+ * came back green.
+ */
+export declare const deniedToolResult: () => string;

package/dist/wirings/agent/agent-utils.js

@@ -1 +1,17 @@
 export const randomUUID = () => globalThis.crypto.randomUUID();
+/**
+ * The tool result stored and streamed when a user denies an approval.
+ *
+ * Two readers, one string. The model needs the sentence — it has to tell the
+ * user the action was declined and not retry it. A client needs to know a
+ * denial when it sees one, so it can render the call as denied rather than as
+ * a successful call that happened to return prose; that is what `approved`
+ * carries, and it is the same flag a client sets optimistically the moment the
+ * deny button is clicked. Emitting only the sentence made the two disagree:
+ * live the call showed denied, and on any re-render from storage the same call
+ * came back green.
+ */
+export const deniedToolResult = () => JSON.stringify({
+    approved: false,
+    message: 'The user explicitly declined this action. Inform them that it was declined and do not retry.',
+});