@ai-setting/roy-agent-core 1.6.9 → 1.6.11

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

@@ -68,6 +68,46 @@ function registerWorkflowJsonOutputPlugin(options = undefined) {
   });
   logger.info("Workflow JSON output plugin registered on agent:after.react");
 }
+function readProviderReasoning(source) {
+  if (!source)
+    return;
+  const configComponent = source.configComponent;
+  if (!configComponent)
+    return;
+  const isConfigError = (e) => e instanceof Error && (e.name === "ConfigValidationError" || e.name === "ConfigError");
+  let providerId;
+  try {
+    providerId = configComponent.get("llm.defaultProvider");
+  } catch (e) {
+    if (isConfigError(e))
+      return;
+    throw e;
+  }
+  if (!providerId)
+    return;
+  let capabilities;
+  try {
+    const capKey = `llm.providers.${providerId}.capabilities`;
+    capabilities = configComponent.get(capKey);
+  } catch (e) {
+    if (isConfigError(e))
+      return;
+    throw e;
+  }
+  return { providerId, reasoning: capabilities?.reasoning === true };
+}
+function resolveProviderToolChoice(source) {
+  const ctx = readProviderReasoning(source);
+  if (!ctx)
+    return "required";
+  if (FIRST_PARTY_PROVIDERS.has(ctx.providerId)) {
+    return "required";
+  }
+  if (ctx.reasoning) {
+    return "auto";
+  }
+  return "required";
+}
 async function runWorkflowJsonOutputExtraction(hookCtx) {
   const schema = hookCtx.context.metadata?.outputSchema;
   if (!schema) {
@@ -113,11 +153,13 @@ async function runWorkflowJsonOutputExtraction(hookCtx) {
       content: userQuery
     }
   ];
+  const resolvedToolChoice = resolveProviderToolChoice(agentComponentRef);
   const extractContext = {
     messages: messagesOverride,
     extraTools: [submitToolAsExtra],
     persistSession: false,
-    abort: hookCtx.context.abort
+    abort: hookCtx.context.abort,
+    toolChoice: resolvedToolChoice
   };
   try {
     const result = await agentComponentRef.run("json-extract", "", extractContext);
@@ -134,7 +176,7 @@ async function runWorkflowJsonOutputExtraction(hookCtx) {
     logger.error(`Workflow JSON extraction: json-extract sub-agent threw: ${error instanceof Error ? error.message : String(error)}`);
   }
 }
-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, agentComponentRef = null, tracedRunWorkflowJsonOutputExtraction;
+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, agentComponentRef = null, FIRST_PARTY_PROVIDERS, tracedRunWorkflowJsonOutputExtraction;
 var init_workflow_json_output_plugin = __esm(() => {
   init_global_hook_manager();
   init_workflow_hil();
@@ -144,6 +186,7 @@ var init_workflow_json_output_plugin = __esm(() => {
   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}`;
+  FIRST_PARTY_PROVIDERS = new Set(["openai", "anthropic", "google"]);
   tracedRunWorkflowJsonOutputExtraction = wrapFunction(runWorkflowJsonOutputExtraction, "workflow.json_output.extraction", { recordParams: true, recordResult: true, log: true });
 });
 

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

@@ -3,7 +3,7 @@ import {
 } from "./roy-agent-core-dcd1s7ct.js";
 import {
   truncateOutputInline
-} from "./roy-agent-core-sk4xg1dw.js";
+} from "./roy-agent-core-zs31w092.js";
 import {
   AskUserError,
   init_workflow_hil
@@ -22,7 +22,7 @@ import {
 } from "./roy-agent-core-8x4ngxcy.js";
 import {
   envKeyToConfigKey
-} from "./roy-agent-core-qxhq8ven.js";
+} from "./roy-agent-core-7hh0brvs.js";
 import {
   BaseComponent
 } from "./roy-agent-core-j62bjagf.js";
@@ -628,6 +628,22 @@ class AgentComponent extends BaseComponent {
     hookCtx.messages.push(message);
     this.notifyMessageAdded(message);
   }
+  consumeMetaProtocolUserMessage(hookCtx) {
+    const toolResultMeta = hookCtx.toolResult?.result?.metadata;
+    if (!toolResultMeta || !("toAddFakeUserMessage" in toolResultMeta)) {
+      return;
+    }
+    const userMsg = toolResultMeta.toAddFakeUserMessage;
+    delete toolResultMeta.toAddFakeUserMessage;
+    if (!userMsg || userMsg.role !== "user") {
+      return;
+    }
+    return userMsg;
+  }
+  flushPendingFakeUserMessage(hookCtx, pendingMsg, iter) {
+    this.pushMessage(hookCtx, pendingMsg);
+    logger.debug(`[ReAct] Meta-protocol: flushed user message AFTER all tool-results (iter=${iter})`);
+  }
   async _run(agentName, query, context) {
     await this.refreshDependencies();
     const agent = this.getAgent(agentName);
@@ -866,6 +882,7 @@ class AgentComponent extends BaseComponent {
             });
             iterAllToolCalls = llmOutput.toolCalls ?? [];
             iterProcessedCount = 0;
+            let pendingFakeUserMessage;
             for (const toolCall of iterAllToolCalls) {
               if (this.aborted.get(runId) || effectiveContext.abort?.aborted) {
                 hookCtx._stopped = true;
@@ -918,19 +935,18 @@ class AgentComponent extends BaseComponent {
                 }]
               });
               {
-                const toolResultMeta = hookCtx.toolResult?.result?.metadata;
-                if (toolResultMeta && "toAddFakeUserMessage" in toolResultMeta) {
-                  const userMsg = toolResultMeta.toAddFakeUserMessage;
-                  if (userMsg && userMsg.role === "user") {
-                    this.pushMessage(hookCtx, userMsg);
-                    logger.debug(`[ReAct] Meta-protocol: appended user message after tool result (tool=${toolResult.name}, iter=${iteration})`);
-                    delete toolResultMeta.toAddFakeUserMessage;
-                  }
+                const captured = this.consumeMetaProtocolUserMessage(hookCtx);
+                if (captured) {
+                  pendingFakeUserMessage = captured;
+                  logger.debug(`[ReAct] Meta-protocol: captured user message (tool=${toolResult.name}, iter=${iteration}); will flush after loop`);
                 }
               }
               result.toolCalls.push(hookCtx.currentToolCall);
               iterProcessedCount++;
             }
+            if (pendingFakeUserMessage) {
+              this.flushPendingFakeUserMessage(hookCtx, pendingFakeUserMessage, iteration);
+            }
             await this.executePluginHooks(agent, "agent:on.iteration", hookCtx);
           }
         } catch (error) {
@@ -1499,6 +1515,12 @@ __legacyDecorateClassTS([
 __legacyDecorateClassTS([
   TracedAs("agent.component.resolveSystemPrompt", { recordParams: true, recordResult: true, log: true })
 ], AgentComponent.prototype, "resolveSystemPrompt", null);
+__legacyDecorateClassTS([
+  TracedAs("agent.meta-protocol.consumeUserMessage", { recordParams: false, recordResult: false, log: true })
+], AgentComponent.prototype, "consumeMetaProtocolUserMessage", null);
+__legacyDecorateClassTS([
+  TracedAs("agent.meta-protocol.flushPendingUserMessage", { recordParams: false, recordResult: false, log: true })
+], AgentComponent.prototype, "flushPendingFakeUserMessage", null);
 __legacyDecorateClassTS([
   TracedAs("agent.component.run", { recordParams: true, recordResult: true, log: true })
 ], AgentComponent.prototype, "_run", null);

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

@@ -14,7 +14,7 @@ import {
 } from "./roy-agent-core-c1v263jn.js";
 import {
   isValidSessionId
-} from "./roy-agent-core-jmzz2yxs.js";
+} from "./roy-agent-core-nw39k111.js";
 import {
   TracedAs,
   init_decorator
@@ -671,6 +671,48 @@ __legacyDecorateClassTS([
     recordResult: true
   })
 ], RunWorkflowToolRunner.prototype, "execute", null);
+
+class RunWorkflowLifecycleTracer {
+  runner;
+  bgTaskId;
+  hooks;
+  constructor(runner, bgTaskId, hooks) {
+    this.runner = runner;
+    this.bgTaskId = bgTaskId;
+    this.hooks = hooks;
+  }
+  async execute(args, ctx) {
+    const hasHooks = !!this.hooks?.attachWorkflowRun;
+    const hasBgTask = !!this.bgTaskId;
+    const result = await this.runner.execute(args, ctx);
+    let detached = false;
+    if (this.bgTaskId && this.hooks?.detachWorkflowRun) {
+      const runId = result?.metadata?.run_id ?? result?.output?.run_id ?? "";
+      if (runId && result.success) {
+        this.hooks.detachWorkflowRun(this.bgTaskId, runId);
+        detached = true;
+      }
+    }
+    return {
+      ...result,
+      metadata: {
+        ...result.metadata,
+        __pre_attach: {
+          hasBgTask,
+          hasHooks,
+          detached,
+          success: !!result.success
+        }
+      }
+    };
+  }
+}
+__legacyDecorateClassTS([
+  TracedAs("workflow.run-tool.pre-attach", {
+    recordParams: true,
+    recordResult: true
+  })
+], RunWorkflowLifecycleTracer.prototype, "execute", null);
 function createRunWorkflowTool(workflowService, hooks) {
   const tool = {
     name: "workflow_run",
@@ -708,12 +750,19 @@ function createRunWorkflowTool(workflowService, hooks) {
       let timedOut = false;
       let capturedByCallback = false;
       let capturedRunId = session ? session : reservedRunId;
+      const bgTaskIdForAttach = getCurrentBgTaskId();
+      if (bgTaskIdForAttach && hooks?.attachWorkflowRun) {
+        hooks.attachWorkflowRun(bgTaskIdForAttach, reservedRunId);
+      }
       const onSessionCreated = (sid) => {
         capturedRunId = sid;
         capturedByCallback = true;
         if (timedOut) {
           attemptStopOnTimeout(workflowService, sid, "timed out");
         }
+        if (bgTaskIdForAttach && hooks?.replaceWorkflowRun) {
+          hooks.replaceWorkflowRun(bgTaskIdForAttach, reservedRunId, sid);
+        }
       };
       try {
         let result;
@@ -811,19 +860,8 @@ function createRunWorkflowTool(workflowService, hooks) {
   const runner = new RunWorkflowToolRunner(tool.execute);
   const wrappedExecute = async (args, ctx) => {
     const bgTaskId = getCurrentBgTaskId();
-    if (!bgTaskId || !hooks?.attachWorkflowRun) {
-      return runner.execute(args, ctx);
-    }
-    const initialRunId = "wf_attach_pending_placeholder";
-    const result = await runner.execute(args, ctx);
-    const runId = result?.metadata?.run_id ?? result?.output?.run_id ?? "";
-    if (runId) {
-      hooks.attachWorkflowRun?.(bgTaskId, runId);
-      if (result.success) {
-        hooks.detachWorkflowRun?.(bgTaskId, runId);
-      }
-    }
-    return result;
+    const lifecycleTracer = new RunWorkflowLifecycleTracer(runner, bgTaskId, hooks);
+    return lifecycleTracer.execute(args, ctx);
   };
   return {
     ...tool,

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

@@ -9,7 +9,7 @@ import {
 } from "./roy-agent-core-95bbd2jv.js";
 import {
   envKeyToConfigKey
-} from "./roy-agent-core-qxhq8ven.js";
+} from "./roy-agent-core-7hh0brvs.js";
 import {
   BaseComponent
 } from "./roy-agent-core-j62bjagf.js";

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

@@ -11,7 +11,7 @@ import {
 } from "./roy-agent-core-4w6rgxs4.js";
 import {
   toEnvKey
-} from "./roy-agent-core-qxhq8ven.js";
+} from "./roy-agent-core-7hh0brvs.js";
 import {
   BaseComponent
 } from "./roy-agent-core-j62bjagf.js";

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

@@ -3,7 +3,7 @@ import {
 } from "./roy-agent-core-psvxt4c9.js";
 import {
   envKeyToConfigKey
-} from "./roy-agent-core-qxhq8ven.js";
+} from "./roy-agent-core-7hh0brvs.js";
 import {
   BaseComponent
 } from "./roy-agent-core-j62bjagf.js";

package/dist/shared/@ai-setting/{roy-agent-core-1qcpvtp8.js → roy-agent-core-xxgazz27.js}

@@ -1,6 +1,6 @@
 import {
   envKeyToConfigKey
-} from "./roy-agent-core-qxhq8ven.js";
+} from "./roy-agent-core-7hh0brvs.js";
 import {
   BaseComponent
 } from "./roy-agent-core-j62bjagf.js";

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

@@ -0,0 +1,229 @@
+import {
+  envKeyToConfigKey,
+  fromEnvKey,
+  toEnvKey
+} from "./roy-agent-core-7hh0brvs.js";
+
+// src/config/env-source.ts
+class EnvSource {
+  name = "env";
+  priority = 20;
+  prefix;
+  transform;
+  pollInterval;
+  watchers = new Set;
+  pollTimer;
+  lastValues = new Map;
+  watchEnabled = true;
+  constructor(options = {}) {
+    this.prefix = options.prefix ?? "";
+    this.transform = options.transform;
+    this.pollInterval = options.pollInterval;
+    this.watchEnabled = options.watch ?? true;
+  }
+  getEnvKey(key) {
+    return toEnvKey(key, this.prefix);
+  }
+  getInternalKey(envKey) {
+    return fromEnvKey(envKey, this.prefix);
+  }
+  read(key) {
+    const envKey = this.getEnvKey(key);
+    const value = process.env[envKey];
+    if (value === undefined) {
+      return;
+    }
+    if (this.transform) {
+      return this.transform(value, key);
+    }
+    return value;
+  }
+  write(key, value) {
+    const envKey = this.getEnvKey(key);
+    const oldValue = process.env[envKey];
+    const stringValue = String(value);
+    process.env[envKey] = stringValue;
+    const event = {
+      type: oldValue === undefined ? "add" : "change",
+      key,
+      oldValue: oldValue !== undefined ? this.transformValue(oldValue, key) : undefined,
+      newValue: this.transformValue(stringValue, key),
+      source: this.name,
+      timestamp: Date.now()
+    };
+    this.notifyWatchers(event);
+    return true;
+  }
+  delete(key) {
+    const envKey = this.getEnvKey(key);
+    const oldValue = process.env[envKey];
+    if (oldValue === undefined) {
+      return false;
+    }
+    delete process.env[envKey];
+    const event = {
+      type: "delete",
+      key,
+      oldValue: this.transformValue(oldValue, key),
+      newValue: undefined,
+      source: this.name,
+      timestamp: Date.now()
+    };
+    this.notifyWatchers(event);
+    return true;
+  }
+  list() {
+    const result = [];
+    const prefix = this.prefix.toUpperCase();
+    for (const envKey of Object.keys(process.env)) {
+      if (prefix && !envKey.startsWith(prefix)) {
+        continue;
+      }
+      const key = this.getInternalKey(envKey);
+      const value = process.env[envKey];
+      if (value !== undefined) {
+        result.push({
+          key,
+          value: this.transformValue(value, key)
+        });
+      }
+    }
+    return result;
+  }
+  watch(callback) {
+    this.watchers.add(callback);
+    if (!this.watchEnabled) {
+      return () => {
+        this.watchers.delete(callback);
+      };
+    }
+    this.ensurePolling();
+    this.recordCurrentValues();
+    return () => {
+      this.watchers.delete(callback);
+      if (this.watchers.size === 0) {
+        this.stopPolling();
+      }
+    };
+  }
+  ensurePolling() {
+    if (this.pollTimer !== undefined) {
+      return;
+    }
+    const interval = this.pollInterval ?? 1000;
+    this.pollTimer = setInterval(() => {
+      this.checkForChanges();
+    }, interval);
+  }
+  stopPolling() {
+    if (this.pollTimer) {
+      clearInterval(this.pollTimer);
+      this.pollTimer = undefined;
+    }
+  }
+  recordCurrentValues() {
+    this.lastValues.clear();
+    const entries = this.list();
+    for (const entry of entries) {
+      const envKey = this.getEnvKey(entry.key);
+      const value = process.env[envKey];
+      if (value !== undefined) {
+        this.lastValues.set(envKey, value);
+      }
+    }
+  }
+  checkForChanges() {
+    const currentEntries = this.list();
+    const currentValues = new Map;
+    for (const entry of currentEntries) {
+      const envKey = this.getEnvKey(entry.key);
+      const value = process.env[envKey];
+      if (value !== undefined) {
+        currentValues.set(envKey, value);
+      }
+    }
+    for (const [envKey, oldValue] of this.lastValues.entries()) {
+      if (!currentValues.has(envKey)) {
+        const key = this.getInternalKey(envKey);
+        this.notifyWatchers({
+          type: "delete",
+          key,
+          oldValue: this.transformValue(oldValue, key),
+          newValue: undefined,
+          source: this.name,
+          timestamp: Date.now()
+        });
+      }
+    }
+    for (const [envKey, newValue] of currentValues.entries()) {
+      const key = this.getInternalKey(envKey);
+      const oldValue = this.lastValues.get(envKey);
+      if (oldValue === undefined) {
+        this.notifyWatchers({
+          type: "add",
+          key,
+          oldValue: undefined,
+          newValue: this.transformValue(newValue, key),
+          source: this.name,
+          timestamp: Date.now()
+        });
+      } else if (oldValue !== newValue) {
+        this.notifyWatchers({
+          type: "change",
+          key,
+          oldValue: this.transformValue(oldValue, key),
+          newValue: this.transformValue(newValue, key),
+          source: this.name,
+          timestamp: Date.now()
+        });
+      }
+    }
+    this.lastValues = currentValues;
+  }
+  transformValue(value, key) {
+    if (this.transform) {
+      return this.transform(value, key);
+    }
+    return value;
+  }
+  notifyWatchers(event) {
+    this.watchers.forEach((cb) => cb(event));
+  }
+  close() {
+    this.stopPolling();
+    this.watchers.clear();
+  }
+  validateUnrecognizedEnvVars(options = {}) {
+    const { componentName, knownKeys, logger } = options;
+    const prefixUpper = this.prefix.toUpperCase();
+    const unrecognized = [];
+    if (!knownKeys || knownKeys.size === 0) {
+      return unrecognized;
+    }
+    for (const envKey of Object.keys(process.env)) {
+      if (prefixUpper && !envKey.toUpperCase().startsWith(prefixUpper)) {
+        continue;
+      }
+      const configKey = componentName ? envKeyToConfigKey(envKey, this.prefix, componentName) : undefined;
+      const candidateKey = configKey ?? fromEnvKey(envKey, this.prefix).toLowerCase().replace(/_/g, ".");
+      const isKnown = Array.from(knownKeys).some((known) => {
+        if (known === candidateKey)
+          return true;
+        if (candidateKey.startsWith(known + "."))
+          return true;
+        return false;
+      });
+      if (!isKnown) {
+        const valuePreview = JSON.stringify(process.env[envKey]);
+        const truncated = valuePreview.length > 50 ? valuePreview.slice(0, 47) + "..." : valuePreview;
+        const msg = `[EnvSource] Unrecognized env var: ${envKey}=${truncated} ` + `(resolved config key "${candidateKey}" not in known keys: ${Array.from(knownKeys).join(", ") || "<empty>"}). ` + `Check spelling, or add the key to the component's known config keys.`;
+        unrecognized.push(envKey);
+        if (logger?.warn)
+          logger.warn(msg);
+      }
+    }
+    return unrecognized;
+  }
+}
+
+export { EnvSource };

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

@@ -1,7 +1,7 @@
 import {
   AgentComponentAdapter,
   init_agent_component_adapter
-} from "./roy-agent-core-g2ntbc33.js";
+} from "./roy-agent-core-jenchn33.js";
 import"./roy-agent-core-1db4vpc6.js";
 import"./roy-agent-core-e25xkv53.js";
 import"./roy-agent-core-dbkkjmqz.js";

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

@@ -8,7 +8,7 @@ import {
 import {
   envKeyToConfigKey,
   toEnvKey
-} from "./roy-agent-core-qxhq8ven.js";
+} from "./roy-agent-core-7hh0brvs.js";
 import {
   BaseComponent
 } from "./roy-agent-core-j62bjagf.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-setting/roy-agent-core",
-  "version": "1.6.9",
+  "version": "1.6.11",
   "type": "module",
   "description": "Core SDK for roy-agent - Environment, Components, Tools, Sessions, Tasks",
   "main": "./dist/index.js",