psadk 1.3.7 → 1.4.3

package/build/main/lib/PSAgentLogger.js

@@ -8,17 +8,21 @@ exports.PSAgentLogger = void 0;
 const node_fs_1 = __importDefault(require("node:fs"));
 const debuglogger_1 = __importDefault(require("./utils/debuglogger"));
 class PSAgentLogger {
+    static id = 1000;
+    logFn = (0, debuglogger_1.default)('PSAI:');
+    logFilePath;
+    taskId;
+    task;
     constructor(options) {
-        this.logFn = (0, debuglogger_1.default)('PSAI:');
-        if ((options === null || options === void 0 ? void 0 : options.startcounter) !== undefined) {
+        if (options?.startcounter !== undefined) {
             PSAgentLogger.id = options.startcounter;
         }
-        if (options === null || options === void 0 ? void 0 : options.prefix) {
+        if (options?.prefix) {
             this.logFn = (0, debuglogger_1.default)(options.prefix);
         }
-        this.logFilePath = options === null || options === void 0 ? void 0 : options.logFilePath;
-        this.taskId = options === null || options === void 0 ? void 0 : options.taskId;
-        this.task = options === null || options === void 0 ? void 0 : options.task;
+        this.logFilePath = options?.logFilePath;
+        this.taskId = options?.taskId;
+        this.task = options?.task;
     }
     log(type, message, ...optionalParams) {
         const logId = PSAgentLogger.id++;
@@ -31,7 +35,7 @@ class PSAgentLogger {
                 taskId: this.taskId,
                 task: this.task,
                 message,
-                params: Object.assign({}, optionalParams),
+                params: { ...optionalParams },
             })}\n`, { encoding: 'utf-8' });
             return logId;
         }
@@ -70,5 +74,4 @@ class PSAgentLogger {
     }
 }
 exports.PSAgentLogger = PSAgentLogger;
-PSAgentLogger.id = 1000;
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/build/main/lib/PSAgentTask.js

@@ -2,6 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PSAgentTask = void 0;
 class PSAgentTask {
+    name;
+    description;
+    examples;
     constructor(name, description, examples) {
         this.name = name;
         this.description = description;
@@ -27,4 +30,4 @@ class PSAgentTask {
     }
 }
 exports.PSAgentTask = PSAgentTask;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiUFNBZ2VudFRhc2suanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvbGliL1BTQWdlbnRUYXNrLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7OztBQUFBLE1BQWEsV0FBVztJQUl0QixZQUFZLElBQVksRUFBRSxXQUFtQixFQUFFLFFBQW1CO1FBQ2hFLElBQUksQ0FBQyxJQUFJLEdBQUcsSUFBSSxDQUFDO1FBQ2pCLElBQUksQ0FBQyxXQUFXLEdBQUcsV0FBVyxDQUFDO1FBQy9CLElBQUksQ0FBQyxRQUFRLEdBQUcsUUFBUSxDQUFDO0lBQzNCLENBQUM7SUFDRCxJQUFXLElBQUk7UUFDYixPQUFPLElBQUksQ0FBQyxJQUFJLENBQUM7SUFDbkIsQ0FBQztJQUNELElBQVcsSUFBSSxDQUFDLEtBQWE7UUFDM0IsSUFBSSxDQUFDLElBQUksR0FBRyxLQUFLLENBQUM7SUFDcEIsQ0FBQztJQUNELElBQVcsV0FBVztRQUNwQixPQUFPLElBQUksQ0FBQyxXQUFXLENBQUM7SUFDMUIsQ0FBQztJQUNELElBQVcsV0FBVyxDQUFDLEtBQWE7UUFDbEMsSUFBSSxDQUFDLFdBQVcsR0FBRyxLQUFLLENBQUM7SUFDM0IsQ0FBQztJQUNELElBQVcsUUFBUTtRQUNqQixPQUFPLElBQUksQ0FBQyxRQUFRLElBQUksRUFBRSxDQUFDO0lBQzdCLENBQUM7SUFDRCxJQUFXLFFBQVEsQ0FBQyxLQUFlO1FBQ2pDLElBQUksQ0FBQyxRQUFRLEdBQUcsS0FBSyxJQUFJLEVBQUUsQ0FBQztJQUM5QixDQUFDO0NBQ0Y7QUEzQkQsa0NBMkJDIn0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiUFNBZ2VudFRhc2suanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvbGliL1BTQWdlbnRUYXNrLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7OztBQUFBLE1BQWEsV0FBVztJQUNkLElBQUksQ0FBUztJQUNiLFdBQVcsQ0FBUztJQUNwQixRQUFRLENBQVk7SUFDNUIsWUFBWSxJQUFZLEVBQUUsV0FBbUIsRUFBRSxRQUFtQjtRQUNoRSxJQUFJLENBQUMsSUFBSSxHQUFHLElBQUksQ0FBQztRQUNqQixJQUFJLENBQUMsV0FBVyxHQUFHLFdBQVcsQ0FBQztRQUMvQixJQUFJLENBQUMsUUFBUSxHQUFHLFFBQVEsQ0FBQztJQUMzQixDQUFDO0lBQ0QsSUFBVyxJQUFJO1FBQ2IsT0FBTyxJQUFJLENBQUMsSUFBSSxDQUFDO0lBQ25CLENBQUM7SUFDRCxJQUFXLElBQUksQ0FBQyxLQUFhO1FBQzNCLElBQUksQ0FBQyxJQUFJLEdBQUcsS0FBSyxDQUFDO0lBQ3BCLENBQUM7SUFDRCxJQUFXLFdBQVc7UUFDcEIsT0FBTyxJQUFJLENBQUMsV0FBVyxDQUFDO0lBQzFCLENBQUM7SUFDRCxJQUFXLFdBQVcsQ0FBQyxLQUFhO1FBQ2xDLElBQUksQ0FBQyxXQUFXLEdBQUcsS0FBSyxDQUFDO0lBQzNCLENBQUM7SUFDRCxJQUFXLFFBQVE7UUFDakIsT0FBTyxJQUFJLENBQUMsUUFBUSxJQUFJLEVBQUUsQ0FBQztJQUM3QixDQUFDO0lBQ0QsSUFBVyxRQUFRLENBQUMsS0FBZTtRQUNqQyxJQUFJLENBQUMsUUFBUSxHQUFHLEtBQUssSUFBSSxFQUFFLENBQUM7SUFDOUIsQ0FBQztDQUNGO0FBM0JELGtDQTJCQyJ9

package/build/main/lib/PSAgentTool.js

@@ -3,6 +3,13 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.PSAgentTool = void 0;
 const helpers_1 = require("./utils/helpers");
 class PSAgentTool {
+    name;
+    description;
+    type;
+    local_execution;
+    hitl;
+    inputschema;
+    runCallback;
     constructor({ name, description, type = 'API', local_execution = true, hitl = true, inputschema, runCallback, }) {
         this.name = name;
         this.description = description;
@@ -52,7 +59,10 @@ class PSAgentTool {
         this.hitl = value;
     }
     get Inputs() {
-        return Object.assign(Object.assign({}, this.inputschema), { requestBody: (0, helpers_1.removeSchemaMetadata)(this.inputschema.requestBody) });
+        return {
+            ...this.inputschema,
+            requestBody: (0, helpers_1.removeSchemaMetadata)(this.inputschema.requestBody),
+        };
     }
     set Inputs(value) {
         this.inputschema = value;
@@ -82,4 +92,4 @@ class PSAgentTool {
     }
 }
 exports.PSAgentTool = PSAgentTool;
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/build/main/lib/agent-core/agent-loop.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Agent loop that works with AgentMessage throughout.
+ * Transforms to Message[] only at the LLM call boundary.
+ */
+import { EventStream } from '@earendil-works/pi-ai';
+import type { AgentContext, AgentEvent, AgentLoopConfig, AgentMessage, StreamFn } from './types.js';
+export type AgentEventSink = (event: AgentEvent) => Promise<void> | void;
+/**
+ * Start an agent loop with a new prompt message.
+ * The prompt is added to the context and events are emitted for it.
+ */
+export declare function agentLoop(prompts: AgentMessage[], context: AgentContext, config: AgentLoopConfig, signal?: AbortSignal, streamFn?: StreamFn): EventStream<AgentEvent, AgentMessage[]>;
+/**
+ * Continue an agent loop from the current context without adding a new message.
+ * Used for retries - context already has user message or tool results.
+ *
+ * **Important:** The last message in context must convert to a `user` or `toolResult` message
+ * via `convertToLlm`. If it doesn't, the LLM provider will reject the request.
+ * This cannot be validated here since `convertToLlm` is only called once per turn.
+ */
+export declare function agentLoopContinue(context: AgentContext, config: AgentLoopConfig, signal?: AbortSignal, streamFn?: StreamFn): EventStream<AgentEvent, AgentMessage[]>;
+export declare function runAgentLoop(prompts: AgentMessage[], context: AgentContext, config: AgentLoopConfig, emit: AgentEventSink, signal?: AbortSignal, streamFn?: StreamFn): Promise<AgentMessage[]>;
+export declare function runAgentLoopContinue(context: AgentContext, config: AgentLoopConfig, emit: AgentEventSink, signal?: AbortSignal, streamFn?: StreamFn): Promise<AgentMessage[]>;

package/build/main/lib/agent-core/agent-loop.js

@@ -0,0 +1,483 @@
+/**
+ * Agent loop that works with AgentMessage throughout.
+ * Transforms to Message[] only at the LLM call boundary.
+ */
+import { EventStream, streamSimple, validateToolArguments, } from '@earendil-works/pi-ai';
+/**
+ * Start an agent loop with a new prompt message.
+ * The prompt is added to the context and events are emitted for it.
+ */
+export function agentLoop(prompts, context, config, signal, streamFn) {
+    const stream = createAgentStream();
+    void runAgentLoop(prompts, context, config, async (event) => {
+        stream.push(event);
+    }, signal, streamFn).then((messages) => {
+        stream.end(messages);
+    });
+    return stream;
+}
+/**
+ * Continue an agent loop from the current context without adding a new message.
+ * Used for retries - context already has user message or tool results.
+ *
+ * **Important:** The last message in context must convert to a `user` or `toolResult` message
+ * via `convertToLlm`. If it doesn't, the LLM provider will reject the request.
+ * This cannot be validated here since `convertToLlm` is only called once per turn.
+ */
+export function agentLoopContinue(context, config, signal, streamFn) {
+    if (context.messages.length === 0) {
+        throw new Error('Cannot continue: no messages in context');
+    }
+    if (context.messages[context.messages.length - 1].role === 'assistant') {
+        throw new Error('Cannot continue from message role: assistant');
+    }
+    const stream = createAgentStream();
+    void runAgentLoopContinue(context, config, async (event) => {
+        stream.push(event);
+    }, signal, streamFn).then((messages) => {
+        stream.end(messages);
+    });
+    return stream;
+}
+export async function runAgentLoop(prompts, context, config, emit, signal, streamFn) {
+    const newMessages = [...prompts];
+    const currentContext = {
+        ...context,
+        messages: [...context.messages, ...prompts],
+    };
+    await emit({ type: 'agent_start' });
+    await emit({ type: 'turn_start' });
+    for (const prompt of prompts) {
+        await emit({ type: 'message_start', message: prompt });
+        await emit({ type: 'message_end', message: prompt });
+    }
+    await runLoop(currentContext, newMessages, config, signal, emit, streamFn);
+    return newMessages;
+}
+export async function runAgentLoopContinue(context, config, emit, signal, streamFn) {
+    if (context.messages.length === 0) {
+        throw new Error('Cannot continue: no messages in context');
+    }
+    if (context.messages[context.messages.length - 1].role === 'assistant') {
+        throw new Error('Cannot continue from message role: assistant');
+    }
+    const newMessages = [];
+    const currentContext = { ...context };
+    await emit({ type: 'agent_start' });
+    await emit({ type: 'turn_start' });
+    await runLoop(currentContext, newMessages, config, signal, emit, streamFn);
+    return newMessages;
+}
+function createAgentStream() {
+    return new EventStream((event) => event.type === 'agent_end', (event) => (event.type === 'agent_end' ? event.messages : []));
+}
+/**
+ * Main loop logic shared by agentLoop and agentLoopContinue.
+ */
+async function runLoop(initialContext, newMessages, initialConfig, signal, emit, streamFn) {
+    let currentContext = initialContext;
+    let config = initialConfig;
+    let firstTurn = true;
+    // Check for steering messages at start (user may have typed while waiting)
+    let pendingMessages = (await config.getSteeringMessages?.()) || [];
+    // Outer loop: continues when queued follow-up messages arrive after agent would stop
+    while (true) {
+        let hasMoreToolCalls = true;
+        // Inner loop: process tool calls and steering messages
+        while (hasMoreToolCalls || pendingMessages.length > 0) {
+            if (!firstTurn) {
+                await emit({ type: 'turn_start' });
+            }
+            else {
+                firstTurn = false;
+            }
+            // Process pending messages (inject before next assistant response)
+            if (pendingMessages.length > 0) {
+                for (const message of pendingMessages) {
+                    await emit({ type: 'message_start', message });
+                    await emit({ type: 'message_end', message });
+                    currentContext.messages.push(message);
+                    newMessages.push(message);
+                }
+                pendingMessages = [];
+            }
+            // Stream assistant response
+            const message = await streamAssistantResponse(currentContext, config, signal, emit, streamFn);
+            newMessages.push(message);
+            if (message.stopReason === 'error' || message.stopReason === 'aborted') {
+                await emit({ type: 'turn_end', message, toolResults: [] });
+                await emit({ type: 'agent_end', messages: newMessages });
+                return;
+            }
+            // Check for tool calls
+            const toolCalls = message.content.filter((c) => c.type === 'toolCall');
+            const toolResults = [];
+            hasMoreToolCalls = false;
+            if (toolCalls.length > 0) {
+                const executedToolBatch = await executeToolCalls(currentContext, message, config, signal, emit);
+                toolResults.push(...executedToolBatch.messages);
+                hasMoreToolCalls = !executedToolBatch.terminate;
+                for (const result of toolResults) {
+                    currentContext.messages.push(result);
+                    newMessages.push(result);
+                }
+            }
+            await emit({ type: 'turn_end', message, toolResults });
+            const nextTurnContext = {
+                message,
+                toolResults,
+                context: currentContext,
+                newMessages,
+            };
+            const nextTurnSnapshot = await config.prepareNextTurn?.(nextTurnContext);
+            if (nextTurnSnapshot) {
+                currentContext = nextTurnSnapshot.context ?? currentContext;
+                config = {
+                    ...config,
+                    model: nextTurnSnapshot.model ?? config.model,
+                    reasoning: nextTurnSnapshot.thinkingLevel === undefined
+                        ? config.reasoning
+                        : nextTurnSnapshot.thinkingLevel === 'off'
+                            ? undefined
+                            : nextTurnSnapshot.thinkingLevel,
+                };
+            }
+            if (await config.shouldStopAfterTurn?.({
+                message,
+                toolResults,
+                context: currentContext,
+                newMessages,
+            })) {
+                await emit({ type: 'agent_end', messages: newMessages });
+                return;
+            }
+            pendingMessages = (await config.getSteeringMessages?.()) || [];
+        }
+        // Agent would stop here. Check for follow-up messages.
+        const followUpMessages = (await config.getFollowUpMessages?.()) || [];
+        if (followUpMessages.length > 0) {
+            // Set as pending so inner loop processes them
+            pendingMessages = followUpMessages;
+            continue;
+        }
+        // No more messages, exit
+        break;
+    }
+    await emit({ type: 'agent_end', messages: newMessages });
+}
+/**
+ * Stream an assistant response from the LLM.
+ * This is where AgentMessage[] gets transformed to Message[] for the LLM.
+ */
+async function streamAssistantResponse(context, config, signal, emit, streamFn) {
+    // Apply context transform if configured (AgentMessage[] → AgentMessage[])
+    let messages = context.messages;
+    if (config.transformContext) {
+        messages = await config.transformContext(messages, signal);
+    }
+    // Convert to LLM-compatible messages (AgentMessage[] → Message[])
+    const llmMessages = await config.convertToLlm(messages);
+    // Build LLM context
+    const llmContext = {
+        systemPrompt: context.systemPrompt,
+        messages: llmMessages,
+        tools: context.tools,
+    };
+    const streamFunction = streamFn || streamSimple;
+    // Resolve API key (important for expiring tokens)
+    const resolvedApiKey = (config.getApiKey
+        ? await config.getApiKey(config.model.provider)
+        : undefined) || config.apiKey;
+    const response = await streamFunction(config.model, llmContext, {
+        ...config,
+        apiKey: resolvedApiKey,
+        signal,
+    });
+    let partialMessage = null;
+    let addedPartial = false;
+    for await (const event of response) {
+        switch (event.type) {
+            case 'start':
+                partialMessage = event.partial;
+                context.messages.push(partialMessage);
+                addedPartial = true;
+                await emit({ type: 'message_start', message: { ...partialMessage } });
+                break;
+            case 'text_start':
+            case 'text_delta':
+            case 'text_end':
+            case 'thinking_start':
+            case 'thinking_delta':
+            case 'thinking_end':
+            case 'toolcall_start':
+            case 'toolcall_delta':
+            case 'toolcall_end':
+                if (partialMessage) {
+                    partialMessage = event.partial;
+                    context.messages[context.messages.length - 1] = partialMessage;
+                    await emit({
+                        type: 'message_update',
+                        assistantMessageEvent: event,
+                        message: { ...partialMessage },
+                    });
+                }
+                break;
+            case 'done':
+            case 'error': {
+                const finalMessage = await response.result();
+                if (addedPartial) {
+                    context.messages[context.messages.length - 1] = finalMessage;
+                }
+                else {
+                    context.messages.push(finalMessage);
+                }
+                if (!addedPartial) {
+                    await emit({ type: 'message_start', message: { ...finalMessage } });
+                }
+                await emit({ type: 'message_end', message: finalMessage });
+                return finalMessage;
+            }
+        }
+    }
+    const finalMessage = await response.result();
+    if (addedPartial) {
+        context.messages[context.messages.length - 1] = finalMessage;
+    }
+    else {
+        context.messages.push(finalMessage);
+        await emit({ type: 'message_start', message: { ...finalMessage } });
+    }
+    await emit({ type: 'message_end', message: finalMessage });
+    return finalMessage;
+}
+/**
+ * Execute tool calls from an assistant message.
+ */
+async function executeToolCalls(currentContext, assistantMessage, config, signal, emit) {
+    const toolCalls = assistantMessage.content.filter((c) => c.type === 'toolCall');
+    const hasSequentialToolCall = toolCalls.some((tc) => currentContext.tools?.find((t) => t.name === tc.name)?.executionMode ===
+        'sequential');
+    if (config.toolExecution === 'sequential' || hasSequentialToolCall) {
+        return executeToolCallsSequential(currentContext, assistantMessage, toolCalls, config, signal, emit);
+    }
+    return executeToolCallsParallel(currentContext, assistantMessage, toolCalls, config, signal, emit);
+}
+async function executeToolCallsSequential(currentContext, assistantMessage, toolCalls, config, signal, emit) {
+    const finalizedCalls = [];
+    const messages = [];
+    for (const toolCall of toolCalls) {
+        await emit({
+            type: 'tool_execution_start',
+            toolCallId: toolCall.id,
+            toolName: toolCall.name,
+            args: toolCall.arguments,
+        });
+        const preparation = await prepareToolCall(currentContext, assistantMessage, toolCall, config, signal);
+        let finalized;
+        if (preparation.kind === 'immediate') {
+            finalized = {
+                toolCall,
+                result: preparation.result,
+                isError: preparation.isError,
+            };
+        }
+        else {
+            const executed = await executePreparedToolCall(preparation, signal, emit);
+            finalized = await finalizeExecutedToolCall(currentContext, assistantMessage, preparation, executed, config, signal);
+        }
+        await emitToolExecutionEnd(finalized, emit);
+        const toolResultMessage = createToolResultMessage(finalized);
+        await emitToolResultMessage(toolResultMessage, emit);
+        finalizedCalls.push(finalized);
+        messages.push(toolResultMessage);
+    }
+    return {
+        messages,
+        terminate: shouldTerminateToolBatch(finalizedCalls),
+    };
+}
+async function executeToolCallsParallel(currentContext, assistantMessage, toolCalls, config, signal, emit) {
+    const finalizedCalls = [];
+    for (const toolCall of toolCalls) {
+        await emit({
+            type: 'tool_execution_start',
+            toolCallId: toolCall.id,
+            toolName: toolCall.name,
+            args: toolCall.arguments,
+        });
+        const preparation = await prepareToolCall(currentContext, assistantMessage, toolCall, config, signal);
+        if (preparation.kind === 'immediate') {
+            const finalized = {
+                toolCall,
+                result: preparation.result,
+                isError: preparation.isError,
+            };
+            await emitToolExecutionEnd(finalized, emit);
+            finalizedCalls.push(finalized);
+            continue;
+        }
+        finalizedCalls.push(async () => {
+            const executed = await executePreparedToolCall(preparation, signal, emit);
+            const finalized = await finalizeExecutedToolCall(currentContext, assistantMessage, preparation, executed, config, signal);
+            await emitToolExecutionEnd(finalized, emit);
+            return finalized;
+        });
+    }
+    const orderedFinalizedCalls = await Promise.all(finalizedCalls.map((entry) => typeof entry === 'function' ? entry() : Promise.resolve(entry)));
+    const messages = [];
+    for (const finalized of orderedFinalizedCalls) {
+        const toolResultMessage = createToolResultMessage(finalized);
+        await emitToolResultMessage(toolResultMessage, emit);
+        messages.push(toolResultMessage);
+    }
+    return {
+        messages,
+        terminate: shouldTerminateToolBatch(orderedFinalizedCalls),
+    };
+}
+function shouldTerminateToolBatch(finalizedCalls) {
+    return (finalizedCalls.length > 0 &&
+        finalizedCalls.every((finalized) => finalized.result.terminate === true));
+}
+function prepareToolCallArguments(tool, toolCall) {
+    if (!tool.prepareArguments) {
+        return toolCall;
+    }
+    const preparedArguments = tool.prepareArguments(toolCall.arguments);
+    if (preparedArguments === toolCall.arguments) {
+        return toolCall;
+    }
+    return {
+        ...toolCall,
+        arguments: preparedArguments,
+    };
+}
+async function prepareToolCall(currentContext, assistantMessage, toolCall, config, signal) {
+    const tool = currentContext.tools?.find((t) => t.name === toolCall.name);
+    if (!tool) {
+        return {
+            kind: 'immediate',
+            result: createErrorToolResult(`Tool ${toolCall.name} not found`),
+            isError: true,
+        };
+    }
+    try {
+        const preparedToolCall = prepareToolCallArguments(tool, toolCall);
+        const validatedArgs = validateToolArguments(tool, preparedToolCall);
+        if (config.beforeToolCall) {
+            const beforeResult = await config.beforeToolCall({
+                assistantMessage,
+                toolCall,
+                args: validatedArgs,
+                context: currentContext,
+            }, signal);
+            if (beforeResult?.block) {
+                return {
+                    kind: 'immediate',
+                    result: createErrorToolResult(beforeResult.reason || 'Tool execution was blocked'),
+                    isError: true,
+                };
+            }
+        }
+        return {
+            kind: 'prepared',
+            toolCall,
+            tool,
+            args: validatedArgs,
+        };
+    }
+    catch (error) {
+        return {
+            kind: 'immediate',
+            result: createErrorToolResult(error instanceof Error ? error.message : String(error)),
+            isError: true,
+        };
+    }
+}
+async function executePreparedToolCall(prepared, signal, emit) {
+    const updateEvents = [];
+    try {
+        const result = await prepared.tool.execute(prepared.toolCall.id, prepared.args, signal, (partialResult) => {
+            updateEvents.push(Promise.resolve(emit({
+                type: 'tool_execution_update',
+                toolCallId: prepared.toolCall.id,
+                toolName: prepared.toolCall.name,
+                args: prepared.toolCall.arguments,
+                partialResult,
+            })));
+        });
+        await Promise.all(updateEvents);
+        return { result, isError: false };
+    }
+    catch (error) {
+        await Promise.all(updateEvents);
+        return {
+            result: createErrorToolResult(error instanceof Error ? error.message : String(error)),
+            isError: true,
+        };
+    }
+}
+async function finalizeExecutedToolCall(currentContext, assistantMessage, prepared, executed, config, signal) {
+    let result = executed.result;
+    let isError = executed.isError;
+    if (config.afterToolCall) {
+        try {
+            const afterResult = await config.afterToolCall({
+                assistantMessage,
+                toolCall: prepared.toolCall,
+                args: prepared.args,
+                result,
+                isError,
+                context: currentContext,
+            }, signal);
+            if (afterResult) {
+                result = {
+                    content: afterResult.content ?? result.content,
+                    details: afterResult.details ?? result.details,
+                    terminate: afterResult.terminate ?? result.terminate,
+                };
+                isError = afterResult.isError ?? isError;
+            }
+        }
+        catch (error) {
+            result = createErrorToolResult(error instanceof Error ? error.message : String(error));
+            isError = true;
+        }
+    }
+    return {
+        toolCall: prepared.toolCall,
+        result,
+        isError,
+    };
+}
+function createErrorToolResult(message) {
+    return {
+        content: [{ type: 'text', text: message }],
+        details: {},
+    };
+}
+async function emitToolExecutionEnd(finalized, emit) {
+    await emit({
+        type: 'tool_execution_end',
+        toolCallId: finalized.toolCall.id,
+        toolName: finalized.toolCall.name,
+        result: finalized.result,
+        isError: finalized.isError,
+    });
+}
+function createToolResultMessage(finalized) {
+    return {
+        role: 'toolResult',
+        toolCallId: finalized.toolCall.id,
+        toolName: finalized.toolCall.name,
+        content: finalized.result.content,
+        details: finalized.result.details,
+        isError: finalized.isError,
+        timestamp: Date.now(),
+    };
+}
+async function emitToolResultMessage(toolResultMessage, emit) {
+    await emit({ type: 'message_start', message: toolResultMessage });
+    await emit({ type: 'message_end', message: toolResultMessage });
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"agent-loop.js","sourceRoot":"","sources":["../../../../src/lib/agent-core/agent-loop.ts"],"names":[],"mappings":"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"}