@pikku/core 0.12.83 → 0.12.86

package/dist/wirings/{ai-agent/ai-agent-prepare.js → agent/agent-prepare.js}

@@ -5,14 +5,14 @@ import { ForbiddenError } from '../../errors/errors.js';
 import { verifyScopes } from '../../scopes.js';
 import { pikkuState, getSingletonServices } from '../../pikku-state.js';
 import { createMiddlewareSessionWireProps } from '../../services/user-session-service.js';
-import { randomUUID } from './ai-agent-utils.js';
-import { awaitPendingInterruptNote } from './ai-agent-interrupt.js';
-import { streamAIAgent } from './ai-agent-stream.js';
-import { runAIAgent } from './ai-agent-runner.js';
+import { randomUUID } from './agent-utils.js';
+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 { resolveMemoryServices, loadContextMessages, trimMessages, } from './ai-agent-memory.js';
-import { resolveModelConfig } from './ai-agent-model-config.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) {
     const session = params.sessionService?.get();
     if ((sessionScope ?? 'user') === 'org') {
@@ -258,7 +258,7 @@ export function createScopedChannel(parent, agentName, session) {
 export function buildSubAgentRunInput(message, threadId, resourceId, parentContext) {
     return { message, threadId, resourceId, context: parentContext };
 }
-export async function buildToolDefs(params, agentSessionMap, resourceId, agentName, packageName, streamContext, aiMiddlewares, agentMode, parentContext) {
+export async function buildToolDefs(params, agentSessionMap, resourceId, agentName, packageName, streamContext, agentMiddlewares, agentMode, parentContext) {
     const singletonServices = getSingletonServices();
     const tools = [];
     const missingRpcs = [];
@@ -451,7 +451,7 @@ export async function buildToolDefs(params, agentSessionMap, resourceId, agentNa
                                     subChannel.send(event);
                                 },
                             };
-                        const resultText = await streamAIAgent(subAgentName, buildSubAgentRunInput(message, threadId, resourceId, parentContext), effectiveChannel, params, agentSessionMap, streamContext.options);
+                        const resultText = await streamAgent(subAgentName, buildSubAgentRunInput(message, threadId, resourceId, parentContext), effectiveChannel, params, agentSessionMap, streamContext.options);
                         if (subChannel.approvals.length > 0) {
                             return {
                                 [APPROVAL_REQUIRED]: true,
@@ -470,7 +470,7 @@ export async function buildToolDefs(params, agentSessionMap, resourceId, agentNa
                         });
                         return resultText;
                     }
-                    const result = await runAIAgent(subAgentName, buildSubAgentRunInput(message, threadId, resourceId, parentContext), params, agentSessionMap);
+                    const result = await runAgent(subAgentName, buildSubAgentRunInput(message, threadId, resourceId, parentContext), params, agentSessionMap);
                     if (result.status === 'suspended' &&
                         result.pendingApprovals?.length) {
                         return {
@@ -553,14 +553,14 @@ export async function buildToolDefs(params, agentSessionMap, resourceId, agentNa
             }
         };
     }
-    const hasToolHooks = aiMiddlewares?.some((mw) => mw.beforeToolCall || mw.afterToolCall);
+    const hasToolHooks = agentMiddlewares?.some((mw) => mw.beforeToolCall || mw.afterToolCall);
     if (hasToolHooks) {
         for (const tool of tools) {
             const originalExecute = tool.execute;
             tool.execute = async (toolInput) => {
                 const toolCallId = randomUUID();
                 let args = (toolInput ?? {});
-                for (const mw of aiMiddlewares) {
+                for (const mw of agentMiddlewares) {
                     if (mw.beforeToolCall) {
                         const beforeResult = await mw.beforeToolCall(singletonServices, {
                             toolName: tool.name,
@@ -585,8 +585,8 @@ export async function buildToolDefs(params, agentSessionMap, resourceId, agentNa
                     result = err instanceof Error ? err.message : String(err);
                 }
                 const durationMs = Date.now() - startTime;
-                for (let i = aiMiddlewares.length - 1; i >= 0; i--) {
-                    const mw = aiMiddlewares[i];
+                for (let i = agentMiddlewares.length - 1; i >= 0; i--) {
+                    const mw = agentMiddlewares[i];
                     if (mw.afterToolCall) {
                         const afterResult = await mw.afterToolCall(singletonServices, {
                             toolName: tool.name,
@@ -612,7 +612,7 @@ export async function prepareAgentRun(agentName, input, params, agentSessionMap,
     const singletonServices = getSingletonServices();
     const { agent, packageName, resolvedName } = resolveAgent(agentName);
     await assertAgentAuthorized(agent, params, packageName);
-    let agentRunner = singletonServices.aiAgentRunner;
+    let agentRunner = singletonServices.agentRunner;
     if (!agentRunner) {
         throw new AIProviderNotConfiguredError();
     }
@@ -682,8 +682,8 @@ export async function prepareAgentRun(agentName, input, params, agentSessionMap,
     };
     const allMessages = [...contextMessages, ...messages, userMessage];
     const trimmedMessages = trimMessages(allMessages);
-    const aiMiddlewares = agent.aiMiddleware ?? [];
-    const { tools, missingRpcs } = await buildToolDefs(params, agentSessionMap, input.resourceId, resolvedName, packageName, streamContext, aiMiddlewares, agent.agentMode, input.context);
+    const agentMiddlewares = agent.agentMiddleware ?? [];
+    const { tools, missingRpcs } = await buildToolDefs(params, agentSessionMap, input.resourceId, resolvedName, packageName, streamContext, agentMiddlewares, agent.agentMode, input.context);
     let instructions = await buildInstructions(resolvedName, packageName);
     if (input.context) {
         instructions = `${instructions}\n\nCurrent context (use these identifiers directly in tool calls — do not ask the user for them):\n${input.context}`;

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

@@ -0,0 +1,16 @@
+import type { CoreAgent } from './agent.types.js';
+import type { AgentRunStateService } from '../../services/agent-run-state-service.js';
+import { type RunAgentParams } from './agent-prepare.js';
+export declare const addAgent: (agentName: string, agent: CoreAgent<any, any>, packageName?: string | null) => void;
+export declare function approveAgent(agentRunState: AgentRunStateService, runId: string, approvals: {
+    toolCallId: string;
+    approved: boolean;
+}[], expectedAgentName?: string, params?: RunAgentParams): Promise<{
+    status: 'resumed' | 'suspended';
+    runId: string;
+    approved: string[];
+    rejected: string[];
+    remainingApprovals: number;
+}>;
+export declare const getAgents: () => Map<string, CoreAgent>;
+export declare const getAgentsMeta: () => import("./agent.types.js").AgentsMeta;

package/dist/wirings/{ai-agent/ai-agent-registry.js → agent/agent-registry.js}

@@ -1,6 +1,6 @@
 import { pikkuState } from '../../pikku-state.js';
-import { agentSessionScope, assertAgentAuthorized, assertResourcePrincipalOwner, resolveAgent, } from './ai-agent-prepare.js';
-export const addAIAgent = (agentName, agent, packageName = null) => {
+import { agentSessionScope, assertAgentAuthorized, assertResourcePrincipalOwner, resolveAgent, } from './agent-prepare.js';
+export const addAgent = (agentName, agent, packageName = null) => {
     const agentsMeta = pikkuState(packageName, 'agent', 'agentsMeta');
     const agentMeta = agentsMeta[agentName];
     if (!agentMeta) {
@@ -13,10 +13,10 @@ export const addAIAgent = (agentName, agent, packageName = null) => {
     }
     agents.set(agentName, agent);
 };
-export async function approveAIAgent(aiRunState, runId, approvals, expectedAgentName, params = {}) {
-    if (!aiRunState)
-        throw new Error('AIRunStateService not available');
-    const run = await aiRunState.getRun(runId);
+export async function approveAgent(agentRunState, runId, approvals, expectedAgentName, params = {}) {
+    if (!agentRunState)
+        throw new Error('AgentRunStateService not available');
+    const run = await agentRunState.getRun(runId);
     if (!run)
         throw new Error('Run not found: ' + runId);
     assertResourcePrincipalOwner(params, agentSessionScope(run.agentName), run.resourceId, 'run');
@@ -31,7 +31,7 @@ export async function approveAIAgent(aiRunState, runId, approvals, expectedAgent
     const rejectedIds = new Set(approvals.filter((a) => !a.approved).map((a) => a.toolCallId));
     const remaining = (run.pendingApprovals ?? []).filter((p) => !approvedIds.has(p.toolCallId) && !rejectedIds.has(p.toolCallId));
     const hasApproved = approvedIds.size > 0;
-    await aiRunState.updateRun(runId, {
+    await agentRunState.updateRun(runId, {
         status: hasApproved ? 'running' : 'suspended',
         pendingApprovals: remaining.length > 0 ? remaining : undefined,
     });
@@ -43,9 +43,9 @@ export async function approveAIAgent(aiRunState, runId, approvals, expectedAgent
         remainingApprovals: remaining.length,
     };
 }
-export const getAIAgents = () => {
+export const getAgents = () => {
     return pikkuState(null, 'agent', 'agents');
 };
-export const getAIAgentsMeta = () => {
+export const getAgentsMeta = () => {
     return pikkuState(null, 'agent', 'agentsMeta');
 };

package/dist/wirings/{ai-agent → agent}/agent-rpc.js

@@ -1,6 +1,6 @@
-import { runAIAgent, resumeAIAgentSync } from './ai-agent-runner.js';
-import { streamAIAgent, resumeAIAgent, interruptAIAgent, } from './ai-agent-stream.js';
-import { wrapChannelWithAGUI } from './ai-agent-agui.js';
+import { runAgent, resumeAgentSync } from './agent-runner.js';
+import { streamAgent, resumeAgent, interruptAgent } from './agent-stream.js';
+import { wrapChannelWithAGUI } from './agent-agui.js';
 /**
  * `wire.rpc.agent`, implemented.
  *
@@ -30,10 +30,10 @@ export const createAgentRPC = (wire, options) => {
         }),
     });
     return {
-        run: async (agentName, input) => asRunResult(await runAIAgent(agentName, input, params())),
+        run: async (agentName, input) => asRunResult(await runAgent(agentName, input, params())),
         stream: async (agentName, input, streamOptions) => {
             let currentRunId;
-            await streamAIAgent(agentName, input, wrapChannelWithAGUI(streamingChannel(), {
+            await streamAgent(agentName, input, wrapChannelWithAGUI(streamingChannel(), {
                 threadId: input.threadId,
                 getRunId: () => currentRunId,
             }), params(), undefined, {
@@ -45,9 +45,9 @@ export const createAgentRPC = (wire, options) => {
             });
         },
         resume: async (runId, input, streamOptions) => {
-            await resumeAIAgent({ runId, ...input }, wrapChannelWithAGUI(streamingChannel(), { runId }), params(), streamOptions);
+            await resumeAgent({ runId, ...input }, wrapChannelWithAGUI(streamingChannel(), { runId }), params(), streamOptions);
         },
-        interrupt: async (runId, reason) => interruptAIAgent({ runId, ...(reason ? { reason } : {}) }, { sessionService: options.sessionService }),
-        approve: async (runId, approvals, expectedAgentName) => asRunResult(await resumeAIAgentSync(runId, approvals, { sessionService: options.sessionService }, expectedAgentName)),
+        interrupt: async (runId, reason) => interruptAgent({ runId, ...(reason ? { reason } : {}) }, { sessionService: options.sessionService }),
+        approve: async (runId, approvals, expectedAgentName) => asRunResult(await resumeAgentSync(runId, approvals, { sessionService: options.sessionService }, expectedAgentName)),
     };
 };

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

@@ -0,0 +1,7 @@
+import type { AgentInput, AgentOutput } from './agent.types.js';
+import { type RunAgentParams } from './agent-prepare.js';
+export declare function runAgent(agentName: string, input: AgentInput, params: RunAgentParams, agentSessionMap?: Map<string, string>): Promise<AgentOutput>;
+export declare function resumeAgentSync(runId: string, approvals: {
+    toolCallId: string;
+    approved: boolean;
+}[], params: RunAgentParams, expectedAgentName?: string): Promise<AgentOutput>;

package/dist/wirings/{ai-agent/ai-agent-runner.js → agent/agent-runner.js}

@@ -1,13 +1,13 @@
-import { saveMessages, resolveMemoryServices, loadContextMessages, trimMessages, getWorkingMemoryMiddleware, } from './ai-agent-memory.js';
-import { prepareAgentRun, resolveAgent, buildInstructions, buildToolDefs, resolveOwnerResourceId, agentSessionScope, assertResourcePrincipalOwner, assertAgentAuthorized, } from './ai-agent-prepare.js';
-import { checkForApprovals, appendStepMessages } from './ai-agent-stream.js';
-import { AgentInterruptedError, isAbortError, persistOrphanedToolResults, registerInterruptibleRun, trackInterruptNote, trackToolExecution, } from './ai-agent-interrupt.js';
+import { saveMessages, resolveMemoryServices, loadContextMessages, trimMessages, getWorkingMemoryMiddleware, } from './agent-memory.js';
+import { prepareAgentRun, resolveAgent, buildInstructions, buildToolDefs, resolveOwnerResourceId, agentSessionScope, assertResourcePrincipalOwner, assertAgentAuthorized, } from './agent-prepare.js';
+import { checkForApprovals, appendStepMessages } from './agent-stream.js';
+import { AgentInterruptedError, isAbortError, persistOrphanedToolResults, registerInterruptibleRun, trackInterruptNote, trackToolExecution, } from './agent-interrupt.js';
 import { pikkuState, getSingletonServices } from '../../pikku-state.js';
-import { applyInputMiddleware, describeApprovals, notifyAfterStep, toAccumulatedStep, } from './ai-agent-turn.js';
-import { applyOutputMiddleware, finalizeAgentRun, lastUserMessageText, } from './ai-agent-finalize.js';
-import { resolveModelConfig } from './ai-agent-model-config.js';
+import { applyInputMiddleware, describeApprovals, notifyAfterStep, toAccumulatedStep, } from './agent-turn.js';
+import { applyOutputMiddleware, finalizeAgentRun, lastUserMessageText, } from './agent-finalize.js';
+import { resolveModelConfig } from './agent-model-config.js';
 import { AIProviderNotConfiguredError } from '../../errors/errors.js';
-import { randomUUID } from './ai-agent-utils.js';
+import { deniedToolResult, randomUUID } from './agent-utils.js';
 function stripNulls(obj) {
     if (obj === null)
         return undefined;
@@ -33,7 +33,7 @@ function extractStructuredAssistantOutput(object) {
         uiSpec: record.ui ?? null,
     };
 }
-export async function runAIAgent(agentName, input, params, agentSessionMap) {
+export async function runAgent(agentName, input, params, agentSessionMap) {
     const sessionMap = agentSessionMap ?? new Map();
     input = {
         ...input,
@@ -42,12 +42,12 @@ export async function runAIAgent(agentName, input, params, agentSessionMap) {
     const { agent, agentRunner, storage, memoryConfig, threadId, userMessage, runnerParams, maxSteps, missingRpcs, workingMemorySchemaName, } = await prepareAgentRun(agentName, input, params, sessionMap);
     runnerParams.agentId = agentName;
     const singletonServices = getSingletonServices();
-    const { aiRunState } = singletonServices;
-    if (!aiRunState) {
-        throw new Error('AIRunStateService not available in singletonServices');
+    const { agentRunState } = singletonServices;
+    if (!agentRunState) {
+        throw new Error('AgentRunStateService not available in singletonServices');
     }
     if (missingRpcs.length > 0) {
-        const runId = await aiRunState.createRun({
+        const runId = await agentRunState.createRun({
             agentName,
             threadId,
             resourceId: input.resourceId,
@@ -66,18 +66,18 @@ export async function runAIAgent(agentName, input, params, agentSessionMap) {
             usage: { inputTokens: 0, outputTokens: 0 },
         };
     }
-    const aiMiddlewares = [
+    const agentMiddlewares = [
         ...getWorkingMemoryMiddleware(memoryConfig, storage, {
             threadId,
             workingMemorySchemaName,
             logger: singletonServices.logger,
             schemaService: singletonServices.schema,
         }),
-        ...(agent.aiMiddleware ?? []),
+        ...(agent.agentMiddleware ?? []),
     ];
-    // One bag per run, shared by every middleware — see PikkuAIMiddlewareHooks.
+    // One bag per run, shared by every middleware — see PikkuAgentMiddlewareHooks.
     const sharedNotes = {};
-    const { messages: modifiedMessages, instructions: modifiedInstructions } = await applyInputMiddleware(aiMiddlewares, singletonServices, {
+    const { messages: modifiedMessages, instructions: modifiedInstructions } = await applyInputMiddleware(agentMiddlewares, singletonServices, {
         messages: runnerParams.messages,
         instructions: runnerParams.instructions,
     }, sharedNotes);
@@ -86,7 +86,7 @@ export async function runAIAgent(agentName, input, params, agentSessionMap) {
     // 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;
-    const runId = await aiRunState.createRun({
+    const runId = await agentRunState.createRun({
         agentName,
         threadId,
         resourceId: input.resourceId,
@@ -123,7 +123,7 @@ export async function runAIAgent(agentName, input, params, agentSessionMap) {
             lastStepResult = stepResult;
             totalUsage.inputTokens += stepResult.usage.inputTokens;
             totalUsage.outputTokens += stepResult.usage.outputTokens;
-            await notifyAfterStep(aiMiddlewares, singletonServices, step, stepResult);
+            await notifyAfterStep(agentMiddlewares, singletonServices, step, stepResult);
             accumulatedSteps.push(toAccumulatedStep(stepResult));
             if (stepResult.toolCalls.length === 0)
                 break;
@@ -161,7 +161,7 @@ export async function runAIAgent(agentName, input, params, agentSessionMap) {
                         },
                     ]);
                 }
-                await aiRunState.updateRun(runId, {
+                await agentRunState.updateRun(runId, {
                     status: 'suspended',
                     suspendReason: 'approval',
                     pendingApprovals,
@@ -193,7 +193,7 @@ export async function runAIAgent(agentName, input, params, agentSessionMap) {
             text: finalText,
             steps: accumulatedSteps,
         };
-        const { text: outputText, steps: outputSteps } = await applyOutputMiddleware(aiMiddlewares, singletonServices, {
+        const { text: outputText, steps: outputSteps } = await applyOutputMiddleware(agentMiddlewares, singletonServices, {
             text: finalText,
             messages: runnerParams.messages,
             steps: result.steps,
@@ -204,7 +204,7 @@ export async function runAIAgent(agentName, input, params, agentSessionMap) {
             steps: outputSteps,
             uiSpec: structuredOutput.uiSpec,
         });
-        await finalizeAgentRun(aiRunState, {
+        await finalizeAgentRun(agentRunState, {
             runId,
             agentName,
             threadId,
@@ -227,13 +227,13 @@ export async function runAIAgent(agentName, input, params, agentSessionMap) {
         // 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' });
+            await agentRunState.updateRun(runId, { status: 'interrupted' });
             if (storage) {
                 trackInterruptNote(threadId, persistOrphanedToolResults(interruptHandle, storage, threadId));
             }
             throw new AgentInterruptedError(runId, interruption ?? { reason: 'user' });
         }
-        for (const mw of aiMiddlewares) {
+        for (const mw of agentMiddlewares) {
             if (mw.onError) {
                 try {
                     await mw.onError(singletonServices, {
@@ -245,7 +245,7 @@ export async function runAIAgent(agentName, input, params, agentSessionMap) {
                 catch { }
             }
         }
-        await aiRunState.updateRun(runId, {
+        await agentRunState.updateRun(runId, {
             status: 'failed',
             errorMessage: error instanceof Error ? error.message : String(error),
         });
@@ -255,13 +255,13 @@ export async function runAIAgent(agentName, input, params, agentSessionMap) {
         interruptHandle.release();
     }
 }
-export async function resumeAIAgentSync(runId, approvals, params, expectedAgentName) {
+export async function resumeAgentSync(runId, approvals, params, expectedAgentName) {
     const singletonServices = getSingletonServices();
-    const { aiRunState } = singletonServices;
-    if (!aiRunState) {
-        throw new Error('AIRunStateService not available in singletonServices');
+    const { agentRunState } = singletonServices;
+    if (!agentRunState) {
+        throw new Error('AgentRunStateService not available in singletonServices');
     }
-    const run = await aiRunState.getRun(runId);
+    const run = await agentRunState.getRun(runId);
     if (!run)
         throw new Error(`No run found for runId ${runId}`);
     assertResourcePrincipalOwner(params, agentSessionScope(run.agentName), run.resourceId, 'run');
@@ -275,7 +275,7 @@ export async function resumeAIAgentSync(runId, approvals, params, expectedAgentN
     await assertAgentAuthorized(agent, params, packageName);
     const { storage } = resolveMemoryServices(agent, singletonServices);
     const memoryConfig = agent.memory;
-    const agentRunner = singletonServices.aiAgentRunner;
+    const agentRunner = singletonServices.agentRunner;
     if (!agentRunner) {
         throw new AIProviderNotConfiguredError();
     }
@@ -287,7 +287,7 @@ export async function resumeAIAgentSync(runId, approvals, params, expectedAgentN
     // for may run the tool.
     const claimedIds = new Set();
     for (const { toolCallId, approved } of approvals) {
-        const claimed = await aiRunState.resolveApproval(toolCallId, approved ? 'approved' : 'denied');
+        const claimed = await agentRunState.resolveApproval(toolCallId, approved ? 'approved' : 'denied');
         if (claimed) {
             claimedIds.add(toolCallId);
         }
@@ -295,7 +295,7 @@ export async function resumeAIAgentSync(runId, approvals, params, expectedAgentN
     if (approvals.length > 0 && claimedIds.size === 0) {
         throw new Error(`Approvals for run ${runId} were already resolved by another caller`);
     }
-    const { tools } = await buildToolDefs(params, new Map(), run.resourceId, resolvedName, packageName, undefined, agent.aiMiddleware ?? []);
+    const { tools } = await buildToolDefs(params, new Map(), run.resourceId, resolvedName, packageName, undefined, agent.agentMiddleware ?? []);
     const toolCallMessages = [];
     for (const pending of savedPendingApprovals) {
         if (pending.type !== 'tool-call')
@@ -306,8 +306,7 @@ export async function resumeAIAgentSync(runId, approvals, params, expectedAgentN
         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);
@@ -362,8 +361,8 @@ export async function resumeAIAgentSync(runId, approvals, params, expectedAgentN
             },
         ]);
     }
-    await aiRunState.updateRun(runId, { status: 'running' });
-    return continueAfterToolResultSync(run, agent, packageName, resolvedName, storage, memoryConfig, agentRunner, params, aiRunState, 
+    await agentRunState.updateRun(runId, { status: 'running' });
+    return continueAfterToolResultSync(run, agent, packageName, resolvedName, storage, memoryConfig, agentRunner, params, agentRunState, 
     // The approved tools were executed here, before the model was re-entered,
     // so they belong to the run's step record — otherwise a tool that failed
     // after approval leaves no trace on the run at all.
@@ -379,7 +378,7 @@ export async function resumeAIAgentSync(runId, approvals, params, expectedAgentN
         }
         : undefined);
 }
-async function continueAfterToolResultSync(run, agent, packageName, resolvedName, storage, memoryConfig, agentRunner, params, aiRunState, resumedToolStep) {
+async function continueAfterToolResultSync(run, agent, packageName, resolvedName, storage, memoryConfig, agentRunner, params, agentRunState, resumedToolStep) {
     const singletonServices = getSingletonServices();
     const agentsMeta = pikkuState(packageName, 'agent', 'agentsMeta');
     const meta = agentsMeta[resolvedName];
@@ -396,19 +395,19 @@ async function continueAfterToolResultSync(run, agent, packageName, resolvedName
     const allMessages = [...contextMessages, ...messages];
     const trimmedMessages = trimMessages(allMessages);
     const instructions = await buildInstructions(resolvedName, packageName);
-    const aiMiddlewares = [
+    const agentMiddlewares = [
         ...getWorkingMemoryMiddleware(memoryConfig, storage, {
             threadId: run.threadId,
             workingMemorySchemaName,
             logger: singletonServices.logger,
             schemaService: singletonServices.schema,
         }),
-        ...(agent.aiMiddleware ?? []),
+        ...(agent.agentMiddleware ?? []),
     ];
-    // One bag per run, shared by every middleware — see PikkuAIMiddlewareHooks.
+    // One bag per run, shared by every middleware — see PikkuAgentMiddlewareHooks.
     const sharedNotes = {};
-    const { messages: modifiedMessages, instructions: modifiedInstructions } = await applyInputMiddleware(aiMiddlewares, singletonServices, { messages: trimmedMessages, instructions: instructions }, sharedNotes);
-    const { tools: resumeTools } = await buildToolDefs(params, new Map(), run.resourceId, resolvedName, packageName, undefined, aiMiddlewares);
+    const { messages: modifiedMessages, instructions: modifiedInstructions } = await applyInputMiddleware(agentMiddlewares, singletonServices, { messages: trimmedMessages, instructions: instructions }, sharedNotes);
+    const { tools: resumeTools } = await buildToolDefs(params, new Map(), run.resourceId, resolvedName, packageName, undefined, agentMiddlewares);
     const resolved = resolveModelConfig(resolvedName, agent);
     const maxSteps = resolved.maxSteps ?? 10;
     const runnerParams = {
@@ -445,7 +444,7 @@ async function continueAfterToolResultSync(run, agent, packageName, resolvedName
             lastStepResult = stepResult;
             totalUsage.inputTokens += stepResult.usage.inputTokens;
             totalUsage.outputTokens += stepResult.usage.outputTokens;
-            await notifyAfterStep(aiMiddlewares, singletonServices, step, stepResult);
+            await notifyAfterStep(agentMiddlewares, singletonServices, step, stepResult);
             accumulatedSteps.push(toAccumulatedStep(stepResult));
             if (stepResult.toolCalls.length === 0)
                 break;
@@ -485,7 +484,7 @@ async function continueAfterToolResultSync(run, agent, packageName, resolvedName
                         },
                     ]);
                 }
-                await aiRunState.updateRun(run.runId, {
+                await agentRunState.updateRun(run.runId, {
                     status: 'suspended',
                     suspendReason: 'approval',
                     pendingApprovals,
@@ -516,7 +515,7 @@ async function continueAfterToolResultSync(run, agent, packageName, resolvedName
             text: finalText,
             steps: accumulatedSteps,
         };
-        const { text: outputText, steps: outputSteps } = await applyOutputMiddleware(aiMiddlewares, singletonServices, {
+        const { text: outputText, steps: outputSteps } = await applyOutputMiddleware(agentMiddlewares, singletonServices, {
             text: finalText,
             messages: runnerParams.messages,
             steps: withResumedStep(result.steps),
@@ -528,7 +527,7 @@ async function continueAfterToolResultSync(run, agent, packageName, resolvedName
             // re-entered, so only the steps this leg generated are persisted here.
             steps: accumulatedSteps,
         });
-        await finalizeAgentRun(aiRunState, {
+        await finalizeAgentRun(agentRunState, {
             runId: run.runId,
             agentName: resolvedName,
             threadId: run.threadId,
@@ -550,13 +549,13 @@ async function continueAfterToolResultSync(run, agent, packageName, resolvedName
     catch (error) {
         const interruption = interruptHandle.interruption;
         if (interruption || isAbortError(error)) {
-            await aiRunState.updateRun(run.runId, { status: 'interrupted' });
+            await agentRunState.updateRun(run.runId, { status: 'interrupted' });
             if (storage) {
                 trackInterruptNote(run.threadId, persistOrphanedToolResults(interruptHandle, storage, run.threadId));
             }
             throw new AgentInterruptedError(run.runId, interruption ?? { reason: 'user' });
         }
-        for (const mw of aiMiddlewares) {
+        for (const mw of agentMiddlewares) {
             if (mw.onError) {
                 try {
                     await mw.onError(singletonServices, {
@@ -568,7 +567,7 @@ async function continueAfterToolResultSync(run, agent, packageName, resolvedName
                 catch { }
             }
         }
-        await aiRunState.updateRun(run.runId, {
+        await agentRunState.updateRun(run.runId, {
             status: 'failed',
             errorMessage: error instanceof Error ? error.message : String(error),
         });

package/dist/wirings/{ai-agent/ai-agent-stream.d.ts → agent/agent-stream.d.ts}

@@ -1,23 +1,23 @@
-import type { AIStreamChannel } from './ai-agent.types.js';
-import type { AIAgentRunnerParams, AIAgentStepResult } from '../../services/ai-agent-runner-service.js';
-import { ToolApprovalRequired, ToolCredentialRequired, type RunAIAgentParams, type StreamAIAgentOptions } from './ai-agent-prepare.js';
-import { type AgentInterruption, type AgentInterruptResult } from './ai-agent-interrupt.js';
-export declare function checkForApprovals(stepResult: AIAgentStepResult, tools: AIAgentRunnerParams['tools']): ToolApprovalRequired[];
-export declare function checkForCredentialRequests(stepResult: AIAgentStepResult): ToolCredentialRequired[];
-export declare function appendStepMessages(runnerParams: AIAgentRunnerParams, stepResult: AIAgentStepResult): void;
-export declare function streamAIAgent(agentName: string, input: {
+import type { AgentStreamChannel } from './agent.types.js';
+import type { AgentRunnerParams, AgentStepResult } from '../../services/agent-runner-service.js';
+import { ToolApprovalRequired, ToolCredentialRequired, type RunAgentParams, type StreamAgentOptions } from './agent-prepare.js';
+import { type AgentInterruption, type AgentInterruptResult } from './agent-interrupt.js';
+export declare function checkForApprovals(stepResult: AgentStepResult, tools: AgentRunnerParams['tools']): ToolApprovalRequired[];
+export declare function checkForCredentialRequests(stepResult: AgentStepResult): ToolCredentialRequired[];
+export declare function appendStepMessages(runnerParams: AgentRunnerParams, stepResult: AgentStepResult): void;
+export declare function streamAgent(agentName: string, input: {
     message: string;
     threadId: string;
     resourceId: string;
     model?: string;
     temperature?: number;
-}, channel: AIStreamChannel, params: RunAIAgentParams, agentSessionMap?: Map<string, string>, options?: StreamAIAgentOptions): Promise<string>;
+}, channel: AgentStreamChannel, params: RunAgentParams, agentSessionMap?: Map<string, string>, options?: StreamAgentOptions): Promise<string>;
 /**
  * Stop an in-flight run on behalf of a caller, after checking the run is theirs.
  *
- * Unlike {@link resumeAIAgent} this needs no channel: it does not continue the
+ * Unlike {@link resumeAgent} this needs no channel: it does not continue the
  * stream, it ends one. The `interrupted` event and the truncated message are
- * emitted by the original {@link streamAIAgent} call on its own channel, so this
+ * emitted by the original {@link streamAgent} call on its own channel, so this
  * can be reached over a plain RPC while the stream is held open elsewhere —
  * which is exactly the shape a voice barge-in needs.
  *
@@ -30,12 +30,12 @@ export declare function streamAIAgent(agentName: string, input: {
  * Returns `false` when there was nothing to stop. Racing a run that finishes on
  * its own is the normal case in voice, so it is not an error.
  */
-export declare function interruptAIAgent(input: {
+export declare function interruptAgent(input: {
     runId: string;
     reason?: AgentInterruption['reason'];
-}, params: RunAIAgentParams): Promise<AgentInterruptResult>;
-export declare function resumeAIAgent(input: {
+}, params: RunAgentParams): Promise<AgentInterruptResult>;
+export declare function resumeAgent(input: {
     runId: string;
     toolCallId: string;
     approved: boolean;
-}, channel: AIStreamChannel, params: RunAIAgentParams, options?: StreamAIAgentOptions): Promise<void>;
+}, channel: AgentStreamChannel, params: RunAgentParams, options?: StreamAgentOptions): Promise<void>;