@ai-setting/roy-agent-core 1.5.6 → 1.5.8

package/dist/shared/@ai-setting/{roy-agent-core-n2cvdgd6.js → roy-agent-core-gwc4h96n.js}

@@ -1,7 +1,12 @@
+import {
+  BackgroundTaskManager,
+  createDelegateTool,
+  createStopTool
+} from "./roy-agent-core-vf215qfv.js";
 import {
   SQLiteTaskStore,
   getDefaultTaskDbPath
-} from "./roy-agent-core-htwpckw9.js";
+} from "./roy-agent-core-bvr1761x.js";
 import {
   completeTaskTool,
   createTaskTool,
@@ -9,7 +14,7 @@ import {
   getTaskTool,
   listTasksTool,
   updateTaskTool
-} from "./roy-agent-core-dbsk841j.js";
+} from "./roy-agent-core-wa1kzqky.js";
 import {
   createOperationTool,
   deleteOperationTool,
@@ -17,14 +22,12 @@ import {
   listOperationsTool,
   updateOperationTool
 } from "./roy-agent-core-t94ktchq.js";
-import {
-  BackgroundTaskManager,
-  createDelegateTool,
-  createStopTool
-} from "./roy-agent-core-z62zee1e.js";
 import {
   TaskHookPoints
 } from "./roy-agent-core-92z6t4he.js";
+import {
+  TaskEntityEventTypes
+} from "./roy-agent-core-8gxth0eh.js";
 import {
   envKeyToConfigKey
 } from "./roy-agent-core-qxhq8ven.js";
@@ -155,6 +158,19 @@ class TaskComponent extends BaseComponent {
   configComponent;
   tagService;
   plugins = new Map;
+  publishEvent(type, payload, sessionId) {
+    if (this.env?.pushEnvEvent) {
+      this.env.pushEnvEvent({
+        type,
+        payload,
+        metadata: {
+          source: "task.component",
+          trigger_session_id: sessionId
+        }
+      });
+      logger2.info(`[TaskComponent] Event published: ${type}`);
+    }
+  }
   constructor() {
     super();
   }
@@ -344,6 +360,7 @@ class TaskComponent extends BaseComponent {
       tagService: this.tagService
     };
     await this.executeHook(TaskHookPoints.AFTER_CREATE, resultCtx);
+    this.publishEvent(TaskEntityEventTypes.CREATED, { task, sessionId }, sessionId);
     logger2.info(`[TaskComponent] Task created: ${task.id} - ${task.title}`);
     return task;
   }
@@ -372,6 +389,7 @@ class TaskComponent extends BaseComponent {
         tagService: this.tagService
       };
       await this.executeHook(TaskHookPoints.AFTER_UPDATE, resultCtx);
+      this.publishEvent(TaskEntityEventTypes.UPDATED, { task, changes: options, sessionId: "" }, "");
       logger2.info(`[TaskComponent] Task updated: ${id}`);
     }
     return task;
@@ -383,6 +401,7 @@ class TaskComponent extends BaseComponent {
     const resultCtx = { id, deleted: result };
     await this.executeHook(TaskHookPoints.AFTER_DELETE, resultCtx);
     if (result) {
+      this.publishEvent(TaskEntityEventTypes.DELETED, { taskId: id, sessionId: "" }, "");
       logger2.info(`[TaskComponent] Task deleted: ${id}`);
     }
     return result;
@@ -402,6 +421,7 @@ class TaskComponent extends BaseComponent {
         actionType: "completed",
         actionTitle: "Task completed"
       });
+      this.publishEvent(TaskEntityEventTypes.COMPLETED, { task, sessionId }, sessionId);
       logger2.info(`[TaskComponent] Task completed: ${id}`);
     }
     return task;
@@ -414,6 +434,7 @@ class TaskComponent extends BaseComponent {
     const op = await this.store.createOperation(createCtx.options);
     const resultCtx = { operation: op };
     await this.executeHook(TaskHookPoints.OPERATION_AFTER_CREATE, resultCtx);
+    this.publishEvent(TaskEntityEventTypes.OPERATION_ADDED, { operation: op, taskId: op.taskId }, op.sessionId);
     logger2.info(`[TaskComponent] Operation created: ${op.id} for task ${op.taskId}`);
     return op;
   }

package/dist/shared/@ai-setting/{roy-agent-core-z62zee1e.js → roy-agent-core-vf215qfv.js}

@@ -12,55 +12,15 @@ import {
 // src/env/task/delegate/delegate-tool.ts
 init_logger();
 import { z } from "zod";
-
-// src/env/task/delegate/task-events.ts
-var TaskEventTypes = {
-  TASK_STARTED: "task.started",
-  TASK_PROGRESS: "task.progress",
-  TASK_COMPLETED: "task.completed",
-  TASK_FAILED: "task.failed",
-  TASK_TIMEOUT: "task.timeout",
-  TASK_STOPPED: "task.stopped"
-};
-function createTaskStartedPayload(task, parentSessionId) {
-  return {
-    taskId: task.id,
-    subSessionId: task.subSessionId,
-    parentSessionId,
-    description: task.description,
-    subagentType: task.subagentType,
-    associatedTaskId: task.taskId
-  };
-}
-function createTaskProgressPayload(task, parentSessionId) {
-  return {
-    taskId: task.id,
-    subSessionId: task.subSessionId,
-    parentSessionId,
-    status: task.status,
-    progress: task.progress,
-    progressMessage: task.progressMessage,
-    description: task.description,
-    subagentType: task.subagentType
-  };
-}
-function createTaskCompletedPayload(task, parentSessionId, executionTimeMs) {
-  return {
-    taskId: task.id,
-    subSessionId: task.subSessionId,
-    parentSessionId,
-    status: task.status,
-    result: task.result,
-    error: task.error,
-    executionTimeMs,
-    associatedTaskId: task.taskId,
-    description: task.description,
-    subagentType: task.subagentType
-  };
-}
-
-// src/env/task/delegate/delegate-tool.ts
 var logger = createLogger("task:delegate");
+var BackgroundTaskEventTypes = {
+  STARTED: "task.background.started",
+  PROGRESS: "task.background.progress",
+  COMPLETED: "task.background.completed",
+  FAILED: "task.background.failed",
+  TIMEOUT: "task.background.timeout",
+  STOPPED: "task.background.stopped"
+};
 var builtInSubAgents = [
   {
     id: "general",
@@ -177,14 +137,27 @@ var PROGRESS_INTERVAL = 120000;
 class BackgroundTaskManager {
   env;
   tasks = new Map;
-  progressTimers = new Map;
   abortControllers = new Map;
+  progressTimers = new Map;
   constructor(env) {
     this.env = env;
   }
   getSessionComponent() {
     return this.env?.getComponent?.("session");
   }
+  publishBackgroundEvent(type, payload, parentSessionId) {
+    if (this.env?.pushEnvEvent) {
+      this.env.pushEnvEvent({
+        type,
+        payload,
+        metadata: {
+          source: "task.background",
+          trigger_session_id: parentSessionId
+        }
+      });
+      logger.info(`[BackgroundTaskManager] Event published: ${type}`);
+    }
+  }
   async createTask(options) {
     const { parentSessionId, description, prompt, subagentType, timeout, cleanup, taskId } = options;
     const taskIdGen = `task_${Date.now()}_${Math.random().toString(36).slice(2, 11)}`;
@@ -225,7 +198,15 @@ class BackgroundTaskManager {
     };
     this.tasks.set(taskIdGen, task);
     this.abortControllers.set(taskIdGen, abortController);
-    this.publishEvent(TaskEventTypes.TASK_STARTED, createTaskStartedPayload(task, parentSessionId), parentSessionId);
+    const startedPayload = {
+      backgroundTaskId: taskIdGen,
+      subSessionId: subSession.id,
+      parentSessionId,
+      description,
+      subagentType,
+      associatedTaskId: taskId
+    };
+    this.publishBackgroundEvent(BackgroundTaskEventTypes.STARTED, startedPayload, parentSessionId);
     this.executeTask(taskIdGen, prompt, timeout, cleanup, parentSessionId).catch((err) => {
       logger.error(`[BackgroundTaskManager] executeTask unhandled rejection`, {
         taskId: taskIdGen,
@@ -260,7 +241,17 @@ class BackgroundTaskManager {
       task.completedAt = Date.now();
       task.result = result;
       const executionTimeMs = task.completedAt - task.startedAt;
-      this.publishEvent(TaskEventTypes.TASK_COMPLETED, createTaskCompletedPayload(task, parentSessionId || task.parentSessionId, executionTimeMs), parentSessionId || task.parentSessionId);
+      const completedPayload = {
+        backgroundTaskId: task.id,
+        subSessionId: task.subSessionId,
+        parentSessionId: parentSessionId || task.parentSessionId,
+        status: "completed",
+        result: task.result,
+        description: task.description,
+        executionTimeMs,
+        associatedTaskId: task.taskId
+      };
+      this.publishBackgroundEvent(BackgroundTaskEventTypes.COMPLETED, completedPayload, parentSessionId || task.parentSessionId);
       logger.info(`[BackgroundTaskManager] Task completed successfully`, {
         taskId,
         executionTimeMs
@@ -268,15 +259,46 @@ class BackgroundTaskManager {
     } catch (error) {
       const errorMessage = error instanceof Error ? error.message : String(error);
       const isStoppedError = errorMessage.toLowerCase().includes("stopped") || errorMessage.toLowerCase().includes("aborted");
+      const executionTimeMs = task.startedAt ? Date.now() - task.startedAt : 0;
       if (isStoppedError) {
         task.status = "stopped";
-        this.publishEvent(TaskEventTypes.TASK_STOPPED, createTaskCompletedPayload(task, parentSessionId || task.parentSessionId, task.completedAt - task.startedAt), parentSessionId || task.parentSessionId);
+        const stoppedPayload = {
+          backgroundTaskId: task.id,
+          subSessionId: task.subSessionId,
+          parentSessionId: parentSessionId || task.parentSessionId,
+          status: "stopped",
+          description: task.description,
+          error: errorMessage,
+          executionTimeMs,
+          associatedTaskId: task.taskId
+        };
+        this.publishBackgroundEvent(BackgroundTaskEventTypes.STOPPED, stoppedPayload, parentSessionId || task.parentSessionId);
       } else if (errorMessage.includes("timeout")) {
         task.status = "timeout";
-        this.publishEvent(TaskEventTypes.TASK_TIMEOUT, createTaskCompletedPayload(task, parentSessionId || task.parentSessionId, task.completedAt - task.startedAt), parentSessionId || task.parentSessionId);
+        const timeoutPayload = {
+          backgroundTaskId: task.id,
+          subSessionId: task.subSessionId,
+          parentSessionId: parentSessionId || task.parentSessionId,
+          status: "timeout",
+          description: task.description,
+          error: errorMessage,
+          executionTimeMs,
+          associatedTaskId: task.taskId
+        };
+        this.publishBackgroundEvent(BackgroundTaskEventTypes.TIMEOUT, timeoutPayload, parentSessionId || task.parentSessionId);
       } else {
         task.status = "failed";
-        this.publishEvent(TaskEventTypes.TASK_FAILED, createTaskCompletedPayload(task, parentSessionId || task.parentSessionId, task.completedAt - task.startedAt), parentSessionId || task.parentSessionId);
+        const failedPayload = {
+          backgroundTaskId: task.id,
+          subSessionId: task.subSessionId,
+          parentSessionId: parentSessionId || task.parentSessionId,
+          status: "failed",
+          description: task.description,
+          error: errorMessage,
+          executionTimeMs,
+          associatedTaskId: task.taskId
+        };
+        this.publishBackgroundEvent(BackgroundTaskEventTypes.FAILED, failedPayload, parentSessionId || task.parentSessionId);
       }
       task.error = errorMessage;
       task.completedAt = Date.now();
@@ -289,6 +311,35 @@ class BackgroundTaskManager {
       this.stopProgressReporter(taskId);
     }
   }
+  startProgressReporter(taskId, parentSessionId) {
+    const timer = setInterval(() => {
+      const task = this.tasks.get(taskId);
+      if (!task || task.status !== "running") {
+        this.stopProgressReporter(taskId);
+        return;
+      }
+      if (task.startedAt) {
+        const elapsedMs = Date.now() - task.startedAt;
+        task.progress = Math.min(95, Math.floor(elapsedMs / PROGRESS_INTERVAL * 100));
+      }
+      const progressPayload = {
+        backgroundTaskId: taskId,
+        subSessionId: task.subSessionId,
+        parentSessionId,
+        status: task.status,
+        progress: task.progress
+      };
+      this.publishBackgroundEvent(BackgroundTaskEventTypes.PROGRESS, progressPayload, parentSessionId);
+    }, PROGRESS_INTERVAL);
+    this.progressTimers.set(taskId, timer);
+  }
+  stopProgressReporter(taskId) {
+    const timer = this.progressTimers.get(taskId);
+    if (timer) {
+      clearInterval(timer);
+      this.progressTimers.delete(taskId);
+    }
+  }
   async executeWithAbort(subSession, prompt, timeoutMs, signal) {
     return new Promise((resolve, reject) => {
       const timer = setTimeout(() => {
@@ -346,41 +397,6 @@ ${prompt}
       });
     });
   }
-  startProgressReporter(taskId, parentSessionId) {
-    const timer = setInterval(() => {
-      const task = this.tasks.get(taskId);
-      if (!task || task.status !== "running") {
-        this.stopProgressReporter(taskId);
-        return;
-      }
-      if (task.startedAt) {
-        const elapsedMs = Date.now() - task.startedAt;
-        task.progress = Math.min(95, Math.floor(elapsedMs / PROGRESS_INTERVAL * 100));
-      }
-      this.publishEvent(TaskEventTypes.TASK_PROGRESS, createTaskProgressPayload(task, parentSessionId), parentSessionId);
-    }, PROGRESS_INTERVAL);
-    this.progressTimers.set(taskId, timer);
-  }
-  stopProgressReporter(taskId) {
-    const timer = this.progressTimers.get(taskId);
-    if (timer) {
-      clearInterval(timer);
-      this.progressTimers.delete(taskId);
-    }
-  }
-  publishEvent(type, payload, triggerSessionId) {
-    if (this.env?.pushEnvEvent) {
-      this.env.pushEnvEvent({
-        type,
-        metadata: {
-          trigger_session_id: triggerSessionId,
-          source: "task.delegate"
-        },
-        payload
-      });
-      logger.info(`[BackgroundTaskManager] Event published: ${type}`, { payload });
-    }
-  }
   stopTask(taskId) {
     const task = this.tasks.get(taskId);
     if (!task) {
@@ -396,7 +412,17 @@ ${prompt}
     task.status = "stopped";
     task.abortController?.abort();
     task.completedAt = Date.now();
-    this.publishEvent(TaskEventTypes.TASK_STOPPED, createTaskCompletedPayload(task, task.parentSessionId, task.completedAt - task.startedAt), task.parentSessionId);
+    const stoppedPayload = {
+      backgroundTaskId: task.id,
+      subSessionId: task.subSessionId,
+      parentSessionId: task.parentSessionId,
+      status: "stopped",
+      description: task.description,
+      error: "Task stopped by user",
+      executionTimeMs: task.startedAt ? task.completedAt - task.startedAt : 0,
+      associatedTaskId: task.taskId
+    };
+    this.publishBackgroundEvent(BackgroundTaskEventTypes.STOPPED, stoppedPayload, task.parentSessionId);
     return { success: true, task, message: "Task has been stopped" };
   }
   getTask(taskId) {
@@ -406,11 +432,6 @@ ${prompt}
     return Array.from(this.tasks.values());
   }
   dispose() {
-    for (const [taskId, timer] of this.progressTimers) {
-      clearInterval(timer);
-      logger.debug(`[BackgroundTaskManager] Cleared progress timer for task: ${taskId}`);
-    }
-    this.progressTimers.clear();
     for (const [taskId, controller] of this.abortControllers) {
       controller.abort();
       logger.debug(`[BackgroundTaskManager] Aborted task: ${taskId}`);
@@ -423,6 +444,7 @@ ${prompt}
 function createDelegateTool(taskComponent) {
   const env = taskComponent.env;
   const backgroundTaskManager = new BackgroundTaskManager(env);
+  taskComponent._backgroundTaskManager = backgroundTaskManager;
   const tool = {
     name: "delegate_task",
     description: `Launch a new sub-agent to handle complex, multistep tasks autonomously.
@@ -622,7 +644,9 @@ async function handleBackgroundTask(taskComponent, backgroundTaskManager, parent
         description: `Background task delegated to ${subagentType} subagent`,
         priority: "medium",
         goals_and_expected_deliverables: prompt,
-        sessionId: parentSessionId
+        sessionId: parentSessionId,
+        project_path: "unknown",
+        context: "unknown"
       });
       associatedTaskId = newTask.id;
       await taskComponent.createOperation({
@@ -785,4 +809,4 @@ function createStopTool(taskManager) {
     }
   };
 }
-export { TaskEventTypes, BackgroundTaskManager, createDelegateTool, createStopTool };
+export { BackgroundTaskEventTypes, BackgroundTaskManager, createDelegateTool, createStopTool };

package/dist/shared/@ai-setting/{roy-agent-core-3xwneva0.js → roy-agent-core-vkz81f7v.js}

@@ -486,13 +486,19 @@ function generateProviderOptions(providerType, options) {
 }
 function createEnvEventEmitter(env, context) {
   if (!env) {
+    logger.warn("[invoke] createEnvEventEmitter: env is null/undefined, streaming events will be disabled");
     return null;
   }
   return (event) => {
     try {
+      const fullType = `llm.${event.type}`;
+      logger.info(`[invoke] Pushing LLM event: ${fullType}`, {
+        hasPayload: !!event,
+        payloadType: typeof event
+      });
       env.pushEnvEvent({
         id: randomUUID(),
-        type: `llm.${event.type}`,
+        type: fullType,
         timestamp: Date.now(),
         metadata: {
           source: "llm.invoke",
@@ -501,6 +507,7 @@ function createEnvEventEmitter(env, context) {
         },
         payload: event
       });
+      logger.info(`[invoke] LLM event pushed successfully: ${fullType}`);
     } catch (err) {
       logger.warn("Failed to push env event", { error: String(err), eventType: event.type });
     }
@@ -576,6 +583,7 @@ function processThinkingStream(textDelta, config, state) {
 async function invoke(config, options, ctx) {
   try {
     const emitToEnv = createEnvEventEmitter(options.env, options.context);
+    logger.info("[invoke] Created event emitter, env available:", !!options.env, "context:", options.context);
     const { providerId, modelId } = parseModelString(options.model || config.model);
     const provider = createProviderInstance(providerId, config.apiKey, config.baseURL);
     if (!provider) {
@@ -622,7 +630,10 @@ async function invoke(config, options, ctx) {
     });
     const model = `${providerId}/${modelId}`;
     if (emitToEnv) {
+      logger.info("[invoke] Emitting llm.start event");
       emitToEnv({ type: "start", metadata: { model } });
+    } else {
+      logger.warn("[invoke] emitToEnv is null, skipping llm.start event");
     }
     const streamTextOptions = {
       model: provider.languageModel(modelId),

package/dist/shared/@ai-setting/{roy-agent-core-dbsk841j.js → roy-agent-core-wa1kzqky.js}

@@ -6,7 +6,9 @@ var CreateTaskToolSchema = z.object({
   priority: z.enum(["low", "medium", "high"]).optional().describe("Task priority"),
   goals_and_expected_deliverables: z.string().optional().describe("Goals and expected deliverables"),
   due_date: z.string().optional().describe("Due date (ISO format)"),
-  tags: z.array(z.string()).optional().describe("Task tags (for search, stored in task.tags JSON field)")
+  tags: z.array(z.string()).optional().describe("Task tags (for search, stored in task.tags JSON field)"),
+  project_path: z.string().describe("Project root path for task positioning. " + "Used to locate the project space for this task. " + "Use 'unknown' if unknown."),
+  context: z.string().describe("JSON string with time-space positioning information for task continuity. " + "This field is crucial for Agent task handoff. " + "Core fields: worktree_path (git worktree path), branch (current branch), type (feature/bug/refactor/chore). " + 'Example for coding: {"worktree_path": "/path/worktree", "branch": "feature/xyz", "type": "feature"}. ' + 'Example for other: {"type": "general"}. ' + `If unknown, use '{}' or '{"type":"unknown"}'. ` + "IMPORTANT: Must be a valid JSON string!")
 });
 var GetTaskToolSchema = z.object({
   task_id: z.number().describe("Task ID"),
@@ -28,7 +30,9 @@ var UpdateTaskToolSchema = z.object({
   current_status: z.string().optional(),
   goals_and_expected_deliverables: z.string().optional(),
   due_date: z.string().optional(),
-  tags: z.array(z.string()).optional()
+  tags: z.array(z.string()).optional(),
+  project_path: z.string().optional().describe("Project path, identifies which project this task belongs to"),
+  context: z.string().optional().describe("Task context information for storing additional context")
 });
 var DeleteTaskToolSchema = z.object({
   task_id: z.number().describe("Task ID")
@@ -38,7 +42,41 @@ var DeleteTaskToolSchema = z.object({
 function createTaskTool(taskComponent) {
   return {
     name: "task_create",
-    description: "Create a new task. The task will be associated with the current session.",
+    description: `
+      Create a new task for tracking work.
+      
+      ## IMPORTANT: Task Continuity Fields
+      
+      This tool creates persistent task records that can be picked up by a 
+      Task Manager Agent to continue推进未完成的任务.
+      
+      The following fields are critical for task context preservation:
+      
+      - project_path: The project root path where this task belongs.
+        Used to locate the project space for this task.
+        If unknown, use 'unknown'.
+      
+      - context: A JSON string containing time-space positioning information.
+        This field is crucial for Agent task handoff.
+        
+        **Required format**: Valid JSON string (parseable).
+        
+        **Core fields**:
+        - worktree_path: Git worktree path (for code development)
+        - branch: Current branch name
+        - type: Task type (feature/bug/refactor/chore)
+        
+        **Example for coding tasks**:
+        {"worktree_path": "/path/to/worktree", "branch": "feature/xyz", "type": "feature", "parent_branch": "main"}
+        
+        **Example for other tasks**:
+        {"type": "general"}
+        
+        If unable to fill in details, use at minimum:
+        {"type": "unknown"}
+        
+        **DO NOT leave this as plain text** - it must be valid JSON!
+    `,
     parameters: CreateTaskToolSchema,
     execute: async (args, ctx) => {
       const params = CreateTaskToolSchema.parse(args);
@@ -51,7 +89,9 @@ function createTaskTool(taskComponent) {
           goals_and_expected_deliverables: params.goals_and_expected_deliverables,
           due_date: params.due_date,
           tags: params.tags,
-          sessionId
+          sessionId,
+          project_path: params.project_path,
+          context: params.context
         });
         return {
           success: true,
@@ -175,7 +215,9 @@ function updateTaskTool(taskComponent) {
           current_status: params.current_status,
           goals_and_expected_deliverables: params.goals_and_expected_deliverables,
           due_date: params.due_date,
-          tags: params.tags
+          tags: params.tags,
+          project_path: params.project_path,
+          context: params.context
         });
         if (!task) {
           return {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-setting/roy-agent-core",
-  "version": "1.5.6",
+  "version": "1.5.8",
   "type": "module",
   "description": "Core SDK for roy-agent - Environment, Components, Tools, Sessions, Tasks",
   "main": "./dist/index.js",

package/dist/shared/@ai-setting/{roy-agent-core-dc497hmk.js → roy-agent-core-rhmtwnw1.js}

@@ -2,17 +2,17 @@ import {
   exports_node_registry_helper,
   init_node_registry_helper
 } from "./roy-agent-core-0rtxwr28.js";
+import {
+  WorkflowEngine,
+  exports_engine,
+  init_engine
+} from "./roy-agent-core-wrcy0h6z.js";
 import {
   WorkflowService
 } from "./roy-agent-core-4t40mkpv.js";
 import {
   askUserTool
 } from "./roy-agent-core-0vbdz0x7.js";
-import {
-  WorkflowEngine,
-  exports_engine,
-  init_engine
-} from "./roy-agent-core-wrcy0h6z.js";
 import {
   BaseComponent
 } from "./roy-agent-core-kkbwepqb.js";