@nebutra/agents 1.1.1 → 1.1.2

package/README.md

@@ -41,7 +41,7 @@ integration hook lives here in `providers/langchain.ts` as an extension point.
 ```ts
 import { configure, streamText } from "@nebutra/agents";
 
-configure({ provider: "openrouter", defaultModel: "anthropic/claude-sonnet-4" });
+configure({ provider: "openrouter", defaultModel: "anthropic/claude-sonnet-4.6" });
 
 const result = await streamText(
   [{ role: "user", content: "Explain monorepos" }],
@@ -58,13 +58,13 @@ import { VercelAIAgent } from "@nebutra/agents/providers/vercel-ai";
 
 const orchestrator = new AgentOrchestrator({
   agents: [
-    { id: "assistant", name: "Assistant", description: "Helpful", model: "openai/gpt-4", instructions: "..." },
+    { id: "assistant", name: "Assistant", description: "Helpful", model: "openai/gpt-5.5", instructions: "..." },
   ],
 });
 
 // Swap the BaseAgent for a real VercelAIAgent at runtime:
 orchestrator.registerAgent(
-  new VercelAIAgent({ id: "assistant", name: "Assistant", description: "Helpful", model: "openai/gpt-4", instructions: "..." }),
+  new VercelAIAgent({ id: "assistant", name: "Assistant", description: "Helpful", model: "openai/gpt-5.5", instructions: "..." }),
 );
 
 const ctx = createAgentContext("org_123", "user_456");
@@ -76,3 +76,7 @@ const response = await orchestrator.chat("Hello", ctx);
 
 Every agent operation requires a `tenantId`. Usage events are emitted for
 billing and metering integration (see `@nebutra/billing/credits`).
+
+## License
+
+MIT

package/dist/{agent-CahnMASx.d.ts → agent-DDGWuUpe.d.ts}

@@ -1,4 +1,4 @@
-import { c as AgentConfig, A as AgentMessage, a as AgentContext, b as AgentResponse } from './types-NtgB3pch.js';
+import { c as AgentConfig, A as AgentMessage, a as AgentContext, b as AgentResponse } from './types-BytC-HfQ.js';
 
 /**
  * BaseAgent — abstract agent with memory, usage tracking, and tenant scoping.

package/{src/env.ts → dist/chunk-BMSL4E4A.js}

@@ -1,79 +1,55 @@
-/**
- * Environment validation for `@nebutra/agents`.
- *
- * All variables are OPTIONAL — the package must work with zero new env config.
- * Provider keys (OPENROUTER_API_KEY, OPENAI_API_KEY, ANTHROPIC_API_KEY, etc.)
- * are validated lazily by the provider resolver, not here.
- */
-
+// src/env.ts
 import { z } from "zod";
-
-/** Comma-separated provider chain. Order = priority. */
-const FallbackProviderName = z.enum(["openrouter", "anthropic", "openai"]);
-export type FallbackProviderName = z.infer<typeof FallbackProviderName>;
-
-const FallbackChain = z
-  .string()
-  .transform((raw) =>
-    raw
-      .split(",")
-      .map((s) => s.trim())
-      .filter(Boolean),
-  )
-  .pipe(z.array(FallbackProviderName).min(1));
-
-export const AgentsEnvSchema = z.object({
+var FallbackProviderName = z.enum(["openrouter", "anthropic", "openai"]);
+var FallbackChain = z.string().transform(
+  (raw) => raw.split(",").map((s) => s.trim()).filter(Boolean)
+).pipe(z.array(FallbackProviderName).min(1));
+var AgentsEnvSchema = z.object({
   // ── Anthropic (direct) ─────────────────────────────────────────────────
   ANTHROPIC_API_KEY: z.string().optional(),
-
   // ── Langfuse (LLM tracing — optional) ─────────────────────────────────
   LANGFUSE_PUBLIC_KEY: z.string().optional(),
   LANGFUSE_SECRET_KEY: z.string().optional(),
   LANGFUSE_HOST: z.string().url().default("https://cloud.langfuse.com"),
-
   // ── Multi-provider fallback chain ─────────────────────────────────────
   /**
    * Comma-separated chain of providers tried in order on retryable failures.
    * Default: "openrouter,anthropic,openai" — OpenRouter first (multi-model),
    * then direct Anthropic (prompt caching), then direct OpenAI as last resort.
    */
-  LLM_FALLBACK_CHAIN: FallbackChain.default((): FallbackProviderName[] => [
+  LLM_FALLBACK_CHAIN: FallbackChain.default(() => [
     "openrouter",
     "anthropic",
-    "openai",
+    "openai"
   ]),
-
   /**
    * Comma-separated chain of providers tried for EMBEDDINGS, in order.
    * Default: "openrouter,openai" — Anthropic does not currently expose
    * embedding models, so it is excluded by default. If unset, falls back
    * to LLM_FALLBACK_CHAIN with embedding-incompatible providers filtered out.
    */
-  LLM_EMBEDDING_FALLBACK_CHAIN: FallbackChain.default((): FallbackProviderName[] => [
+  LLM_EMBEDDING_FALLBACK_CHAIN: FallbackChain.default(() => [
     "openrouter",
-    "openai",
-  ]),
+    "openai"
+  ])
 });
-
-export type AgentsEnv = z.infer<typeof AgentsEnvSchema>;
-
-/** Lazy parsed env — re-read once on first call. */
-let _cached: AgentsEnv | undefined;
-
-/** Returns the validated env (cached). Safe to call from any runtime. */
-export function getAgentsEnv(): AgentsEnv {
+var _cached;
+function getAgentsEnv() {
   if (_cached) return _cached;
   _cached = AgentsEnvSchema.parse(globalThis.process?.env ?? {});
   return _cached;
 }
-
-/** Test helper — clears cache so updated process.env is picked up. */
-export function _resetAgentsEnvCache(): void {
-  _cached = undefined;
+function _resetAgentsEnvCache() {
+  _cached = void 0;
 }
-
-/** True iff Langfuse credentials are present. */
-export function isLangfuseConfigured(): boolean {
+function isLangfuseConfigured() {
   const env = getAgentsEnv();
   return Boolean(env.LANGFUSE_PUBLIC_KEY && env.LANGFUSE_SECRET_KEY);
 }
+
+export {
+  AgentsEnvSchema,
+  getAgentsEnv,
+  _resetAgentsEnvCache,
+  isLangfuseConfigured
+};

package/dist/{chunk-5JZJ5KMC.js → chunk-BZKIMAGK.js}

@@ -1,17 +1,17 @@
 // src/sdk/models.ts
 var models = {
   /** High-quality reasoning — default for complex tasks */
-  flagship: "anthropic/claude-sonnet-4",
+  flagship: "anthropic/claude-sonnet-4.6",
   /** Deep reasoning for architecture and research */
-  reasoning: "anthropic/claude-opus-4",
+  reasoning: "anthropic/claude-opus-4.8",
   /** Fast + cheap — chat, summaries, classification */
-  fast: "anthropic/claude-haiku-4",
+  fast: "anthropic/claude-haiku-4.5",
   /** OpenAI flagship */
-  "openai-flagship": "openai/gpt-5.4",
+  "openai-flagship": "openai/gpt-5.5",
   /** Google flagship */
-  "google-flagship": "google/gemini-2.5-pro",
+  "google-flagship": "google/gemini-3.1-pro-preview",
   /** Google fast */
-  "google-fast": "google/gemini-2.5-flash",
+  "google-fast": "google/gemini-3.5-flash",
   /** Embedding model */
   embedding: "openai/text-embedding-3-small",
   /** Embedding model (high-dimensional) */
@@ -22,7 +22,16 @@ var models = {
   /** SiliconFlow — DeepSeek R1 reasoning (via SiliconFlow Pro) */
   "sf-deepseek-r1": "Pro/deepseek-ai/DeepSeek-R1",
   /** SiliconFlow — DeepSeek V3 (fast, capable) */
-  "sf-deepseek-v3": "deepseek-ai/DeepSeek-V3"
+  "sf-deepseek-v3": "deepseek-ai/DeepSeek-V3",
+  // --- SenseNova Token Plan presets (use with provider: "sensenova") ---
+  // Base URL: https://token.sensenova.cn/v1
+  // Docs: https://github.com/OpenSenseNova/SenseNova6.7/blob/main/API_CN.md
+  /** SenseNova 6.7 Flash-Lite — small multimodal agent (default for i18n CI) */
+  "sn-flash-lite": "sensenova-6.7-flash-lite",
+  /** DeepSeek V4 Flash via SenseNova Token Plan — long context, cheap */
+  "sn-deepseek-flash": "deepseek-v4-flash",
+  /** Alias: prefer flash-lite for bulk translation */
+  "sn-translate": "sensenova-6.7-flash-lite"
 };
 function resolveModel(modelOrPreset) {
   if (modelOrPreset in models) {

package/dist/{chunk-NPQECBXL.js → chunk-GRSMUTUS.js}

@@ -1,20 +1,69 @@
-import {
-  runEmbedWithFallback
-} from "./chunk-5LX742GP.js";
 import {
   createModel
-} from "./chunk-RLWM437Q.js";
+} from "./chunk-RNFUEMUB.js";
 import {
   NebutraAIConfigSchema
-} from "./chunk-NVPE5EDI.js";
+} from "./chunk-V6VC2O6Q.js";
+import {
+  assertSafeOpenAIJsonPayload
+} from "./chunk-VZPQOXWW.js";
+import {
+  runEmbedWithFallback,
+  runWithFallback
+} from "./chunk-XLBS3XUI.js";
 
 // src/sdk/index.ts
 import {
   embed as _embed,
   embedMany as _embedMany,
-  generateText as _generateText,
+  generateText as _generateText2,
   streamText as _streamText
 } from "ai";
+
+// src/sdk/structured.ts
+import { generateText as _generateText, jsonSchema, tool } from "ai";
+import Ajv from "ajv";
+var ajv = new Ajv({ allErrors: true, strict: false });
+function validateStructured(value, schema) {
+  const validate = ajv.compile(schema);
+  if (!validate(value)) {
+    throw new Error(
+      `structured output failed schema validation: ${ajv.errorsText(validate.errors)}`
+    );
+  }
+}
+async function generateStructured(messages, schema, options = {}) {
+  assertSafeOpenAIJsonPayload("OpenAI structured request messages", messages);
+  assertSafeOpenAIJsonPayload("OpenAI structured output schema", schema);
+  const { result } = await runWithFallback(
+    (model) => _generateText({
+      model,
+      messages,
+      tools: {
+        _output: tool({
+          description: "Return the final result as a structured object matching the schema.",
+          inputSchema: jsonSchema(schema)
+        })
+      },
+      toolChoice: { type: "tool", toolName: "_output" }
+    }),
+    { model: options.model ?? "flagship" }
+  );
+  const call = result.toolCalls?.find((c) => c.toolName === "_output");
+  const output = call?.input ?? null;
+  validateStructured(output, schema);
+  const usage = result.usage;
+  return {
+    output,
+    usage: {
+      inputTokens: usage?.inputTokens ?? 0,
+      outputTokens: usage?.outputTokens ?? 0,
+      reasoningOutputTokens: usage?.reasoningTokens ?? 0
+    }
+  };
+}
+
+// src/sdk/index.ts
 var _resolved = NebutraAIConfigSchema.parse({});
 function configure(config = {}) {
   _resolved = NebutraAIConfigSchema.parse(config);
@@ -23,8 +72,9 @@ function getConfig() {
   return _resolved;
 }
 async function generateText(messages, options = {}) {
+  assertSafeOpenAIJsonPayload("OpenAI request messages", messages);
   const model = createModel(options.model ?? _resolved.defaultModel, _resolved);
-  return await _generateText({
+  return await _generateText2({
     model,
     messages,
     ...options.system ? { system: options.system } : {},
@@ -34,6 +84,7 @@ async function generateText(messages, options = {}) {
   });
 }
 async function streamText(messages, options = {}) {
+  assertSafeOpenAIJsonPayload("OpenAI request messages", messages);
   const model = createModel(options.model ?? _resolved.defaultModel, _resolved);
   const userOnFinish = options.onFinish;
   return _streamText({
@@ -73,6 +124,8 @@ async function embedMany(values, options = {}) {
 }
 
 export {
+  validateStructured,
+  generateStructured,
   configure,
   getConfig,
   generateText,

package/dist/{chunk-B7XWL35G.js → chunk-QYZDHC5A.js}

@@ -1,7 +1,7 @@
 import {
   getAgentsEnv,
   isLangfuseConfigured
-} from "./chunk-5LX742GP.js";
+} from "./chunk-BMSL4E4A.js";
 
 // src/observability.ts
 import { logger } from "@nebutra/logger";
@@ -28,6 +28,9 @@ async function initLangfuse() {
     return null;
   }
 }
+function _resetLangfuseCache() {
+  _client = void 0;
+}
 function buildTelemetryConfig(args) {
   if (!isLangfuseConfigured()) {
     return { isEnabled: false };
@@ -55,6 +58,7 @@ async function flushTelemetry() {
 
 export {
   initLangfuse,
+  _resetLangfuseCache,
   buildTelemetryConfig,
   flushTelemetry
 };

package/dist/{chunk-RLWM437Q.js → chunk-RNFUEMUB.js}

@@ -1,9 +1,9 @@
 import {
   resolveApiKey
-} from "./chunk-NVPE5EDI.js";
+} from "./chunk-V6VC2O6Q.js";
 import {
   resolveModel
-} from "./chunk-5JZJ5KMC.js";
+} from "./chunk-BZKIMAGK.js";
 
 // src/sdk/provider.ts
 import { createOpenAI } from "@ai-sdk/openai";
@@ -27,7 +27,14 @@ function createModel(modelOrPreset, config) {
     case "siliconflow": {
       const provider = createOpenAI({
         apiKey,
-        baseURL: "https://api.siliconflow.cn/v1"
+        baseURL: process.env.SILICONFLOW_BASE_URL ?? "https://api.siliconflow.cn/v1"
+      });
+      return provider(modelId);
+    }
+    case "sensenova": {
+      const provider = createOpenAI({
+        apiKey,
+        baseURL: process.env.SENSENOVA_BASE_URL ?? "https://token.sensenova.cn/v1"
       });
       return provider(modelId);
     }

package/dist/chunk-RWQL4HXC.js

@@ -0,0 +1,171 @@
+import {
+  isRetryableError
+} from "./chunk-XLBS3XUI.js";
+
+// src/generation/index.ts
+import { logger } from "@nebutra/logger";
+
+// src/generation/mock-provider.ts
+function hash(input) {
+  let h = 2166136261;
+  for (let i = 0; i < input.length; i++) {
+    h ^= input.charCodeAt(i);
+    h = Math.imul(h, 16777619);
+  }
+  return h >>> 0;
+}
+function escapeXml(s) {
+  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+function svgDataUri(label, prompt, w, h) {
+  const hue = hash(prompt) % 360;
+  const hue2 = (hue + 40) % 360;
+  const words = prompt.split(/\s+/);
+  const lines = [];
+  let cur = "";
+  for (const word of words) {
+    if ((cur + " " + word).trim().length > 32) {
+      lines.push(cur.trim());
+      cur = word;
+    } else {
+      cur = `${cur} ${word}`;
+    }
+    if (lines.length === 4) break;
+  }
+  if (cur && lines.length < 4) lines.push(cur.trim());
+  const tspans = lines.map((ln, i) => `<tspan x="50%" dy="${i === 0 ? 0 : 26}">${escapeXml(ln)}</tspan>`).join("");
+  const svg = `<svg xmlns="http://www.w3.org/2000/svg" width="${w}" height="${h}" viewBox="0 0 ${w} ${h}">
+<defs><linearGradient id="g" x1="0" y1="0" x2="1" y2="1">
+<stop offset="0" stop-color="hsl(${hue} 70% 55%)"/>
+<stop offset="1" stop-color="hsl(${hue2} 70% 45%)"/>
+</linearGradient></defs>
+<rect width="${w}" height="${h}" fill="url(#g)"/>
+<text x="50%" y="14%" fill="rgba(255,255,255,.7)" font-family="sans-serif" font-size="20" text-anchor="middle">${escapeXml(label)}</text>
+<text x="50%" y="46%" fill="#fff" font-family="sans-serif" font-size="22" font-weight="600" text-anchor="middle">${tspans}</text>
+</svg>`;
+  const b64 = typeof btoa === "function" ? btoa(unescape(encodeURIComponent(svg))) : Buffer.from(svg, "utf8").toString("base64");
+  return `data:image/svg+xml;base64,${b64}`;
+}
+var mockGenerationProvider = {
+  name: "mock",
+  envKey: null,
+  capabilities: ["image", "video"],
+  async generateImage(req, _ctx) {
+    const width = req.width ?? 1024;
+    const height = req.height ?? 1024;
+    return {
+      modality: "image",
+      mimeType: "image/svg+xml",
+      url: svgDataUri("mock \xB7 image", req.prompt, width, height),
+      width,
+      height,
+      providerName: "mock",
+      model: req.model ?? "mock-image-1",
+      usage: { units: 1 }
+    };
+  },
+  async generateVideo(req, _ctx) {
+    const width = req.width ?? 1280;
+    const height = req.height ?? 720;
+    const seconds = req.durationSeconds ?? 5;
+    return {
+      modality: "video",
+      mimeType: "image/svg+xml",
+      url: svgDataUri(`mock \xB7 video \xB7 ${seconds}s`, req.prompt, width, height),
+      width,
+      height,
+      providerName: "mock",
+      model: req.model ?? "mock-video-1",
+      usage: { units: seconds }
+    };
+  }
+};
+
+// src/generation/index.ts
+var log = logger.child({ module: "agents/generation" });
+var _registry = /* @__PURE__ */ new Map();
+function registerGenerationProvider(provider) {
+  _registry.set(provider.name, provider);
+}
+function _resetGenerationRegistry() {
+  _registry.clear();
+  _registry.set(mockGenerationProvider.name, mockGenerationProvider);
+}
+_resetGenerationRegistry();
+function hasEnvKey(provider) {
+  if (provider.envKey === null) return true;
+  return Boolean(globalThis.process?.env?.[provider.envKey]);
+}
+function listGenerationProviders(modality, options = {}) {
+  const envChain = (globalThis.process?.env?.GENERATION_FALLBACK_CHAIN ?? "").split(",").map((s) => s.trim()).filter(Boolean);
+  const preferred = options.chain ?? (envChain.length > 0 ? envChain : []);
+  const mockName = mockGenerationProvider.name;
+  const all = [...preferred, ..._registry.keys()];
+  const seen = /* @__PURE__ */ new Set();
+  const resolved = [];
+  for (const name of all) {
+    if (seen.has(name) || name === mockName) continue;
+    seen.add(name);
+    const provider = _registry.get(name);
+    if (!provider) continue;
+    if (!provider.capabilities.includes(modality)) continue;
+    if (!hasEnvKey(provider)) continue;
+    resolved.push(name);
+  }
+  resolved.push(mockName);
+  return resolved;
+}
+async function runChain(modality, options, ctx, invoke) {
+  const chain = listGenerationProviders(modality, options);
+  let lastErr;
+  for (const name of chain) {
+    const provider = _registry.get(name);
+    if (!provider) continue;
+    try {
+      const result = await invoke(provider);
+      log.debug("generation succeeded", {
+        provider: name,
+        modality,
+        tenantId: ctx.tenantId
+      });
+      return result;
+    } catch (err) {
+      lastErr = err;
+      const retryable = isRetryableError(err);
+      log.warn("generation provider failed", {
+        provider: name,
+        modality,
+        retryable,
+        tenantId: ctx.tenantId
+      });
+      if (!retryable && name !== mockGenerationProvider.name) continue;
+      if (!retryable) throw err;
+    }
+  }
+  throw lastErr instanceof Error ? lastErr : new Error("[@nebutra/agents] generation chain exhausted");
+}
+async function generateImage(req, ctx, options = {}) {
+  return runChain("image", options, ctx, (p) => {
+    if (!p.generateImage) {
+      throw new Error(`[@nebutra/agents] provider "${p.name}" lacks image support`);
+    }
+    return p.generateImage(req, ctx);
+  });
+}
+async function generateVideo(req, ctx, options = {}) {
+  return runChain("video", options, ctx, (p) => {
+    if (!p.generateVideo) {
+      throw new Error(`[@nebutra/agents] provider "${p.name}" lacks video support`);
+    }
+    return p.generateVideo(req, ctx);
+  });
+}
+
+export {
+  mockGenerationProvider,
+  registerGenerationProvider,
+  _resetGenerationRegistry,
+  listGenerationProviders,
+  generateImage,
+  generateVideo
+};

package/dist/{chunk-NVPE5EDI.js → chunk-V6VC2O6Q.js}

@@ -1,13 +1,13 @@
 // src/sdk/config.ts
 import { z } from "zod";
-var ProviderType = z.enum(["openrouter", "openai", "siliconflow", "gateway"]);
+var ProviderType = z.enum(["openrouter", "openai", "siliconflow", "sensenova", "gateway"]);
 var NebutraAIConfigSchema = z.object({
   /** Which provider backend to use. Defaults to "openrouter". */
   provider: ProviderType.default("openrouter"),
   /** API key override. Falls back to env vars per provider. */
   apiKey: z.string().optional(),
-  /** Default model identifier. Provider-specific format. */
-  defaultModel: z.string().default("anthropic/claude-sonnet-4"),
+  /** Default model id — OpenRouter / models.dev frontier (not Claude 3.x / GPT-4 era). */
+  defaultModel: z.string().default("anthropic/claude-sonnet-4.6"),
   /** Default temperature for generations. */
   temperature: z.number().min(0).max(2).default(0.7),
   /** Default max tokens for output. */
@@ -23,6 +23,7 @@ function resolveApiKey(config) {
     openrouter: "OPENROUTER_API_KEY",
     openai: "OPENAI_API_KEY",
     siliconflow: "SILICONFLOW_API_KEY",
+    sensenova: "SENSENOVA_API_KEY",
     gateway: "VERCEL_OIDC_TOKEN"
   };
   const envVar = envMap[config.provider];

package/dist/chunk-VZPQOXWW.js

@@ -0,0 +1,47 @@
+// src/sdk/payload-guard.ts
+var OPENAI_MAX_PROPERTY_NAME_LENGTH = 256;
+function isObjectLike(value) {
+  return typeof value === "object" && value !== null;
+}
+function pathSegment(key) {
+  const preview = key.length > 32 ? `${key.slice(0, 29)}...` : key;
+  return /^[A-Za-z_$][\w$]*$/.test(preview) ? `.${preview}` : `[${JSON.stringify(preview)}]`;
+}
+function findOversizedPropertyName(value, maxLength = OPENAI_MAX_PROPERTY_NAME_LENGTH) {
+  const seen = /* @__PURE__ */ new WeakSet();
+  function visit(candidate, path) {
+    if (!isObjectLike(candidate)) return null;
+    if (seen.has(candidate)) return null;
+    seen.add(candidate);
+    if (Array.isArray(candidate)) {
+      for (let index = 0; index < candidate.length; index += 1) {
+        const issue = visit(candidate[index], `${path}[${index}]`);
+        if (issue) return issue;
+      }
+      return null;
+    }
+    for (const [key, nested] of Object.entries(candidate)) {
+      const nestedPath = `${path}${pathSegment(key)}`;
+      if (key.length > maxLength) {
+        return { path: nestedPath, length: key.length };
+      }
+      const issue = visit(nested, nestedPath);
+      if (issue) return issue;
+    }
+    return null;
+  }
+  return visit(value, "$");
+}
+function assertSafeOpenAIJsonPayload(label, value) {
+  const issue = findOversizedPropertyName(value);
+  if (!issue) return;
+  throw new Error(
+    `${label} contains an object property name at ${issue.path} that is ${issue.length} characters long; maximum is ${OPENAI_MAX_PROPERTY_NAME_LENGTH}. Put generated text in a string value instead of using it as a JSON key.`
+  );
+}
+
+export {
+  OPENAI_MAX_PROPERTY_NAME_LENGTH,
+  findOversizedPropertyName,
+  assertSafeOpenAIJsonPayload
+};

package/dist/{chunk-5LX742GP.js → chunk-XLBS3XUI.js}

@@ -1,52 +1,9 @@
 import {
   resolveModel
-} from "./chunk-5JZJ5KMC.js";
-
-// src/env.ts
-import { z } from "zod";
-var FallbackProviderName = z.enum(["openrouter", "anthropic", "openai"]);
-var FallbackChain = z.string().transform(
-  (raw) => raw.split(",").map((s) => s.trim()).filter(Boolean)
-).pipe(z.array(FallbackProviderName).min(1));
-var AgentsEnvSchema = z.object({
-  // ── Anthropic (direct) ─────────────────────────────────────────────────
-  ANTHROPIC_API_KEY: z.string().optional(),
-  // ── Langfuse (LLM tracing — optional) ─────────────────────────────────
-  LANGFUSE_PUBLIC_KEY: z.string().optional(),
-  LANGFUSE_SECRET_KEY: z.string().optional(),
-  LANGFUSE_HOST: z.string().url().default("https://cloud.langfuse.com"),
-  // ── Multi-provider fallback chain ─────────────────────────────────────
-  /**
-   * Comma-separated chain of providers tried in order on retryable failures.
-   * Default: "openrouter,anthropic,openai" — OpenRouter first (multi-model),
-   * then direct Anthropic (prompt caching), then direct OpenAI as last resort.
-   */
-  LLM_FALLBACK_CHAIN: FallbackChain.default(() => [
-    "openrouter",
-    "anthropic",
-    "openai"
-  ]),
-  /**
-   * Comma-separated chain of providers tried for EMBEDDINGS, in order.
-   * Default: "openrouter,openai" — Anthropic does not currently expose
-   * embedding models, so it is excluded by default. If unset, falls back
-   * to LLM_FALLBACK_CHAIN with embedding-incompatible providers filtered out.
-   */
-  LLM_EMBEDDING_FALLBACK_CHAIN: FallbackChain.default(() => [
-    "openrouter",
-    "openai"
-  ])
-});
-var _cached;
-function getAgentsEnv() {
-  if (_cached) return _cached;
-  _cached = AgentsEnvSchema.parse(globalThis.process?.env ?? {});
-  return _cached;
-}
-function isLangfuseConfigured() {
-  const env = getAgentsEnv();
-  return Boolean(env.LANGFUSE_PUBLIC_KEY && env.LANGFUSE_SECRET_KEY);
-}
+} from "./chunk-BZKIMAGK.js";
+import {
+  getAgentsEnv
+} from "./chunk-BMSL4E4A.js";
 
 // src/fallback.ts
 import { logger } from "@nebutra/logger";
@@ -212,9 +169,6 @@ async function runEmbedWithFallback(invoke, options = {}) {
 }
 
 export {
-  AgentsEnvSchema,
-  getAgentsEnv,
-  isLangfuseConfigured,
   filterAvailableProviders,
   isRetryableError,
   runWithFallback,