@ai-setting/roy-agent-core 1.5.43 → 1.5.45

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

@@ -0,0 +1,190 @@
+import {
+  WORKFLOW_SUBMIT_OUTPUT_TOOL_NAME,
+  createSubmitJsonOutputTool,
+  init_submit_json_output_tool,
+  parseWorkflowJsonOutput
+} from "./roy-agent-core-nhfy3p8q.js";
+import {
+  AskUserError,
+  init_workflow_hil
+} from "./roy-agent-core-e25xkv53.js";
+import {
+  globalHookManager,
+  init_global_hook_manager
+} from "./roy-agent-core-rgj6hq15.js";
+import {
+  createLogger,
+  init_logger
+} from "./roy-agent-core-10n2jh7p.js";
+import {
+  __esm
+} from "./roy-agent-core-fs0mn2jk.js";
+
+// src/env/workflow/utils/output-schema-hint.ts
+function describeOutputSchema(schema) {
+  if (!schema || typeof schema !== "object") {
+    return "Submit a JSON object matching the configured output schema";
+  }
+  const obj = schema;
+  if (!obj.properties || Object.keys(obj.properties).length === 0) {
+    return "Submit a JSON object matching the configured output schema";
+  }
+  const required = new Set(obj.required ?? []);
+  const fields = Object.entries(obj.properties).map(([name, prop]) => {
+    const type = prop.type ?? "unknown";
+    const req = required.has(name) ? "required" : "optional";
+    const desc = prop.description ? ` — ${prop.description}` : "";
+    return `${name}: ${type} (${req})${desc}`;
+  });
+  return `Expected fields: ${fields.join("; ")}`;
+}
+var init_output_schema_hint = () => {};
+
+// src/env/workflow/plugins/workflow-json-output-plugin.ts
+function isWorkflowJsonOutputEnabled(pluginEnabled) {
+  return pluginEnabled?.[WORKFLOW_JSON_OUTPUT_PLUGIN_KEY] === true;
+}
+function registerWorkflowJsonOutputPlugin(llmComponent) {
+  if (registered) {
+    return;
+  }
+  registered = true;
+  globalHookManager.register(HOOK_POINT, {
+    name: HOOK_NAME,
+    pluginName: WORKFLOW_JSON_OUTPUT_PLUGIN_NAME,
+    sourceId: WORKFLOW_JSON_OUTPUT_SOURCE_ID,
+    priority: 100,
+    description: "Extract structured JSON after ReAct via a dedicated LLM invoke",
+    execute: async (wrapper) => {
+      const hookCtx = wrapper.data;
+      await runWorkflowJsonOutputExtraction(hookCtx, llmComponent);
+    }
+  });
+  logger.info("Workflow JSON output plugin registered on agent:after.react");
+}
+function unregisterWorkflowJsonOutputPlugin() {
+  globalHookManager.unregister(HOOK_POINT, HOOK_NAME);
+  registered = false;
+}
+async function runWorkflowJsonOutputExtraction(hookCtx, llmComponent) {
+  const schema = hookCtx.context.metadata?.outputSchema;
+  if (!schema) {
+    return;
+  }
+  if (hookCtx.error instanceof AskUserError) {
+    return;
+  }
+  if (hookCtx.structuredOutputExtracted) {
+    return;
+  }
+  const extracted = await extractStructuredJsonViaLlm(llmComponent, hookCtx.messages, schema, {
+    model: hookCtx.context.model ?? hookCtx.agent.config.model,
+    sessionId: hookCtx.context.sessionId,
+    abortSignal: hookCtx.context.abort
+  });
+  if (extracted) {
+    hookCtx.structuredOutputExtracted = extracted;
+  }
+}
+async function extractStructuredJsonViaLlm(llmComponent, historyMessages, schema, options = {}) {
+  const submitTool = createSubmitJsonOutputTool(schema);
+  const extractionUserMessage = {
+    role: "user",
+    content: "Based on the conversation above, call workflow_submit_output exactly once with structured JSON. " + `${describeOutputSchema(schema)}.`
+  };
+  const messages = [...historyMessages, extractionUserMessage].map(toLLMMessage);
+  const result = await llmComponent.invoke({
+    messages,
+    tools: [
+      {
+        name: submitTool.name,
+        description: submitTool.description ?? "",
+        parameters: submitTool.parameters
+      }
+    ],
+    toolChoice: {
+      type: "function",
+      function: { name: WORKFLOW_SUBMIT_OUTPUT_TOOL_NAME }
+    },
+    model: options.model,
+    context: {
+      sessionId: options.sessionId
+    },
+    abortSignal: options.abortSignal,
+    skipThresholdCheck: true
+  });
+  const toolCalls = result.output?.toolCalls ?? [];
+  for (let i = toolCalls.length - 1;i >= 0; i--) {
+    const tc = toolCalls[i];
+    const name = tc.function?.name ?? tc.name;
+    if (name !== WORKFLOW_SUBMIT_OUTPUT_TOOL_NAME) {
+      continue;
+    }
+    const argsRaw = tc.function?.arguments ?? tc.arguments;
+    const argsStr = typeof argsRaw === "string" ? argsRaw : JSON.stringify(argsRaw ?? {});
+    try {
+      const parsed = submitTool.parameters.parse(JSON.parse(argsStr));
+      return parsed;
+    } catch {
+      const fromExecute = await submitTool.execute(JSON.parse(argsStr));
+      const fromMarker = parseWorkflowJsonOutput(fromExecute.output);
+      if (fromMarker) {
+        return fromMarker;
+      }
+    }
+  }
+  logger.warn("Workflow JSON extraction invoke did not return workflow_submit_output");
+  return;
+}
+function toLLMMessage(msg) {
+  if (typeof msg.content === "string") {
+    return {
+      role: msg.role,
+      content: msg.content
+    };
+  }
+  if (Array.isArray(msg.content)) {
+    if (msg.role === "tool") {
+      const toolResult = msg.content.find((part) => part.type === "tool-result");
+      const output = toolResult?.output;
+      const content = typeof output === "string" ? output : output && typeof output === "object" && ("value" in output) ? String(output.value ?? "") : JSON.stringify(output ?? "");
+      return {
+        role: "tool",
+        content,
+        toolCallId: toolResult?.toolCallId,
+        name: toolResult?.toolName
+      };
+    }
+    const text = msg.content.filter((part) => part.type === "text").map((part) => part.text ?? "").join("");
+    const toolCallParts = msg.content.filter((part) => part.type === "tool-call");
+    const toolCalls = msg.role === "assistant" && toolCallParts.length > 0 ? toolCallParts.map((part) => {
+      const argsString = typeof part.input === "string" ? part.input : JSON.stringify(part.input ?? {});
+      const toolName = part.toolName ?? "unknown";
+      return {
+        id: part.toolCallId ?? "",
+        name: toolName,
+        arguments: argsString,
+        function: { name: toolName, arguments: argsString }
+      };
+    }) : undefined;
+    return {
+      role: msg.role,
+      content: text,
+      ...toolCalls?.length ? { toolCalls } : {}
+    };
+  }
+  return { role: msg.role, content: "" };
+}
+var logger, WORKFLOW_JSON_OUTPUT_SOURCE_ID = "workflow", WORKFLOW_JSON_OUTPUT_PLUGIN_NAME = "json-output", WORKFLOW_JSON_OUTPUT_PLUGIN_KEY, HOOK_POINT = "agent:after.react", HOOK_NAME, registered = false;
+var init_workflow_json_output_plugin = __esm(() => {
+  init_global_hook_manager();
+  init_workflow_hil();
+  init_submit_json_output_tool();
+  init_output_schema_hint();
+  init_logger();
+  logger = createLogger("WorkflowJsonOutputPlugin");
+  WORKFLOW_JSON_OUTPUT_PLUGIN_KEY = `${WORKFLOW_JSON_OUTPUT_SOURCE_ID}:${WORKFLOW_JSON_OUTPUT_PLUGIN_NAME}`;
+  HOOK_NAME = `${WORKFLOW_JSON_OUTPUT_PLUGIN_NAME}:${HOOK_POINT}`;
+});
+
+export { WORKFLOW_JSON_OUTPUT_SOURCE_ID, WORKFLOW_JSON_OUTPUT_PLUGIN_NAME, WORKFLOW_JSON_OUTPUT_PLUGIN_KEY, isWorkflowJsonOutputEnabled, registerWorkflowJsonOutputPlugin, unregisterWorkflowJsonOutputPlugin, runWorkflowJsonOutputExtraction, extractStructuredJsonViaLlm, init_workflow_json_output_plugin };

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

@@ -7,7 +7,7 @@ import {
 } from "./roy-agent-core-qxhq8ven.js";
 import {
   BaseComponent
-} from "./roy-agent-core-4jqq077c.js";
+} from "./roy-agent-core-6e3wz81d.js";
 import {
   __require
 } from "./roy-agent-core-fs0mn2jk.js";

package/dist/shared/@ai-setting/{roy-agent-core-7fgf85wc.js → roy-agent-core-h0x19xgn.js}

@@ -132,6 +132,11 @@ class WorkflowConverter {
       retry: meta.retry,
       timeout: meta.timeout
     }));
+    const edges = edgeMetadatas.map((edge) => ({
+      from: edge.from,
+      to: edge.to,
+      when: edge.condition
+    }));
     const entry = workflowMeta.entry || nodeMetadatas[0]?.nodeId || "unknown";
     return {
       name: workflowMeta.name,
@@ -139,6 +144,7 @@ class WorkflowConverter {
       description: workflowMeta.description,
       config: workflowMeta.config || {},
       nodes,
+      edges,
       entry,
       outputs: [],
       metadata: {
@@ -158,13 +164,6 @@ class WorkflowConverter {
         if (!targetNode.dependsOn.includes(edge.from)) {
           targetNode.dependsOn = [...targetNode.dependsOn, edge.from];
         }
-        if (edge.condition) {
-          if (targetNode.condition) {
-            targetNode.condition = `(${targetNode.condition}) AND (${edge.condition})`;
-          } else {
-            targetNode.condition = edge.condition;
-          }
-        }
       }
     }
     return nodeMap;

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

@@ -1,20 +1,22 @@
 import {
   TaskTagPlugin,
   createLarkCliTaskNotifyHook
-} from "./roy-agent-core-e9fdm13a.js";
+} from "./roy-agent-core-4gmxjdhn.js";
 import {
   envKeyToConfigKey
 } from "./roy-agent-core-qxhq8ven.js";
 import {
   BaseComponent
-} from "./roy-agent-core-4jqq077c.js";
+} from "./roy-agent-core-6e3wz81d.js";
 import {
-  globalHookManager
-} from "./roy-agent-core-jqy2mdyq.js";
+  globalHookManager,
+  init_global_hook_manager
+} from "./roy-agent-core-rgj6hq15.js";
 import {
   createEnvContext,
+  init_context,
   runWithEnvContext
-} from "./roy-agent-core-z33en0cz.js";
+} from "./roy-agent-core-rm3hay00.js";
 import {
   createLogger,
   init_logger
@@ -27,7 +29,9 @@ import {
 } from "./roy-agent-core-fs0mn2jk.js";
 
 // src/env/event-source/event-source-handlers.ts
+init_global_hook_manager();
 import { spawn } from "child_process";
+init_context();
 var BUILT_IN_PLUGIN_FACTORIES = {
   LarkCliTaskNotifyPlugin: (cfg) => createLarkCliTaskNotifyHook(cfg),
   "task-tag": () => new TaskTagPlugin

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

@@ -6,7 +6,7 @@ import {
 } from "./roy-agent-core-qxhq8ven.js";
 import {
   BaseComponent
-} from "./roy-agent-core-4jqq077c.js";
+} from "./roy-agent-core-6e3wz81d.js";
 import {
   createLogger,
   init_logger,

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

@@ -1,15 +1,17 @@
 import {
   BaseComponent
-} from "./roy-agent-core-4jqq077c.js";
+} from "./roy-agent-core-6e3wz81d.js";
 import {
-  globalHookManager
-} from "./roy-agent-core-jqy2mdyq.js";
+  globalHookManager,
+  init_global_hook_manager
+} from "./roy-agent-core-rgj6hq15.js";
 import {
   createLogger,
   init_logger
 } from "./roy-agent-core-10n2jh7p.js";
 
 // src/env/plugin/plugin-component.ts
+init_global_hook_manager();
 init_logger();
 
 class PluginComponent extends BaseComponent {

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

@@ -0,0 +1,132 @@
+import {
+  __esm
+} from "./roy-agent-core-fs0mn2jk.js";
+
+// src/env/workflow/utils/json-schema-to-zod.ts
+import { z } from "zod";
+function validateJsonOutputSchema(schema) {
+  if (!schema || typeof schema !== "object" || Array.isArray(schema)) {
+    throw new Error("output.schema must be a JSON object");
+  }
+  const record = schema;
+  if (record.type !== "object") {
+    throw new Error('output.schema.type must be "object"');
+  }
+  const properties = record.properties;
+  if (!properties || typeof properties !== "object" || Array.isArray(properties)) {
+    throw new Error("output.schema.properties must be an object");
+  }
+  const propertyEntries = Object.entries(properties);
+  if (propertyEntries.length === 0) {
+    throw new Error("output.schema.properties must not be empty");
+  }
+  const required = record.required;
+  if (required !== undefined) {
+    if (!Array.isArray(required)) {
+      throw new Error("output.schema.required must be an array of property names");
+    }
+    for (const key of required) {
+      if (typeof key !== "string") {
+        throw new Error("output.schema.required entries must be strings");
+      }
+      if (!(key in properties)) {
+        throw new Error(`output.schema.required references unknown property "${key}"`);
+      }
+    }
+  }
+  for (const [name, prop] of propertyEntries) {
+    if (!prop || typeof prop !== "object" || Array.isArray(prop)) {
+      throw new Error(`output.schema.properties.${name} must be an object`);
+    }
+    const propRecord = prop;
+    const type = propRecord.type;
+    if (typeof type !== "string" || !SUPPORTED_PROPERTY_TYPES.has(type)) {
+      throw new Error(`output.schema.properties.${name}.type must be one of: ${[...SUPPORTED_PROPERTY_TYPES].join(", ")}`);
+    }
+    if (propRecord.description !== undefined && typeof propRecord.description !== "string") {
+      throw new Error(`output.schema.properties.${name}.description must be a string`);
+    }
+  }
+  jsonSchemaToZod(record);
+  return record;
+}
+function jsonSchemaToZod(schema) {
+  if (schema.type !== "object" || !schema.properties) {
+    throw new Error("Agent output schema must be a JSON object with properties");
+  }
+  const required = new Set(schema.required ?? []);
+  const shape = {};
+  for (const [key, prop] of Object.entries(schema.properties)) {
+    let field = propertyToZod(prop);
+    if (prop.description) {
+      field = field.describe(prop.description);
+    }
+    if (!required.has(key)) {
+      field = field.optional();
+    }
+    shape[key] = field;
+  }
+  return z.object(shape);
+}
+function propertyToZod(prop) {
+  switch (prop.type) {
+    case "boolean":
+      return z.boolean();
+    case "string":
+      return z.string();
+    case "number":
+    case "integer":
+      return z.number();
+    default:
+      return z.unknown();
+  }
+}
+var SUPPORTED_PROPERTY_TYPES;
+var init_json_schema_to_zod = __esm(() => {
+  SUPPORTED_PROPERTY_TYPES = new Set(["boolean", "string", "number", "integer"]);
+});
+
+// src/env/workflow/tools/submit-json-output-tool.ts
+function createSubmitJsonOutputTool(schema) {
+  const parameters = jsonSchemaToZod(schema);
+  return {
+    name: WORKFLOW_SUBMIT_OUTPUT_TOOL_NAME,
+    description: "Submit the final structured JSON result for this workflow agent step. " + "You MUST call this tool once with your final answer — do not reply with plain text only.",
+    parameters,
+    async execute(args) {
+      const parsed = parameters.parse(args);
+      return {
+        success: true,
+        output: `${WorkflowJsonOutputMarker}:${JSON.stringify(parsed)}`
+      };
+    },
+    metadata: {
+      category: "workflow",
+      tags: ["structured-output"],
+      version: "1.0.0"
+    }
+  };
+}
+function parseWorkflowJsonOutput(output) {
+  if (typeof output !== "string") {
+    return;
+  }
+  if (!output.startsWith(`${WorkflowJsonOutputMarker}:`)) {
+    return;
+  }
+  try {
+    const data = JSON.parse(output.slice(WorkflowJsonOutputMarker.length + 1));
+    if (data && typeof data === "object" && !Array.isArray(data)) {
+      return data;
+    }
+  } catch {
+    return;
+  }
+  return;
+}
+var WORKFLOW_SUBMIT_OUTPUT_TOOL_NAME = "workflow_submit_output", WorkflowJsonOutputMarker = "__WORKFLOW_JSON_OUTPUT__";
+var init_submit_json_output_tool = __esm(() => {
+  init_json_schema_to_zod();
+});
+
+export { validateJsonOutputSchema, jsonSchemaToZod, init_json_schema_to_zod, WORKFLOW_SUBMIT_OUTPUT_TOOL_NAME, WorkflowJsonOutputMarker, createSubmitJsonOutputTool, parseWorkflowJsonOutput, init_submit_json_output_tool };