@ai-setting/roy-agent-core 1.5.88 → 1.5.90

package/dist/shared/@ai-setting/{roy-agent-core-jymz9fzp.js → roy-agent-core-2c8eraxq.js}

@@ -6,10 +6,7 @@ import {
 import {
   MemorySessionStore,
   SQLiteSessionStore
-} from "./roy-agent-core-q7sqeax6.js";
-import {
-  SummaryAgent
-} from "./roy-agent-core-x3gtyqax.js";
+} from "./roy-agent-core-zky9jse4.js";
 import {
   envKeyToConfigKey
 } from "./roy-agent-core-qxhq8ven.js";
@@ -67,9 +64,40 @@ var SESSION_CONFIG_REGISTRATION = {
 // src/env/session/session-component.ts
 init_search_query_parser();
 import path from "path";
+import { z } from "zod";
 var logger = createLogger("session");
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function isBusyError(err) {
+  if (err == null)
+    return false;
+  const e = err;
+  if (typeof e.code === "string") {
+    if (/^SQLITE_(BUSY|LOCKED)$/i.test(e.code))
+      return true;
+  }
+  if (typeof e.errno === "number" && (e.errno === 5 || e.errno === 6)) {
+    return true;
+  }
+  const msg = e.message ?? "";
+  return /SQLiteError:\s+(database is locked|database table is locked)/i.test(msg);
+}
+
+class AddMessageLockExhaustedError extends Error {
+  kind = "lock_exhausted";
+  attempts;
+  cause;
+  constructor(attempts, cause) {
+    super(`Failed to add message after ${attempts} attempts: ${String(cause)}`);
+    this.name = "AddMessageLockExhaustedError";
+    this.attempts = attempts;
+    this.cause = cause;
+  }
+}
 
 class SessionComponent extends BaseComponent {
+  static BACKOFFS_MS = [50, 100, 200];
   name = "session";
   version = "1.1.0";
   config;
@@ -78,9 +106,6 @@ class SessionComponent extends BaseComponent {
   hooksConfig = {};
   configComponent;
   configWatcher;
-  summaryAgent;
-  promptComponent;
-  llmComponent;
   constructor() {
     super();
   }
@@ -328,14 +353,38 @@ class SessionComponent extends BaseComponent {
   async addMessage(sessionId, message) {
     const contentPreview = typeof message.content === "string" ? message.content.substring(0, 100) : JSON.stringify(message.content).substring(0, 100);
     logger.info(`[SessionComponent.addMessage] sessionId=${sessionId}, role=${message.role}, content="${contentPreview}"`);
-    try {
-      const messageId = await this.store?.addMessage(sessionId, message);
-      logger.info(`[SessionComponent.addMessage] Success: messageId=${messageId}`);
-      return messageId;
-    } catch (error) {
-      logger.error(`[SessionComponent] Failed to add message: ${error}`);
-      return;
+    return this.addMessageWithRetry(sessionId, message);
+  }
+  async addMessageWithRetry(sessionId, message) {
+    const MAX_ATTEMPTS = SessionComponent.BACKOFFS_MS.length;
+    for (let attempt = 0;attempt < MAX_ATTEMPTS; attempt++) {
+      try {
+        const messageId = await this.store?.addMessage(sessionId, message);
+        if (attempt > 0) {
+          logger.info(`[SessionComponent.addMessage] Recovered after ${attempt + 1} attempts: messageId=${messageId}`);
+        } else {
+          logger.info(`[SessionComponent.addMessage] Success: messageId=${messageId}`);
+        }
+        return messageId;
+      } catch (error) {
+        if (!isBusyError(error)) {
+          logger.error(`[SessionComponent] Failed to add message (non-busy): ${error}`);
+          return;
+        }
+        const isLastAttempt = attempt === MAX_ATTEMPTS - 1;
+        if (isLastAttempt) {
+          logger.error(`[SessionComponent] Failed to add message after ${MAX_ATTEMPTS} attempts (busy): ${error}`);
+          throw new AddMessageLockExhaustedError(MAX_ATTEMPTS, error);
+        }
+        const backoffMs = SessionComponent.BACKOFFS_MS[attempt];
+        logger.warn(`[SessionComponent] SQLITE_BUSY on attempt ${attempt + 1}/${MAX_ATTEMPTS}, retrying in ${backoffMs}ms: ${error}`);
+        await sleep(backoffMs);
+      }
     }
+    return;
+  }
+  async addMessages(sessionId, messages) {
+    return this.store?.addMessages(sessionId, messages) ?? [];
   }
   async getMessages(sessionId, options) {
     const messages = await this.store?.getMessages(sessionId, options?.offset, options?.limit);
@@ -398,19 +447,6 @@ class SessionComponent extends BaseComponent {
     const date = new Date().toISOString().replace("T", " ").substring(0, 19);
     return template.replace("{date}", date);
   }
-  setSummaryComponents(promptComponent, llmComponent) {
-    this.promptComponent = promptComponent;
-    this.llmComponent = llmComponent;
-    this.summaryAgent = new SummaryAgent(promptComponent, llmComponent);
-  }
-  ensureSummaryAgent() {
-    if (!this.summaryAgent) {
-      if (!this.promptComponent || !this.llmComponent) {
-        throw new Error("SummaryAgent components not initialized. Call setSummaryComponents() first.");
-      }
-      this.summaryAgent = new SummaryAgent(this.promptComponent, this.llmComponent);
-    }
-  }
   async generateCompactHint(sessionId) {
     const session = await this.get(sessionId);
     if (!session) {
@@ -424,16 +460,33 @@ class SessionComponent extends BaseComponent {
       logger.warn("[SessionComponent] Not enough messages for hint generation");
       return "";
     }
-    this.ensureSummaryAgent();
-    const result = await this.summaryAgent.generateCompactHint({
-      messages: messages.map((m) => ({ role: m.role, content: m.content })),
-      sessionContext: {}
+    const agentComponent = this.env.getComponent("agent");
+    let hintData;
+    const submitTool = {
+      name: "workflow_submit_output",
+      description: "Submit the final result. Call this with your guidance_prompt.",
+      parameters: z.object({
+        guidance_prompt: z.string().describe("The compact guidance prompt (3-4 sentences)")
+      }),
+      execute: async (args) => {
+        const parsed = z.object({
+          guidance_prompt: z.string()
+        }).parse(args);
+        hintData = parsed;
+        return { success: true, output: "OK" };
+      }
+    };
+    await agentComponent.run("compact-hint", "Analyze this conversation and generate a compact guidance prompt for checkpoint generation.", {
+      sessionId,
+      persistSession: false,
+      extraTools: [submitTool]
     });
+    const hint = hintData?.guidance_prompt || "[Hint extraction failed]";
     logger.info("[SessionComponent] Compact hint generated", {
       sessionId,
-      hintLength: result.hint.length
+      hintLength: hint.length
     });
-    return result.hint;
+    return hint;
   }
   async compact(sessionId, options) {
     const session = await this.get(sessionId);
@@ -448,20 +501,52 @@ class SessionComponent extends BaseComponent {
       throw new Error("Not enough messages to compact (minimum 3 required)");
     }
     const recentMessages = this.extractRecentMessages(messages, 2);
-    this.ensureSummaryAgent();
     await this.executeBeforeHooks("compact", { session, options });
     let summaryResult;
     try {
-      summaryResult = await this.summaryAgent.run({
-        messages: messages.map((m) => ({ role: m.role, content: m.content })),
-        userContext: options?.summary,
-        outputFormat: "json",
-        scenarioHint: options?.scenarioHint
+      const userQuery = options?.scenarioHint ? options.scenarioHint : "Generate a checkpoint from this conversation.";
+      let checkpointData;
+      const submitTool = {
+        name: "workflow_submit_output",
+        description: "Submit the checkpoint result with title, processKeyPoints, currentState, nextSteps, userIntents.",
+        parameters: z.object({
+          title: z.string().describe("Brief checkpoint title (max 30 chars)"),
+          processKeyPoints: z.array(z.string()).describe("Key discoveries or decisions"),
+          currentState: z.string().describe("Current progress and status"),
+          nextSteps: z.array(z.string()).describe("Follow-up items"),
+          userIntents: z.array(z.string()).describe("User's core intents (2-5 items)")
+        }),
+        execute: async (args) => {
+          const parsed = z.object({
+            title: z.string(),
+            processKeyPoints: z.array(z.string()),
+            currentState: z.string(),
+            nextSteps: z.array(z.string()),
+            userIntents: z.array(z.string())
+          }).parse(args);
+          checkpointData = parsed;
+          return { success: true, output: "OK" };
+        }
+      };
+      const agentComponent = this.env.getComponent("agent");
+      await agentComponent.run("compact", userQuery, {
+        sessionId,
+        persistSession: false,
+        extraTools: [submitTool]
       });
+      const data = checkpointData || {};
+      summaryResult = {
+        title: data.title || "Untitled Checkpoint",
+        processKeyPoints: data.processKeyPoints || [],
+        currentState: data.currentState || "",
+        nextSteps: data.nextSteps || [],
+        userIntents: data.userIntents || [],
+        rawResponse: JSON.stringify(data)
+      };
     } catch (error) {
       const errorMessage = error instanceof Error ? error.message : String(error);
-      logger.error(`[SessionComponent] SummaryAgent.run failed: ${errorMessage}`);
-      throw new Error(`Session compaction failed: SummaryAgent error - ${errorMessage}`);
+      logger.error(`[SessionComponent] Compact agent failed: ${errorMessage}`);
+      throw new Error(`Session compaction failed: ${errorMessage}`);
     }
     const checkpointId = `cp_${Date.now().toString(36)}_${Math.random().toString(36).substring(2, 8)}`;
     const checkpoint = {

package/dist/shared/@ai-setting/{roy-agent-core-0y64qaac.js → roy-agent-core-32m0nb9j.js}

@@ -2,6 +2,9 @@ import {
   TAG_MAX_COUNT,
   TAG_MIN_COUNT
 } from "./roy-agent-core-tq9528d3.js";
+import {
+  validateWorkflowDefinition
+} from "./roy-agent-core-8wd3qwx5.js";
 import {
   AskUserError,
   init_workflow_hil
@@ -409,6 +412,15 @@ function createWorkflowAddTool(workflowService) {
             metadata: { execution_time_ms: 0 }
           };
         }
+        const validation = validateWorkflowDefinition(definition);
+        if (!validation.valid) {
+          return {
+            success: false,
+            output: "",
+            error: `Validation failed: ${validation.errors.join("; ")}`,
+            metadata: { execution_time_ms: 0 }
+          };
+        }
         const workflow = await workflowService.createWorkflow(definition, {
           tags: params.tags
         });
@@ -453,15 +465,92 @@ function createWorkflowAddTool(workflowService) {
   };
 }
 
-// src/env/workflow/tools/workflow-search-tool.ts
+// src/env/workflow/tools/workflow-validate-tool.ts
 init_logger();
 import { z as z6 } from "zod";
-var logger5 = createLogger("workflow-search-tool");
-var WorkflowSearchInputSchema = z6.object({
-  keyword: z6.string().optional().describe("Search keyword in name and description (case-insensitive substring)"),
-  tags: z6.array(z6.string()).optional().describe("Filter by tags (ALL must match - AND filter)"),
-  limit: z6.number().positive().optional().describe("Maximum number of results"),
-  offset: z6.number().min(0).optional().describe("Pagination offset")
+import yaml2 from "yaml";
+var logger5 = createLogger("workflow-validate-tool");
+var WorkflowValidateInputSchema = z6.object({
+  definition: z6.any().optional().describe("Workflow definition object (alternative to definition_yaml)"),
+  definition_yaml: z6.string().optional().describe("Workflow definition as YAML or JSON string"),
+  yaml: z6.string().optional().describe("Alias for definition_yaml — workflow definition as YAML or JSON string")
+});
+function createWorkflowValidateTool(_workflowService) {
+  return {
+    name: "workflow_validate",
+    description: `Validate a workflow definition (YAML or JSON) without persisting it. ` + `Checks for: duplicate node IDs, missing dependencies, cycles, empty node IDs. ` + `Returns { valid: boolean, errors: string[], workflowName?, nodeCount }. ` + `Use this BEFORE workflow_add to ensure the workflow is structurally sound.`,
+    parameters: WorkflowValidateInputSchema,
+    execute: async (args, _ctx) => {
+      try {
+        const params = WorkflowValidateInputSchema.parse(args);
+        let definition;
+        if (params.definition && typeof params.definition === "object") {
+          definition = params.definition;
+        } else {
+          const yamlText = params.yaml ?? params.definition_yaml;
+          if (!yamlText || typeof yamlText !== "string") {
+            return {
+              success: false,
+              output: "",
+              error: "Must provide either 'definition' (object), 'definition_yaml', or 'yaml' (string)",
+              metadata: { execution_time_ms: 0 }
+            };
+          }
+          try {
+            definition = yaml2.parse(yamlText);
+          } catch (yamlErr) {
+            return {
+              success: false,
+              output: "",
+              error: `Invalid YAML: ${yamlErr instanceof Error ? yamlErr.message : String(yamlErr)}`,
+              metadata: { execution_time_ms: 0 }
+            };
+          }
+        }
+        if (!definition || typeof definition !== "object") {
+          return {
+            success: false,
+            output: "",
+            error: "Parsed definition is not an object",
+            metadata: { execution_time_ms: 0 }
+          };
+        }
+        const result = validateWorkflowDefinition(definition);
+        const nodeCount = Array.isArray(definition.nodes) ? definition.nodes.length : 0;
+        const output = {
+          valid: result.valid,
+          errors: result.errors,
+          workflowName: definition.name,
+          nodeCount
+        };
+        return {
+          success: result.valid,
+          output: JSON.stringify(output, null, 2),
+          error: result.valid ? undefined : `Validation failed: ${result.errors.join("; ")}`,
+          metadata: { execution_time_ms: 0 }
+        };
+      } catch (error) {
+        logger5.error("[workflow_validate] failed", { error });
+        return {
+          success: false,
+          output: "",
+          error: error instanceof Error ? error.message : String(error),
+          metadata: { execution_time_ms: 0 }
+        };
+      }
+    }
+  };
+}
+
+// src/env/workflow/tools/workflow-search-tool.ts
+init_logger();
+import { z as z7 } from "zod";
+var logger6 = createLogger("workflow-search-tool");
+var WorkflowSearchInputSchema = z7.object({
+  keyword: z7.string().optional().describe("Search keyword in name and description (case-insensitive substring)"),
+  tags: z7.array(z7.string()).optional().describe("Filter by tags (ALL must match - AND filter)"),
+  limit: z7.number().positive().optional().describe("Maximum number of results"),
+  offset: z7.number().min(0).optional().describe("Pagination offset")
 });
 function createWorkflowSearchTool(workflowService) {
   return {
@@ -507,7 +596,7 @@ function createWorkflowSearchTool(workflowService) {
           metadata: { execution_time_ms: 0 }
         };
       } catch (error) {
-        logger5.error("Failed to search workflows", { error });
+        logger6.error("Failed to search workflows", { error });
         return {
           success: false,
           output: "",
@@ -521,13 +610,13 @@ function createWorkflowSearchTool(workflowService) {
 
 // src/env/workflow/tools/run-workflow.ts
 init_logger();
-import { z as z7 } from "zod";
-var logger6 = createLogger("run-workflow-tool");
-var RunWorkflowInputSchema = z7.object({
-  workflow_name: z7.string().describe("Name of the workflow to run"),
-  input: z7.record(z7.any()).optional().describe("Input to pass to the workflow"),
-  sync: z7.boolean().default(true).describe("Wait for completion (default: true)"),
-  timeout: z7.number().positive().optional().describe("Timeout in milliseconds (default: 1800000 = 30 min)")
+import { z as z8 } from "zod";
+var logger7 = createLogger("run-workflow-tool");
+var RunWorkflowInputSchema = z8.object({
+  workflow_name: z8.string().describe("Name of the workflow to run"),
+  input: z8.record(z8.any()).optional().describe("Input to pass to the workflow"),
+  sync: z8.boolean().default(true).describe("Wait for completion (default: true)"),
+  timeout: z8.number().positive().optional().describe("Timeout in milliseconds (default: 1800000 = 30 min)")
 });
 function createRunWorkflowTool(workflowService) {
   return {
@@ -549,7 +638,7 @@ function createRunWorkflowTool(workflowService) {
     execute: async (args, ctx) => {
       const startTime = Date.now();
       const { workflow_name, input, sync = true, timeout = 1800000 } = args;
-      logger6.info(`Running workflow: ${workflow_name}`, { input, sync, timeout });
+      logger7.info(`Running workflow: ${workflow_name}`, { input, sync, timeout });
       let timeoutHandle;
       let durationMs;
       try {
@@ -623,8 +712,8 @@ function createRunWorkflowTool(workflowService) {
             }
           };
         }
-        if (logger6?.error) {
-          logger6.error(`Failed to run workflow: ${workflow_name}`, { error: errorMessage });
+        if (logger7?.error) {
+          logger7.error(`Failed to run workflow: ${workflow_name}`, { error: errorMessage });
         }
         return {
           success: false,
@@ -664,10 +753,10 @@ function createLegacyRunWorkflowTool(workflowService) {
 
 // src/env/workflow/tools/workflow-run-status-tool.ts
 init_logger();
-import { z as z8 } from "zod";
-var logger7 = createLogger("workflow-run-status-tool");
-var WorkflowRunStatusInputSchema = z8.object({
-  run_id: z8.string().describe("Run/session ID to query status")
+import { z as z9 } from "zod";
+var logger8 = createLogger("workflow-run-status-tool");
+var WorkflowRunStatusInputSchema = z9.object({
+  run_id: z9.string().describe("Run/session ID to query status")
 });
 function createWorkflowRunStatusTool(workflowService) {
   return {
@@ -707,7 +796,7 @@ function createWorkflowRunStatusTool(workflowService) {
           metadata: { execution_time_ms: 0 }
         };
       } catch (error) {
-        logger7.error("Failed to get run status", { error });
+        logger8.error("Failed to get run status", { error });
         return {
           success: false,
           output: "",
@@ -721,11 +810,11 @@ function createWorkflowRunStatusTool(workflowService) {
 
 // src/env/workflow/tools/workflow-run-stop-tool.ts
 init_logger();
-import { z as z9 } from "zod";
-var logger8 = createLogger("workflow-run-stop-tool");
-var WorkflowRunStopInputSchema = z9.object({
-  run_id: z9.string().describe("Run/session ID to stop"),
-  reason: z9.string().optional().describe("Optional reason for stopping the workflow")
+import { z as z10 } from "zod";
+var logger9 = createLogger("workflow-run-stop-tool");
+var WorkflowRunStopInputSchema = z10.object({
+  run_id: z10.string().describe("Run/session ID to stop"),
+  reason: z10.string().optional().describe("Optional reason for stopping the workflow")
 });
 function createWorkflowRunStopTool(workflowService) {
   return {
@@ -747,7 +836,7 @@ function createWorkflowRunStopTool(workflowService) {
           metadata: { execution_time_ms: 0 }
         };
       } catch (error) {
-        logger8.error("Failed to stop workflow run", { error });
+        logger9.error("Failed to stop workflow run", { error });
         return {
           success: false,
           output: "",
@@ -759,4 +848,4 @@ function createWorkflowRunStopTool(workflowService) {
   };
 }
 
-export { AskUserInputSchema, askUserTool, askUserToolInstance, WorkflowGetInputSchema, createWorkflowGetTool, WorkflowListInputSchema, createWorkflowListTool, WorkflowTagListInputSchema, createWorkflowTagListTool, WorkflowAddInputSchema, createWorkflowAddTool, WorkflowSearchInputSchema, createWorkflowSearchTool, RunWorkflowInputSchema, createRunWorkflowTool, initRunWorkflowTool, getRunWorkflowTool, resetRunWorkflowTool, createLegacyRunWorkflowTool, WorkflowRunStatusInputSchema, createWorkflowRunStatusTool, WorkflowRunStopInputSchema, createWorkflowRunStopTool };
+export { AskUserInputSchema, askUserTool, askUserToolInstance, WorkflowGetInputSchema, createWorkflowGetTool, WorkflowListInputSchema, createWorkflowListTool, WorkflowTagListInputSchema, createWorkflowTagListTool, WorkflowAddInputSchema, createWorkflowAddTool, WorkflowValidateInputSchema, createWorkflowValidateTool, WorkflowSearchInputSchema, createWorkflowSearchTool, RunWorkflowInputSchema, createRunWorkflowTool, initRunWorkflowTool, getRunWorkflowTool, resetRunWorkflowTool, createLegacyRunWorkflowTool, WorkflowRunStatusInputSchema, createWorkflowRunStatusTool, WorkflowRunStopInputSchema, createWorkflowRunStopTool };