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

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

@@ -0,0 +1,1316 @@
+import {
+  ContextError,
+  ErrorCodes
+} from "./roy-agent-core-ctdhjv68.js";
+import {
+  envKeyToConfigKey,
+  toEnvKey
+} from "./roy-agent-core-qxhq8ven.js";
+import {
+  BaseComponent
+} from "./roy-agent-core-kkbwepqb.js";
+import {
+  LLMHookPoints,
+  globalHookManager
+} from "./roy-agent-core-gjq1yk68.js";
+import {
+  TracedAs,
+  init_decorator
+} from "./roy-agent-core-zgypchmt.js";
+import {
+  createLogger,
+  init_logger
+} from "./roy-agent-core-44hnfb02.js";
+import {
+  __legacyDecorateClassTS,
+  __require
+} from "./roy-agent-core-fs0mn2jk.js";
+
+// src/env/llm/types.ts
+import { z } from "zod";
+var ProviderCapabilitiesSchema = z.object({
+  reasoning: z.boolean().optional(),
+  toolcall: z.boolean().optional(),
+  interleaved: z.object({
+    field: z.string()
+  }).optional(),
+  thinkingInText: z.object({
+    enabled: z.boolean().optional(),
+    tags: z.array(z.string()).optional(),
+    removeFromOutput: z.boolean().optional()
+  }).optional()
+});
+var ModelLimitsSchema = z.object({
+  contextWindow: z.number().int().positive(),
+  compactionThreshold: z.number().min(0).max(1).optional(),
+  maxOutputTokens: z.number().int().positive().optional()
+});
+var ProviderConfigSchema = z.object({
+  provider: z.string(),
+  name: z.string().optional(),
+  description: z.string().optional(),
+  apiKey: z.string(),
+  baseURL: z.string().optional(),
+  models: z.array(z.string()).optional(),
+  defaultModel: z.string().optional(),
+  temperature: z.number().min(0).max(2).optional(),
+  maxTokens: z.number().int().positive().optional(),
+  capabilities: ProviderCapabilitiesSchema.optional(),
+  limits: z.record(z.string(), ModelLimitsSchema).optional(),
+  providerOptions: z.record(z.unknown()).optional(),
+  options: z.record(z.unknown()).optional()
+});
+var LLMDefaultConfigSchema = z.object({
+  temperature: z.number().min(0).max(2).optional(),
+  maxTokens: z.number().int().positive().optional()
+});
+var LLMConfigSchema = z.object({
+  default: LLMDefaultConfigSchema.optional(),
+  defaultModel: z.string().optional(),
+  providers: z.record(z.string(), ProviderConfigSchema),
+  defaultProvider: z.string(),
+  temperature: z.number().min(0).max(2).default(0.7),
+  maxTokens: z.number().int().positive().optional(),
+  topP: z.number().min(0).max(1).optional(),
+  stream: z.boolean().default(true),
+  options: z.record(z.unknown()).optional()
+});
+// src/env/llm/provider.ts
+class ProviderManager {
+  providers = new Map;
+  async initialize(config) {
+    this.providers.clear();
+    for (const [id, providerConfig] of Object.entries(config.providers)) {
+      const resolvedConfig = await this.resolveProviderConfig(providerConfig);
+      const provider = this.createProvider(id, resolvedConfig);
+      this.providers.set(id, provider);
+    }
+  }
+  getProvider(id) {
+    return this.providers.get(id);
+  }
+  listProviders() {
+    return Array.from(this.providers.values());
+  }
+  async resolveProviderConfig(config) {
+    return {
+      ...config,
+      apiKey: await this.resolveEnvVar(config.apiKey),
+      baseURL: config.baseURL ? await this.resolveEnvVar(config.baseURL) : undefined
+    };
+  }
+  async resolveEnvVar(value) {
+    const envVarPattern = /\$\{([^}]+)\}/g;
+    const matches = [...value.matchAll(envVarPattern)];
+    if (matches.length === 0) {
+      return value;
+    }
+    let result = value;
+    for (const match of matches) {
+      const varName = match[1];
+      const envValue = process.env[varName];
+      if (envValue === undefined) {
+        throw new Error(`Environment variable ${varName} is not set`);
+      }
+      result = result.replace(match[0], envValue);
+    }
+    return result;
+  }
+  createProvider(id, config) {
+    return {
+      id,
+      provider: null,
+      models: config.models || []
+    };
+  }
+  createAIProvider(id, config, createFn) {
+    const providerInstance = createFn(config.apiKey, config.baseURL);
+    return {
+      id,
+      provider: providerInstance,
+      models: config.models || []
+    };
+  }
+}
+// src/env/llm/transform.ts
+class LLMTransform {
+  normalizeMessages(messages, providerType) {
+    return messages.map((msg) => {
+      switch (providerType) {
+        case "anthropic":
+          return this.normalizeForAnthropic(msg);
+        case "openai":
+        case "openai-compatible":
+        default:
+          return this.normalizeForOpenAI(msg);
+      }
+    });
+  }
+  normalizeForOpenAI(msg) {
+    return {
+      role: msg.role,
+      content: msg.content,
+      toolCalls: msg.toolCalls,
+      toolCallId: msg.toolCallId
+    };
+  }
+  normalizeForAnthropic(msg) {
+    if (msg.role === "tool") {
+      return {
+        role: "user",
+        content: msg.content,
+        toolCallId: msg.toolCallId
+      };
+    }
+    return msg;
+  }
+  extractToolSchema(tool) {
+    return {
+      name: tool.name,
+      description: tool.description,
+      parameters: tool.parameters
+    };
+  }
+  zodToJsonSchema(schema) {
+    return this.extractZodSchema(schema);
+  }
+  extractZodSchema(schema) {
+    const def = schema._def;
+    if (!def)
+      return {};
+    const typeName = def.typeName || "";
+    const type = def.type || "";
+    const isV3 = typeName.startsWith("Zod");
+    const isV4 = !isV3 && type !== "";
+    if (isV3 && typeName === "ZodObject" || isV4 && type === "object") {
+      let shape;
+      if (isV3) {
+        const shapeFn = def.shape;
+        shape = shapeFn ? shapeFn() : undefined;
+      } else {
+        shape = def.shape;
+      }
+      const properties = {};
+      const required = [];
+      if (shape) {
+        for (const [key, value] of Object.entries(shape)) {
+          properties[key] = this.extractZodSchema(value);
+          let isOptional = false;
+          if (isV3) {
+            const zodType = value;
+            isOptional = typeof zodType.isOptional === "function" ? zodType.isOptional() : false;
+          } else {
+            const innerDef = value._def;
+            isOptional = innerDef?.defaultValue !== undefined;
+          }
+          if (!isOptional) {
+            required.push(key);
+          }
+        }
+      }
+      return {
+        type: "object",
+        properties,
+        ...required.length > 0 ? { required } : {}
+      };
+    }
+    if (isV3 && typeName === "ZodEnum" || isV4 && type === "enum") {
+      const zodV3Enum = def;
+      const zodV4Enum = def;
+      const values = zodV3Enum.values || Object.values(zodV4Enum.entries || {});
+      return {
+        enum: values
+      };
+    }
+    if (isV3 && typeName === "ZodNativeEnum") {
+      const enumDef = def;
+      const values = Object.values(enumDef.values || {});
+      return {
+        enum: values
+      };
+    }
+    if (isV3 && typeName === "ZodString" || isV4 && type === "string") {
+      return { type: "string" };
+    }
+    if (isV3 && (typeName === "ZodNumber" || typeName === "ZodBigInt") || isV4 && (type === "number" || type === "bigint")) {
+      return { type: "number" };
+    }
+    if (isV3 && typeName === "ZodBoolean" || isV4 && type === "boolean") {
+      return { type: "boolean" };
+    }
+    if (isV3 && typeName === "ZodArray" || isV4 && type === "array") {
+      if (isV3) {
+        const itemsType = def.type;
+        if (itemsType) {
+          return {
+            type: "array",
+            items: this.extractZodSchema(itemsType)
+          };
+        }
+      }
+      const shape = def.shape;
+      if (shape) {
+        const itemKey = Object.keys(shape)[0];
+        const items = this.extractZodSchema(shape[itemKey]);
+        return {
+          type: "array",
+          items
+        };
+      }
+      return {
+        type: "array",
+        items: {}
+      };
+    }
+    if (isV3 && typeName === "ZodOptional" || isV4 && type === "optional") {
+      if (isV3) {
+        const innerType = def.innerType;
+        if (innerType) {
+          return this.extractZodSchema(innerType);
+        }
+      }
+      const shape = def.shape;
+      if (shape) {
+        const innerKey = Object.keys(shape).find((k) => k !== "undefinedType");
+        if (innerKey) {
+          return this.extractZodSchema(shape[innerKey]);
+        }
+      }
+      return {};
+    }
+    if (isV3 && typeName === "ZodNullable") {
+      const innerType = def.innerType;
+      if (innerType) {
+        return this.extractZodSchema(innerType);
+      }
+    }
+    return {};
+  }
+  formatToolResult(result) {
+    return {
+      role: "tool",
+      tool_call_id: result.toolCallId,
+      content: result.result,
+      ...result.isError ? { isError: true } : {}
+    };
+  }
+  parseToolArguments(args) {
+    if (!args || args.trim() === "") {
+      return {};
+    }
+    try {
+      return JSON.parse(args);
+    } catch {
+      return {};
+    }
+  }
+  serializeToolArguments(args) {
+    return JSON.stringify(args);
+  }
+}
+// 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;
+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 {
+              input = JSON.parse(tc.function.arguments);
+            } catch {
+              input = tc.function.arguments;
+            }
+          } else {
+            input = tc.function.arguments;
+          }
+        } else if (tc.arguments) {
+          if (typeof tc.arguments === "string") {
+            try {
+              input = JSON.parse(tc.arguments);
+            } catch {
+              input = 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 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 reasoningEvents = [];
+  let isOpen = state.isOpen;
+  let currentContent = 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 (!isOpen) {
+        isOpen = true;
+        currentContent = "";
+        reasoningEvents.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);
+        currentContent += thinkingContent;
+        reasoningEvents.push(currentContent);
+        isOpen = false;
+        currentContent = "";
+        result += afterClose;
+      } else {
+        currentContent += afterOpen;
+        reasoningEvents.push(currentContent);
+        result += "";
+      }
+      remainingText = result;
+    } else if (closeIndex !== -1) {
+      const beforeClose = text.substring(0, closeIndex);
+      const afterClose = text.substring(closeIndex + closeTag.length);
+      if (isOpen) {
+        currentContent += beforeClose;
+        reasoningEvents.push(currentContent);
+        isOpen = false;
+        currentContent = "";
+        result = afterClose;
+      } else {
+        result = text;
+      }
+      remainingText = result;
+    }
+  }
+  return {
+    cleanedText: remainingText,
+    isThinkingTagOpen: isOpen,
+    currentThinkingContent: currentContent,
+    reasoningEvents
+  };
+}
+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 = streamPart.text;
+          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 reasoningDelta2 of thinkingResult.reasoningEvents) {
+              reasoningContent = reasoningDelta2;
+              if (emitToEnv) {
+                emitToEnv({ type: "reasoning", content: reasoningContent });
+              }
+            }
+            if (emitToEnv) {
+              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 = streamPart.text;
+          reasoningContent += reasoningDelta;
+          if (emitToEnv) {
+            emitToEnv({ type: "reasoning", content: reasoningContent });
+          }
+          break;
+        case "tool-call":
+          const toolInput = streamPart.input;
+          const toolCallId = streamPart.toolCallId;
+          const toolName = streamPart.toolName;
+          toolCalls.push({
+            id: toolCallId,
+            name: toolName,
+            args: toolInput
+          });
+          if (emitToEnv) {
+            emitToEnv({
+              type: "tool_call",
+              toolCall: {
+                id: toolCallId,
+                name: toolName,
+                arguments: JSON.stringify(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
+  };
+}
+// src/env/llm/hooks.ts
+class LLMHookManager {
+  registrations = [];
+  register(type, handler, name) {
+    const registration = {
+      type,
+      name
+    };
+    switch (type) {
+      case "before-invoke":
+        registration.beforeInvoke = handler;
+        break;
+      case "after-invoke":
+        registration.afterInvoke = handler;
+        break;
+      case "stream":
+        registration.stream = handler;
+        break;
+    }
+    this.registrations.push(registration);
+    this.registerToGlobal(registration);
+  }
+  registerToGlobal(reg) {
+    const hookName = `llm:${reg.name || `anon-${reg.type}-${this.registrations.indexOf(reg)}`}`;
+    if (reg.beforeInvoke) {
+      globalHookManager.register(LLMHookPoints.BEFORE_INVOKE, {
+        name: hookName,
+        priority: 0,
+        execute: async (ctx) => {
+          await reg.beforeInvoke(ctx.data);
+        }
+      });
+    }
+    if (reg.afterInvoke) {
+      globalHookManager.register(LLMHookPoints.AFTER_INVOKE, {
+        name: hookName,
+        priority: 0,
+        execute: async (ctx) => {
+          const { request, providerId, model, metadata, result } = ctx.data;
+          await reg.afterInvoke({ request, providerId, model, metadata }, result);
+        }
+      });
+    }
+    if (reg.stream) {
+      globalHookManager.register(LLMHookPoints.ON_STREAM, {
+        name: hookName,
+        priority: 0,
+        execute: async (ctx) => {
+          const { request, providerId, model, metadata, event } = ctx.data;
+          await reg.stream({ request, providerId, model, metadata }, event);
+        }
+      });
+    }
+  }
+  unregister(hook) {
+    const index = this.registrations.findIndex((h) => {
+      return h.beforeInvoke === hook || h.afterInvoke === hook || h.stream === hook;
+    });
+    if (index !== -1) {
+      const reg = this.registrations[index];
+      this.unregisterFromGlobal(reg);
+      this.registrations.splice(index, 1);
+    }
+  }
+  unregisterFromGlobal(reg) {
+    const hookName = `llm:${reg.name || `anon-${reg.type}`}`;
+    globalHookManager.unregister(LLMHookPoints.BEFORE_INVOKE, hookName);
+    globalHookManager.unregister(LLMHookPoints.AFTER_INVOKE, hookName);
+    globalHookManager.unregister(LLMHookPoints.ON_STREAM, hookName);
+  }
+  unregisterByName(name) {
+    const hookName = `llm:${name}`;
+    globalHookManager.unregister(LLMHookPoints.BEFORE_INVOKE, hookName);
+    globalHookManager.unregister(LLMHookPoints.AFTER_INVOKE, hookName);
+    globalHookManager.unregister(LLMHookPoints.ON_STREAM, hookName);
+    this.registrations = this.registrations.filter((h) => h.name !== name);
+  }
+  unregisterByType(type) {
+    const filtered = this.registrations.filter((h) => h.type === type);
+    for (const reg of filtered) {
+      this.unregisterFromGlobal(reg);
+    }
+    this.registrations = this.registrations.filter((h) => h.type !== type);
+  }
+  clear() {
+    for (const reg of this.registrations) {
+      this.unregisterFromGlobal(reg);
+    }
+    this.registrations = [];
+  }
+  getHooks() {
+    return [...this.registrations];
+  }
+  getHooksByType(type) {
+    return this.registrations.filter((h) => h.type === type);
+  }
+}
+
+class LLMHooks {
+  hookManager = new LLMHookManager;
+  register(type, handler, name) {
+    this.hookManager.register(type, handler, name);
+  }
+  unregister(hook) {
+    this.hookManager.unregister(hook);
+  }
+  unregisterByName(name) {
+    this.hookManager.unregisterByName(name);
+  }
+  unregisterByType(type) {
+    this.hookManager.unregisterByType(type);
+  }
+  clear() {
+    this.hookManager.clear();
+  }
+  getHooks() {
+    return this.hookManager.getHooks();
+  }
+  getHooksByType(type) {
+    return this.hookManager.getHooksByType(type);
+  }
+  async executeBeforeInvoke(context) {
+    await globalHookManager.execute(LLMHookPoints.BEFORE_INVOKE, context);
+  }
+  async executeAfterInvoke(context, result) {
+    await globalHookManager.execute(LLMHookPoints.AFTER_INVOKE, { ...context, result });
+  }
+  async executeStream(context, event) {
+    await globalHookManager.execute(LLMHookPoints.ON_STREAM, { ...context, event });
+  }
+}
+// src/env/llm/llm.ts
+init_logger();
+init_decorator();
+var logger2 = createLogger("llm");
+
+class LLMComponent extends BaseComponent {
+  name = "llm";
+  version = "2.0.0";
+  configComponent;
+  configWatcher;
+  constructor() {
+    super();
+  }
+  async init(config) {
+    await super.init(config);
+    const options = config.options;
+    if (!options?.configComponent) {
+      throw new Error("ConfigComponent is required for LLMComponent initialization");
+    }
+    this.configComponent = options.configComponent;
+    await this.registerConfig(options);
+    this.setStatus("running");
+  }
+  async registerConfig(options) {
+    const configComponent = options.configComponent;
+    if (!configComponent)
+      return;
+    const { configPath, envPrefix, config } = options;
+    const prefix = envPrefix !== undefined ? envPrefix : "LLM";
+    const llmKeys = [
+      "llm.defaultModel",
+      "llm.defaultProvider",
+      "llm.temperature",
+      "llm.maxTokens",
+      "llm.topP",
+      "llm.stream",
+      "llm.providers",
+      "llm.limits",
+      "llm.capabilities"
+    ];
+    let fileSource = null;
+    if (configPath) {
+      configComponent.registerSource({
+        type: "file",
+        relativePath: configPath,
+        optional: true,
+        watch: false
+      });
+      configComponent.ensureSourcesCreated?.();
+      const sources = configComponent.getSources?.() || [];
+      fileSource = sources.find((s) => s.name === "file");
+      if (fileSource) {
+        for (const key of llmKeys) {
+          const value = fileSource.read?.(key);
+          if (value !== undefined) {
+            await configComponent.set(key, value);
+          }
+        }
+      }
+    }
+    configComponent.registerSource({
+      type: "env",
+      envPrefix: prefix,
+      priority: 20,
+      watch: false
+    });
+    configComponent.ensureSourcesCreated?.();
+    const sourcesAfterEnv = configComponent.getSources?.() || [];
+    const envSource = sourcesAfterEnv.find((s) => s.name === "env");
+    if (envSource) {
+      for (const key of llmKeys) {
+        const value = envSource.read?.(key);
+        if (value !== undefined) {
+          await configComponent.set(key, value);
+        }
+      }
+    }
+    for (const key of llmKeys) {
+      const envKey = toEnvKey(key, prefix);
+      const value = process.env[envKey];
+      if (value !== undefined) {
+        await configComponent.set(key, value);
+      }
+    }
+    const loadedKeys = new Set(llmKeys);
+    for (const envKey of Object.keys(process.env)) {
+      const configKey = envKeyToConfigKey(envKey, prefix, "llm");
+      if (!configKey)
+        continue;
+      if (loadedKeys.has(configKey))
+        continue;
+      loadedKeys.add(configKey);
+      const value = process.env[envKey];
+      if (value !== undefined) {
+        await configComponent.set(configKey, value);
+      }
+    }
+    if (config) {
+      const flatConfig = this.flattenConfig(config);
+      for (const [key, value] of Object.entries(flatConfig)) {
+        await configComponent.set(key, value);
+      }
+    }
+    this.registerConfigWatcher(configComponent);
+  }
+  flattenConfig(obj, prefix = "llm") {
+    const result = {};
+    for (const [key, value] of Object.entries(obj)) {
+      const fullKey = `${prefix}.${key}`;
+      if (value && typeof value === "object" && !Array.isArray(value)) {
+        Object.assign(result, this.flattenConfig(value, fullKey));
+      } else {
+        result[fullKey] = value;
+      }
+    }
+    return result;
+  }
+  registerConfigWatcher(configComponent) {
+    if (typeof configComponent.watch !== "function") {
+      logger2.debug("ConfigComponent does not support watch, hot reload disabled");
+      return;
+    }
+    this.configWatcher = configComponent.watch("llm.*", (event) => {
+      this.onConfigChange(event);
+    });
+    logger2.debug("Config hot reload watcher registered for llm.*");
+  }
+  onConfigChange(event) {
+    logger2.info(`LLM config changed: ${event.key}`);
+    if (event.key === "llm.providers" || event.key.startsWith("llm.providers.")) {
+      logger2.info(`LLM provider config changed, will use new config on next call`);
+    } else if (event.key === "llm.defaultModel") {
+      logger2.info(`LLM default model changed to: ${event.newValue}`);
+    } else if (event.key === "llm.defaultProvider") {
+      logger2.info(`LLM default provider changed to: ${event.newValue}`);
+    } else {
+      logger2.debug(`LLM config updated: ${event.key}`);
+    }
+  }
+  async onStart() {
+    if (this._status === "stopped") {
+      this.setStatus("running");
+    }
+  }
+  async onStop() {
+    this.configWatcher?.();
+    this.configWatcher = undefined;
+    this.setStatus("stopped");
+  }
+  getLLMConfig(key, defaultValue) {
+    if (this.configComponent) {
+      const value = this.configComponent.get(key);
+      if (value !== undefined) {
+        return value;
+      }
+    }
+    return defaultValue;
+  }
+  resolveRequest(request) {
+    const defaultModel = this.getLLMConfig("llm.defaultModel", "gpt-4o");
+    const defaultProvider = this.getLLMConfig("llm.defaultProvider", "openai");
+    const defaultTemperature = this.getLLMConfig("llm.temperature", 0.7);
+    const defaultMaxTokens = this.getLLMConfig("llm.maxTokens", 4096);
+    const defaultTopP = this.getLLMConfig("llm.topP", 1);
+    const model = request.model || defaultModel;
+    const providerId = request.providerId || defaultProvider;
+    const apiKey = this.getApiKey(providerId);
+    if (!apiKey) {
+      throw new Error(`API key not found for provider ${providerId}. Set providers.${providerId}.apiKey in config, or use \${env://...} protocol in config file.`);
+    }
+    const messages = request.messages.map((msg) => ({
+      role: msg.role,
+      content: msg.content,
+      name: msg.name,
+      toolCallId: msg.toolCallId,
+      toolCalls: msg.toolCalls
+    }));
+    return {
+      providerId,
+      model,
+      invokeConfig: {
+        model: `${providerId}/${model}`,
+        apiKey,
+        baseURL: this.getProvider(providerId)?.baseURL
+      },
+      messages,
+      temperature: request.temperature ?? defaultTemperature,
+      maxTokens: request.maxTokens ?? defaultMaxTokens,
+      topP: request.topP ?? defaultTopP,
+      abortSignal: request.abortSignal
+    };
+  }
+  async invoke(request) {
+    const startTime = Date.now();
+    if (this._status !== "running") {
+      throw new Error("LLMComponent is not running");
+    }
+    const ctx = this.resolveRequest(request);
+    let output = {
+      content: "",
+      reasoning: undefined,
+      finishReason: "stop"
+    };
+    let finishUsage;
+    const result = await invoke(ctx.invokeConfig, {
+      messages: ctx.messages,
+      model: ctx.invokeConfig.model,
+      temperature: ctx.temperature,
+      maxTokens: ctx.maxTokens,
+      tools: request.tools,
+      env: this.env,
+      context: {
+        sessionId: request.context?.sessionId,
+        messageId: request.context?.messageId
+      }
+    }, { abort: ctx.abortSignal });
+    if (result.isError) {
+      throw new Error(result.result);
+    }
+    try {
+      const parsed = JSON.parse(result.result);
+      output.content = parsed.content || "";
+      output.reasoning = parsed.reasoning || undefined;
+      output.finishReason = parsed.tool_calls?.length ? "tool-calls" : "stop";
+      output.toolCalls = parsed.tool_calls || [];
+      if (parsed.usage) {
+        finishUsage = {
+          promptTokens: parsed.usage.promptTokens ?? parsed.usage.inputTokens ?? 0,
+          completionTokens: parsed.usage.completionTokens ?? parsed.usage.outputTokens ?? 0,
+          totalTokens: parsed.usage.totalTokens ?? 0
+        };
+      }
+      output.usage = finishUsage;
+    } catch {
+      output.content = result.result;
+      output.finishReason = "stop";
+    }
+    const latencyMs = Date.now() - startTime;
+    if (!request.skipThresholdCheck) {
+      const sessionId = request.context?.sessionId;
+      const contextError = this.checkContextThreshold(finishUsage, ctx.providerId, ctx.model, sessionId);
+      if (contextError) {
+        contextError.llmOutput = {
+          content: output.content,
+          reasoning: output.reasoning,
+          toolCalls: output.toolCalls,
+          usage: output.usage
+        };
+        throw contextError;
+      }
+    }
+    return {
+      output,
+      providerId: ctx.providerId,
+      model: ctx.model,
+      latencyMs
+    };
+  }
+  getApiKey(providerId) {
+    const providers = this.getLLMConfig("llm.providers", {});
+    return providers?.[providerId]?.apiKey;
+  }
+  getProvider(id) {
+    const providers = this.getLLMConfig("llm.providers", {});
+    return providers?.[id];
+  }
+  listProviders() {
+    const providers = this.getLLMConfig("llm.providers", {});
+    return Object.keys(providers || {});
+  }
+  getModelLimits(providerId, modelId) {
+    const provider = this.getProvider(providerId);
+    if (!provider?.limits)
+      return;
+    const targetModel = modelId || provider.defaultModel;
+    if (!targetModel)
+      return;
+    return provider.limits[targetModel];
+  }
+  getContextThresholdConfig(providerId, modelId) {
+    const defaults = {
+      contextWindow: 128000,
+      thresholdRatio: 0.9
+    };
+    const limits = this.getModelLimits(providerId, modelId);
+    if (!limits)
+      return defaults;
+    return {
+      contextWindow: limits.contextWindow || defaults.contextWindow,
+      thresholdRatio: limits.compactionThreshold ?? defaults.thresholdRatio
+    };
+  }
+  checkContextThreshold(usage, providerId, modelId, sessionId) {
+    if (!usage)
+      return;
+    const config = this.getContextThresholdConfig(providerId, modelId);
+    const threshold = config.contextWindow * config.thresholdRatio;
+    if (usage.totalTokens >= threshold) {
+      return new ContextError(`Context threshold exceeded: ${usage.totalTokens}/${config.contextWindow} (${(usage.totalTokens / config.contextWindow * 100).toFixed(1)}%)`, ErrorCodes.CONTEXT_THRESHOLD_EXCEEDED, sessionId, {
+        promptTokens: usage.promptTokens ?? 0,
+        completionTokens: usage.completionTokens ?? 0,
+        totalTokens: usage.totalTokens
+      }, config.contextWindow);
+    }
+    return;
+  }
+}
+__legacyDecorateClassTS([
+  TracedAs("llm.component.invoke", { recordParams: true, recordResult: true, log: true })
+], LLMComponent.prototype, "invoke", null);
+export { ProviderCapabilitiesSchema, ModelLimitsSchema, ProviderConfigSchema, LLMDefaultConfigSchema, LLMConfigSchema, ProviderManager, LLMTransform, parseModelString, invoke, invokeNonStream, createInvokeConfig, LLMHooks, LLMComponent };