@ai-setting/roy-agent-core 1.6.42 → 1.7.1

package/dist/shared/@ai-setting/{roy-agent-core-7wv7gh6t.js → roy-agent-core-w93wrd77.js}

@@ -1,13 +1,14 @@
 import {
   EnvSource
 } from "./roy-agent-core-y3g3ar7a.js";
-import {
-  invoke
-} from "./roy-agent-core-c1stgqnw.js";
 import {
   ContextError,
   ErrorCodes
 } from "./roy-agent-core-ctdhjv68.js";
+import {
+  invoke,
+  invokeNonStream
+} from "./roy-agent-core-2xb3f3ye.js";
 import {
   envKeyToConfigKey,
   toEnvKey
@@ -22,16 +23,467 @@ import {
 } from "./roy-agent-core-j29yg06n.js";
 import {
   TracedAs,
-  init_decorator
+  init_decorator,
+  wrapFunction
 } from "./roy-agent-core-gb7pm9c0.js";
 import {
   createLogger,
   init_logger
 } from "./roy-agent-core-kaq037np.js";
 import {
-  __legacyDecorateClassTS
+  __legacyDecorateClassTS,
+  __require
 } from "./roy-agent-core-fs0mn2jk.js";
 
+// src/env/llm/adapter.ts
+var ADAPTER_NAMES = ["pi-ai", "ai-sdk"];
+// src/env/llm/adapter-pi-ai.ts
+init_decorator();
+init_logger();
+import {
+  complete,
+  stream as piStream,
+  getModel
+} from "@earendil-works/pi-ai";
+import { zodToJsonSchema } from "zod-to-json-schema";
+var logger = createLogger("llm:adapter-pi-ai");
+var KNOWN_PROVIDER_APIS = {
+  anthropic: { api: "anthropic-messages", contextLimit: 200000, maxTokensLimit: 8192 },
+  openai: { api: "openai-responses", contextLimit: 128000, maxTokensLimit: 16384 },
+  google: { api: "google-generative-ai", contextLimit: 1e6, maxTokensLimit: 8192 },
+  "google-vertex": { api: "google-vertex", contextLimit: 1e6, maxTokensLimit: 8192 },
+  deepseek: { api: "openai-completions", contextLimit: 64000, maxTokensLimit: 8192 },
+  xai: { api: "openai-completions", contextLimit: 131072, maxTokensLimit: 8192 },
+  groq: { api: "openai-completions", contextLimit: 32768, maxTokensLimit: 8192 },
+  minimax: { api: "openai-completions", contextLimit: 128000, maxTokensLimit: 8192 },
+  "minimax-cn": { api: "openai-completions", contextLimit: 128000, maxTokensLimit: 8192 },
+  moonshotai: { api: "openai-completions", contextLimit: 128000, maxTokensLimit: 8192 },
+  "kimi-coding": { api: "openai-completions", contextLimit: 128000, maxTokensLimit: 8192 }
+};
+function resolvePiModel(provider, modelId, baseURL) {
+  const builtIn = getModel(provider, modelId);
+  if (builtIn)
+    return baseURL ? { ...builtIn, baseUrl: baseURL } : builtIn;
+  const providerApiOverride = {
+    "minimax-responses": "openai-responses",
+    "minimax-openai": "openai-completions"
+  };
+  let configuredApi;
+  if (providerApiOverride[provider]) {
+    configuredApi = providerApiOverride[provider];
+  } else if (provider === "minimax" || provider === "minimax-cn") {
+    configuredApi = baseURL?.includes("anthropic") ? "anthropic-messages" : "openai-completions";
+  } else if (baseURL?.includes("/responses")) {
+    configuredApi = "openai-responses";
+  } else if (baseURL?.includes("anthropic")) {
+    configuredApi = "anthropic-messages";
+  } else {
+    configuredApi = KNOWN_PROVIDER_APIS[provider]?.api || "openai-completions";
+  }
+  return {
+    id: modelId,
+    name: modelId,
+    api: configuredApi,
+    provider,
+    baseUrl: baseURL || "",
+    reasoning: false,
+    input: ["text"],
+    cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+    contextWindow: KNOWN_PROVIDER_APIS[provider]?.contextLimit || 128000,
+    maxTokens: KNOWN_PROVIDER_APIS[provider]?.maxTokensLimit || 8192
+  };
+}
+function toPiMessages(messages) {
+  const out = [];
+  const ts = Date.now();
+  for (const m of messages) {
+    if (m.role === "system")
+      continue;
+    if (m.role === "user") {
+      if (typeof m.content === "string") {
+        out.push({ role: "user", content: m.content, timestamp: ts });
+      } else {
+        out.push({ role: "user", content: m.content.flatMap((c) => {
+          if (c.type === "text")
+            return [{ type: "text", text: c.text }];
+          if (c.type === "image")
+            return [{ type: "image", data: c.image instanceof Uint8Array ? Buffer.from(c.image).toString("base64") : c.image, mimeType: "image/*" }];
+          return [{ type: "text", text: `[file:${c.mediaType}] ${typeof c.file === "string" ? c.file : Buffer.from(c.file).toString("base64")}` }];
+        }), timestamp: ts });
+      }
+      continue;
+    }
+    if (m.role === "tool") {
+      out.push({ role: "toolResult", toolCallId: m.toolCallId || "", toolName: m.name || "", content: [{ type: "text", text: typeof m.content === "string" ? m.content : JSON.stringify(m.content) }], isError: false, timestamp: ts });
+      continue;
+    }
+    const content = [];
+    if (typeof m.content === "string" && m.content)
+      content.push({ type: "text", text: m.content });
+    else if (Array.isArray(m.content))
+      for (const c of m.content) {
+        if (c.type === "text")
+          content.push({ type: "text", text: c.text });
+        else if (c.type === "image")
+          content.push({ type: "image", data: c.image instanceof Uint8Array ? Buffer.from(c.image).toString("base64") : c.image, mimeType: "image/*" });
+        else
+          content.push({ type: "text", text: `[file:${c.mediaType}] ${typeof c.file === "string" ? c.file : Buffer.from(c.file).toString("base64")}` });
+      }
+    for (const tc of m.toolCalls || [])
+      content.push({ type: "toolCall", id: tc.id, name: tc.name, arguments: safeJson(tc.arguments) });
+    out.push({ role: "assistant", content, api: "openai-completions", model: "", provider: "", usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, totalTokens: 0, cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 } }, stopReason: "stop", timestamp: ts });
+  }
+  return out;
+}
+function extractSystemPrompt(messages) {
+  const prompts = messages.filter((m) => m.role === "system").map((m) => typeof m.content === "string" ? m.content : m.content.filter((c) => c.type === "text").map((c) => c.text).join(""));
+  return prompts.length ? prompts.join(`
+
+`) : undefined;
+}
+function safeJson(s) {
+  try {
+    return JSON.parse(s);
+  } catch (e) {
+    logger.warn(`[safeJson] JSON.parse failed`, {
+      parse_failed: true,
+      input_length: s.length,
+      error: e.message
+    });
+    return {};
+  }
+}
+function isZodSchema(obj) {
+  return !!obj && typeof obj === "object" && "_def" in obj;
+}
+function convertToolParameters(parameters) {
+  if (parameters == null)
+    return { type: "object", properties: {} };
+  if (typeof parameters !== "object")
+    return { type: "object", properties: {} };
+  if (isZodSchema(parameters)) {
+    try {
+      const jsonSchema = zodToJsonSchema(parameters, "zod");
+      if ("$ref" in jsonSchema && jsonSchema.definitions) {
+        const def = jsonSchema.definitions.zod;
+        if (def && def.type === "object" && def.properties) {
+          return def;
+        }
+      }
+      return jsonSchema;
+    } catch {
+      return { type: "object", properties: {} };
+    }
+  }
+  const paramsObj = parameters;
+  if (paramsObj.type === "object" && paramsObj.properties) {
+    return paramsObj;
+  }
+  return { type: "object", properties: {} };
+}
+function toPiTools(tools) {
+  if (!tools)
+    return;
+  return tools.map((t) => ({
+    name: t.name,
+    description: t.description || "",
+    parameters: convertToolParameters(t.parameters)
+  }));
+}
+function fromAssistantMessage(msg) {
+  let text = "";
+  const toolCalls = [];
+  for (const block of msg.content) {
+    const b = block;
+    if (b.type === "text") {
+      text += b.text || "";
+    } else if (b.type === "toolCall") {
+      toolCalls.push({
+        id: b.id || "",
+        name: b.name || "",
+        arguments: typeof b.arguments === "string" ? b.arguments : JSON.stringify(b.arguments ?? {})
+      });
+    }
+  }
+  return {
+    text,
+    finishReason: msg.stopReason || "stop",
+    toolCalls: toolCalls.length ? toolCalls : undefined,
+    usage: {
+      promptTokens: msg.usage?.input ?? 0,
+      completionTokens: msg.usage?.output ?? 0,
+      totalTokens: msg.usage?.totalTokens ?? 0,
+      cacheRead: msg.usage?.cacheRead,
+      cacheWrite: msg.usage?.cacheWrite
+    },
+    raw: msg
+  };
+}
+
+class EmbeddingNotSupportedError extends Error {
+  constructor(adapter) {
+    super(`Embedding is not supported by ${adapter}; use AiSdkAdapter.embed() or apply at higher layer.`);
+    this.name = "EmbeddingNotSupportedError";
+  }
+}
+
+class PiAiAdapter {
+  name = "pi-ai";
+  async chat(req) {
+    const model = resolvePiModel(req.provider, req.modelId, req.baseURL);
+    const ctx = {
+      systemPrompt: [req.systemPrompt, extractSystemPrompt(req.messages)].filter(Boolean).join(`
+
+`) || undefined,
+      messages: toPiMessages(req.messages),
+      tools: toPiTools(req.tools)
+    };
+    const msg = await complete(model, ctx, {
+      apiKey: req.apiKey,
+      baseURL: req.baseURL,
+      temperature: req.temperature,
+      maxTokens: req.maxTokens,
+      signal: req.signal
+    });
+    return fromAssistantMessage(msg);
+  }
+  async stream(req) {
+    const model = resolvePiModel(req.provider, req.modelId, req.baseURL);
+    const ctx = {
+      systemPrompt: [req.systemPrompt, extractSystemPrompt(req.messages)].filter(Boolean).join(`
+
+`) || undefined,
+      messages: toPiMessages(req.messages),
+      tools: toPiTools(req.tools)
+    };
+    const eventStream = piStream(model, ctx, { apiKey: req.apiKey, baseURL: req.baseURL, temperature: req.temperature, maxTokens: req.maxTokens, signal: req.signal });
+    return { events: eventStream, result: async () => fromAssistantMessage(await eventStream.result()) };
+  }
+  async embed(_req) {
+    throw new EmbeddingNotSupportedError(this.name);
+  }
+  async resolveProvider(provider, modelId) {
+    const model = resolvePiModel(provider, modelId);
+    const caps = KNOWN_PROVIDER_APIS[provider] || {
+      api: model.api,
+      contextLimit: model.contextWindow,
+      maxTokensLimit: model.maxTokens
+    };
+    return {
+      api: model.api,
+      provider,
+      modelId,
+      contextLimit: caps.contextLimit,
+      maxTokensLimit: caps.maxTokensLimit
+    };
+  }
+}
+__legacyDecorateClassTS([
+  TracedAs("llm.adapter.chat", {
+    recordParams: true,
+    recordResult: true,
+    log: true,
+    paramFilter: (args) => {
+      const req = args[0];
+      return {
+        provider: req?.provider,
+        model_id: req?.modelId,
+        messages_count: req?.messages?.length,
+        tools_count: req?.tools?.length,
+        temperature: req?.temperature,
+        max_tokens: req?.maxTokens
+      };
+    },
+    resultFilter: (r) => ({
+      finish_reason: r?.finishReason,
+      usage_input: r?.usage?.promptTokens,
+      usage_output: r?.usage?.completionTokens,
+      usage_total: r?.usage?.totalTokens,
+      content_length: r?.text?.length
+    })
+  })
+], PiAiAdapter.prototype, "chat", null);
+__legacyDecorateClassTS([
+  TracedAs("llm.adapter.stream", {
+    recordParams: true,
+    recordResult: false,
+    log: true,
+    paramFilter: (args) => {
+      const req = args[0];
+      return {
+        provider: req?.provider,
+        model_id: req?.modelId,
+        messages_count: req?.messages?.length
+      };
+    }
+  })
+], PiAiAdapter.prototype, "stream", null);
+__legacyDecorateClassTS([
+  TracedAs("llm.adapter.embed", { recordParams: true, recordResult: false, log: true })
+], PiAiAdapter.prototype, "embed", null);
+__legacyDecorateClassTS([
+  TracedAs("llm.adapter.resolve_provider", {
+    recordParams: true,
+    recordResult: true,
+    log: true,
+    paramFilter: (args) => ({
+      provider: args[0],
+      model_id: args[1]
+    }),
+    resultFilter: (r) => ({
+      api: r?.api,
+      context_limit: r?.contextLimit,
+      max_tokens_limit: r?.maxTokensLimit
+    })
+  })
+], PiAiAdapter.prototype, "resolveProvider", null);
+// src/env/llm/adapter-ai-sdk.ts
+init_decorator();
+import { embed as aiEmbed, embedMany as aiEmbedMany } from "ai";
+class AiSdkAdapter {
+  name = "ai-sdk";
+  async chat(req) {
+    const config = this.toInvokeConfig(req);
+    const opts = this.toInvokeOptions(req);
+    const ctx = { abort: req.signal };
+    const out = await invokeNonStream(config, opts, ctx);
+    return {
+      text: out.content || "",
+      finishReason: out.finishReason || "stop",
+      toolCalls: out.toolCalls?.map((tc) => ({
+        id: tc.id,
+        name: tc.name,
+        arguments: tc.arguments
+      })),
+      usage: out.usage || { promptTokens: 0, completionTokens: 0, totalTokens: 0 },
+      raw: out
+    };
+  }
+  async stream(req) {
+    const config = this.toInvokeConfig(req);
+    const opts = this.toInvokeOptions(req);
+    const ctx = { abort: req.signal };
+    let output;
+    const events = async function* () {
+      output = await invoke(config, opts, ctx);
+      yield output;
+    }();
+    return {
+      events,
+      result: async () => ({
+        text: output?.content || "",
+        finishReason: output?.finishReason || "stop",
+        toolCalls: output?.toolCalls?.map((tc) => ({
+          id: tc.id,
+          name: tc.name,
+          arguments: tc.arguments
+        })),
+        usage: output?.usage || { promptTokens: 0, completionTokens: 0, totalTokens: 0 },
+        raw: output
+      })
+    };
+  }
+  async embed(req) {
+    const { createOpenAICompatible } = await import("@ai-sdk/openai-compatible");
+    const provider = createOpenAICompatible({ name: req.provider, apiKey: req.apiKey, baseURL: req.baseURL });
+    const model = provider.textEmbeddingModel(req.modelId);
+    const values = Array.isArray(req.input) ? req.input : [req.input];
+    const result = values.length === 1 ? { embeddings: [(await aiEmbed({ model, value: values[0], abortSignal: req.signal })).embedding] } : await aiEmbedMany({ model, values, abortSignal: req.signal });
+    return { embeddings: result.embeddings, usage: { promptTokens: 0, completionTokens: 0, totalTokens: 0 } };
+  }
+  async resolveProvider(provider, modelId) {
+    return {
+      api: provider === "anthropic" ? "anthropic-messages" : "openai-completions",
+      provider,
+      modelId,
+      contextLimit: 0,
+      maxTokensLimit: 0
+    };
+  }
+  toInvokeConfig(req) {
+    return {
+      model: `${req.provider}/${req.modelId}`,
+      baseURL: req.baseURL,
+      apiKey: req.apiKey
+    };
+  }
+  toInvokeOptions(req) {
+    return {
+      messages: req.messages,
+      tools: req.tools,
+      temperature: req.temperature,
+      maxTokens: req.maxTokens,
+      model: req.modelId
+    };
+  }
+}
+__legacyDecorateClassTS([
+  TracedAs("llm.adapter.ai_sdk.chat", {
+    recordParams: true,
+    recordResult: true,
+    log: true,
+    paramFilter: (args) => {
+      const req = args[0];
+      return {
+        provider: req?.provider,
+        model_id: req?.modelId,
+        messages_count: req?.messages?.length
+      };
+    },
+    resultFilter: (r) => ({
+      finish_reason: r?.finishReason,
+      usage_input: r?.usage?.promptTokens,
+      usage_output: r?.usage?.completionTokens
+    })
+  })
+], AiSdkAdapter.prototype, "chat", null);
+__legacyDecorateClassTS([
+  TracedAs("llm.adapter.ai_sdk.stream", {
+    recordParams: true,
+    recordResult: false,
+    log: true
+  })
+], AiSdkAdapter.prototype, "stream", null);
+__legacyDecorateClassTS([
+  TracedAs("llm.adapter.ai_sdk.embed", { recordParams: true, recordResult: true, log: true })
+], AiSdkAdapter.prototype, "embed", null);
+__legacyDecorateClassTS([
+  TracedAs("llm.adapter.ai_sdk.resolve_provider", {
+    recordParams: true,
+    recordResult: true,
+    log: true
+  })
+], AiSdkAdapter.prototype, "resolveProvider", null);
+// src/env/llm/factory.ts
+init_decorator();
+var runtimeOverride;
+function setLLMProvider(name) {
+  runtimeOverride = name;
+}
+function getLLMProviderOverride() {
+  return runtimeOverride;
+}
+var _createLLMAdapter = function _createLLMAdapter2() {
+  const arg = runtimeOverride ?? process.env.ROY_LLM_PROVIDER ?? "pi-ai";
+  switch (arg) {
+    case "pi-ai":
+      return new PiAiAdapter;
+    case "ai-sdk":
+      return new AiSdkAdapter;
+    default:
+      throw new Error(`Invalid ROY_LLM_PROVIDER value: "${arg}". Expected: pi-ai | ai-sdk`);
+  }
+};
+var createLLMAdapter = wrapFunction(_createLLMAdapter, "llm.adapter.factory", {
+  recordParams: false,
+  recordResult: true,
+  log: true,
+  resultFilter: (_r) => ({
+    adapter_name: _r?.name,
+    env_arg: process.env.ROY_LLM_PROVIDER ?? null,
+    runtime_override: runtimeOverride ?? null
+  })
+});
 // src/env/llm/types.ts
 import { z } from "zod";
 var ProviderCapabilitiesSchema = z.object({
@@ -450,13 +902,16 @@ class LLMHooks {
 // src/env/llm/llm.ts
 init_logger();
 init_decorator();
-var logger = createLogger("llm");
+import { randomUUID } from "crypto";
+var logger2 = createLogger("llm");
 
 class LLMComponent extends BaseComponent {
   name = "llm";
   version = "2.0.0";
   configComponent;
   configWatcher;
+  cachedAdapter;
+  cachedAdapterProvider;
   constructor() {
     super();
   }
@@ -562,7 +1017,7 @@ class LLMComponent extends BaseComponent {
         componentName: "llm",
         knownKeys,
         logger: {
-          warn: (msg) => logger.warn(msg)
+          warn: (msg) => logger2.warn(msg)
         }
       });
     }
@@ -596,24 +1051,24 @@ class LLMComponent extends BaseComponent {
   }
   registerConfigWatcher(configComponent) {
     if (typeof configComponent.watch !== "function") {
-      logger.debug("ConfigComponent does not support watch, hot reload disabled");
+      logger2.debug("ConfigComponent does not support watch, hot reload disabled");
       return;
     }
     this.configWatcher = configComponent.watch("llm.*", (event) => {
       this.onConfigChange(event);
     });
-    logger.debug("Config hot reload watcher registered for llm.*");
+    logger2.debug("Config hot reload watcher registered for llm.*");
   }
   onConfigChange(event) {
-    logger.info(`LLM config changed: ${event.key}`);
+    logger2.info(`LLM config changed: ${event.key}`);
     if (event.key === "llm.providers" || event.key.startsWith("llm.providers.")) {
-      logger.info(`LLM provider config changed, will use new config on next call`);
+      logger2.info(`LLM provider config changed, will use new config on next call`);
     } else if (event.key === "llm.defaultModel") {
-      logger.info(`LLM default model changed to: ${event.newValue}`);
+      logger2.info(`LLM default model changed to: ${event.newValue}`);
     } else if (event.key === "llm.defaultProvider") {
-      logger.info(`LLM default provider changed to: ${event.newValue}`);
+      logger2.info(`LLM default provider changed to: ${event.newValue}`);
     } else {
-      logger.debug(`LLM config updated: ${event.key}`);
+      logger2.debug(`LLM config updated: ${event.key}`);
     }
   }
   async onStart() {
@@ -691,52 +1146,177 @@ class LLMComponent extends BaseComponent {
       abortSignal: request.abortSignal
     };
   }
+  getAdapter() {
+    const currentProvider = process.env.ROY_LLM_PROVIDER || "pi-ai";
+    if (this.cachedAdapter && this.cachedAdapterProvider === currentProvider) {
+      return this.cachedAdapter;
+    }
+    this.cachedAdapter = createLLMAdapter();
+    this.cachedAdapterProvider = currentProvider;
+    return this.cachedAdapter;
+  }
+  invalidateAdapterCache() {
+    this.cachedAdapter = undefined;
+    this.cachedAdapterProvider = undefined;
+  }
   async invoke(request) {
     const startTime = Date.now();
     if (this._status !== "running") {
       throw new Error("LLMComponent is not running");
     }
     const ctx = this.resolveRequest(request);
+    const adapter = this.getAdapter();
+    const chatReq = {
+      provider: ctx.providerId,
+      modelId: ctx.model,
+      messages: ctx.messages,
+      tools: request.tools,
+      systemPrompt: undefined,
+      temperature: ctx.temperature,
+      maxTokens: ctx.maxTokens,
+      apiKey: ctx.invokeConfig.apiKey || "",
+      baseURL: ctx.invokeConfig.baseURL,
+      signal: ctx.abortSignal
+    };
     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
-      },
-      toolChoice: request.toolChoice
-    }, { abort: ctx.abortSignal });
-    if (result.isError) {
-      throw new Error(result.result);
+    let resp;
+    try {
+      const streamHandle = await adapter.stream(chatReq);
+      resp = await this.consumeStreamAndGetResult(streamHandle, request, ctx);
+      if (resp.finishReason === "error") {
+        throw new Error(resp.raw?.errorMessage || "adapter returned an error response");
+      }
+    } catch (adapterErr) {
+      logger2.warn(`[LLMComponent.invoke] adapter(${adapter.name}) failed, falling back to AI SDK invoke: ${adapterErr.message}`);
+      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
+        },
+        toolChoice: request.toolChoice
+      }, { 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";
+      }
+      return this.finalizeOutput(request, ctx, output, finishUsage, startTime, `adapter-fallback:${adapter.name}`);
     }
+    output.content = resp.text || "";
+    output.finishReason = resp.finishReason;
+    output.toolCalls = resp.toolCalls || [];
+    if (resp.usage) {
+      finishUsage = {
+        promptTokens: resp.usage.promptTokens ?? 0,
+        completionTokens: resp.usage.completionTokens ?? 0,
+        totalTokens: resp.usage.totalTokens ?? 0
+      };
+    }
+    output.usage = finishUsage;
+    return this.finalizeOutput(request, ctx, output, finishUsage, startTime, adapter.name);
+  }
+  async consumeStreamAndGetResult(streamHandle, request, ctx) {
+    let accumulatedText = "";
+    let accumulatedReasoning = "";
+    let capturedResult;
+    const emitEnvEvent = (fullType, payload) => {
+      try {
+        this.env?.pushEnvEvent?.({
+          id: randomUUID(),
+          type: fullType,
+          timestamp: Date.now(),
+          metadata: {
+            source: "llm.adapter.stream",
+            sessionId: request.context?.sessionId,
+            messageId: request.context?.messageId,
+            provider: ctx.providerId,
+            model: ctx.model
+          },
+          payload
+        });
+      } catch (err) {
+        logger2.warn(`Failed to push env event ${fullType}`, { error: String(err) });
+      }
+    };
     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
-        };
+      for await (const rawEvent of streamHandle.events) {
+        const event = rawEvent;
+        if (!event || typeof event !== "object")
+          continue;
+        switch (event.type) {
+          case "text_delta": {
+            if (typeof event.delta === "string" && event.delta.length > 0) {
+              accumulatedText += event.delta;
+              emitEnvEvent("llm.text", {
+                type: "text",
+                content: accumulatedText,
+                delta: event.delta,
+                contentIndex: event.contentIndex
+              });
+            }
+            break;
+          }
+          case "thinking_delta": {
+            if (typeof event.delta === "string" && event.delta.length > 0) {
+              accumulatedReasoning += event.delta;
+              emitEnvEvent("llm.reasoning", {
+                type: "reasoning",
+                content: accumulatedReasoning,
+                delta: event.delta,
+                contentIndex: event.contentIndex
+              });
+            }
+            break;
+          }
+          default:
+            break;
+        }
+      }
+    } finally {
+      try {
+        capturedResult = await streamHandle.result();
+      } catch (resultErr) {
+        if (accumulatedText) {
+          capturedResult = {
+            text: accumulatedText,
+            finishReason: "aborted",
+            usage: { promptTokens: 0, completionTokens: 0, totalTokens: 0 }
+          };
+        } else {
+          throw resultErr;
+        }
       }
-      output.usage = finishUsage;
-    } catch {
-      output.content = result.result;
-      output.finishReason = "stop";
     }
+    return capturedResult;
+  }
+  finalizeOutput(request, ctx, output, finishUsage, startTime, adapterName) {
     const latencyMs = Date.now() - startTime;
     if (!request.skipThresholdCheck) {
       const sessionId = request.context?.sessionId;
@@ -746,7 +1326,8 @@ class LLMComponent extends BaseComponent {
           content: output.content,
           reasoning: output.reasoning,
           toolCalls: output.toolCalls,
-          usage: output.usage
+          usage: output.usage,
+          adapter: adapterName
         };
         throw contextError;
       }
@@ -810,4 +1391,4 @@ class LLMComponent extends BaseComponent {
 __legacyDecorateClassTS([
   TracedAs("llm.component.invoke", { recordParams: true, recordResult: true, log: true })
 ], LLMComponent.prototype, "invoke", null);
-export { ProviderCapabilitiesSchema, ModelLimitsSchema, ProviderConfigSchema, LLMDefaultConfigSchema, LLMConfigSchema, ProviderManager, LLMTransform, LLMHooks, LLMComponent };
+export { ADAPTER_NAMES, PiAiAdapter, AiSdkAdapter, setLLMProvider, getLLMProviderOverride, createLLMAdapter, ProviderCapabilitiesSchema, ModelLimitsSchema, ProviderConfigSchema, LLMDefaultConfigSchema, LLMConfigSchema, ProviderManager, LLMTransform, LLMHooks, LLMComponent };