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

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

@@ -1,1316 +0,0 @@
-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 };