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

package/dist/shared/chunk-0q6s9wm6.js

@@ -0,0 +1,249 @@
+import {
+  __esm
+} from "./chunk-wbkh7wat.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 } : {}
+  };
+}
+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
+      };
+    }
+  };
+});
+
+// src/env/workflow/nodes/agent-component-adapter.ts
+class AgentComponentAdapter {
+  agentComponent;
+  options;
+  _sessionComponent;
+  agentSessionPrefix = "agent";
+  _currentAgentSessionId;
+  pendingSessions = new Map;
+  runSessionToAgentSessions = new Map;
+  constructor(agentComponent, options = {}, _sessionComponent) {
+    this.agentComponent = agentComponent;
+    this.options = options;
+    this._sessionComponent = _sessionComponent;
+  }
+  setSessionComponent(sessionComponent) {
+    this._sessionComponent = sessionComponent;
+  }
+  getCurrentAgentSessionId() {
+    return this._currentAgentSessionId;
+  }
+  registerAgent(name, config) {
+    this.agentComponent.registerAgent(name, {
+      type: config.type || "general",
+      model: config.model,
+      systemPrompt: config.systemPrompt,
+      maxIterations: config.maxIterations,
+      allowedTools: config.allowedTools,
+      deniedTools: config.deniedTools,
+      timeout: config.timeout,
+      maxErrorRetries: config.maxErrorRetries
+    });
+    if (config.sessionIdPrefix) {
+      this.agentSessionPrefixes.set(name, config.sessionIdPrefix);
+    }
+  }
+  async run(config, resumeOptions) {
+    const startTime = Date.now();
+    const nodeId = config.nodeId || "unknown";
+    const runId = config.runId || "unknown";
+    const workflowSessionId = config.workflowSessionId;
+    const existingAgentSessionId = config.agentSessionId;
+    const resumeAgentSessionId = resumeOptions?.agentSessionId;
+    const isResume = !!resumeOptions?.userResponse || !!existingAgentSessionId || !!resumeAgentSessionId;
+    let agentSessionId;
+    if (isResume && (this._currentAgentSessionId || existingAgentSessionId || resumeAgentSessionId)) {
+      agentSessionId = resumeAgentSessionId || existingAgentSessionId || this._currentAgentSessionId;
+      if (resumeOptions?.userResponse && this._sessionComponent && agentSessionId) {
+        try {
+          await this._sessionComponent.addMessage(agentSessionId, {
+            role: "user",
+            content: resumeOptions.userResponse,
+            metadata: {
+              type: "user_intent",
+              intent: "workflow.resume",
+              workflowNodeId: nodeId
+            }
+          });
+        } catch (error) {
+          console.warn(`Failed to add user response to agent session ${agentSessionId}:`, error);
+        }
+      }
+    } else {
+      if (this._sessionComponent) {
+        agentSessionId = `${this.agentSessionPrefix}_${runId}_${nodeId}_${Date.now()}`;
+        try {
+          await this._sessionComponent.create({
+            title: `Agent Session: ${config.type} (${agentSessionId})`,
+            metadata: {
+              type: "agent",
+              workflowRunId: runId,
+              workflowNodeId: nodeId
+            }
+          });
+          this._currentAgentSessionId = agentSessionId;
+          if (workflowSessionId) {
+            const mapping = this.runSessionToAgentSessions.get(workflowSessionId) || [];
+            mapping.push(agentSessionId);
+            this.runSessionToAgentSessions.set(workflowSessionId, mapping);
+          }
+          this.pendingSessions.set(agentSessionId, {
+            agentSessionId,
+            nodeId,
+            runId,
+            createdAt: Date.now()
+          });
+        } catch (error) {
+          console.warn(`Failed to create agent session ${agentSessionId}:`, error);
+        }
+      }
+    }
+    try {
+      const context = {};
+      if (config.options?.timeout) {
+        context.abort = new AbortController;
+      }
+      if (agentSessionId) {
+        context.sessionId = agentSessionId;
+      }
+      if (config.options?.allowedTools) {
+        context.allowedTools = config.options.allowedTools;
+      }
+      if (config.options?.deniedTools) {
+        context.deniedTools = config.options.deniedTools;
+      }
+      if (config.workflowHistory) {
+        context.workflowHistory = config.workflowHistory;
+      }
+      const result = await this.agentComponent.run(config.type || "general", config.prompt, context);
+      if (result.error?.startsWith("__ASK_USER_ERROR__:")) {
+        const jsonStr = result.error.substring("__ASK_USER_ERROR__:".length);
+        const errorInfo = JSON.parse(jsonStr);
+        throw new AskUserError(runId, errorInfo.sessionId, errorInfo.nodeId, errorInfo.nodeType || "agent", errorInfo.query);
+      }
+      const duration = Date.now() - startTime;
+      if (agentSessionId) {
+        this.pendingSessions.delete(agentSessionId);
+      }
+      const messages = result._messages || [];
+      return {
+        output: result.finalText || result.output,
+        metadata: {
+          duration,
+          iterations: result.iterations,
+          toolCalls: result.toolCalls?.length,
+          agentSessionId
+        },
+        messages
+      };
+    } catch (error) {
+      const isAskUserError = error instanceof Error && error.name === "AskUserError";
+      if (isAskUserError) {
+        throw error;
+      }
+      const duration = Date.now() - startTime;
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      if (agentSessionId) {
+        this.pendingSessions.delete(agentSessionId);
+      }
+      return {
+        output: undefined,
+        metadata: {
+          duration,
+          error: errorMessage,
+          agentSessionId
+        }
+      };
+    } finally {
+      if (!isResume) {
+        this._currentAgentSessionId = undefined;
+      }
+    }
+  }
+  async resumeAgent(agentSessionId, userResponse, config) {
+    if (this._sessionComponent) {
+      try {
+        await this._sessionComponent.addMessage(agentSessionId, {
+          role: "user",
+          content: userResponse,
+          metadata: {
+            type: "user_intent",
+            intent: "workflow.resume"
+          }
+        });
+        this.pendingSessions.delete(agentSessionId);
+        this._currentAgentSessionId = agentSessionId;
+      } catch (error) {
+        console.warn(`Failed to add user response to agent session ${agentSessionId}:`, error);
+      }
+    }
+    config.agentSessionId = agentSessionId;
+    return this.run(config, { userResponse });
+  }
+  getPendingSession(agentSessionId) {
+    return this.pendingSessions.get(agentSessionId);
+  }
+  getPendingSessionsForRun(runId) {
+    return Array.from(this.pendingSessions.values()).filter((session) => session.runId === runId);
+  }
+  getAgentSessionsForWorkflowSession(workflowSessionId) {
+    return this.runSessionToAgentSessions.get(workflowSessionId) || [];
+  }
+  hasAgent(name) {
+    return this.agentComponent.getAgent(name) !== undefined;
+  }
+  listAgents() {
+    return this.agentComponent.listAgents().map((a) => a.name);
+  }
+  getAgentComponent() {
+    return this.agentComponent;
+  }
+  agentSessionPrefixes = new Map;
+}
+var init_agent_component_adapter = __esm(() => {
+  init_workflow_hil();
+});
+
+export { createNodeInterruptEvent, AskUserError, init_workflow_hil, AgentComponentAdapter, init_agent_component_adapter };

package/dist/shared/chunk-1aakcfp1.js

@@ -0,0 +1,15 @@
+import {
+  OTelTracerProvider,
+  getTracerProvider,
+  init_tracer_provider,
+  resetTracerProvider
+} from "./chunk-q9j99fsm.js";
+import"./chunk-1qwabsm0.js";
+import"./chunk-wbkh7wat.js";
+init_tracer_provider();
+
+export {
+  resetTracerProvider,
+  getTracerProvider,
+  OTelTracerProvider
+};

package/dist/shared/chunk-1d4rwms4.js

@@ -0,0 +1,25 @@
+import {
+  bashTool,
+  echoTool,
+  editFileTool,
+  getAllBuiltInTools,
+  getBuiltInTool,
+  globTool,
+  grepTool,
+  readFileTool,
+  writeFileTool
+} from "./chunk-g6j5n3gv.js";
+import"./chunk-q9j99fsm.js";
+import"./chunk-1qwabsm0.js";
+import"./chunk-wbkh7wat.js";
+export {
+  writeFileTool,
+  readFileTool,
+  grepTool,
+  globTool,
+  getBuiltInTool,
+  getAllBuiltInTools,
+  editFileTool,
+  echoTool,
+  bashTool
+};

package/dist/shared/chunk-1pf5mfgd.js

@@ -0,0 +1,82 @@
+import {
+  createLogger,
+  init_logger
+} from "./chunk-a9qmy3sc.js";
+import {
+  __require
+} from "./chunk-wbkh7wat.js";
+
+// src/env/workflow/storage/sqlite.ts
+init_logger();
+import { join } from "path";
+var logger = createLogger("workflow:sqlite");
+function getDefaultDataDir() {
+  const home = process.env.HOME || process.env.USERPROFILE || "/tmp";
+  return join(home, ".local", "share", "roy-agent");
+}
+function getDatabasePath() {
+  return join(getDefaultDataDir(), "workflows.db");
+}
+var dbInstance = null;
+function getDatabase(path) {
+  if (!dbInstance) {
+    const dbPath = path ?? getDatabasePath();
+    const dbDir = dbPath.substring(0, dbPath.lastIndexOf("/"));
+    if (dbDir && dbDir !== "/") {
+      try {
+        const { mkdirSync } = __require("fs");
+        mkdirSync(dbDir, { recursive: true });
+      } catch {}
+    }
+    const { Database } = __require("bun:sqlite");
+    dbInstance = new Database(dbPath);
+    try {
+      if (typeof dbInstance.pragma === "function") {
+        dbInstance.pragma("journal_mode = WAL");
+      }
+    } catch {
+      logger?.debug("WAL mode not available, using default journal mode");
+    }
+  }
+  return dbInstance;
+}
+function closeDatabase() {
+  if (dbInstance) {
+    dbInstance.close();
+    dbInstance = null;
+  }
+}
+function initializeTables() {
+  const db = getDatabase();
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS workflows (
+      id TEXT PRIMARY KEY,
+      name TEXT NOT NULL UNIQUE,
+      version TEXT NOT NULL DEFAULT '1.0',
+      description TEXT,
+      definition TEXT NOT NULL,
+      config TEXT NOT NULL DEFAULT '{}',
+      metadata TEXT NOT NULL DEFAULT '{}',
+      tags TEXT NOT NULL DEFAULT '[]',
+      task_id INTEGER,
+      created_at TEXT NOT NULL,
+      updated_at TEXT NOT NULL
+    )
+  `);
+  db.exec(`
+    CREATE INDEX IF NOT EXISTS idx_workflows_name ON workflows(name);
+    CREATE INDEX IF NOT EXISTS idx_workflows_tags ON workflows(tags);
+    CREATE INDEX IF NOT EXISTS idx_workflows_task_id ON workflows(task_id);
+  `);
+}
+function resetDatabase() {
+  closeDatabase();
+  dbInstance = null;
+}
+function initDatabase(path) {
+  const db = getDatabase(path);
+  initializeTables();
+  return db;
+}
+
+export { getDatabasePath, getDatabase, closeDatabase, initializeTables, resetDatabase, initDatabase };

package/dist/shared/chunk-1qwabsm0.js

@@ -0,0 +1,154 @@
+import {
+  __esm,
+  __require
+} from "./chunk-wbkh7wat.js";
+
+// src/env/log-trace/span-storage.ts
+class SQLiteSpanStorage {
+  db = null;
+  dbPath;
+  initialized = false;
+  constructor(dbPath) {
+    if (!dbPath) {
+      throw new Error("SQLiteSpanStorage requires a valid dbPath parameter");
+    }
+    if (dbPath === ":memory:") {
+      throw new Error("SQLiteSpanStorage does not support :memory: mode. Use a file path instead.");
+    }
+    this.dbPath = dbPath;
+  }
+  async initialize() {
+    if (this.initialized)
+      return;
+    const { Database } = __require("bun:sqlite");
+    const fs = __require("fs");
+    const path = __require("path");
+    const dir = path.dirname(this.dbPath);
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+    this.db = new Database(this.dbPath);
+    this.db.run("PRAGMA journal_mode=WAL");
+    this.db.run("PRAGMA busy_timeout=5000");
+    this.db.run("PRAGMA synchronous=NORMAL");
+    this.db.run(`
+      CREATE TABLE IF NOT EXISTS span (
+        span_id TEXT PRIMARY KEY,
+        trace_id TEXT NOT NULL,
+        parent_span_id TEXT,
+        name TEXT NOT NULL,
+        kind TEXT NOT NULL,
+        status TEXT NOT NULL,
+        start_time INTEGER NOT NULL,
+        end_time INTEGER,
+        attributes TEXT,
+        result TEXT,
+        error TEXT,
+        time_created INTEGER NOT NULL
+      )
+    `);
+    this.db.run("CREATE INDEX IF NOT EXISTS idx_span_trace ON span(trace_id)");
+    this.db.run("CREATE INDEX IF NOT EXISTS idx_span_parent ON span(parent_span_id)");
+    this.initialized = true;
+  }
+  save(span) {
+    if (!this.db)
+      return;
+    const stmt = this.db.prepare(`
+      INSERT OR REPLACE INTO span 
+      (span_id, trace_id, parent_span_id, name, kind, status, start_time, end_time, attributes, result, error, time_created)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `);
+    const resultValue = span.result !== undefined && span.result !== null ? typeof span.result === "string" ? span.result : JSON.stringify(span.result) : null;
+    stmt.run(span.spanId, span.traceId, span.parentSpanId || null, span.name, span.kind, span.status, span.startTime, span.endTime || null, JSON.stringify(span.attributes), resultValue, span.error || null, Date.now());
+  }
+  saveBatch(spans) {
+    for (const span of spans) {
+      this.save(span);
+    }
+  }
+  findByTraceId(traceId) {
+    if (!this.db)
+      return [];
+    const rows = this.db.prepare("SELECT * FROM span WHERE trace_id = ?").all(traceId);
+    return this.buildTree(rows.map(this.rowToSpan));
+  }
+  findBySpanId(spanId) {
+    if (!this.db)
+      return;
+    const row = this.db.prepare("SELECT * FROM span WHERE span_id = ?").get(spanId);
+    return row ? this.rowToSpan(row) : undefined;
+  }
+  listTraces(limit = 10) {
+    if (!this.db)
+      return [];
+    const rows = this.db.prepare(`
+      SELECT trace_id, 
+             MIN(start_time) as start_time,
+             MAX(end_time) as end_time,
+             COUNT(*) as span_count
+      FROM span 
+      GROUP BY trace_id 
+      ORDER BY start_time DESC 
+      LIMIT ?
+    `).all(limit);
+    return rows.map((row) => ({
+      traceId: row.trace_id,
+      rootSpanName: "unknown",
+      startTime: row.start_time,
+      endTime: row.end_time,
+      duration: row.end_time - row.start_time,
+      spanCount: row.span_count,
+      status: "ok"
+    }));
+  }
+  deleteByTraceId(traceId) {
+    if (this.db) {
+      this.db.prepare("DELETE FROM span WHERE trace_id = ?").run(traceId);
+    }
+  }
+  close() {
+    if (this.db) {
+      this.db.close();
+      this.db = null;
+    }
+  }
+  rowToSpan(row) {
+    return {
+      traceId: row.trace_id,
+      spanId: row.span_id,
+      parentSpanId: row.parent_span_id,
+      name: row.name,
+      kind: row.kind,
+      status: row.status,
+      startTime: row.start_time,
+      endTime: row.end_time,
+      attributes: row.attributes ? JSON.parse(row.attributes) : {},
+      result: row.result || undefined,
+      error: row.error || undefined
+    };
+  }
+  buildTree(spans) {
+    const spanMap = new Map;
+    const roots = [];
+    for (const span of spans) {
+      spanMap.set(span.spanId, { ...span, children: [] });
+    }
+    for (const span of spanMap.values()) {
+      if (span.parentSpanId) {
+        const parent = spanMap.get(span.parentSpanId);
+        if (parent) {
+          parent.children.push(span);
+        } else {
+          roots.push(span);
+        }
+      } else {
+        roots.push(span);
+      }
+    }
+    return roots;
+  }
+}
+var init_span_storage = () => {};
+
+export { SQLiteSpanStorage, init_span_storage };

package/dist/shared/chunk-25x2pdtp.js

@@ -0,0 +1,107 @@
+import {
+  __esm
+} from "./chunk-wbkh7wat.js";
+
+// src/env/workflow/utils/session-recovery.ts
+function inferNextNode(messages, definition) {
+  if (messages.length === 0) {
+    return { type: "entry_node", nodeId: definition.entryNode };
+  }
+  const lastMessage = messages[messages.length - 1];
+  const metadata = lastMessage.metadata;
+  switch (metadata?.type) {
+    case "workflow.node.call":
+      return {
+        type: "resume_node",
+        nodeId: metadata.workflowNodeId,
+        agentSessionId: metadata.agentSessionId
+      };
+    case "workflow.node.interrupt":
+      return {
+        type: "ask_user",
+        nodeId: metadata.workflowNodeId,
+        agentSessionId: metadata.agentSessionId
+      };
+    case "workflow.node.result":
+      return getNextNodes(metadata.workflowNodeId, definition);
+    default:
+      const lastCall = findLastCallMessage(messages);
+      if (lastCall) {
+        const callMetadata = lastCall.metadata;
+        return {
+          type: "resume_node",
+          nodeId: callMetadata.workflowNodeId,
+          agentSessionId: callMetadata.agentSessionId
+        };
+      }
+      return { type: "entry_node", nodeId: definition.entryNode };
+  }
+}
+function getNextNodes(completedNodeId, definition) {
+  if (!definition.edges) {
+    return { type: "next_nodes", nodeIds: [] };
+  }
+  const nextNodeIds = definition.edges.filter((edge) => edge.from === completedNodeId).map((edge) => edge.to);
+  return { type: "next_nodes", nodeIds: nextNodeIds };
+}
+function findLastInterruptMessage(messages) {
+  for (let i = messages.length - 1;i >= 0; i--) {
+    const msg = messages[i];
+    if (msg.metadata?.type === "workflow.node.interrupt") {
+      return msg;
+    }
+  }
+  return null;
+}
+function findLastCallMessage(messages) {
+  for (let i = messages.length - 1;i >= 0; i--) {
+    const msg = messages[i];
+    if (msg.metadata?.type === "workflow.node.call") {
+      return msg;
+    }
+  }
+  return null;
+}
+function parseNodeOutputs(messages) {
+  const outputs = new Map;
+  let lastCallNodeId = null;
+  for (const msg of messages) {
+    const metadata = msg.metadata;
+    if (metadata?.type === "workflow.node.call") {
+      lastCallNodeId = metadata.workflowNodeId;
+    } else if (metadata?.type === "workflow.node.result" && lastCallNodeId) {
+      try {
+        outputs.set(lastCallNodeId, JSON.parse(msg.content));
+      } catch {
+        outputs.set(lastCallNodeId, msg.content);
+      }
+      lastCallNodeId = null;
+    }
+  }
+  return outputs;
+}
+function hasPendingAskUser(messages) {
+  if (messages.length === 0)
+    return false;
+  const lastMessage = messages[messages.length - 1];
+  const metadata = lastMessage.metadata;
+  return metadata?.type === "workflow.node.interrupt";
+}
+function getAgentSessionIdFromInterrupt(messages) {
+  const lastInterrupt = findLastInterruptMessage(messages);
+  if (!lastInterrupt)
+    return null;
+  const metadata = lastInterrupt.metadata;
+  return metadata?.agentSessionId || null;
+}
+var init_session_recovery = () => {};
+init_session_recovery();
+
+export {
+  parseNodeOutputs,
+  inferNextNode,
+  hasPendingAskUser,
+  getAgentSessionIdFromInterrupt,
+  findLastInterruptMessage,
+  findLastCallMessage
+};