@modular-prompt/process 0.1.28 → 0.2.1

package/README.md

@@ -10,6 +10,8 @@ npm install @modular-prompt/process
 
 ## ワークフロー
 
+すべてのワークフロー関数は第1引数として `DriverInput` 型（`AIDriver` または `DriverSet`）を受け入れます。これにより、単一のドライバーまたは役割別の複数ドライバーを柔軟に指定できます。
+
 ### 基本ワークフロー
 
 - **`defaultProcess`** - 最小のワークフロー（compile + driver.query）
@@ -19,7 +21,9 @@ npm install @modular-prompt/process
 ### チャンク処理ワークフロー
 
 - **`streamProcess`** - ステートを保持しながらチャンクを逐次処理
+  - 内部で `streamProcessing` モジュールを自動的にマージ
 - **`concatProcess`** - 各チャンクを独立して処理し、結果を結合
+  - 内部で `concatProcessing` モジュールを自動的にマージ
 
 ### エージェント型ワークフロー
 
@@ -69,14 +73,20 @@ console.log(result.output);  // AIの応答
 
 ```typescript
 import { streamProcess } from '@modular-prompt/process';
-import { streamProcessing } from '@modular-prompt/process';
 import { TestDriver } from '@modular-prompt/driver';
 
 const driver = new TestDriver(['response1', 'response2']);
 
+// streamProcessingモジュールは自動的にマージされるため、
+// ユーザーモジュールのみを渡すことができます
+const userModule = {
+  objective: ['チャンクを順次処理して要約を作成'],
+  instructions: ['各チャンクの内容を前の状態と統合']
+};
+
 const result = await streamProcess(
   driver,
-  streamProcessing,
+  userModule,  // streamProcessingは内部で自動マージ
   {
     chunks: [{ content: 'text1' }, { content: 'text2' }],
     state: { content: '', usage: 0 }
@@ -122,79 +132,60 @@ const context = {
   }
 };
 
-// ワークフロー実行（計画→実行→統合）
+// ワークフロー実行（planning → execution tasks → output）
 const result = await agenticProcess(driver, userModule, context, {
-  maxSteps: 5  // 最大5ステップまで
+  maxTasks: 5,  // 最大5タスクまで
 });
 
 console.log(result.output);  // 最終的な献立提案
-console.log(result.metadata); // { planSteps: 5, executedSteps: 5, actionsUsed: 0 }
+console.log(result.metadata); // { planTasks, executedTasks, toolCallsUsed, finishReason }
 ```
 
-### 簡易エージェントワークフロー
-
-```typescript
-import { agentProcess } from '@modular-prompt/process';
-import { TestDriver } from '@modular-prompt/driver';
-
-const driver = new TestDriver();
-
-const userModule = {
-  objective: ['週末旅行プランを提案する'],
-  instructions: [
-    '- 交通手段・宿泊先・食事プランを検討する',
-    '- 入力データに応じて実行計画を自律的に組み立てる'
-  ]
-};
-
-const context = {
-  objective: '週末旅行プランを提案する',
-  inputs: {
-    budget: '50,000円',
-    city: '箱根'
-  }
-};
-
-const actions = {
-  lookupHotel: async (params: { city: string }) => {
-    return { recommended: [`${params.city} 温泉旅館`] };
-  }
-};
-
-const result = await agentProcess(driver, userModule, context, {
-  maxSteps: 4,
-  actions
-});
-
-console.log(result.output);
-console.log(result.metadata); // { planSteps: 3, executedSteps: 3, actionsUsed: 1 }
-```
-
-### アクション（外部ツール）の使用
+### 外部ツールの使用
 
 ```typescript
 import { agenticProcess } from '@modular-prompt/process';
+import type { ToolSpec } from '@modular-prompt/process';
 
-// 外部ツール/APIの定義
-const actions = {
-  fetchWeather: async (params: { location: string }) => {
-    const response = await fetch(`https://api.weather.com/${params.location}`);
-    return response.json();
+// 外部ツールの定義（definition + handler）
+const tools: ToolSpec[] = [
+  {
+    definition: {
+      name: 'fetchWeather',
+      description: 'Get weather information for a location',
+      parameters: {
+        type: 'object',
+        properties: {
+          location: { type: 'string', description: 'City name' }
+        },
+        required: ['location'],
+      },
+    },
+    handler: async (params) => {
+      const response = await fetch(`https://api.weather.com/${params.location}`);
+      return JSON.stringify(await response.json());
+    },
   },
-  searchRecipes: async (params: { ingredients: string[] }) => {
-    // レシピ検索APIを呼び出し
-    return { recipes: [...] };
-  }
-};
+];
 
 const result = await agenticProcess(driver, userModule, context, {
-  maxSteps: 5,
-  actions  // アクションを渡す
+  tools,       // 外部ツールを渡す
+  maxTasks: 5,
 });
 
-// AIが計画フェーズで必要なアクションを判断し、実行フェーズで自動的に呼び出す
+// 外部ツール呼び出しが発生するとワークフローは中断し、
+// pendingToolCalls として返却される
+if (result.metadata.finishReason === 'tool_calls') {
+  // 呼び出し元でツールを実行し、結果を渡して再開する
+  console.log(result.context.executionLog);
+}
 ```
 
+## 開発者向けドキュメント
+
+ワークフロー実装者向けのドキュメント:
+
+- **[ワークフローログ規約](./docs/WORKFLOW_LOG_CONVENTIONS.md)** - Logger 使用規約とログ出力の標準化
 
 ## ライセンス
 

package/dist/workflows/agentic-workflow/agentic-workflow.d.ts

@@ -1,13 +1,17 @@
-import type { PromptModule } from '@modular-prompt/core';
-import type { AIDriver, WorkflowResult } from '../types.js';
-import type { AgenticWorkflowContext, AgenticWorkflowOptions } from './types.js';
 /**
- * Agentic workflow - autonomous multi-step processing with planning
+ * Agentic workflow v2 - task sequence based processing
+ *
+ * Fixed phases are replaced by a task sequence.
+ * Each task type has its own prompt construction and input contract.
  *
  * Flow:
- * 1. Planning phase: Generate execution plan using structured outputs
- * 2. Execution phase: Execute each step (with optional actions)
- * 3. Integration phase: Integrate results and generate final output
+ * 1. Bootstrap: Generate initial task list [planning, outputXxx]
+ * 2. Task loop: Execute each task sequentially
+ * 3. Output: Last task (outputMessage/outputStructured) result is the final output
  */
-export declare function agenticProcess(driver: AIDriver, module: PromptModule<AgenticWorkflowContext>, context: AgenticWorkflowContext, options?: AgenticWorkflowOptions): Promise<WorkflowResult<AgenticWorkflowContext>>;
+import type { PromptModule } from '@modular-prompt/core';
+import type { WorkflowResult } from '../types.js';
+import type { AgenticWorkflowContext, AgenticWorkflowOptions } from './types.js';
+import { type DriverInput } from '../driver-input.js';
+export declare function agenticProcess(driver: DriverInput, module: PromptModule<AgenticWorkflowContext>, context: AgenticWorkflowContext, options?: AgenticWorkflowOptions): Promise<WorkflowResult<AgenticWorkflowContext>>;
 //# sourceMappingURL=agentic-workflow.d.ts.map

package/dist/workflows/agentic-workflow/agentic-workflow.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"agentic-workflow.d.ts","sourceRoot":"","sources":["../../../src/workflows/agentic-workflow/agentic-workflow.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AAEzD,OAAO,KAAK,EAAE,QAAQ,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAC5D,OAAO,KAAK,EAAE,sBAAsB,EAAE,sBAAsB,EAAmD,MAAM,YAAY,CAAC;AA+QlI;;;;;;;GAOG;AACH,wBAAsB,cAAc,CAClC,MAAM,EAAE,QAAQ,EAChB,MAAM,EAAE,YAAY,CAAC,sBAAsB,CAAC,EAC5C,OAAO,EAAE,sBAAsB,EAC/B,OAAO,GAAE,sBAA2B,GACnC,OAAO,CAAC,cAAc,CAAC,sBAAsB,CAAC,CAAC,CA+CjD"}
+{"version":3,"file":"agentic-workflow.d.ts","sourceRoot":"","sources":["../../../src/workflows/agentic-workflow/agentic-workflow.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAGH,OAAO,KAAK,EAAE,YAAY,EAAkB,MAAM,sBAAsB,CAAC;AAGzE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAClD,OAAO,KAAK,EACV,sBAAsB,EACtB,sBAAsB,EAKvB,MAAM,YAAY,CAAC;AAEpB,OAAO,EAAE,KAAK,WAAW,EAAiB,MAAM,oBAAoB,CAAC;AAiKrE,wBAAsB,cAAc,CAClC,MAAM,EAAE,WAAW,EACnB,MAAM,EAAE,YAAY,CAAC,sBAAsB,CAAC,EAC5C,OAAO,EAAE,sBAAsB,EAC/B,OAAO,GAAE,sBAA2B,GACnC,OAAO,CAAC,cAAc,CAAC,sBAAsB,CAAC,CAAC,CAqHjD"}

package/dist/workflows/agentic-workflow/agentic-workflow.js

@@ -1,235 +1,216 @@
-import { compile, merge } from '@modular-prompt/core';
-import { WorkflowExecutionError } from '../types.js';
-import { agentic } from './modules/agentic.js';
-import { planning } from './modules/planning.js';
-import { execution } from './modules/execution.js';
-import { executionFreeform } from './modules/execution-freeform.js';
-import { integration } from './modules/integration.js';
 /**
- * Execute planning phase
+ * Agentic workflow v2 - task sequence based processing
+ *
+ * Fixed phases are replaced by a task sequence.
+ * Each task type has its own prompt construction and input contract.
+ *
+ * Flow:
+ * 1. Bootstrap: Generate initial task list [planning, outputXxx]
+ * 2. Task loop: Execute each task sequentially
+ * 3. Output: Last task (outputMessage/outputStructured) result is the final output
  */
-async function executePlanningPhase(driver, module, context, maxSteps, logger) {
-    const planningModule = merge(agentic, planning, module);
-    const prompt = compile(planningModule, context);
-    try {
-        const planResult = await driver.query(prompt);
-        logger?.debug('Planning phase - AI generated:', planResult.content);
-        // Check finish reason
-        if (planResult.finishReason && planResult.finishReason !== 'stop') {
-            throw new WorkflowExecutionError(`Planning failed with reason: ${planResult.finishReason}`, context, {
-                phase: 'planning',
-                finishReason: planResult.finishReason
-            });
-        }
-        // Get plan from structured output
-        if (!planResult.structuredOutput) {
-            throw new WorkflowExecutionError('Planning did not return structured output', context, {
-                phase: 'planning',
-                partialResult: planResult.content
-            });
-        }
-        const plan = planResult.structuredOutput;
-        // Validate and limit steps
-        if (!plan.steps || !Array.isArray(plan.steps)) {
-            throw new WorkflowExecutionError('Invalid plan structure: steps is not an array', context, {
-                phase: 'planning',
-                partialResult: JSON.stringify(planResult.structuredOutput)
-            });
-        }
-        // Limit number of steps
-        if (plan.steps.length > maxSteps) {
-            plan.steps = plan.steps.slice(0, maxSteps);
-        }
-        return plan;
-    }
-    catch (error) {
-        if (error instanceof WorkflowExecutionError) {
-            throw error;
-        }
-        throw new WorkflowExecutionError(error, context, {
-            phase: 'planning'
-        });
-    }
+import { merge, resolve } from '@modular-prompt/core';
+import { Logger } from '@modular-prompt/utils';
+import { DEFAULT_DRIVER_ROLE } from './types.js';
+import { resolveDriver } from '../driver-input.js';
+import { getTaskTypeConfig, taskCommon } from './task-types/index.js';
+import { createPlanningTools, createExecutionBuiltinTools, createUpdateStateTool, } from './process/builtin-tools.js';
+import { queryWithTools, rethrowAsWorkflowError } from './process/query-with-tools.js';
+const logger = new Logger({ prefix: 'process', context: 'agentic' });
+/**
+ * Strip <think>...</think> blocks from model output.
+ * Thinking traces are internal reasoning and should not be passed to subsequent tasks.
+ */
+function stripThinkBlocks(text) {
+    return text.replace(/<think>[\s\S]*?<\/think>\s*/g, '').replace(/^[\s\S]*?<\/think>\s*/g, '').trim();
 }
+// ---------------------------------------------------------------------------
+// Bootstrap
+// ---------------------------------------------------------------------------
 /**
- * Execute a single step
+ * Generate the initial task list based on the user module.
+ * - Always starts with a planning task.
+ * - Ends with outputStructured (if schema) or outputMessage.
  */
-async function executeStep(driver, module, context, step, actions, executionLog, useFreeform, logger) {
-    // Execute actions if specified
-    let actionResult;
-    if (step.actions && step.actions.length > 0) {
-        for (const action of step.actions) {
-            if (actions[action.tool]) {
-                try {
-                    actionResult = await actions[action.tool](action.params, context);
-                }
-                catch (error) {
-                    throw new WorkflowExecutionError(`Tool '${action.tool}' failed: ${error.message}`, {
-                        ...context,
-                        executionLog,
-                        currentStep: step
-                    }, {
-                        phase: 'execution',
-                        partialResult: executionLog.map(log => log.result).join('\n\n')
-                    });
-                }
-            }
-        }
-    }
-    // Execute step with AI
-    const executionPhaseModule = useFreeform ? executionFreeform : execution;
-    // For freeform mode, omit user's instructions to use plan-based guidelines/constraints instead
-    // For structured mode, use user's instructions as-is
-    const userModule = useFreeform
-        ? { ...module, instructions: undefined }
-        : module;
-    const executionModule = merge(agentic, executionPhaseModule, userModule);
-    const stepContext = {
-        ...context,
-        currentStep: step,
-        actionResult,
-        executionLog
-    };
-    const prompt = compile(executionModule, stepContext);
-    try {
-        const stepResult = await driver.query(prompt);
-        logger?.debug(`Execution step ${step.id} - AI generated:`, stepResult.content);
-        // Check finish reason
-        if (stepResult.finishReason && stepResult.finishReason !== 'stop') {
-            throw new WorkflowExecutionError(`Step execution failed with reason: ${stepResult.finishReason}`, stepContext, {
-                phase: 'execution',
-                partialResult: executionLog.map(log => log.result).join('\n\n'),
-                finishReason: stepResult.finishReason
-            });
-        }
-        // Get reasoning, result and nextState from structured output
-        let reasoning;
-        let result;
-        let nextState;
-        if (stepResult.structuredOutput) {
-            const output = stepResult.structuredOutput;
-            reasoning = output.reasoning || '';
-            result = output.result || stepResult.content;
-            nextState = output.nextState || '';
-        }
-        else {
-            // Fallback if structured output is not available
-            reasoning = '';
-            result = stepResult.content;
-            nextState = '';
-        }
-        // Update context state with nextState for the next step
-        context.state = {
-            content: nextState,
-            usage: stepResult.usage?.totalTokens
-        };
-        // Create execution log entry (without nextState - it's in context.state now)
-        return {
-            stepId: step.id,
-            reasoning,
-            result,
-            actionResult,
-            metadata: {
-                usage: stepResult.usage
-            }
-        };
+function bootstrap(module, enablePlanning) {
+    const tasks = [];
+    if (enablePlanning) {
+        tasks.push({
+            instruction: 'Analyze the prompt and register tasks',
+            taskType: 'planning',
+        });
     }
-    catch (error) {
-        if (error instanceof WorkflowExecutionError) {
-            throw error;
-        }
-        throw new WorkflowExecutionError(error, stepContext, {
-            phase: 'execution',
-            partialResult: executionLog.map(log => log.result).join('\n\n')
+    else {
+        // No planning: default to a single output task
+        tasks.push({
+            instruction: 'Compose the response using the preceding task results.',
+            taskType: 'output',
         });
     }
+    return tasks;
 }
+// ---------------------------------------------------------------------------
+// Task execution
+// ---------------------------------------------------------------------------
 /**
- * Execute execution phase
+ * Get builtin tools for a task based on its type config.
  */
-async function executeExecutionPhase(driver, module, context, plan, actions, useFreeform, logger) {
-    const executionLog = context.executionLog || [];
-    // Determine starting position (for resumption)
-    const startIndex = executionLog.length;
-    // Execute each step
-    for (let i = startIndex; i < plan.steps.length; i++) {
-        const step = plan.steps[i];
-        const logEntry = await executeStep(driver, module, context, step, actions, executionLog, useFreeform, logger);
-        executionLog.push(logEntry);
+function getBuiltinToolsForTask(taskType, taskList, currentIndex, context) {
+    const config = getTaskTypeConfig(taskType);
+    const toolNames = new Set(config.builtinToolNames);
+    const allTools = [];
+    if (toolNames.has('__insert_tasks')) {
+        allTools.push(...createPlanningTools(taskList, currentIndex));
     }
-    return executionLog;
+    if (toolNames.has('__update_state')) {
+        allTools.push(createUpdateStateTool(context));
+    }
+    if (toolNames.has('__time')) {
+        // createExecutionBuiltinTools returns [__insert_tasks, __time]
+        // We only want __time if __insert_tasks is not already added
+        const execTools = createExecutionBuiltinTools(taskList, currentIndex);
+        const timeOnly = execTools.filter(t => t.definition.name === '__time');
+        allTools.push(...timeOnly);
+    }
+    return allTools;
 }
 /**
- * Execute integration phase
+ * Execute a single task.
  */
-async function executeIntegrationPhase(driver, module, context, executionLog, logger) {
-    const integrationModule = merge(agentic, integration, module);
-    const finalPrompt = compile(integrationModule, context);
+async function executeTask(driver, userModule, context, task, taskIndex, taskList, externalTools, maxToolCalls) {
+    const taskLogger = logger.context(`agentic:task:${taskIndex + 1}:${task.taskType}`);
+    taskLogger.info('[start]', task.instruction);
+    const taskConfig = getTaskTypeConfig(task.taskType);
+    // Build workflowBase from resolved userModule
+    // output tasks get the full userModule; other tasks get objective/terms/state only
+    const workflowBase = task.taskType === 'output'
+        ? { ...userModule }
+        : {
+            objective: userModule.objective,
+            terms: userModule.terms,
+            state: userModule.state,
+        };
+    // Merge and resolve (taskCommon first for objective framing)
+    const resolved = resolve(merge(workflowBase, taskCommon, taskConfig.module), context);
+    const builtinTools = getBuiltinToolsForTask(task.taskType, taskList, taskIndex, context);
+    const externalToolDefs = externalTools.map(t => t.definition);
+    const allToolNames = [...builtinTools.map(t => t.definition.name), ...externalToolDefs.map(t => t.name)];
+    taskLogger.verbose('[prompt]', JSON.stringify(resolved), allToolNames.length > 0 ? `tools: [${allToolNames.join(', ')}]` : '');
+    const driverRole = task.driverRole || DEFAULT_DRIVER_ROLE[task.taskType];
     try {
-        const integrationResult = await driver.query(finalPrompt);
-        logger?.debug('Integration phase - AI generated:', integrationResult.content);
-        // Check finish reason
-        if (integrationResult.finishReason && integrationResult.finishReason !== 'stop') {
-            throw new WorkflowExecutionError(`Integration failed with reason: ${integrationResult.finishReason}`, context, {
-                phase: 'integration',
-                partialResult: executionLog.map(log => log.result).join('\n\n'),
-                finishReason: integrationResult.finishReason
-            });
-        }
-        return integrationResult.content;
+        const isPlanning = task.taskType === 'planning';
+        const toolChoice = isPlanning ? 'required' : 'auto';
+        const result = await queryWithTools(resolveDriver(driver, driverRole), resolved, builtinTools, {
+            externalToolDefs: externalToolDefs.length > 0 ? externalToolDefs : undefined,
+            toolChoice,
+            maxIterations: maxToolCalls,
+            stopAfterToolCall: isPlanning,
+            logger: taskLogger,
+        });
+        taskLogger.info('[end]');
+        return {
+            taskType: task.taskType,
+            result: stripThinkBlocks(result.content),
+            pendingToolCalls: result.pendingToolCalls,
+            metadata: {
+                usage: result.usage,
+            },
+        };
     }
     catch (error) {
-        if (error instanceof WorkflowExecutionError) {
-            throw error;
-        }
-        throw new WorkflowExecutionError(error, context, {
-            phase: 'integration',
-            partialResult: executionLog.map(log => log.result).join('\n\n')
+        rethrowAsWorkflowError(error, context, {
+            phase: task.taskType,
+            partialResult: context.executionLog?.map(log => log.result).join('\n\n') || '',
         });
     }
 }
-/**
- * Agentic workflow - autonomous multi-step processing with planning
- *
- * Flow:
- * 1. Planning phase: Generate execution plan using structured outputs
- * 2. Execution phase: Execute each step (with optional actions)
- * 3. Integration phase: Integrate results and generate final output
- */
+// ---------------------------------------------------------------------------
+// Main workflow
+// ---------------------------------------------------------------------------
 export async function agenticProcess(driver, module, context, options = {}) {
-    const { maxSteps = 5, actions = {}, enablePlanning = true, useFreeformExecution = false, logger } = options;
-    let currentContext = { ...context };
-    let plan;
-    // Phase 1: Planning
-    if (enablePlanning && !currentContext.plan) {
-        currentContext.phase = 'planning';
-        plan = await executePlanningPhase(driver, module, currentContext, maxSteps, logger);
-        currentContext.plan = plan;
+    logger.info('[start] agentic workflow');
+    const { maxTasks = 10, tools = [], maxToolCalls = 10, enablePlanning = true, includeThinking = false, } = options;
+    // Resolve user module: DynamicContent → static values
+    // userModule is available throughout the workflow via context.userModule
+    const userModule = resolve(module, context);
+    context.userModule = userModule;
+    // Bootstrap task list
+    const taskList = bootstrap(userModule, enablePlanning);
+    const executionLog = context.executionLog
+        ? [...context.executionLog]
+        : [];
+    const startIndex = executionLog.length;
+    // Task loop
+    for (let i = startIndex; i < taskList.length; i++) {
+        // Guard: max tasks
+        if (i >= maxTasks) {
+            logger.info('[end] Max tasks reached', `(${maxTasks})`);
+            break;
+        }
+        const task = taskList[i];
+        const currentContext = {
+            ...context,
+            taskList,
+            executionLog,
+            currentTaskIndex: i,
+        };
+        const logEntry = await executeTask(driver, userModule, currentContext, task, i, taskList, tools, maxToolCalls);
+        executionLog.push(logEntry);
+    }
+    // Auto-append output task if the last executed task was not output
+    const lastExecuted = executionLog[executionLog.length - 1];
+    if (lastExecuted && lastExecuted.taskType !== 'output') {
+        const outputTask = {
+            instruction: 'Compose the response using the preceding task results.',
+            taskType: 'output',
+        };
+        taskList.push(outputTask);
+        const outputIndex = taskList.length - 1;
+        const outputContext = {
+            ...context,
+            taskList,
+            executionLog,
+            currentTaskIndex: outputIndex,
+        };
+        const outputLog = await executeTask(driver, userModule, outputContext, outputTask, outputIndex, taskList, tools, maxToolCalls);
+        executionLog.push(outputLog);
+    }
+    // Final output: last task's result, optionally prefixed with intermediate results as <think>
+    const lastLog = executionLog[executionLog.length - 1];
+    const finalResult = lastLog?.result || '';
+    let output;
+    if (includeThinking && executionLog.length > 1) {
+        const intermediateLog = executionLog.slice(0, -1);
+        const thinkingLines = intermediateLog
+            .map(log => `[${log.taskType}]\n${log.result}`)
+            .join('\n\n');
+        output = `<think>\n${thinkingLines}\n</think>\n\n${finalResult}`;
     }
     else {
-        // Use existing plan
-        plan = currentContext.plan;
+        output = finalResult;
     }
-    // Phase 2: Execution
-    currentContext.phase = 'execution';
-    const executionLog = await executeExecutionPhase(driver, module, currentContext, plan, actions, useFreeformExecution, logger);
-    currentContext.executionLog = executionLog;
-    // Phase 3: Integration
-    currentContext.phase = 'integration';
-    const finalOutput = await executeIntegrationPhase(driver, module, currentContext, executionLog, logger);
-    // Complete
-    const finalContext = {
-        ...currentContext,
-        phase: 'complete'
-    };
+    // Determine finishReason
+    const hasPendingToolCalls = executionLog.some(log => log.pendingToolCalls && log.pendingToolCalls.length > 0);
+    const finishReason = hasPendingToolCalls
+        ? 'tool_calls'
+        : 'stop';
+    const totalToolCalls = executionLog.reduce((sum, log) => sum + (log.pendingToolCalls?.length || 0), 0);
+    logger.info('[end] agentic workflow');
     return {
-        output: finalOutput,
-        context: finalContext,
+        output,
+        context: {
+            ...context,
+            taskList,
+            executionLog,
+            currentTaskIndex: taskList.length,
+        },
         metadata: {
-            planSteps: plan.steps.length,
-            executedSteps: executionLog.length,
-            actionsUsed: executionLog.filter(log => log.actionResult !== undefined).length
-        }
+            planTasks: taskList.length,
+            executedTasks: executionLog.length,
+            toolCallsUsed: totalToolCalls,
+            finishReason,
+            usage: lastLog?.metadata?.usage,
+        },
     };
 }
 //# sourceMappingURL=agentic-workflow.js.map