@ai-setting/roy-agent-core 1.5.52 → 1.5.54

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

@@ -0,0 +1,610 @@
+import {
+  createLogger,
+  init_logger
+} from "./roy-agent-core-10n2jh7p.js";
+import {
+  __require
+} from "./roy-agent-core-fs0mn2jk.js";
+
+// src/env/llm/invoke.ts
+init_logger();
+import { randomUUID } from "crypto";
+import { streamText, jsonSchema } from "ai";
+import { createOpenAI } from "@ai-sdk/openai";
+import { createAnthropic } from "@ai-sdk/anthropic";
+import { createGoogleGenerativeAI } from "@ai-sdk/google";
+import { createOpenAICompatible } from "@ai-sdk/openai-compatible";
+import { zodToJsonSchema } from "zod-to-json-schema";
+var logger = createLogger("llm:invoke");
+var MAX_RETRIES = 3;
+var DEFAULT_TIMEOUT = 60000;
+
+class TimeoutError extends Error {
+  timeout;
+  constructor(message, timeout) {
+    super(message);
+    this.timeout = timeout;
+    this.name = "TimeoutError";
+  }
+}
+async function withTimeout(promise, timeoutMs = DEFAULT_TIMEOUT, message) {
+  let timer;
+  const timeoutPromise = new Promise((_, reject) => {
+    timer = setTimeout(() => {
+      reject(new TimeoutError(message || `LLM invocation timeout after ${timeoutMs}ms`, timeoutMs));
+    }, timeoutMs);
+  });
+  try {
+    return await Promise.race([promise, timeoutPromise]);
+  } finally {
+    if (timer) {
+      clearTimeout(timer);
+    }
+  }
+}
+function parseModelString(model) {
+  if (!model) {
+    return { providerId: "openai", modelId: "gpt-4o" };
+  }
+  const parts = model.split("/");
+  if (parts.length >= 2) {
+    return { providerId: parts[0], modelId: parts.slice(1).join("/") };
+  }
+  return { providerId: "openai", modelId: model };
+}
+function extractUsageInfo(usage) {
+  if (!usage)
+    return;
+  if (usage.inputTokens && typeof usage.inputTokens === "object") {
+    return {
+      promptTokens: usage.inputTokens.total ?? 0,
+      completionTokens: usage.outputTokens?.total ?? 0,
+      totalTokens: usage.totalTokens ?? 0
+    };
+  }
+  if (typeof usage.promptTokens === "number") {
+    return {
+      promptTokens: usage.promptTokens,
+      completionTokens: usage.completionTokens ?? 0,
+      totalTokens: usage.totalTokens ?? 0
+    };
+  }
+  if (usage.inputTokenDetails || usage.outputTokenDetails) {
+    return {
+      promptTokens: usage.inputTokenDetails?.tokens ?? 0,
+      completionTokens: usage.outputTokenDetails?.tokens ?? 0,
+      totalTokens: usage.totalTokens ?? 0
+    };
+  }
+  if (usage.raw && typeof usage.raw.total_tokens === "number") {
+    return {
+      promptTokens: 0,
+      completionTokens: 0,
+      totalTokens: usage.raw.total_tokens
+    };
+  }
+  return;
+}
+function convertToSDKMessages(messages) {
+  return messages.map((msg) => {
+    if (msg.role === "assistant" && msg.toolCalls && msg.toolCalls.length > 0) {
+      const toolCallParts = msg.toolCalls.map((tc) => {
+        let input = {};
+        if (tc.function?.arguments) {
+          if (typeof tc.function.arguments === "string") {
+            try {
+              const parsed = JSON.parse(tc.function.arguments);
+              input = typeof parsed === "string" ? { _raw: parsed } : parsed;
+            } catch {
+              input = { _raw: tc.function.arguments };
+            }
+          } else {
+            input = tc.function.arguments;
+          }
+        } else if (tc.arguments) {
+          if (typeof tc.arguments === "string") {
+            try {
+              const parsed = JSON.parse(tc.arguments);
+              input = typeof parsed === "string" ? { _raw: parsed } : parsed;
+            } catch {
+              input = { _raw: tc.arguments };
+            }
+          } else {
+            input = tc.arguments;
+          }
+        }
+        return {
+          type: "tool-call",
+          toolCallId: tc.id,
+          toolName: tc.function?.name || tc.name || "unknown",
+          input
+        };
+      });
+      return {
+        role: "assistant",
+        content: toolCallParts
+      };
+    }
+    if (msg.role === "tool") {
+      if (!msg.toolCallId) {
+        logger.warn("Tool message missing toolCallId", { msg });
+      }
+      let outputValue = "";
+      const content = msg.content;
+      if (typeof content === "string") {
+        outputValue = content;
+      } else if (Array.isArray(content)) {
+        const toolResultPart = content.find((p) => p?.type === "tool-result");
+        if (toolResultPart) {
+          outputValue = typeof toolResultPart.output === "string" ? toolResultPart.output : JSON.stringify(toolResultPart.output);
+        } else {
+          outputValue = JSON.stringify(content);
+        }
+      } else {
+        outputValue = JSON.stringify(content);
+      }
+      const converted = {
+        role: "tool",
+        content: [{
+          type: "tool-result",
+          toolCallId: msg.toolCallId || "unknown",
+          toolName: msg.name || "unknown",
+          output: {
+            type: "text",
+            value: outputValue
+          }
+        }]
+      };
+      return converted;
+    }
+    return msg;
+  });
+}
+function convertToolsToSDK(tools) {
+  const result = {};
+  for (const tool of tools) {
+    const jsonSchemaObj = extractToolSchema(tool.parameters);
+    result[tool.name] = {
+      description: tool.description || "",
+      inputSchema: jsonSchema(jsonSchemaObj)
+    };
+  }
+  return result;
+}
+function extractToolSchema(parameters) {
+  if (parameters && typeof parameters === "object" && "_def" in parameters) {
+    const zodSchema = parameters;
+    const schema = zodToJsonSchema(zodSchema, "zod");
+    if ("$ref" in schema && schema.definitions) {
+      const def = schema.definitions.zod;
+      if (def && def.type === "object" && def.properties) {
+        return {
+          type: "object",
+          properties: def.properties,
+          required: def.required,
+          additionalProperties: true
+        };
+      }
+    }
+    return schema;
+  }
+  return parameters;
+}
+function generateProviderOptions(providerType, options) {
+  const result = {
+    providerOptions: {}
+  };
+  if (options.temperature !== undefined) {
+    result.temperature = options.temperature;
+  }
+  if (options.maxTokens !== undefined) {
+    result.maxTokens = options.maxTokens;
+  }
+  switch (providerType) {
+    case "anthropic":
+      break;
+    case "openai-compatible":
+      result.providerOptions.includeUsage = true;
+      break;
+  }
+  return result;
+}
+function createEnvEventEmitter(env, context) {
+  if (!env) {
+    logger.warn("[invoke] createEnvEventEmitter: env is null/undefined, streaming events will be disabled");
+    return null;
+  }
+  return (event) => {
+    try {
+      const fullType = `llm.${event.type}`;
+      logger.info(`[invoke] Pushing LLM event: ${fullType}`, {
+        hasPayload: !!event,
+        payloadType: typeof event
+      });
+      env.pushEnvEvent({
+        id: randomUUID(),
+        type: fullType,
+        timestamp: Date.now(),
+        metadata: {
+          source: "llm.invoke",
+          sessionId: context?.sessionId,
+          messageId: context?.messageId
+        },
+        payload: event
+      });
+      logger.info(`[invoke] LLM event pushed successfully: ${fullType}`);
+    } catch (err) {
+      logger.warn("Failed to push env event", { error: String(err), eventType: event.type });
+    }
+  };
+}
+function getStreamPartText(part) {
+  const value = part.text ?? part.delta ?? part.textDelta;
+  return typeof value === "string" ? value : "";
+}
+function processThinkingStream(textDelta, config, state) {
+  if (!config.enabled || !textDelta) {
+    return {
+      cleanedText: textDelta,
+      isThinkingTagOpen: state.isOpen,
+      currentThinkingContent: state.content,
+      reasoningEvents: []
+    };
+  }
+  const tags = config.tags || ["thinking"];
+  let remainingText = textDelta;
+  const reasoningEvents2 = [];
+  let isOpen2 = state.isOpen;
+  let currentContent2 = state.content;
+  for (const tag of tags) {
+    const openTag = `<${tag}>`;
+    const closeTag = `</${tag}>`;
+    let text = remainingText;
+    let result = "";
+    const openIndex = text.toLowerCase().indexOf(openTag.toLowerCase());
+    const closeIndex = text.toLowerCase().indexOf(closeTag.toLowerCase());
+    if (openIndex !== -1 && (closeIndex === -1 || openIndex < closeIndex)) {
+      const beforeOpen = text.substring(0, openIndex);
+      const afterOpen = text.substring(openIndex + openTag.length);
+      if (!isOpen2) {
+        isOpen2 = true;
+        currentContent2 = "";
+        reasoningEvents2.push("");
+      }
+      result += beforeOpen;
+      const innerCloseIndex = afterOpen.toLowerCase().indexOf(closeTag.toLowerCase());
+      if (innerCloseIndex !== -1) {
+        const thinkingContent = afterOpen.substring(0, innerCloseIndex);
+        const afterClose = afterOpen.substring(innerCloseIndex + closeTag.length);
+        currentContent2 += thinkingContent;
+        reasoningEvents2.push(currentContent2);
+        isOpen2 = false;
+        currentContent2 = "";
+        result += afterClose;
+      } else {
+        currentContent2 += afterOpen;
+        reasoningEvents2.push(currentContent2);
+        result += "";
+      }
+      remainingText = result;
+    } else if (closeIndex !== -1) {
+      const beforeClose = text.substring(0, closeIndex);
+      const afterClose = text.substring(closeIndex + closeTag.length);
+      if (isOpen2) {
+        currentContent2 += beforeClose;
+        reasoningEvents2.push(currentContent2);
+        isOpen2 = false;
+        currentContent2 = "";
+        result = afterClose;
+      } else {
+        result = text;
+      }
+      remainingText = result;
+    }
+  }
+  if (isOpen2 && remainingText === textDelta) {
+    currentContent2 += remainingText;
+    reasoningEvents2.push(currentContent2);
+    remainingText = "";
+  }
+  return {
+    cleanedText: remainingText,
+    isThinkingTagOpen: isOpen2,
+    currentThinkingContent: currentContent2,
+    reasoningEvents: reasoningEvents2
+  };
+}
+async function invoke(config, options, ctx) {
+  try {
+    const emitToEnv = createEnvEventEmitter(options.env, options.context);
+    logger.info("[invoke] Created event emitter, env available:", !!options.env, "context:", options.context);
+    const { providerId, modelId } = parseModelString(options.model || config.model);
+    const provider = createProviderInstance(providerId, config.apiKey, config.baseURL);
+    if (!provider) {
+      throw new Error(`Failed to create provider for ${providerId}`);
+    }
+    const messages = convertToSDKMessages(options.messages);
+    const toolCallIds = new Set;
+    const assistantToolCalls = [];
+    const toolResultIds = [];
+    for (const msg of messages) {
+      if (msg.role === "assistant") {
+        const assistantContent = Array.isArray(msg.content) ? msg.content : [];
+        for (const part of assistantContent) {
+          if (part && typeof part === "object" && part.type === "tool-call") {
+            const tc = part.toolCall || part;
+            assistantToolCalls.push({ id: tc.id, name: tc.name || tc.function && tc.function.name });
+            toolCallIds.add(tc.id);
+          }
+        }
+      }
+      if (msg.role === "tool") {
+        const toolContent = Array.isArray(msg.content) ? msg.content : [];
+        for (const part of toolContent) {
+          if (part && typeof part === "object" && part.type === "tool-result") {
+            toolResultIds.push(part.toolCallId);
+          }
+        }
+      }
+    }
+    const missingToolResults = assistantToolCalls.filter((tc) => !toolResultIds.includes(tc.id));
+    const orphanedToolResults = toolResultIds.filter((id) => !toolCallIds.has(id));
+    if (assistantToolCalls.length > 0 || toolResultIds.length > 0) {
+      logger.debug("[invoke] ToolCallId matching analysis:", {
+        assistantToolCalls,
+        toolResultIds,
+        missingToolResults: missingToolResults.length > 0 ? missingToolResults : "none",
+        orphanedToolResults: orphanedToolResults.length > 0 ? orphanedToolResults : "none"
+      });
+    }
+    const tools = options.tools && options.tools.length > 0 ? convertToolsToSDK(options.tools) : undefined;
+    const providerOptions = generateProviderOptions(providerId, {
+      temperature: options.temperature,
+      maxTokens: options.maxTokens
+    });
+    const model = `${providerId}/${modelId}`;
+    if (emitToEnv) {
+      logger.info("[invoke] Emitting llm.start event");
+      emitToEnv({ type: "start", metadata: { model } });
+    } else {
+      logger.warn("[invoke] emitToEnv is null, skipping llm.start event");
+    }
+    const streamTextOptions = {
+      model: provider.languageModel(modelId),
+      messages,
+      tools,
+      temperature: providerOptions.temperature,
+      maxTokens: providerOptions.maxTokens,
+      abortSignal: ctx.abort,
+      maxRetries: MAX_RETRIES,
+      streamOptions: {
+        includeUsage: true
+      },
+      allowSystemInMessages: true
+    };
+    const result = await streamText(streamTextOptions);
+    let fullContent = "";
+    let reasoningContent = "";
+    const toolCalls = [];
+    let usageInfo;
+    let isThinkingTagOpen = false;
+    let currentThinkingContent = "";
+    for await (const part of result.fullStream) {
+      const streamPart = part;
+      switch (streamPart.type) {
+        case "text-delta": {
+          const textDelta = getStreamPartText(streamPart);
+          if (!textDelta)
+            break;
+          const thinkingConfig = config.options?.thinkingInText;
+          if (thinkingConfig?.enabled) {
+            const thinkingResult = processThinkingStream(textDelta, thinkingConfig, {
+              isOpen: isThinkingTagOpen,
+              content: currentThinkingContent
+            });
+            isThinkingTagOpen = thinkingResult.isThinkingTagOpen;
+            currentThinkingContent = thinkingResult.currentThinkingContent;
+            fullContent += thinkingResult.cleanedText;
+            for (const reasoningSnapshot of thinkingResult.reasoningEvents) {
+              const delta = reasoningSnapshot.slice(reasoningContent.length);
+              reasoningContent = reasoningSnapshot;
+              if (emitToEnv && delta) {
+                emitToEnv({ type: "reasoning", content: reasoningContent, delta });
+              }
+            }
+            if (emitToEnv && thinkingResult.cleanedText) {
+              emitToEnv({ type: "text", content: fullContent, delta: thinkingResult.cleanedText });
+            }
+          } else {
+            fullContent += textDelta;
+            if (emitToEnv) {
+              emitToEnv({ type: "text", content: fullContent, delta: textDelta });
+            }
+          }
+          break;
+        }
+        case "reasoning-delta": {
+          const reasoningDelta = getStreamPartText(streamPart);
+          if (!reasoningDelta)
+            break;
+          reasoningContent += reasoningDelta;
+          if (emitToEnv) {
+            emitToEnv({ type: "reasoning", content: reasoningContent, delta: reasoningDelta });
+          }
+          break;
+        }
+        case "reasoning-end":
+          break;
+        case "tool-call": {
+          const toolInput = streamPart.input;
+          const toolCallId = streamPart.toolCallId ?? streamPart.id;
+          const toolName = streamPart.toolName;
+          toolCalls.push({
+            id: toolCallId,
+            name: toolName,
+            args: toolInput
+          });
+          break;
+        }
+        case "finish-step":
+          const stepUsage = extractUsageInfo(streamPart.usage);
+          if (stepUsage) {
+            usageInfo = stepUsage;
+          }
+          break;
+        case "error":
+          throw streamPart.error;
+        case "finish":
+          usageInfo = extractUsageInfo(streamPart.totalUsage);
+          if (!usageInfo && streamPart.usage) {
+            usageInfo = extractUsageInfo(streamPart.usage);
+          }
+          break;
+      }
+    }
+    if (emitToEnv) {
+      emitToEnv({
+        type: "completed",
+        content: fullContent,
+        metadata: {
+          model,
+          usage: usageInfo
+        }
+      });
+    }
+    if (toolCalls.length > 0) {
+      const firstToolCall = toolCalls[0];
+      return {
+        toolCallId: firstToolCall.id,
+        result: JSON.stringify({
+          content: fullContent,
+          reasoning: reasoningContent || undefined,
+          tool_calls: toolCalls.map((tc) => ({
+            id: tc.id,
+            function: {
+              name: tc.name,
+              arguments: JSON.stringify(tc.args)
+            }
+          }))
+        })
+      };
+    }
+    return {
+      toolCallId: "invoke-" + Date.now(),
+      result: JSON.stringify({
+        content: fullContent,
+        reasoning: reasoningContent || undefined,
+        usage: usageInfo,
+        model
+      })
+    };
+  } catch (error) {
+    logger.error("Error during invocation", {
+      error: error instanceof Error ? error.message : String(error),
+      stack: error instanceof Error ? error.stack : undefined
+    });
+    return {
+      toolCallId: "error-" + Date.now(),
+      result: error instanceof Error ? error.message : String(error),
+      isError: true
+    };
+  }
+}
+function createProviderInstance(providerId, apiKey, baseURL) {
+  try {
+    if (providerId === "openai") {
+      const openai = createOpenAI({
+        apiKey,
+        baseURL
+      });
+      return openai;
+    }
+    if (providerId === "anthropic") {
+      const anthropic = createAnthropic({
+        apiKey
+      });
+      return anthropic;
+    }
+    if (providerId === "google") {
+      const google = createGoogleGenerativeAI({
+        apiKey
+      });
+      return google;
+    }
+    const defaultProvider = createOpenAICompatible({
+      name: providerId,
+      apiKey,
+      baseURL: baseURL || "",
+      includeUsage: true
+    });
+    return defaultProvider;
+  } catch (error) {
+    logger.error(`Failed to create provider ${providerId}`, { error: String(error) });
+    return null;
+  }
+}
+async function invokeNonStream(config, options, ctx) {
+  const { providerId, modelId } = parseModelString(options.model || config.model);
+  const provider = createProviderInstance(providerId, config.apiKey, config.baseURL);
+  if (!provider) {
+    throw new Error(`Failed to create provider for ${providerId}`);
+  }
+  const messages = convertToSDKMessages(options.messages);
+  const tools = options.tools && options.tools.length > 0 ? convertToolsToSDK(options.tools) : undefined;
+  const providerOptions = generateProviderOptions(providerId, {
+    temperature: options.temperature,
+    maxTokens: options.maxTokens
+  });
+  const { generateText } = await import("ai");
+  const genTextFn = generateText;
+  const result = await genTextFn({
+    model: provider.languageModel(modelId),
+    messages,
+    tools,
+    temperature: providerOptions.temperature,
+    maxTokens: providerOptions.maxTokens,
+    abortSignal: ctx.abort,
+    allowSystemInMessages: true
+  });
+  const usage = result.usage;
+  const usageInfo = usage ? {
+    promptTokens: usage.promptTokens ?? 0,
+    completionTokens: usage.completionTokens ?? 0,
+    totalTokens: usage.totalTokens ?? 0
+  } : undefined;
+  if (options.env) {
+    options.env.pushEnvEvent({
+      id: randomUUID(),
+      type: "llm.completed",
+      timestamp: Date.now(),
+      metadata: {
+        source: "llm.invokeNonStream",
+        sessionId: options.context?.sessionId,
+        messageId: options.context?.messageId
+      },
+      payload: {
+        type: "completed",
+        content: result.text,
+        metadata: {
+          model: `${providerId}/${modelId}`,
+          usage: usageInfo
+        }
+      }
+    });
+  }
+  return {
+    content: result.text,
+    finishReason: result.finishReason === "stop" ? "stop" : "tool-calls",
+    model: `${providerId}/${modelId}`,
+    usage: usageInfo
+  };
+}
+function createInvokeConfig(model, apiKey, baseURL) {
+  return {
+    model,
+    apiKey,
+    baseURL
+  };
+}
+
+export { withTimeout, parseModelString, invoke, invokeNonStream, createInvokeConfig };

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

@@ -92,6 +92,16 @@ var makeBashSpawner = () => {
           stderrChunks.push(data);
         });
         const exitCode = yield* Effect.async((resume) => {
+          if (child.exitCode !== null) {
+            exited = true;
+            resume(Effect.succeed(child.exitCode));
+            return;
+          }
+          if (child.killed) {
+            exited = true;
+            resume(Effect.succeed(1));
+            return;
+          }
           exitResolve = (code) => {
             if (!exited) {
               exited = true;

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

@@ -5,7 +5,7 @@ import {
   BackgroundTaskManager,
   createDelegateTool,
   createStopTool
-} from "./roy-agent-core-vehgmfj1.js";
+} from "./roy-agent-core-nfa6fc3a.js";
 import {
   SQLiteTaskStore,
   getDefaultTaskDbPath

package/dist/shared/@ai-setting/{roy-agent-core-4mw6rs37.js → roy-agent-core-g7qhnsz3.js}

@@ -1,3 +1,6 @@
+import {
+  withTimeout
+} from "./roy-agent-core-4ch3ghj6.js";
 import {
   AskUserError,
   init_workflow_hil
@@ -965,6 +968,16 @@ class AgentComponent extends BaseComponent {
     }
     logger.info(`Agent aborted: ${agentName}`);
   }
+  abortAll() {
+    for (const key of this.aborted.keys()) {
+      this.aborted.set(key, true);
+    }
+    for (const [key, controller] of this.abortControllers) {
+      controller.abort();
+      logger.debug(`[abortAll] AbortController.abort() called for run: ${key}`);
+    }
+    logger.info(`All agents aborted (${this.abortControllers.size} runs)`);
+  }
   async _buildAdditionInfo(ctx) {
     let additionInfo = ctx.context?.additionInfo || "";
     const currentTaskId = getCurrentTaskId();
@@ -1002,7 +1015,7 @@ ${additionInfo}`
       const convertedMessages = messages.map(toLLMMessage);
       logger.debug(`[invokeLLM] Calling LLMComponent.invoke with ${convertedMessages.length} messages`);
       try {
-        const result = await this.llmComponent.invoke({
+        const llmPromise = this.llmComponent.invoke({
           messages: convertedMessages,
           tools: ctx.tools.map((t) => ({
             name: t.name,
@@ -1016,6 +1029,7 @@ ${additionInfo}`
           },
           abortSignal: ctx.context.abort
         });
+        const result = await withTimeout(llmPromise, 120000, "LLM invocation timeout after 120s");
         logger.debug("[invokeLLM] LLMComponent.invoke returned successfully");
         return {
           content: result.output?.content || "",
@@ -1089,11 +1103,22 @@ ${additionInfo}`
         context: toolContext
       };
       let result;
+      const isLongRunningTool = toolName === "delegate_task" || toolName === "stop_task" || toolName === "bash";
       if (this.toolComponent?.execute) {
-        result = await this.toolComponent.execute(request);
+        const toolPromise = this.toolComponent.execute(request);
+        if (isLongRunningTool) {
+          result = await toolPromise;
+        } else {
+          result = await withTimeout(toolPromise, 120000, `Tool '${toolName}' execution timeout after 120s`);
+        }
       } else {
         logger.debug(`[executeTool] No ToolComponent available, executing tool directly`);
-        result = await tool.execute(toolCall.arguments, toolContext);
+        const toolPromise = tool.execute(toolCall.arguments, toolContext);
+        if (isLongRunningTool) {
+          result = await toolPromise;
+        } else {
+          result = await withTimeout(toolPromise, 120000, `Tool '${toolName}' execution timeout after 120s`);
+        }
       }
       this.pushEnvEvent({
         type: "tool.result",