@ai-setting/roy-agent-core 1.5.14-test → 1.5.15-test

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

@@ -1,350 +0,0 @@
-import {
-  AskUserError,
-  init_workflow_hil
-} from "./roy-agent-core-e25xkv53.js";
-import {
-  __esm,
-  __require
-} from "./roy-agent-core-fs0mn2jk.js";
-
-// src/env/workflow/types/workflow.ts
-import { z } from "zod";
-async function getYamlParser() {
-  if (!yamlParser) {
-    yamlParser = await import("yaml");
-  }
-  return yamlParser;
-}
-async function parseWorkflowFile(content, filename) {
-  const isYaml = filename.endsWith(".yaml") || filename.endsWith(".yml");
-  const isJson = filename.endsWith(".json");
-  let definition;
-  if (isYaml) {
-    const yaml = await getYamlParser();
-    definition = WorkflowDefinitionSchema.parse(yaml.parse(content));
-  } else if (isJson) {
-    definition = WorkflowDefinitionSchema.parse(JSON.parse(content));
-  } else {
-    try {
-      definition = WorkflowDefinitionSchema.parse(JSON.parse(content));
-    } catch {
-      const yaml = await getYamlParser();
-      definition = WorkflowDefinitionSchema.parse(yaml.parse(content));
-    }
-  }
-  return {
-    format: isYaml ? "yaml" : "json",
-    definition
-  };
-}
-function parseWorkflowFileSync(content, filename) {
-  const isYaml = filename.endsWith(".yaml") || filename.endsWith(".yml");
-  const isJson = filename.endsWith(".json");
-  let definition;
-  if (isJson) {
-    definition = WorkflowDefinitionSchema.parse(JSON.parse(content));
-  } else if (isYaml) {
-    throw new Error("Synchronous YAML parsing not supported. Use parseWorkflowFile() instead.");
-  } else {
-    try {
-      definition = WorkflowDefinitionSchema.parse(JSON.parse(content));
-    } catch {
-      throw new Error("Cannot auto-detect format. Please use .yaml, .yml, or .json extension.");
-    }
-  }
-  return {
-    format: isJson ? "json" : "yaml",
-    definition
-  };
-}
-var DependsOnSchema, RetryConfigSchema, NodeDefinitionSchema, WorkflowConfigSchema, OutputDefinitionSchema, InputParameterSchema, WorkflowInputsSchema, WorkflowMetadataSchema, WorkflowDefinitionSchema, yamlParser = null;
-var init_workflow = __esm(() => {
-  DependsOnSchema = z.array(z.string());
-  RetryConfigSchema = z.object({
-    max_attempts: z.number().min(1).default(1),
-    backoff: z.enum(["fixed", "exponential"]).default("exponential"),
-    initial_delay: z.number().min(0).default(1000)
-  });
-  NodeDefinitionSchema = z.object({
-    id: z.string().min(1, "Node ID is required"),
-    type: z.string().min(1, "Node type is required"),
-    name: z.string().optional(),
-    config: z.record(z.string(), z.unknown()).optional().default({}),
-    depends_on: z.array(z.string()).optional(),
-    condition: z.string().optional(),
-    retry: RetryConfigSchema.optional(),
-    timeout: z.number().optional()
-  });
-  WorkflowConfigSchema = z.object({
-    parallel_limit: z.number().nullable().optional(),
-    timeout: z.number().nullable().optional(),
-    retry: RetryConfigSchema.optional(),
-    debug: z.boolean().optional()
-  });
-  OutputDefinitionSchema = z.object({
-    name: z.string(),
-    source: z.string(),
-    path: z.string()
-  });
-  InputParameterSchema = z.object({
-    type: z.enum(["string", "number", "boolean", "object", "array"]),
-    description: z.string().optional(),
-    default: z.unknown().optional(),
-    required: z.boolean().default(false)
-  });
-  WorkflowInputsSchema = z.record(z.string(), InputParameterSchema);
-  WorkflowMetadataSchema = z.object({
-    author: z.string().optional(),
-    taskId: z.number().optional(),
-    tags: z.array(z.string()).optional().default([]),
-    created_at: z.string().optional(),
-    updated_at: z.string().optional()
-  });
-  WorkflowDefinitionSchema = z.object({
-    name: z.string().min(1, "Workflow name is required"),
-    version: z.string().default("1.0"),
-    description: z.string().optional(),
-    config: WorkflowConfigSchema.optional().default({}),
-    nodes: z.array(NodeDefinitionSchema).min(1, "At least one node is required"),
-    entry: z.union([z.string(), z.array(z.string())]).default("__default_entry__"),
-    outputs: z.array(OutputDefinitionSchema).optional().default([]),
-    inputs: WorkflowInputsSchema.optional().default({}),
-    metadata: WorkflowMetadataSchema.optional().default({})
-  });
-});
-
-// src/env/workflow/types/workflow-message.ts
-import { z as z2 } from "zod";
-var WorkflowMessageRoleSchema;
-var init_workflow_message = __esm(() => {
-  init_workflow_hil();
-  WorkflowMessageRoleSchema = z2.enum([
-    "workflow.node.start",
-    "workflow.node.interrupt",
-    "workflow.node.end",
-    "workflow.node.resume"
-  ]);
-});
-
-// src/env/workflow/types/workflow-session.ts
-function isWorkflowSessionMetadata(metadata) {
-  if (typeof metadata !== "object" || metadata === null || !("type" in metadata) || metadata.type !== "workflow") {
-    return false;
-  }
-  const m = metadata;
-  if (!m.workflowId || typeof m.workflowId !== "string") {
-    return false;
-  }
-  if (!m.workflowName || typeof m.workflowName !== "string") {
-    return false;
-  }
-  if (!m.status || typeof m.status !== "string") {
-    return false;
-  }
-  const validStatuses = ["running", "paused", "completed", "failed", "stopped"];
-  if (!validStatuses.includes(m.status)) {
-    return false;
-  }
-  return true;
-}
-function getWorkflowSessionStatus(metadata) {
-  return metadata.status || "running";
-}
-var init_workflow_session = () => {};
-
-// src/env/workflow/types/context.ts
-var init_context = () => {};
-
-// src/env/workflow/types/event.ts
-import { z as z3 } from "zod";
-function createWorkflowEvent(type, runId, data) {
-  return {
-    type,
-    run_id: runId,
-    timestamp: Date.now(),
-    ...data
-  };
-}
-var BaseEventSchema, WorkflowStartedEventSchema, WorkflowPausedEventSchema, WorkflowResumedEventSchema, WorkflowStoppedEventSchema, WorkflowCompletedEventSchema, WorkflowFailedEventSchema, WorkflowOutputEventSchema, NodeScheduledEventSchema, NodeStartedEventSchema, NodeProgressEventSchema, NodeCompletedEventSchema, NodeFailedEventSchema, NodeSkippedEventSchema, NodeDataEventSchema, NodeAddedEventSchema, NodeRemovedEventSchema, ControlPauseEventSchema, ControlResumeEventSchema, ControlStopEventSchema, NodeInterruptEventSchema, WorkflowAskUserEventSchema, WorkflowEventSchema;
-var init_event = __esm(() => {
-  BaseEventSchema = z3.object({
-    type: z3.string(),
-    run_id: z3.string(),
-    timestamp: z3.number()
-  });
-  WorkflowStartedEventSchema = BaseEventSchema.extend({
-    type: z3.literal("workflow.started"),
-    workflow_name: z3.string(),
-    input: z3.record(z3.string(), z3.unknown()).optional()
-  });
-  WorkflowPausedEventSchema = BaseEventSchema.extend({
-    type: z3.literal("workflow.paused")
-  });
-  WorkflowResumedEventSchema = BaseEventSchema.extend({
-    type: z3.literal("workflow.resumed")
-  });
-  WorkflowStoppedEventSchema = BaseEventSchema.extend({
-    type: z3.literal("workflow.stopped"),
-    reason: z3.string()
-  });
-  WorkflowCompletedEventSchema = BaseEventSchema.extend({
-    type: z3.literal("workflow.completed"),
-    result: z3.record(z3.string(), z3.unknown()).optional(),
-    duration_ms: z3.number()
-  });
-  WorkflowFailedEventSchema = BaseEventSchema.extend({
-    type: z3.literal("workflow.failed"),
-    error: z3.object({
-      message: z3.string(),
-      stack: z3.string().optional()
-    }),
-    failed_at: z3.string()
-  });
-  WorkflowOutputEventSchema = BaseEventSchema.extend({
-    type: z3.literal("workflow.output"),
-    output: z3.record(z3.string(), z3.unknown())
-  });
-  NodeScheduledEventSchema = BaseEventSchema.extend({
-    type: z3.literal("node.scheduled"),
-    node_id: z3.string()
-  });
-  NodeStartedEventSchema = BaseEventSchema.extend({
-    type: z3.literal("node.started"),
-    node_id: z3.string(),
-    input: z3.any().optional(),
-    agentSessionId: z3.string().optional(),
-    userQuery: z3.string().optional(),
-    userResponse: z3.string().optional()
-  });
-  NodeProgressEventSchema = BaseEventSchema.extend({
-    type: z3.literal("node.progress"),
-    node_id: z3.string(),
-    progress: z3.number(),
-    message: z3.string().optional()
-  });
-  NodeCompletedEventSchema = BaseEventSchema.extend({
-    type: z3.literal("node.completed"),
-    node_id: z3.string(),
-    output: z3.any(),
-    duration_ms: z3.number()
-  });
-  NodeFailedEventSchema = BaseEventSchema.extend({
-    type: z3.literal("node.failed"),
-    node_id: z3.string(),
-    error: z3.object({
-      message: z3.string(),
-      stack: z3.string().optional()
-    })
-  });
-  NodeSkippedEventSchema = BaseEventSchema.extend({
-    type: z3.literal("node.skipped"),
-    node_id: z3.string(),
-    reason: z3.string()
-  });
-  NodeDataEventSchema = BaseEventSchema.extend({
-    type: z3.literal("node.data"),
-    from_node: z3.string(),
-    to_node: z3.string(),
-    data: z3.any()
-  });
-  NodeAddedEventSchema = BaseEventSchema.extend({
-    type: z3.literal("node.added"),
-    node_id: z3.string(),
-    node: z3.any()
-  });
-  NodeRemovedEventSchema = BaseEventSchema.extend({
-    type: z3.literal("node.removed"),
-    node_id: z3.string()
-  });
-  ControlPauseEventSchema = BaseEventSchema.extend({
-    type: z3.literal("control.pause")
-  });
-  ControlResumeEventSchema = BaseEventSchema.extend({
-    type: z3.literal("control.resume")
-  });
-  ControlStopEventSchema = BaseEventSchema.extend({
-    type: z3.literal("control.stop")
-  });
-  NodeInterruptEventSchema = BaseEventSchema.extend({
-    type: z3.literal("node.interrupt"),
-    node_id: z3.string(),
-    node_type: z3.string(),
-    query: z3.string()
-  });
-  WorkflowAskUserEventSchema = BaseEventSchema.extend({
-    type: z3.literal("workflow.ask-user"),
-    session_id: z3.string(),
-    node_id: z3.string(),
-    node_type: z3.string(),
-    query: z3.string()
-  });
-  WorkflowEventSchema = z3.union([
-    WorkflowStartedEventSchema,
-    WorkflowPausedEventSchema,
-    WorkflowResumedEventSchema,
-    WorkflowStoppedEventSchema,
-    WorkflowCompletedEventSchema,
-    WorkflowFailedEventSchema,
-    WorkflowOutputEventSchema,
-    NodeScheduledEventSchema,
-    NodeStartedEventSchema,
-    NodeProgressEventSchema,
-    NodeCompletedEventSchema,
-    NodeFailedEventSchema,
-    NodeSkippedEventSchema,
-    NodeDataEventSchema,
-    NodeAddedEventSchema,
-    NodeRemovedEventSchema,
-    ControlPauseEventSchema,
-    ControlResumeEventSchema,
-    ControlStopEventSchema,
-    NodeInterruptEventSchema,
-    WorkflowAskUserEventSchema
-  ]);
-});
-
-// src/env/workflow/types/run.ts
-import { z as z4 } from "zod";
-function createNodeExecutionContext(params) {
-  return {
-    ...params,
-    askUser: (query) => {
-      throw new AskUserError(params.runId, params.sessionId, params.nodeId, "unknown", query);
-    }
-  };
-}
-var RunStatusSchema, NodeStatusSchema;
-var init_run = __esm(() => {
-  init_workflow_message();
-  RunStatusSchema = z4.enum([
-    "idle",
-    "running",
-    "paused",
-    "stopped",
-    "completed",
-    "failed"
-  ]);
-  NodeStatusSchema = z4.enum([
-    "pending",
-    "scheduled",
-    "started",
-    "running",
-    "completed",
-    "failed",
-    "skipped"
-  ]);
-});
-
-// src/env/workflow/types/index.ts
-var init_types = __esm(() => {
-  init_run();
-  init_workflow();
-  init_workflow_message();
-  init_workflow_session();
-  init_context();
-  init_workflow_hil();
-  init_event();
-  init_run();
-});
-
-export { BaseEventSchema, WorkflowStartedEventSchema, WorkflowPausedEventSchema, WorkflowResumedEventSchema, WorkflowStoppedEventSchema, WorkflowCompletedEventSchema, WorkflowFailedEventSchema, WorkflowOutputEventSchema, NodeScheduledEventSchema, NodeStartedEventSchema, NodeProgressEventSchema, NodeCompletedEventSchema, NodeFailedEventSchema, NodeSkippedEventSchema, NodeDataEventSchema, NodeAddedEventSchema, NodeRemovedEventSchema, ControlPauseEventSchema, ControlResumeEventSchema, ControlStopEventSchema, NodeInterruptEventSchema, WorkflowAskUserEventSchema, WorkflowEventSchema, createWorkflowEvent, init_event, DependsOnSchema, RetryConfigSchema, NodeDefinitionSchema, WorkflowConfigSchema, OutputDefinitionSchema, InputParameterSchema, WorkflowInputsSchema, WorkflowMetadataSchema, WorkflowDefinitionSchema, parseWorkflowFile, parseWorkflowFileSync, WorkflowMessageRoleSchema, isWorkflowSessionMetadata, getWorkflowSessionStatus, RunStatusSchema, NodeStatusSchema, createNodeExecutionContext, init_types };

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

@@ -1,180 +0,0 @@
-import {
-  AskUserError,
-  init_workflow_hil
-} from "./roy-agent-core-e25xkv53.js";
-import {
-  __esm
-} from "./roy-agent-core-fs0mn2jk.js";
-
-// 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 isResume = !!resumeOptions?.userQuery;
-    let agentSessionId = resumeOptions?.agentSessionId || config.agentSessionId || this._currentAgentSessionId;
-    if (!agentSessionId && 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
-          }
-        });
-      } catch (error) {
-        console.warn(`Failed to create agent session ${agentSessionId}:`, error);
-      }
-    }
-    if (agentSessionId) {
-      this._currentAgentSessionId = agentSessionId;
-      if (workflowSessionId && this._sessionComponent) {
-        const mapping = this.runSessionToAgentSessions.get(workflowSessionId) || [];
-        if (!mapping.includes(agentSessionId)) {
-          mapping.push(agentSessionId);
-          this.runSessionToAgentSessions.set(workflowSessionId, mapping);
-        }
-      }
-      if (isResume) {
-        this.pendingSessions.delete(agentSessionId);
-      } else {
-        this.pendingSessions.set(agentSessionId, {
-          agentSessionId,
-          nodeId,
-          runId,
-          createdAt: Date.now()
-        });
-      }
-    }
-    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;
-      }
-      context.additionInfo = config.prompt;
-      const userInput = resumeOptions?.userQuery || "";
-      const result = await this.agentComponent.run(config.type || "general", userInput, 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, userQuery, config) {
-    this.pendingSessions.delete(agentSessionId);
-    this._currentAgentSessionId = agentSessionId;
-    config.agentSessionId = agentSessionId;
-    return this.run(config, { userQuery, agentSessionId });
-  }
-  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 { AgentComponentAdapter, init_agent_component_adapter };