@pikku/core 0.12.0 → 0.12.2

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

@@ -1,5 +1,5 @@
 import { PikkuError } from '../../errors/error-handler.js';
-import { pikkuState } from '../../pikku-state.js';
+import { pikkuState, getSingletonServices, getCreateWireServices, } from '../../pikku-state.js';
 import { runPikkuFunc } from '../../function/function-runner.js';
 import { createMiddlewareSessionWireProps } from '../../services/user-session-service.js';
 import { randomUUID } from 'crypto';
@@ -33,8 +33,8 @@ export const resolveAgent = (agentName) => {
     if (colonIndex !== -1) {
         const namespace = agentName.substring(0, colonIndex);
         const localName = agentName.substring(colonIndex + 1);
-        const externalPackages = pikkuState(null, 'rpc', 'externalPackages');
-        const pkgConfig = externalPackages.get(namespace);
+        const addons = pikkuState(null, 'rpc', 'addons');
+        const pkgConfig = addons.get(namespace);
         if (pkgConfig) {
             const extAgent = pikkuState(pkgConfig.package, 'agent', 'agents').get(localName);
             if (extAgent) {
@@ -73,6 +73,7 @@ export function createScopedChannel(parent, agentName, session) {
             return capturedApproval;
         },
         close: () => { },
+        sendBinary: (data) => parent.sendBinary(data),
         send: (event) => {
             if (event.type === 'done')
                 return;
@@ -85,7 +86,8 @@ export function createScopedChannel(parent, agentName, session) {
                 };
                 return;
             }
-            if (event.type === 'text-delta' ||
+            if (event.type === 'step-start' ||
+                event.type === 'text-delta' ||
                 event.type === 'reasoning-delta' ||
                 event.type === 'tool-call' ||
                 event.type === 'tool-result' ||
@@ -99,7 +101,8 @@ export function createScopedChannel(parent, agentName, session) {
         },
     };
 }
-export function buildToolDefs(singletonServices, params, agentSessionMap, resourceId, agentName, packageName, streamContext) {
+export function buildToolDefs(params, agentSessionMap, resourceId, agentName, packageName, streamContext, aiMiddlewares) {
+    const singletonServices = getSingletonServices();
     const tools = [];
     const missingRpcs = [];
     const approvalPolicy = streamContext?.options?.requiresToolApproval ?? 'explicit';
@@ -131,38 +134,18 @@ export function buildToolDefs(singletonServices, params, agentSessionMap, resour
             }
             const needsApproval = approvalPolicy === 'all' ||
                 (approvalPolicy === 'explicit' && fnMeta?.requiresApproval);
-            if (needsApproval) {
-                inputSchema = {
-                    ...inputSchema,
-                    properties: {
-                        ...(inputSchema.properties || {}),
-                        toolApprovalReason: {
-                            type: 'string',
-                            description: 'Brief explanation of why this action is needed',
-                        },
-                    },
-                };
-            }
             tools.push({
                 name: pikkuFuncId,
                 description: fnMeta?.description || fnMeta?.title || toolName,
                 inputSchema,
+                needsApproval: needsApproval || undefined,
                 execute: async (toolInput) => {
-                    if (needsApproval) {
-                        const { toolApprovalReason, ...cleanArgs } = toolInput;
-                        return {
-                            __approvalRequired: true,
-                            toolName: pikkuFuncId,
-                            args: cleanArgs,
-                            reason: toolApprovalReason,
-                        };
-                    }
                     const wire = params.sessionService
                         ? { ...createMiddlewareSessionWireProps(params.sessionService) }
                         : {};
                     return runPikkuFunc('agent', `tool:${pikkuFuncId}`, pikkuFuncId, {
                         singletonServices,
-                        createWireServices: params.createWireServices,
+                        createWireServices: getCreateWireServices(),
                         data: () => toolInput,
                         wire,
                         sessionService: params.sessionService,
@@ -237,10 +220,61 @@ export function buildToolDefs(singletonServices, params, agentSessionMap, resour
             });
         }
     }
+    const hasToolHooks = aiMiddlewares?.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) {
+                    if (mw.beforeToolCall) {
+                        const beforeResult = await mw.beforeToolCall(singletonServices, {
+                            toolName: tool.name,
+                            toolCallId,
+                            args,
+                        });
+                        if (beforeResult && 'args' in beforeResult) {
+                            args = beforeResult.args;
+                        }
+                    }
+                }
+                const startTime = Date.now();
+                let result;
+                let execError;
+                try {
+                    result = await originalExecute(args);
+                }
+                catch (err) {
+                    execError = err;
+                    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];
+                    if (mw.afterToolCall) {
+                        const afterResult = await mw.afterToolCall(singletonServices, {
+                            toolName: tool.name,
+                            toolCallId,
+                            args,
+                            result,
+                            durationMs,
+                        });
+                        if (afterResult && 'result' in afterResult) {
+                            result = afterResult.result;
+                        }
+                    }
+                }
+                if (execError)
+                    throw execError;
+                return result;
+            };
+        }
+    }
     return { tools, missingRpcs };
 }
 export async function prepareAgentRun(agentName, input, params, agentSessionMap, streamContext) {
-    const { singletonServices } = params;
+    const singletonServices = getSingletonServices();
     const { agent, packageName, resolvedName } = resolveAgent(agentName);
     const agentRunner = singletonServices.aiAgentRunner;
     if (!agentRunner) {
@@ -274,24 +308,38 @@ export async function prepareAgentRun(agentName, input, params, agentSessionMap,
         });
     }
     const contextMessages = await loadContextMessages(memoryConfig, storage, input, workingMemoryJsonSchema);
+    const userContent = input.attachments?.length
+        ? [
+            { type: 'text', text: input.message },
+            ...input.attachments.map((a) => ({
+                type: a.type,
+                data: a.data,
+                url: a.url,
+                mediaType: a.mediaType,
+                ...(a.filename ? { filename: a.filename } : {}),
+            })),
+        ]
+        : input.message;
     const userMessage = {
         id: randomUUID(),
         role: 'user',
-        content: input.message,
+        content: userContent,
         createdAt: new Date(),
     };
     const allMessages = [...contextMessages, ...messages, userMessage];
     const trimmedMessages = trimMessages(allMessages);
-    const { tools, missingRpcs } = buildToolDefs(singletonServices, params, agentSessionMap, input.resourceId, resolvedName, packageName, streamContext);
+    const aiMiddlewares = agent.aiMiddleware ?? [];
+    const { tools, missingRpcs } = buildToolDefs(params, agentSessionMap, input.resourceId, resolvedName, packageName, streamContext, aiMiddlewares);
     const instructions = buildInstructions(resolvedName, packageName);
     const resolved = resolveModelConfig(resolvedName, agent);
+    const maxSteps = resolved.maxSteps ?? 10;
     const runnerParams = {
         model: resolved.model,
         temperature: resolved.temperature,
         instructions,
         messages: trimmedMessages,
         tools,
-        maxSteps: resolved.maxSteps ?? 10,
+        maxSteps: 1,
         toolChoice: agent.toolChoice ?? 'auto',
         outputSchema,
     };
@@ -305,6 +353,7 @@ export async function prepareAgentRun(agentName, input, params, agentSessionMap,
         threadId,
         userMessage,
         runnerParams,
+        maxSteps,
         missingRpcs,
         workingMemoryJsonSchema,
         workingMemorySchemaName,

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

@@ -1,5 +1,5 @@
 import type { CoreAIAgent } from './ai-agent.types.js';
-import { AIRunStateService } from '../../services/ai-run-state-service.js';
+import type { AIRunStateService } from '../../services/ai-run-state-service.js';
 export declare const addAIAgent: (agentName: string, agent: CoreAIAgent<any, any>, packageName?: string | null) => void;
 export declare function approveAIAgent(aiRunState: AIRunStateService, runId: string, approvals: {
     toolCallId: string;

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

@@ -1,9 +1,11 @@
 import { saveMessages } from './ai-agent-memory.js';
 import { prepareAgentRun } from './ai-agent-prepare.js';
+import { getSingletonServices } from '../../pikku-state.js';
+import { randomUUID } from 'crypto';
 export async function runAIAgent(agentName, input, params, agentSessionMap) {
     const sessionMap = agentSessionMap ?? new Map();
-    const { agent, agentRunner, storage, memoryConfig, threadId, userMessage, runnerParams, missingRpcs, workingMemoryJsonSchema, workingMemorySchemaName, } = await prepareAgentRun(agentName, input, params, sessionMap);
-    const { singletonServices } = params;
+    const { agent, agentRunner, storage, memoryConfig, threadId, userMessage, runnerParams, maxSteps, missingRpcs, workingMemoryJsonSchema, workingMemorySchemaName, } = await prepareAgentRun(agentName, input, params, sessionMap);
+    const singletonServices = getSingletonServices();
     const { aiRunState } = singletonServices;
     if (!aiRunState) {
         throw new Error('AIRunStateService not available in singletonServices');
@@ -53,7 +55,90 @@ export async function runAIAgent(agentName, input, params, agentSessionMap) {
         updatedAt: new Date(),
     });
     try {
-        const result = await agentRunner.run(runnerParams);
+        const accumulatedSteps = [];
+        const totalUsage = { inputTokens: 0, outputTokens: 0 };
+        let lastStepResult = null;
+        for (let step = 0; step < maxSteps; step++) {
+            if (agent.prepareStep) {
+                let stopped = false;
+                await agent.prepareStep({
+                    stepNumber: step,
+                    messages: runnerParams.messages,
+                    tools: runnerParams.tools,
+                    toolChoice: runnerParams.toolChoice,
+                    model: runnerParams.model,
+                    stop: () => {
+                        stopped = true;
+                    },
+                });
+                if (stopped)
+                    break;
+            }
+            const stepResult = await agentRunner.run(runnerParams);
+            lastStepResult = stepResult;
+            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,
+                    });
+                }
+            }
+            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,
+                        result: typeof tr?.result === 'string'
+                            ? tr.result
+                            : JSON.stringify(tr?.result ?? ''),
+                    };
+                }),
+            });
+            if (stepResult.toolCalls.length === 0)
+                break;
+            const assistantMsg = {
+                id: randomUUID(),
+                role: 'assistant',
+                content: stepResult.text || undefined,
+                toolCalls: stepResult.toolCalls.map((tc) => ({
+                    id: tc.toolCallId,
+                    name: tc.toolName,
+                    args: tc.args,
+                })),
+                createdAt: new Date(),
+            };
+            runnerParams.messages.push(assistantMsg);
+            if (stepResult.toolResults.length > 0) {
+                const toolMsg = {
+                    id: randomUUID(),
+                    role: 'tool',
+                    toolResults: stepResult.toolResults.map((tr) => ({
+                        id: tr.toolCallId,
+                        name: tr.toolName,
+                        result: typeof tr.result === 'string'
+                            ? tr.result
+                            : JSON.stringify(tr.result),
+                    })),
+                    createdAt: new Date(),
+                };
+                runnerParams.messages.push(toolMsg);
+            }
+        }
+        const finalText = lastStepResult?.text ?? '';
+        const finalObject = lastStepResult?.object;
+        const result = {
+            text: finalText,
+            steps: accumulatedSteps,
+        };
         const responseText = await saveMessages(storage, threadId, input.resourceId, memoryConfig, userMessage, result, {
             workingMemoryJsonSchema,
             workingMemorySchemaName,
@@ -68,7 +153,7 @@ export async function runAIAgent(agentName, input, params, agentSessionMap) {
                 const modResult = await mw.modifyOutput(singletonServices, {
                     text: outputText,
                     messages: outputMessages,
-                    usage: result.usage,
+                    usage: totalUsage,
                 });
                 outputText = modResult.text;
                 outputMessages = modResult.messages;
@@ -76,18 +161,32 @@ export async function runAIAgent(agentName, input, params, agentSessionMap) {
         }
         await aiRunState.updateRun(runId, {
             status: 'completed',
-            usage: { ...result.usage, model: agent.model },
+            usage: { ...totalUsage, model: agent.model },
         });
         return {
             runId,
             text: outputText,
-            object: result.object,
+            object: finalObject,
             threadId,
-            steps: result.steps,
-            usage: result.usage,
+            steps: accumulatedSteps,
+            usage: totalUsage,
         };
     }
     catch (error) {
+        for (const mw of aiMiddlewares) {
+            if (mw.onError) {
+                try {
+                    await mw.onError(singletonServices, {
+                        error: error instanceof Error ? error : new Error(String(error)),
+                        stepNumber: -1,
+                        messages: runnerParams.messages,
+                    });
+                }
+                catch {
+                    // onError hooks must not affect error flow
+                }
+            }
+        }
         await aiRunState.updateRun(runId, {
             status: 'failed',
         });

package/dist/wirings/ai-agent/ai-agent-stream.d.ts

@@ -4,8 +4,9 @@ export declare function streamAIAgent(agentName: string, input: {
     message: string;
     threadId: string;
     resourceId: string;
-}, channel: AIStreamChannel, params: RunAIAgentParams, agentSessionMap?: Map<string, string>, options?: StreamAIAgentOptions): Promise<void>;
+} | Record<string, unknown>, channel: AIStreamChannel, params: RunAIAgentParams, agentSessionMap?: Map<string, string>, options?: StreamAIAgentOptions): Promise<void>;
 export declare function resumeAIAgent(input: {
+    runId: string;
     toolCallId: string;
     approved: boolean;
 }, channel: AIStreamChannel, params: RunAIAgentParams, options?: StreamAIAgentOptions): Promise<void>;