deepclause-sdk 0.0.74 → 0.0.76

package/dist/runner.d.ts

@@ -42,6 +42,7 @@ export declare class DMLRunner {
     private engine;
     private sessionId;
     private currentMemory;
+    private stepCounter;
     constructor(swipl: SWIPLModule, options: RunnerOptions);
     /**
      * Get the current conversation memory

package/dist/runner.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"runner.d.ts","sourceRoot":"","sources":["../src/runner.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"runner.d.ts","sourceRoot":"","sources":["../src/runner.ts"],"names":[],"mappings":"AAAA;;GAEG;AAIH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AACtD,OAAO,KAAK,EACV,iBAAiB,EACjB,QAAQ,EACR,aAAa,EACb,cAAc,EACd,UAAU,EACV,QAAQ,EACT,MAAM,YAAY,CAAC;AAuHpB,wBAAgB,qBAAqB,CAAC,aAAa,EAAE,OAAO,GAAG,CAAC,MAAM,GAAG,QAAQ,CAAC,EAAE,CAmBnF;AAED,MAAM,WAAW,aAAa;IAC5B,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,MAAM,CAAC;IACjB,WAAW,EAAE,MAAM,CAAC;IACpB,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,KAAK,CAAC,EAAE,OAAO,CAAC;IAEhB,eAAe,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC,CAAC;IACtD,UAAU,CAAC,EAAE,iBAAiB,CAAC;CAChC;AAED,MAAM,WAAW,kBAAkB;IACjC,IAAI,CAAC,EAAE,OAAO,EAAE,CAAC;IACjB,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACjC,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,cAAc,CAAC,CAAC;IACnC,UAAU,EAAE,UAAU,GAAG,IAAI,CAAC;IAC9B,eAAe,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,CAAC,CAAC;IACrD,MAAM,CAAC,EAAE,WAAW,CAAC;IACrB,eAAe,CAAC,EAAE,aAAa,EAAE,CAAC;IAClC,UAAU,CAAC,EAAE,iBAAiB,CAAC;CAChC;AA2CD;;;;;;;GAOG;AACH,qBAAa,SAAS;IACpB,OAAO,CAAC,KAAK,CAAc;IAC3B,OAAO,CAAC,OAAO,CAAgB;IAC/B,OAAO,CAAC,MAAM,CAAiB;IAC/B,OAAO,CAAC,SAAS,CAAc;IAC/B,OAAO,CAAC,aAAa,CAAuB;IAC5C,OAAO,CAAC,WAAW,CAAK;gBAEZ,KAAK,EAAE,WAAW,EAAE,OAAO,EAAE,aAAa;IAKtD;;OAEG;IACH,SAAS,IAAI,aAAa,EAAE;IAI5B;;OAEG;IACI,GAAG,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,kBAAkB,GAAG,cAAc,CAAC,QAAQ,CAAC;IAmJ/E;;OAEG;IACH,OAAO,CAAC,SAAS;IAsBjB;;OAEG;IACH,OAAO,CAAC,SAAS;IAMjB;;OAEG;IACH,OAAO,CAAC,WAAW;IAmBnB;;;OAGG;IACH,OAAO,CAAC,SAAS;IAQjB;;OAEG;IACH,OAAO,CAAC,YAAY;IA2BpB;;OAEG;IACH,OAAO,CAAC,YAAY;IAmBpB;;OAEG;IACH,OAAO,CAAC,UAAU;IA4BlB;;OAEG;YACY,eAAe;IA4Q9B;;OAEG;YACY,iBAAiB;IAwChC;;OAEG;YACY,SAAS;IAoCxB;;OAEG;YACY,UAAU;IAkDzB;;OAEG;IACH,OAAO,CAAC,YAAY;IA6HpB;;OAEG;IACH,OAAO,CAAC,iBAAiB;IAwCzB;;;;OAIG;IACH,OAAO,CAAC,eAAe;IAwDvB;;;;;;;;;;;;;;OAcG;YACW,mBAAmB;YA2YnB,uBAAuB;YAoCvB,iBAAiB;YA2DjB,sBAAsB;IAqBpC;;OAEG;IACH,OAAO,CAAC,wBAAwB;IAmBhC,OAAO,CAAC,wBAAwB;IAKhC,OAAO,CAAC,uBAAuB;IAM/B;;OAEG;IACH,OAAO,CAAC,eAAe;IAoBvB;;OAEG;IACH,OAAO,CAAC,cAAc;IAkBtB;;OAEG;IACH,OAAO,CAAC,qBAAqB;IAkB7B;;OAEG;IACH,OAAO,CAAC,aAAa;IAkBrB;;OAEG;IACH,OAAO,CAAC,mBAAmB;IAwB3B;;OAEG;IACH,OAAO,CAAC,YAAY;IAOpB;;OAEG;IACH,OAAO,CAAC,KAAK;IAWb;;OAEG;IACH,OAAO,CAAC,OAAO;IAWf;;OAEG;IACG,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;CAG/B"}

package/dist/runner.js

@@ -142,6 +142,7 @@ export class DMLRunner {
     engine = null;
     sessionId = '';
     currentMemory = [];
+    stepCounter = 0;
     constructor(swipl, options) {
         this.swipl = swipl;
         this.options = options;
@@ -411,215 +412,228 @@ export class DMLRunner {
      */
     async *handleAgentLoop(payload, _memoryId, // No longer used - memory comes from payload
     options) {
-        // Safely extract payload fields with proper conversion
         const rawPayload = payload;
         const taskDescription = String(toJsValue(rawPayload.taskDescription) ?? '');
-        // Ensure outputVars is an array of either strings or TypedVar objects
-        const outputVars = decodeAgentOutputVars(rawPayload.outputVars);
-        // Parse userTools - now contains schema info as array of tool_info dicts
-        const userTools = [];
-        const rawUserTools = toJsValue(rawPayload.userTools);
-        if (process.env.DEBUG_RUNNER) {
-            console.log('[RUNNER] Raw userTools from Prolog:', JSON.stringify(rawUserTools, null, 2));
-        }
-        if (Array.isArray(rawUserTools)) {
-            for (const tool of rawUserTools) {
-                const toolObj = toJsValue(tool);
-                const toolInfo = this.parseUserToolInfo(toolObj);
-                if (toolInfo) {
-                    userTools.push(toolInfo);
-                }
-            }
-        }
-        // Queue for streaming and internal runtime events
-        const streamQueue = [];
-        let streamResolve = null;
-        const emitRunnerEvent = (event) => {
-            streamQueue.push(event);
-            if (streamResolve) {
-                streamResolve();
-                streamResolve = null;
+        const stepId = `step_${this.stepCounter++}`;
+        yield { type: 'task_activity', taskState: 'started', taskDescription, taskId: stepId };
+        let stepSucceeded = null;
+        try {
+            // Ensure outputVars is an array of either strings or TypedVar objects
+            const outputVars = decodeAgentOutputVars(rawPayload.outputVars);
+            // Parse userTools - now contains schema info as array of tool_info dicts
+            const userTools = [];
+            const rawUserTools = toJsValue(rawPayload.userTools);
+            if (process.env.DEBUG_RUNNER) {
+                console.log('[RUNNER] Raw userTools from Prolog:', JSON.stringify(rawUserTools, null, 2));
             }
-        };
-        // Extract memory from payload (now passed via state threading)
-        const preparedMemory = this.extractMemoryFromPayload(rawPayload);
-        // Store current memory for getMemory() access
-        this.currentMemory = preparedMemory;
-        const emitToolEvent = (event) => {
-            emitRunnerEvent(event);
-        };
-        // Callback for tool output events
-        const onToolOutput = (text) => {
-            emitToolEvent({ type: 'output', content: text });
-        };
-        // Augment registered tools with internal ask_user so DML tools can call exec(ask_user(...))
-        const augmentedTools = new Map(options.tools);
-        if (!augmentedTools.has('ask_user')) {
-            augmentedTools.set('ask_user', {
-                description: 'Ask the user for input or clarification',
-                parameters: {
-                    type: 'object',
-                    properties: {
-                        prompt: { type: 'string', description: 'The question or prompt to show the user' }
-                    },
-                    required: ['prompt']
-                },
-                execute: async (args) => {
-                    const argsObj = args;
-                    const prompt = (argsObj.prompt ?? argsObj.arg1 ?? Object.values(argsObj).find(v => typeof v === 'string'));
-                    if (!prompt) {
-                        return { error: 'No prompt provided to ask_user' };
-                    }
-                    try {
-                        emitToolEvent({ type: 'input_required', prompt });
-                        const response = await options.onInputRequired(prompt);
-                        return { user_response: response };
-                    }
-                    catch (err) {
-                        return { error: String(err) };
+            if (Array.isArray(rawUserTools)) {
+                for (const tool of rawUserTools) {
+                    const toolObj = toJsValue(tool);
+                    const toolInfo = this.parseUserToolInfo(toolObj);
+                    if (toolInfo) {
+                        userTools.push(toolInfo);
                     }
-                },
-            });
-        }
-        // Callback to emit tool call events
-        const emitToolCall = (toolName, args) => {
-            emitToolEvent({ type: 'tool_call', toolName, toolArgs: args });
-        };
-        // Build available tools for agent - SIMPLIFIED: tools run in isolated engines
-        const availableTools = this.buildAgentTools(userTools, options.toolPolicy, 
-        // executeToolIsolated callback - runs tool in separate engine (no state sharing)
-        async (toolName, args) => {
-            return this.executeToolIsolated(toolName, args, augmentedTools, onToolOutput, {
-                workspacePath: options.workspacePath,
-                signal: options.signal,
-                compaction: options.compaction,
-                toolPolicy: options.toolPolicy,
-            }, [], emitToolCall, emitToolEvent);
-        });
-        // Run agent loop with streaming support
-        const resultPromise = runAgentLoop({
-            taskDescription,
-            outputVars,
-            memory: preparedMemory,
-            tools: availableTools,
-            workspacePath: options.workspacePath,
-            modelOptions: {
-                model: this.options.model,
-                provider: this.options.provider,
-                temperature: this.options.temperature,
-                maxOutputTokens: this.options.maxTokens,
-                baseUrl: this.options.baseUrl,
-                providerOptions: this.options.providerOptions,
-            },
-            streaming: this.options.streaming,
-            debug: this.options.debug,
-            onOutput: (_text) => { },
-            onStream: (chunk, done) => {
-                streamQueue.push({ type: 'stream', content: chunk, done });
-                if (streamResolve) {
-                    streamResolve();
-                    streamResolve = null;
-                }
-            },
-            onToolCall: (toolName, args) => {
-                streamQueue.push({ type: 'tool_call', toolName, toolArgs: args });
-                if (streamResolve) {
-                    streamResolve();
-                    streamResolve = null;
                 }
-            },
-            onUsage: (usage) => {
-                streamQueue.push({ type: 'usage', usage });
+            }
+            // Queue for streaming and internal runtime events
+            const streamQueue = [];
+            let streamResolve = null;
+            const emitRunnerEvent = (event) => {
+                streamQueue.push(event);
                 if (streamResolve) {
                     streamResolve();
                     streamResolve = null;
                 }
-            },
-            onBeforeModelCall: async (messages) => this.applyCompactionBindings({
-                messages,
-                scope: 'loop',
-                trigger: 'before_model_call',
-                options,
-                executionContext: {
+            };
+            // Extract memory from payload (now passed via state threading)
+            const preparedMemory = this.extractMemoryFromPayload(rawPayload);
+            // Store current memory for getMemory() access
+            this.currentMemory = preparedMemory;
+            const emitToolEvent = (event) => {
+                emitRunnerEvent(event);
+            };
+            // Callback for tool output events
+            const onToolOutput = (text) => {
+                emitToolEvent({ type: 'output', content: text });
+            };
+            // Augment registered tools with internal ask_user so DML tools can call exec(ask_user(...))
+            const augmentedTools = new Map(options.tools);
+            if (!augmentedTools.has('ask_user')) {
+                augmentedTools.set('ask_user', {
+                    description: 'Ask the user for input or clarification',
+                    parameters: {
+                        type: 'object',
+                        properties: {
+                            prompt: { type: 'string', description: 'The question or prompt to show the user' }
+                        },
+                        required: ['prompt']
+                    },
+                    execute: async (args) => {
+                        const argsObj = args;
+                        const prompt = (argsObj.prompt ?? argsObj.arg1 ?? Object.values(argsObj).find(v => typeof v === 'string'));
+                        if (!prompt) {
+                            return { error: 'No prompt provided to ask_user' };
+                        }
+                        try {
+                            emitToolEvent({ type: 'input_required', prompt });
+                            const response = await options.onInputRequired(prompt);
+                            return { user_response: response };
+                        }
+                        catch (err) {
+                            return { error: String(err) };
+                        }
+                    },
+                });
+            }
+            // Callback to emit tool call events
+            const emitToolCall = (toolName, args) => {
+                emitToolEvent({ type: 'tool_call', toolName, toolArgs: args });
+            };
+            // Build available tools for agent - SIMPLIFIED: tools run in isolated engines
+            const availableTools = this.buildAgentTools(userTools, options.toolPolicy, 
+            // executeToolIsolated callback - runs tool in separate engine (no state sharing)
+            async (toolName, args) => {
+                return this.executeToolIsolated(toolName, args, augmentedTools, onToolOutput, {
                     workspacePath: options.workspacePath,
                     signal: options.signal,
                     compaction: options.compaction,
+                    toolPolicy: options.toolPolicy,
+                }, [], emitToolCall, emitToolEvent);
+            });
+            // Run agent loop with streaming support
+            const resultPromise = runAgentLoop({
+                taskDescription,
+                outputVars,
+                memory: preparedMemory,
+                tools: availableTools,
+                workspacePath: options.workspacePath,
+                modelOptions: {
+                    model: this.options.model,
+                    provider: this.options.provider,
+                    temperature: this.options.temperature,
+                    maxOutputTokens: this.options.maxTokens,
+                    baseUrl: this.options.baseUrl,
+                    providerOptions: this.options.providerOptions,
                 },
-                registeredTools: options.tools,
-                toolPolicy: options.toolPolicy,
-                emitEvent: emitRunnerEvent,
-            }),
-            onAskUser: options.onInputRequired,
-            signal: options.signal,
-        });
-        // Yield streaming events as they arrive
-        if (this.options.streaming) {
-            while (true) {
-                // Process any queued events
-                while (streamQueue.length > 0) {
-                    yield streamQueue.shift();
-                }
-                // Check if result is ready
-                const raceResult = await Promise.race([
-                    resultPromise.then(r => ({ type: 'done', result: r })),
-                    new Promise(resolve => {
-                        streamResolve = () => resolve({ type: 'stream' });
-                    }),
-                ]);
-                if (raceResult.type === 'done') {
-                    // Drain remaining queue
-                    while (streamQueue.length > 0) {
-                        yield streamQueue.shift();
+                streaming: this.options.streaming,
+                debug: this.options.debug,
+                onOutput: (_text) => { },
+                onStream: (chunk, done) => {
+                    streamQueue.push({ type: 'stream', content: chunk, done });
+                    if (streamResolve) {
+                        streamResolve();
+                        streamResolve = null;
+                    }
+                },
+                onToolCall: (toolName, args) => {
+                    streamQueue.push({ type: 'tool_call', toolName, toolArgs: args });
+                    if (streamResolve) {
+                        streamResolve();
+                        streamResolve = null;
                     }
-                    // In streaming mode, output was already shown via onStream - don't repeat it
-                    // The outputs array is kept for memory/history purposes only
-                    const finalizedMemory = [
-                        ...preparedMemory.filter((message) => message.role === 'system'),
-                        ...raceResult.result.messages,
-                    ];
+                },
+                onUsage: (usage) => {
+                    streamQueue.push({ type: 'usage', usage });
+                    if (streamResolve) {
+                        streamResolve();
+                        streamResolve = null;
+                    }
+                },
+                onBeforeModelCall: async (messages) => this.applyCompactionBindings({
+                    messages,
+                    scope: 'loop',
+                    trigger: 'before_model_call',
+                    options,
+                    executionContext: {
+                        workspacePath: options.workspacePath,
+                        signal: options.signal,
+                        compaction: options.compaction,
+                    },
+                    registeredTools: options.tools,
+                    toolPolicy: options.toolPolicy,
+                    emitEvent: emitRunnerEvent,
+                }),
+                onAskUser: options.onInputRequired,
+                signal: options.signal,
+            });
+            // Yield streaming events as they arrive
+            if (this.options.streaming) {
+                while (true) {
+                    // Process any queued events
                     while (streamQueue.length > 0) {
                         yield streamQueue.shift();
                     }
-                    // Update memory with full agent conversation
-                    this.currentMemory = finalizedMemory;
-                    // Post result back to Prolog
-                    this.postAgentResult(raceResult.result, finalizedMemory);
-                    return;
+                    // Check if result is ready
+                    const raceResult = await Promise.race([
+                        resultPromise.then(r => ({ type: 'done', result: r })),
+                        new Promise(resolve => {
+                            streamResolve = () => resolve({ type: 'stream' });
+                        }),
+                    ]);
+                    if (raceResult.type === 'done') {
+                        // Drain remaining queue
+                        while (streamQueue.length > 0) {
+                            yield streamQueue.shift();
+                        }
+                        // In streaming mode, output was already shown via onStream - don't repeat it
+                        // The outputs array is kept for memory/history purposes only
+                        const finalizedMemory = [
+                            ...preparedMemory.filter((message) => message.role === 'system'),
+                            ...raceResult.result.messages,
+                        ];
+                        while (streamQueue.length > 0) {
+                            yield streamQueue.shift();
+                        }
+                        // Update memory with full agent conversation
+                        this.currentMemory = finalizedMemory;
+                        // Post result back to Prolog
+                        stepSucceeded = raceResult.result.success;
+                        this.postAgentResult(raceResult.result, finalizedMemory);
+                        return;
+                    }
+                    // Otherwise continue loop to yield queued stream events
                 }
-                // Otherwise continue loop to yield queued stream events
             }
-        }
-        else {
-            // Non-streaming mode - wait for completion
-            const result = await resultPromise;
-            // Drain tool_call events from queue (they were queued during agent execution)
-            if (process.env.DEBUG_QUEUE) {
-                console.log('[RUNNER] Non-streaming: streamQueue length before drain:', streamQueue.length);
-                if (streamQueue.length > 0) {
-                    console.log('[RUNNER] streamQueue contents:', streamQueue.map(e => `${e.type}:${e.content?.substring(0, 40)}`));
+            else {
+                // Non-streaming mode - wait for completion
+                const result = await resultPromise;
+                // Drain tool_call events from queue (they were queued during agent execution)
+                if (process.env.DEBUG_QUEUE) {
+                    console.log('[RUNNER] Non-streaming: streamQueue length before drain:', streamQueue.length);
+                    if (streamQueue.length > 0) {
+                        console.log('[RUNNER] streamQueue contents:', streamQueue.map(e => `${e.type}:${e.content?.substring(0, 40)}`));
+                    }
                 }
+                while (streamQueue.length > 0) {
+                    yield streamQueue.shift();
+                }
+                if (process.env.DEBUG_QUEUE) {
+                    console.log('[RUNNER] Non-streaming agent result.outputs:', result.outputs);
+                }
+                // Stream any output from the agent
+                for (const output of result.outputs) {
+                    yield { type: 'output', content: output };
+                }
+                const finalizedMemory = [
+                    ...preparedMemory.filter((message) => message.role === 'system'),
+                    ...result.messages,
+                ];
+                while (streamQueue.length > 0) {
+                    yield streamQueue.shift();
+                }
+                // Update memory with full agent conversation
+                this.currentMemory = finalizedMemory;
+                // Post result back to Prolog
+                stepSucceeded = result.success;
+                this.postAgentResult(result, finalizedMemory);
             }
-            while (streamQueue.length > 0) {
-                yield streamQueue.shift();
-            }
-            if (process.env.DEBUG_QUEUE) {
-                console.log('[RUNNER] Non-streaming agent result.outputs:', result.outputs);
-            }
-            // Stream any output from the agent
-            for (const output of result.outputs) {
-                yield { type: 'output', content: output };
-            }
-            const finalizedMemory = [
-                ...preparedMemory.filter((message) => message.role === 'system'),
-                ...result.messages,
-            ];
-            while (streamQueue.length > 0) {
-                yield streamQueue.shift();
-            }
-            // Update memory with full agent conversation
-            this.currentMemory = finalizedMemory;
-            // Post result back to Prolog
-            this.postAgentResult(result, finalizedMemory);
+        }
+        finally {
+            yield {
+                type: 'task_activity',
+                taskState: stepSucceeded === true ? 'completed' : 'failed',
+                taskId: stepId,
+            };
         }
     }
     /**
@@ -632,6 +646,10 @@ export class DMLRunner {
         const allowedTokens = Array.isArray(rawAllowedTokens)
             ? rawAllowedTokens.map((token) => String(token))
             : [];
+        const stepId = `step_${this.stepCounter++}`;
+        const taskDescription = prompt || 'sample_token';
+        yield { type: 'task_activity', taskState: 'started', taskDescription, taskId: stepId };
+        let succeeded = false;
         try {
             const token = await sampleSingleToken({
                 prompt,
@@ -645,6 +663,7 @@ export class DMLRunner {
                 },
                 signal: options.signal,
             });
+            succeeded = true;
             this.postSampleTokenResult({ success: true, token });
         }
         catch (error) {
@@ -652,6 +671,9 @@ export class DMLRunner {
             this.postSampleTokenResult({ success: false, error: message });
             yield { type: 'log', content: `sample_token failed: ${message}` };
         }
+        finally {
+            yield { type: 'task_activity', taskState: succeeded ? 'completed' : 'failed', taskId: stepId };
+        }
     }
     /**
      * Handle direct one-shot LLM request (llm/2)
@@ -659,6 +681,10 @@ export class DMLRunner {
     async *handleLlm(payload, options) {
         const data = payload;
         const messages = this.extractMessagesFromValue(data.messages);
+        const stepId = `step_${this.stepCounter++}`;
+        const taskDescription = summarizeLlmMessages(messages);
+        yield { type: 'task_activity', taskState: 'started', taskDescription, taskId: stepId };
+        let succeeded = false;
         try {
             const text = await generateLlmReply({
                 messages,
@@ -672,6 +698,7 @@ export class DMLRunner {
                 },
                 signal: options.signal,
             });
+            succeeded = true;
             this.postLlmResult({ success: true, text });
         }
         catch (error) {
@@ -679,6 +706,9 @@ export class DMLRunner {
             this.postLlmResult({ success: false, error: message });
             yield { type: 'log', content: `llm/2 failed: ${message}` };
         }
+        finally {
+            yield { type: 'task_activity', taskState: succeeded ? 'completed' : 'failed', taskId: stepId };
+        }
     }
     /**
      * Handle exec request (exec() predicate)
@@ -1022,6 +1052,8 @@ export class DMLRunner {
                         const allowedTokens = Array.isArray(rawAllowedTokens)
                             ? rawAllowedTokens.map((token) => String(token))
                             : [];
+                        const nestedStepId = `step_${this.stepCounter++}`;
+                        onToolEvent?.({ type: 'task_activity', taskState: 'started', taskDescription: prompt || 'sample_token', taskId: nestedStepId });
                         try {
                             const token = await sampleSingleToken({
                                 prompt,
@@ -1036,10 +1068,12 @@ export class DMLRunner {
                                 signal: runContext.signal,
                             });
                             this.postSampleTokenResult({ success: true, token });
+                            onToolEvent?.({ type: 'task_activity', taskState: 'completed', taskId: nestedStepId });
                         }
                         catch (error) {
                             const message = error instanceof Error ? error.message : String(error);
                             this.postSampleTokenResult({ success: false, error: message });
+                            onToolEvent?.({ type: 'task_activity', taskState: 'failed', taskId: nestedStepId });
                             if (process.env.DEBUG_RUNNER) {
                                 console.log('[RUNNER] sample_token request failed:', message);
                             }
@@ -1048,6 +1082,8 @@ export class DMLRunner {
                     }
                     case 'request_llm': {
                         const messages = this.extractMessagesFromValue(payload?.messages);
+                        const nestedStepId = `step_${this.stepCounter++}`;
+                        onToolEvent?.({ type: 'task_activity', taskState: 'started', taskDescription: summarizeLlmMessages(messages), taskId: nestedStepId });
                         try {
                             const text = await generateLlmReply({
                                 messages,
@@ -1062,10 +1098,12 @@ export class DMLRunner {
                                 signal: runContext.signal,
                             });
                             this.postLlmResult({ success: true, text });
+                            onToolEvent?.({ type: 'task_activity', taskState: 'completed', taskId: nestedStepId });
                         }
                         catch (error) {
                             const message = error instanceof Error ? error.message : String(error);
                             this.postLlmResult({ success: false, error: message });
+                            onToolEvent?.({ type: 'task_activity', taskState: 'failed', taskId: nestedStepId });
                             if (process.env.DEBUG_RUNNER) {
                                 console.log('[RUNNER] llm/2 request failed:', message);
                             }
@@ -1167,6 +1205,8 @@ export class DMLRunner {
                         };
                         const availableTools = this.buildAgentTools(filteredTools, null, // No policy override for nested
                         nestedToolCallback);
+                        const nestedStepId = `step_${this.stepCounter++}`;
+                        onToolEvent?.({ type: 'task_activity', taskState: 'started', taskDescription, taskId: nestedStepId });
                         try {
                             // Run the nested agent loop
                             const result = await runAgentLoop({
@@ -1216,6 +1256,7 @@ export class DMLRunner {
                             ];
                             // Post result back to tool engine
                             this.postToolAgentResult(toolEngineId, result, finalizedMemory);
+                            onToolEvent?.({ type: 'task_activity', taskState: 'completed', taskId: nestedStepId });
                         }
                         catch (error) {
                             const message = error instanceof Error ? error.message : String(error);
@@ -1229,6 +1270,7 @@ export class DMLRunner {
                                 variables: {},
                                 messages: preparedMemory.filter((message) => message.role !== 'system'),
                             });
+                            onToolEvent?.({ type: 'task_activity', taskState: 'failed', taskId: nestedStepId });
                         }
                         break;
                     }
@@ -1486,4 +1528,14 @@ export class DMLRunner {
         this.cleanup();
     }
 }
+function summarizeLlmMessages(messages) {
+    if (messages.length === 0)
+        return 'llm()';
+    const last = messages[messages.length - 1];
+    const text = typeof last.content === 'string' ? last.content : '';
+    const summary = text.replace(/\s+/g, ' ').trim();
+    if (!summary)
+        return `llm(${messages.length} messages)`;
+    return summary.length > 80 ? summary.slice(0, 77) + '...' : summary;
+}
 //# sourceMappingURL=runner.js.map