@pikku/core 0.12.2 → 0.12.3

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

@@ -1,6 +1,8 @@
-import { saveMessages } from './ai-agent-memory.js';
-import { prepareAgentRun } from './ai-agent-prepare.js';
-import { getSingletonServices } from '../../pikku-state.js';
+import { saveMessages, resolveMemoryServices, loadContextMessages, trimMessages, } from './ai-agent-memory.js';
+import { prepareAgentRun, resolveAgent, buildInstructions, buildToolDefs, } from './ai-agent-prepare.js';
+import { checkForApprovals, appendStepMessages } from './ai-agent-stream.js';
+import { pikkuState, getSingletonServices } from '../../pikku-state.js';
+import { resolveModelConfig } from './ai-agent-model-config.js';
 import { randomUUID } from 'crypto';
 export async function runAIAgent(agentName, input, params, agentSessionMap) {
     const sessionMap = agentSessionMap ?? new Map();
@@ -105,33 +107,79 @@ export async function runAIAgent(agentName, input, params, agentSessionMap) {
             });
             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),
+            const approvalsNeeded = checkForApprovals(stepResult, runnerParams.tools, runId);
+            if (approvalsNeeded.length > 0) {
+                for (const approval of approvalsNeeded) {
+                    const toolDef = runnerParams.tools.find((t) => t.name === approval.toolName);
+                    if (toolDef?.approvalDescriptionFn && !approval.reason) {
+                        try {
+                            approval.reason = await toolDef.approvalDescriptionFn(approval.args);
+                        }
+                        catch {
+                            // If description generation fails, continue without it
+                        }
+                    }
+                }
+                const pendingApprovals = approvalsNeeded.map((a) => a.agentRunId
+                    ? {
+                        type: 'agent-call',
+                        toolCallId: a.toolCallId,
+                        agentName: a.toolName,
+                        agentRunId: a.agentRunId,
+                        displayToolName: a.displayToolName ?? a.toolName,
+                        displayArgs: a.displayArgs ?? a.args,
+                    }
+                    : {
+                        type: 'tool-call',
+                        toolCallId: a.toolCallId,
+                        toolName: a.toolName,
+                        args: a.args,
+                    });
+                const completedStepsForSave = accumulatedSteps.slice(0, -1);
+                await saveMessages(storage, threadId, input.resourceId, memoryConfig, userMessage, { text: '', steps: completedStepsForSave }, {
+                    workingMemoryJsonSchema,
+                    workingMemorySchemaName,
+                    logger: singletonServices.logger,
+                    schemaService: singletonServices.schema,
+                });
+                if (storage) {
+                    await storage.saveMessages(threadId, [
+                        {
+                            id: randomUUID(),
+                            role: 'assistant',
+                            toolCalls: stepResult.toolCalls.map((tc) => ({
+                                id: tc.toolCallId,
+                                name: tc.toolName,
+                                args: tc.args,
+                            })),
+                            createdAt: new Date(),
+                        },
+                    ]);
+                }
+                await aiRunState.updateRun(runId, {
+                    status: 'suspended',
+                    suspendReason: 'approval',
+                    pendingApprovals,
+                    usage: { ...totalUsage, model: agent.model },
+                });
+                const suspendedFinalText = lastStepResult?.text ?? '';
+                return {
+                    runId,
+                    text: suspendedFinalText,
+                    threadId,
+                    steps: accumulatedSteps,
+                    usage: totalUsage,
+                    status: 'suspended',
+                    pendingApprovals: approvalsNeeded.map((a) => ({
+                        toolCallId: a.toolCallId,
+                        toolName: a.displayToolName ?? a.toolName,
+                        args: a.displayArgs ?? a.args,
+                        reason: a.reason,
+                        runId,
                     })),
-                    createdAt: new Date(),
                 };
-                runnerParams.messages.push(toolMsg);
             }
+            appendStepMessages(runnerParams, stepResult);
         }
         const finalText = lastStepResult?.text ?? '';
         const finalObject = lastStepResult?.object;
@@ -189,6 +237,312 @@ export async function runAIAgent(agentName, input, params, agentSessionMap) {
         }
         await aiRunState.updateRun(runId, {
             status: 'failed',
+            errorMessage: error instanceof Error ? error.message : String(error),
+        });
+        throw error;
+    }
+}
+export async function resumeAIAgentSync(runId, approvals, params, expectedAgentName) {
+    const singletonServices = getSingletonServices();
+    const { aiRunState } = singletonServices;
+    if (!aiRunState) {
+        throw new Error('AIRunStateService not available in singletonServices');
+    }
+    const run = await aiRunState.getRun(runId);
+    if (!run)
+        throw new Error(`No run found for runId ${runId}`);
+    if (expectedAgentName && run.agentName !== expectedAgentName) {
+        throw new Error(`Run ${runId} belongs to agent '${run.agentName}', not '${expectedAgentName}'`);
+    }
+    if (run.status !== 'suspended') {
+        throw new Error(`Run ${runId} is not suspended (status: ${run.status})`);
+    }
+    const { agent, packageName, resolvedName } = resolveAgent(run.agentName);
+    const { storage } = resolveMemoryServices(agent, singletonServices);
+    const memoryConfig = agent.memory;
+    const agentRunner = singletonServices.aiAgentRunner;
+    if (!agentRunner) {
+        throw new Error('AIAgentRunnerService not available');
+    }
+    const approvedIds = new Set(approvals.filter((a) => a.approved).map((a) => a.toolCallId));
+    const rejectedIds = new Set(approvals.filter((a) => !a.approved).map((a) => a.toolCallId));
+    const savedPendingApprovals = [...(run.pendingApprovals ?? [])];
+    for (const { toolCallId, approved } of approvals) {
+        await aiRunState.resolveApproval(toolCallId, approved ? 'approved' : 'denied');
+    }
+    const { tools } = await buildToolDefs(params, new Map(), run.resourceId, resolvedName, packageName, undefined, agent.aiMiddleware ?? []);
+    const toolCallMessages = [];
+    for (const pending of savedPendingApprovals) {
+        if (pending.type !== 'tool-call')
+            continue;
+        const toolCallId = pending.toolCallId;
+        let resultStr;
+        if (rejectedIds.has(toolCallId)) {
+            resultStr =
+                'The user explicitly declined this action. Inform them that it was declined and do not retry.';
+        }
+        else if (approvedIds.has(toolCallId)) {
+            const matchingTool = tools.find((t) => t.name === pending.toolName);
+            if (!matchingTool) {
+                throw new Error(`Tool "${pending.toolName}" not found in agent definition`);
+            }
+            const toolArgs = typeof pending.args === 'string'
+                ? JSON.parse(pending.args)
+                : pending.args;
+            try {
+                const toolResult = await matchingTool.execute(toolArgs);
+                resultStr =
+                    typeof toolResult === 'string'
+                        ? toolResult
+                        : JSON.stringify(toolResult);
+            }
+            catch (err) {
+                resultStr = `Error: ${err instanceof Error ? err.message : String(err)}`;
+            }
+        }
+        else {
+            continue;
+        }
+        toolCallMessages.push({
+            toolCallId,
+            toolName: pending.toolName,
+            args: typeof pending.args === 'string'
+                ? JSON.parse(pending.args)
+                : pending.args,
+            result: resultStr,
+        });
+    }
+    if (storage && toolCallMessages.length > 0) {
+        await storage.saveMessages(run.threadId, [
+            {
+                id: randomUUID(),
+                role: 'tool',
+                toolResults: toolCallMessages.map((tc) => ({
+                    id: tc.toolCallId,
+                    name: tc.toolName,
+                    result: tc.result,
+                })),
+                createdAt: new Date(),
+            },
+        ]);
+    }
+    await aiRunState.updateRun(runId, { status: 'running' });
+    return continueAfterToolResultSync(run, agent, packageName, resolvedName, storage, memoryConfig, agentRunner, params, aiRunState);
+}
+async function continueAfterToolResultSync(run, agent, packageName, resolvedName, storage, memoryConfig, agentRunner, params, aiRunState) {
+    const singletonServices = getSingletonServices();
+    const agentsMeta = pikkuState(packageName, 'agent', 'agentsMeta');
+    const meta = agentsMeta[resolvedName];
+    const workingMemorySchemaName = meta?.workingMemorySchema ?? null;
+    const messages = storage
+        ? await storage.getMessages(run.threadId, {
+            lastN: memoryConfig?.lastMessages ?? 20,
+        })
+        : [];
+    const workingMemoryJsonSchema = workingMemorySchemaName
+        ? pikkuState(packageName, 'misc', 'schemas').get(workingMemorySchemaName)
+        : undefined;
+    const contextMessages = await loadContextMessages(memoryConfig, storage, { message: '', threadId: run.threadId, resourceId: run.resourceId }, workingMemoryJsonSchema);
+    const allMessages = [...contextMessages, ...messages];
+    const trimmedMessages = trimMessages(allMessages);
+    const instructions = await buildInstructions(resolvedName, packageName);
+    const aiMiddlewares = agent.aiMiddleware ?? [];
+    let modifiedMessages = trimmedMessages;
+    let modifiedInstructions = instructions;
+    for (const mw of aiMiddlewares) {
+        if (mw.modifyInput) {
+            const result = await mw.modifyInput(singletonServices, {
+                messages: modifiedMessages,
+                instructions: modifiedInstructions,
+            });
+            modifiedMessages = result.messages;
+            modifiedInstructions = result.instructions;
+        }
+    }
+    const { tools: resumeTools } = await buildToolDefs(params, new Map(), run.resourceId, resolvedName, packageName, undefined, aiMiddlewares);
+    const resolved = resolveModelConfig(resolvedName, agent);
+    const maxSteps = resolved.maxSteps ?? 10;
+    const runnerParams = {
+        model: resolved.model,
+        temperature: resolved.temperature,
+        instructions: modifiedInstructions,
+        messages: modifiedMessages,
+        tools: resumeTools,
+        maxSteps: 1,
+        toolChoice: (agent.toolChoice ?? 'auto'),
+        outputSchema: meta?.outputSchema
+            ? pikkuState(packageName, 'misc', 'schemas').get(meta.outputSchema)
+            : undefined,
+    };
+    try {
+        const accumulatedSteps = [];
+        const totalUsage = { inputTokens: 0, outputTokens: 0 };
+        let lastStepResult = null;
+        for (let step = 0; step < maxSteps; step++) {
+            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 approvalsNeeded = checkForApprovals(stepResult, runnerParams.tools, run.runId);
+            if (approvalsNeeded.length > 0) {
+                for (const approval of approvalsNeeded) {
+                    const toolDef = runnerParams.tools.find((t) => t.name === approval.toolName);
+                    if (toolDef?.approvalDescriptionFn && !approval.reason) {
+                        try {
+                            approval.reason = await toolDef.approvalDescriptionFn(approval.args);
+                        }
+                        catch {
+                            // ignore
+                        }
+                    }
+                }
+                const pendingApprovals = approvalsNeeded.map((a) => a.agentRunId
+                    ? {
+                        type: 'agent-call',
+                        toolCallId: a.toolCallId,
+                        agentName: a.toolName,
+                        agentRunId: a.agentRunId,
+                        displayToolName: a.displayToolName ?? a.toolName,
+                        displayArgs: a.displayArgs ?? a.args,
+                    }
+                    : {
+                        type: 'tool-call',
+                        toolCallId: a.toolCallId,
+                        toolName: a.toolName,
+                        args: a.args,
+                    });
+                const completedSteps = accumulatedSteps.slice(0, -1);
+                if (completedSteps.length > 0) {
+                    await saveMessages(storage, run.threadId, run.resourceId, memoryConfig, null, { text: '', steps: completedSteps }, {
+                        workingMemoryJsonSchema,
+                        workingMemorySchemaName,
+                        logger: singletonServices.logger,
+                        schemaService: singletonServices.schema,
+                    });
+                }
+                if (storage) {
+                    await storage.saveMessages(run.threadId, [
+                        {
+                            id: randomUUID(),
+                            role: 'assistant',
+                            toolCalls: stepResult.toolCalls.map((tc) => ({
+                                id: tc.toolCallId,
+                                name: tc.toolName,
+                                args: tc.args,
+                            })),
+                            createdAt: new Date(),
+                        },
+                    ]);
+                }
+                await aiRunState.updateRun(run.runId, {
+                    status: 'suspended',
+                    suspendReason: 'approval',
+                    pendingApprovals,
+                    usage: { ...totalUsage, model: agent.model },
+                });
+                const suspendedText = lastStepResult?.text ?? '';
+                return {
+                    runId: run.runId,
+                    text: suspendedText,
+                    threadId: run.threadId,
+                    steps: accumulatedSteps,
+                    usage: totalUsage,
+                    status: 'suspended',
+                    pendingApprovals: approvalsNeeded.map((a) => ({
+                        toolCallId: a.toolCallId,
+                        toolName: a.displayToolName ?? a.toolName,
+                        args: a.displayArgs ?? a.args,
+                        reason: a.reason,
+                        runId: run.runId,
+                    })),
+                };
+            }
+            appendStepMessages(runnerParams, stepResult);
+        }
+        const finalText = lastStepResult?.text ?? '';
+        const finalObject = lastStepResult?.object;
+        const result = {
+            text: finalText,
+            steps: accumulatedSteps,
+        };
+        const responseText = await saveMessages(storage, run.threadId, run.resourceId, memoryConfig, null, result, {
+            workingMemoryJsonSchema,
+            workingMemorySchemaName,
+            logger: singletonServices.logger,
+            schemaService: singletonServices.schema,
+        });
+        let outputText = responseText;
+        let outputMessages = runnerParams.messages;
+        for (let i = aiMiddlewares.length - 1; i >= 0; i--) {
+            const mw = aiMiddlewares[i];
+            if (mw.modifyOutput) {
+                const modResult = await mw.modifyOutput(singletonServices, {
+                    text: outputText,
+                    messages: outputMessages,
+                    usage: totalUsage,
+                });
+                outputText = modResult.text;
+                outputMessages = modResult.messages;
+            }
+        }
+        await aiRunState.updateRun(run.runId, {
+            status: 'completed',
+            usage: { ...totalUsage, model: agent.model },
+        });
+        return {
+            runId: run.runId,
+            text: outputText,
+            object: finalObject,
+            threadId: run.threadId,
+            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 {
+                    // ignore
+                }
+            }
+        }
+        await aiRunState.updateRun(run.runId, {
+            status: 'failed',
+            errorMessage: error instanceof Error ? error.message : String(error),
         });
         throw error;
     }

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

@@ -1,10 +1,15 @@
 import type { AIStreamChannel } from './ai-agent.types.js';
-import { type RunAIAgentParams, type StreamAIAgentOptions } from './ai-agent-prepare.js';
+import type { AIAgentRunnerParams, AIAgentStepResult } from '../../services/ai-agent-runner-service.js';
+import { ToolApprovalRequired, type RunAIAgentParams, type StreamAIAgentOptions } from './ai-agent-prepare.js';
+export declare function checkForApprovals(stepResult: AIAgentStepResult, tools: AIAgentRunnerParams['tools'], runId: string): ToolApprovalRequired[];
+export declare function appendStepMessages(runnerParams: AIAgentRunnerParams, stepResult: AIAgentStepResult): void;
 export declare function streamAIAgent(agentName: string, input: {
     message: string;
     threadId: string;
     resourceId: string;
-} | Record<string, unknown>, channel: AIStreamChannel, params: RunAIAgentParams, agentSessionMap?: Map<string, string>, options?: StreamAIAgentOptions): Promise<void>;
+    model?: string;
+    temperature?: number;
+}, channel: AIStreamChannel, params: RunAIAgentParams, agentSessionMap?: Map<string, string>, options?: StreamAIAgentOptions): Promise<string>;
 export declare function resumeAIAgent(input: {
     runId: string;
     toolCallId: string;