@ai-setting/roy-agent-core 1.4.13 → 1.4.15

package/dist/shared/@ai-setting/roy-agent-core-dbsk841j.js

@@ -0,0 +1,286 @@
+// src/env/task/tools/task-types.ts
+import { z } from "zod";
+var CreateTaskToolSchema = z.object({
+  title: z.string().describe("Task title"),
+  description: z.string().optional().describe("Task description"),
+  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)")
+});
+var GetTaskToolSchema = z.object({
+  task_id: z.number().describe("Task ID"),
+  include_operations: z.boolean().optional().default(false).describe("Include operation records")
+});
+var ListTasksToolSchema = z.object({
+  status: z.enum(["todo", "active", "completed", "paused", "cancelled"]).optional(),
+  priority: z.enum(["low", "medium", "high"]).optional(),
+  limit: z.number().optional().default(20),
+  offset: z.number().optional().default(0)
+});
+var UpdateTaskToolSchema = z.object({
+  task_id: z.number().describe("Task ID"),
+  title: z.string().optional(),
+  description: z.string().optional(),
+  status: z.enum(["todo", "active", "completed", "paused", "cancelled"]).optional(),
+  priority: z.enum(["low", "medium", "high"]).optional(),
+  progress: z.number().min(0).max(100).optional(),
+  current_status: z.string().optional(),
+  goals_and_expected_deliverables: z.string().optional(),
+  due_date: z.string().optional(),
+  tags: z.array(z.string()).optional()
+});
+var DeleteTaskToolSchema = z.object({
+  task_id: z.number().describe("Task ID")
+});
+
+// src/env/task/tools/create-tool.ts
+function createTaskTool(taskComponent) {
+  return {
+    name: "task_create",
+    description: "Create a new task. The task will be associated with the current session.",
+    parameters: CreateTaskToolSchema,
+    execute: async (args, ctx) => {
+      const params = CreateTaskToolSchema.parse(args);
+      const sessionId = ctx.session_id || "unknown";
+      try {
+        const task = await taskComponent.createTask({
+          title: params.title,
+          description: params.description,
+          priority: params.priority,
+          goals_and_expected_deliverables: params.goals_and_expected_deliverables,
+          due_date: params.due_date,
+          tags: params.tags,
+          sessionId
+        });
+        return {
+          success: true,
+          output: `Task created successfully: #${task.id} - ${task.title}`,
+          metadata: {
+            execution_time_ms: 0,
+            task_id: task.id,
+            status: task.status,
+            createdAt: task.createdAt
+          }
+        };
+      } catch (error) {
+        return {
+          success: false,
+          output: "",
+          error: error instanceof Error ? error.message : String(error),
+          metadata: { execution_time_ms: 0 }
+        };
+      }
+    }
+  };
+}
+// src/env/task/tools/get-tool.ts
+function getTaskTool(taskComponent) {
+  return {
+    name: "task_get",
+    description: "Get task details by ID. Optionally include operation records.",
+    parameters: GetTaskToolSchema,
+    execute: async (args, ctx) => {
+      const params = GetTaskToolSchema.parse(args);
+      try {
+        if (params.include_operations) {
+          const result = await taskComponent.getTaskWithOperations(params.task_id);
+          if (!result) {
+            return {
+              success: false,
+              output: "",
+              error: `Task not found: ${params.task_id}`,
+              metadata: { execution_time_ms: 0 }
+            };
+          }
+          return {
+            success: true,
+            output: JSON.stringify(result, null, 2),
+            metadata: { execution_time_ms: 0 }
+          };
+        } else {
+          const task = await taskComponent.getTask(params.task_id);
+          if (!task) {
+            return {
+              success: false,
+              output: "",
+              error: `Task not found: ${params.task_id}`,
+              metadata: { execution_time_ms: 0 }
+            };
+          }
+          return {
+            success: true,
+            output: JSON.stringify(task, null, 2),
+            metadata: { execution_time_ms: 0 }
+          };
+        }
+      } catch (error) {
+        return {
+          success: false,
+          output: "",
+          error: error instanceof Error ? error.message : String(error),
+          metadata: { execution_time_ms: 0 }
+        };
+      }
+    }
+  };
+}
+// src/env/task/tools/list-tool.ts
+function listTasksTool(taskComponent) {
+  return {
+    name: "task_list",
+    description: "List tasks with optional filters for status and priority.",
+    parameters: ListTasksToolSchema,
+    execute: async (args, ctx) => {
+      const params = ListTasksToolSchema.parse(args);
+      try {
+        const tasks = await taskComponent.listTasks({
+          status: params.status,
+          priority: params.priority,
+          limit: params.limit,
+          offset: params.offset
+        });
+        return {
+          success: true,
+          output: JSON.stringify({ tasks, count: tasks.length }),
+          metadata: { execution_time_ms: 0 }
+        };
+      } catch (error) {
+        return {
+          success: false,
+          output: "",
+          error: error instanceof Error ? error.message : String(error),
+          metadata: { execution_time_ms: 0 }
+        };
+      }
+    }
+  };
+}
+// src/env/task/tools/update-tool.ts
+function updateTaskTool(taskComponent) {
+  return {
+    name: "task_update",
+    description: "Update an existing task's properties. Status and progress changes will create operation records.",
+    parameters: UpdateTaskToolSchema,
+    execute: async (args, ctx) => {
+      const params = UpdateTaskToolSchema.parse(args);
+      const sessionId = ctx.session_id || "unknown";
+      try {
+        const task = await taskComponent.updateTask(params.task_id, {
+          title: params.title,
+          description: params.description,
+          status: params.status,
+          priority: params.priority,
+          progress: params.progress,
+          current_status: params.current_status,
+          goals_and_expected_deliverables: params.goals_and_expected_deliverables,
+          due_date: params.due_date,
+          tags: params.tags
+        });
+        if (!task) {
+          return {
+            success: false,
+            output: "",
+            error: `Task not found: ${params.task_id}`,
+            metadata: { execution_time_ms: 0 }
+          };
+        }
+        if (params.status || params.progress !== undefined || params.current_status) {
+          await taskComponent.createOperation({
+            taskId: params.task_id,
+            sessionId,
+            actionType: "progress",
+            actionTitle: params.current_status || `Updated: ${params.status || `${params.progress}%`}`,
+            actionDescription: JSON.stringify({
+              status: params.status,
+              progress: params.progress,
+              current_status: params.current_status
+            })
+          });
+        }
+        return {
+          success: true,
+          output: `Task updated: #${task.id} - ${task.title}`,
+          metadata: { execution_time_ms: 0, task }
+        };
+      } catch (error) {
+        return {
+          success: false,
+          output: "",
+          error: error instanceof Error ? error.message : String(error),
+          metadata: { execution_time_ms: 0 }
+        };
+      }
+    }
+  };
+}
+// src/env/task/tools/delete-tool.ts
+function deleteTaskTool(taskComponent) {
+  return {
+    name: "task_delete",
+    description: "Delete a task and all its operation records.",
+    parameters: DeleteTaskToolSchema,
+    execute: async (args, ctx) => {
+      const params = DeleteTaskToolSchema.parse(args);
+      try {
+        const deleted = await taskComponent.deleteTask(params.task_id);
+        if (!deleted) {
+          return {
+            success: false,
+            output: "",
+            error: `Task not found: ${params.task_id}`,
+            metadata: { execution_time_ms: 0 }
+          };
+        }
+        return {
+          success: true,
+          output: `Task deleted: #${params.task_id}`,
+          metadata: { execution_time_ms: 0 }
+        };
+      } catch (error) {
+        return {
+          success: false,
+          output: "",
+          error: error instanceof Error ? error.message : String(error),
+          metadata: { execution_time_ms: 0 }
+        };
+      }
+    }
+  };
+}
+// src/env/task/tools/complete-tool.ts
+function completeTaskTool(taskComponent) {
+  return {
+    name: "task_complete",
+    description: "Mark a task as completed (progress=100, status=completed). Creates an operation record.",
+    parameters: DeleteTaskToolSchema,
+    execute: async (args, ctx) => {
+      const params = DeleteTaskToolSchema.parse(args);
+      const sessionId = ctx.session_id || "unknown";
+      try {
+        const task = await taskComponent.completeTask(params.task_id, sessionId);
+        if (!task) {
+          return {
+            success: false,
+            output: "",
+            error: `Task not found: ${params.task_id}`,
+            metadata: { execution_time_ms: 0 }
+          };
+        }
+        return {
+          success: true,
+          output: `Task completed: #${task.id} - ${task.title}`,
+          metadata: { execution_time_ms: 0, task }
+        };
+      } catch (error) {
+        return {
+          success: false,
+          output: "",
+          error: error instanceof Error ? error.message : String(error),
+          metadata: { execution_time_ms: 0 }
+        };
+      }
+    }
+  };
+}
+export { createTaskTool, getTaskTool, listTasksTool, updateTaskTool, deleteTaskTool, completeTaskTool };

package/dist/shared/@ai-setting/roy-agent-core-e25xkv53.js

@@ -0,0 +1,64 @@
+import {
+  __esm
+} from "./roy-agent-core-fs0mn2jk.js";
+
+// src/env/workflow/types/workflow-hil.ts
+function createNodeInterruptEvent(runId, nodeId, nodeType, query, agentSessionId) {
+  return {
+    type: "node.interrupt",
+    run_id: runId,
+    timestamp: Date.now(),
+    node_id: nodeId,
+    node_type: nodeType,
+    query,
+    ...agentSessionId ? { agent_session_id: agentSessionId } : {}
+  };
+}
+function createWorkflowAskUserEvent(runId, sessionId, nodeId, nodeType, query) {
+  return {
+    type: "workflow.ask-user",
+    run_id: runId,
+    timestamp: Date.now(),
+    session_id: sessionId,
+    node_id: nodeId,
+    node_type: nodeType,
+    query
+  };
+}
+var AskUserError;
+var init_workflow_hil = __esm(() => {
+  AskUserError = class AskUserError extends Error {
+    runId;
+    sessionId;
+    nodeId;
+    nodeType;
+    query;
+    agentSessionId;
+    timestamp;
+    type = "ask-user";
+    name = "AskUserError";
+    constructor(runId, sessionId, nodeId, nodeType, query, agentSessionId, timestamp = Date.now()) {
+      super(`[${nodeType}:${nodeId}] Ask user: ${query}`);
+      this.runId = runId;
+      this.sessionId = sessionId;
+      this.nodeId = nodeId;
+      this.nodeType = nodeType;
+      this.query = query;
+      this.agentSessionId = agentSessionId;
+      this.timestamp = timestamp;
+    }
+    toEvent() {
+      return {
+        type: "workflow.ask-user",
+        run_id: this.runId,
+        timestamp: this.timestamp,
+        session_id: this.sessionId,
+        node_id: this.nodeId,
+        node_type: this.nodeType,
+        query: this.query
+      };
+    }
+  };
+});
+
+export { createNodeInterruptEvent, createWorkflowAskUserEvent, AskUserError, init_workflow_hil };

package/dist/shared/{chunk-yqmx37vm.js → @ai-setting/roy-agent-core-e5jcp24a.js}

@@ -1,8 +1,8 @@
 import {
   SQLiteSpanStorage,
   init_span_storage
-} from "./chunk-1qwabsm0.js";
-import"./chunk-wbkh7wat.js";
+} from "./roy-agent-core-bncgx3gb.js";
+import"./roy-agent-core-fs0mn2jk.js";
 init_span_storage();
 
 export {

package/dist/shared/@ai-setting/roy-agent-core-e62e2a5a.js

@@ -0,0 +1,204 @@
+import {
+  TracedAs,
+  init_decorator
+} from "./roy-agent-core-35x0wrtt.js";
+import {
+  __legacyDecorateClassTS
+} from "./roy-agent-core-fs0mn2jk.js";
+
+// src/env/session/session-message-converter.ts
+init_decorator();
+import { randomUUID } from "crypto";
+var DEFAULT_REASONING_BUDGET_TOKENS = 1e4;
+
+class SessionMessageConverter {
+  toModelMessage(msg) {
+    if (msg.role === "assistant") {
+      const content = [];
+      for (const part of msg.parts || []) {
+        if (part.type === "text") {
+          const textPart = part;
+          content.push({
+            type: "text",
+            text: textPart.content,
+            ...textPart.synthetic !== undefined && { synthetic: textPart.synthetic }
+          });
+        } else if (part.type === "reasoning") {
+          const reasoningPart = part;
+          content.push({
+            type: "reasoning",
+            text: reasoningPart.content,
+            reasoningType: reasoningPart.reasoningType
+          });
+        } else if (part.type === "tool-call") {
+          const toolPart = part;
+          let parsedArgs = {};
+          if (typeof toolPart.arguments === "string") {
+            try {
+              parsedArgs = JSON.parse(toolPart.arguments);
+            } catch {
+              parsedArgs = { _raw: toolPart.arguments };
+            }
+          } else {
+            parsedArgs = toolPart.arguments;
+          }
+          content.push({
+            type: "tool-call",
+            toolCallId: toolPart.toolCallId,
+            toolName: toolPart.toolName,
+            input: parsedArgs
+          });
+        } else if (part.type === "file") {
+          const filePart = part;
+          content.push({
+            type: "file",
+            url: filePart.url,
+            mimeType: filePart.mime,
+            filename: filePart.filename
+          });
+        } else if (part.type === "tool-result" || part.type === "checkpoint") {} else {
+          console.debug(`[session-message-converter] Skipping unsupported part type in assistant: ${part.type}`);
+        }
+      }
+      if (content.length === 0 && msg.content) {
+        return { role: "assistant", content: msg.content };
+      }
+      return { role: "assistant", content };
+    }
+    if (msg.role === "tool") {
+      const toolPart = msg.parts?.find((p) => p.type === "tool-result");
+      return {
+        role: "tool",
+        content: [{
+          type: "tool-result",
+          toolCallId: toolPart?.toolCallId || "",
+          toolName: toolPart?.toolName || "",
+          output: toolPart?.output || msg.content || ""
+        }]
+      };
+    }
+    return {
+      role: msg.role,
+      content: msg.content || ""
+    };
+  }
+  fromModelMessage(aiMsg, options) {
+    const parts = [];
+    const content = typeof aiMsg.content === "string" || Array.isArray(aiMsg.content) ? aiMsg.content : "";
+    let hasToolCallPart = false;
+    let hasToolResultPart = false;
+    if (typeof content === "string") {
+      parts.push({ type: "text", content });
+    } else if (Array.isArray(content)) {
+      for (const part of content) {
+        const p = part;
+        if (p.type === "text") {
+          parts.push({ type: "text", content: p.text || "" });
+        } else if (p.type === "reasoning") {
+          parts.push({
+            type: "reasoning",
+            content: p.text || "",
+            reasoningType: p.reasoningType,
+            state: "completed"
+          });
+        } else if (p.type === "tool-call") {
+          hasToolCallPart = true;
+          parts.push({
+            type: "tool-call",
+            toolCallId: p.toolCallId,
+            toolName: p.toolName,
+            arguments: p.input,
+            state: "pending"
+          });
+        } else if (p.type === "tool-result") {
+          hasToolResultPart = true;
+          parts.push({
+            type: "tool-result",
+            toolCallId: p.toolCallId,
+            toolName: p.toolName,
+            output: typeof p.output === "string" ? p.output : JSON.stringify(p.output),
+            state: "completed"
+          });
+        } else if (p.type === "file") {
+          parts.push({
+            type: "file",
+            mime: p.mimeType || "application/octet-stream",
+            url: p.url,
+            filename: p.filename
+          });
+        } else {
+          console.debug(`[session-message-converter] Unknown part type: ${p.type}`);
+        }
+      }
+    }
+    let metadataType;
+    if (aiMsg.role === "assistant" && hasToolCallPart) {
+      metadataType = "tool_call";
+    } else if (aiMsg.role === "tool") {
+      metadataType = "tool_result";
+    }
+    const result = {
+      id: options?.messageID || `msg_${randomUUID()}`,
+      sessionID: options?.sessionID || "",
+      role: aiMsg.role,
+      timestamp: Date.now(),
+      parts,
+      content: typeof content === "string" ? content : ""
+    };
+    if (metadataType) {
+      result.metadata = { type: metadataType };
+    }
+    return result;
+  }
+  sessionToHistory(messages) {
+    return messages.filter((msg) => !msg.metadata?.isArchived && !msg.isArchived).map((msg) => this.toModelMessage(msg));
+  }
+  extractProviderOptions(msg) {
+    const options = {};
+    const reasoningParts = msg.parts?.filter((p) => p.type === "reasoning");
+    if (reasoningParts && reasoningParts.length > 0) {
+      const firstReasoning = reasoningParts[0];
+      if (firstReasoning.reasoningType) {
+        options.openai = {
+          thinking: {
+            type: firstReasoning.reasoningType === "effort" ? "extended" : "core"
+          }
+        };
+        if (firstReasoning.reasoningType === "effort") {
+          const budgetTokens = firstReasoning.metadata?.tokenCount || DEFAULT_REASONING_BUDGET_TOKENS;
+          options.anthropic = {
+            thinking: {
+              type: "enabled",
+              budgetTokens
+            }
+          };
+        }
+      }
+    }
+    return options;
+  }
+  migrateMessage(oldMsg) {
+    if (oldMsg.parts && oldMsg.parts.length > 0) {
+      const firstPart = oldMsg.parts[0];
+      if (firstPart && typeof firstPart.type === "string" && firstPart.type.length > 0) {
+        return {
+          ...oldMsg,
+          content: oldMsg.content || ""
+        };
+      }
+    }
+    return {
+      ...oldMsg,
+      content: oldMsg.content || "",
+      parts: oldMsg.content ? [{ type: "text", content: oldMsg.content }] : []
+    };
+  }
+}
+__legacyDecorateClassTS([
+  TracedAs("session-message-converter.toModelMessage", { recordParams: true, recordResult: true, log: true })
+], SessionMessageConverter.prototype, "toModelMessage", null);
+__legacyDecorateClassTS([
+  TracedAs("session-message-converter.fromModelMessage", { recordParams: true, recordResult: true, log: true })
+], SessionMessageConverter.prototype, "fromModelMessage", null);
+
+export { SessionMessageConverter };

package/dist/shared/{chunk-g6j5n3gv.js → @ai-setting/roy-agent-core-ewrj1c4k.js}

@@ -3,10 +3,10 @@ import {
   init_propagation,
   init_tracer_provider,
   propagation
-} from "./chunk-q9j99fsm.js";
+} from "./roy-agent-core-fv32jaa8.js";
 import {
   __toCommonJS
-} from "./chunk-wbkh7wat.js";
+} from "./roy-agent-core-fs0mn2jk.js";
 
 // src/env/tool/built-in/bash.ts
 init_propagation();