@elizaos/plugin-elizacloud 2.0.0-beta.1 → 2.0.3-beta.3

package/dist/models/text.js

@@ -19,7 +19,7 @@ var __require = /* @__PURE__ */ createRequire(import.meta.url);
 // src/utils/config.ts
 import { logger } from "@elizaos/core";
 import { DEFAULT_ELIZA_CLOUD_TEXT_MODEL } from "@elizaos/core";
-var DEFAULT_ELIZA_CLOUD_LARGE_MODEL = "deepseek/deepseek-v4-pro";
+var DEFAULT_ELIZA_CLOUD_LARGE_MODEL = "zai-glm-4.7";
 function getEnvValue(key) {
   if (typeof process === "undefined") {
     return;
@@ -109,9 +109,18 @@ function getExperimentalTelemetry(runtime) {
   const setting = getSetting(runtime, "ELIZAOS_CLOUD_EXPERIMENTAL_TELEMETRY", "false");
   return String(setting).toLowerCase() === "true";
 }
+function resolveCloudTimeoutMs(envKey, defaultMs) {
+  const raw = typeof process !== "undefined" ? process.env[envKey] : undefined;
+  if (raw === undefined || raw.trim() === "")
+    return defaultMs;
+  const parsed = Number.parseInt(raw, 10);
+  if (!Number.isFinite(parsed))
+    return defaultMs;
+  return parsed <= 0 ? undefined : parsed;
+}
 
 // src/utils/sdk-client.ts
-import { CloudApiClient, ElizaCloudClient } from "@elizaos/cloud-sdk";
+import { ElizaCloudClient } from "@elizaos/cloud-sdk";
 function trimTrailingSlash(value) {
   return value.replace(/\/+$/, "");
 }
@@ -126,7 +135,11 @@ function apiKeyForRuntime(runtime, embedding = false) {
 }
 function createCloudApiClient(runtime, embedding = false) {
   const baseUrl = embedding ? getEmbeddingBaseURL(runtime) : getBaseURL(runtime);
-  return new CloudApiClient(trimTrailingSlash(baseUrl), apiKeyForRuntime(runtime, embedding));
+  return new ElizaCloudClient({
+    apiBaseUrl: trimTrailingSlash(baseUrl),
+    baseUrl: apiBaseToSiteBaseUrl(baseUrl),
+    apiKey: apiKeyForRuntime(runtime, embedding)
+  }).v1;
 }
 function createElizaCloudClient(runtime) {
   const apiBaseUrl = trimTrailingSlash(getBaseURL(runtime));
@@ -141,7 +154,7 @@ function createElizaCloudClient(runtime) {
 import {
   EventType
 } from "@elizaos/core";
-function emitModelUsageEvent(runtime, type, _prompt, usage) {
+function emitModelUsageEvent(runtime, type, _prompt, usage, meta = {}) {
   const inputTokens = Number(usage.inputTokens || 0);
   const outputTokens = Number(usage.outputTokens || 0);
   const totalTokens = Number(usage.totalTokens != null ? usage.totalTokens : inputTokens + outputTokens);
@@ -153,22 +166,13 @@ function emitModelUsageEvent(runtime, type, _prompt, usage) {
       prompt: inputTokens,
       completion: outputTokens,
       total: totalTokens
-    }
+    },
+    ...meta.modelName ? { modelName: meta.modelName } : {},
+    ...typeof meta.costUsd === "number" && Number.isFinite(meta.costUsd) ? { costUsd: meta.costUsd } : {}
   };
   runtime.emitEvent(EventType.MODEL_USED, payload);
 }
 
-// src/providers/openai.ts
-import { createOpenAI } from "@ai-sdk/openai";
-function createOpenAIClient(runtime) {
-  const baseURL = getBaseURL(runtime);
-  const apiKey = getApiKey(runtime) ?? (isProxyMode(runtime) ? "eliza-proxy" : undefined);
-  return createOpenAI({
-    apiKey: apiKey ?? "",
-    baseURL
-  });
-}
-
 // src/utils/responses-output.ts
 function asRecord(value) {
   if (!value || typeof value !== "object" || Array.isArray(value)) {
@@ -254,8 +258,11 @@ import {
   buildCanonicalSystemPrompt,
   logger as logger2,
   ModelType,
+  recordInferenceSpan,
   renderChatMessagesForPrompt,
-  resolveEffectiveSystemPrompt
+  resolveEffectiveSystemPrompt,
+  Semaphore,
+  timeInferenceSpan
 } from "@elizaos/core";
 var TEXT_NANO_MODEL_TYPE = ModelType.TEXT_NANO ?? "TEXT_NANO";
 var TEXT_MEDIUM_MODEL_TYPE = ModelType.TEXT_MEDIUM ?? "TEXT_MEDIUM";
@@ -264,6 +271,61 @@ var TEXT_LARGE_MODEL_TYPE = ModelType.TEXT_LARGE;
 var TEXT_MEGA_MODEL_TYPE = ModelType.TEXT_MEGA ?? "TEXT_MEGA";
 var RESPONSE_HANDLER_MODEL_TYPE = ModelType.RESPONSE_HANDLER ?? "RESPONSE_HANDLER";
 var ACTION_PLANNER_MODEL_TYPE = ModelType.ACTION_PLANNER ?? "ACTION_PLANNER";
+var NATIVE_CONCURRENCY_ENV = "ELIZAOS_CLOUD_NATIVE_CONCURRENCY";
+var DEFAULT_NATIVE_CONCURRENCY = 8;
+var TEXT_TIMEOUT_ENV = "ELIZAOS_CLOUD_TEXT_TIMEOUT_MS";
+var DEFAULT_TEXT_TIMEOUT_MS = 120000;
+function resolveTextTimeoutMs() {
+  const raw = typeof process !== "undefined" ? process.env[TEXT_TIMEOUT_ENV] : undefined;
+  if (raw === undefined || raw.trim() === "")
+    return DEFAULT_TEXT_TIMEOUT_MS;
+  const parsed = Number.parseInt(raw, 10);
+  if (!Number.isFinite(parsed))
+    return DEFAULT_TEXT_TIMEOUT_MS;
+  return parsed <= 0 ? undefined : parsed;
+}
+var STREAMING_ENV = "ELIZAOS_CLOUD_STREAMING";
+function resolveStreamingEnabled() {
+  const raw = typeof process !== "undefined" ? process.env[STREAMING_ENV] : undefined;
+  if (raw === undefined)
+    return true;
+  const v = raw.trim().toLowerCase();
+  return v !== "0" && v !== "false" && v !== "off";
+}
+function buildStreamAbortSignal(abortSignal, timeoutMs) {
+  const timeoutSig = typeof timeoutMs === "number" && timeoutMs > 0 ? AbortSignal.timeout(timeoutMs) : undefined;
+  if (abortSignal && timeoutSig)
+    return AbortSignal.any([abortSignal, timeoutSig]);
+  return abortSignal ?? timeoutSig;
+}
+var nativeChatLimiter = null;
+function resolveNativeConcurrency() {
+  const raw = typeof process !== "undefined" ? process.env[NATIVE_CONCURRENCY_ENV] : undefined;
+  const parsed = raw ? Number.parseInt(raw, 10) : Number.NaN;
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : DEFAULT_NATIVE_CONCURRENCY;
+}
+function getNativeChatLimiter() {
+  if (!nativeChatLimiter) {
+    nativeChatLimiter = new Semaphore(resolveNativeConcurrency());
+  }
+  return nativeChatLimiter;
+}
+async function withNativeChatLimit(fn, label = "native") {
+  const limiter = getNativeChatLimiter();
+  const waitStartedAt = Date.now();
+  await limiter.acquire();
+  recordInferenceSpan("cloud.semaphore-wait", Date.now() - waitStartedAt, {
+    route: label
+  });
+  try {
+    return await timeInferenceSpan(`cloud.http:${label}`, fn, { route: label });
+  } finally {
+    limiter.release();
+  }
+}
+function __resetNativeChatLimiterForTests() {
+  nativeChatLimiter = null;
+}
 var REASONING_MODEL_PATTERNS = [
   "o1",
   "o3",
@@ -274,26 +336,53 @@ var REASONING_MODEL_PATTERNS = [
   "claude-opus-4-7",
   "gpt-5"
 ];
-var RESPONSES_ROUTED_PREFIXES = ["openai/", "anthropic/"];
-function buildUserContent(params) {
-  const content = [{ type: "text", text: params.prompt ?? "" }];
-  for (const attachment of params.attachments ?? []) {
-    content.push({
-      type: "file",
-      data: attachment.data,
-      mediaType: attachment.mediaType,
-      ...attachment.filename ? { filename: attachment.filename } : {}
-    });
+var SPAN_SAMPLER_HONORING_MODEL_PREFIXES = [
+  "vast/eliza-1-",
+  "elizaos/eliza-1-",
+  "eliza-1-"
+];
+function isSpanSamplerHonoringModel(modelName) {
+  const lower = modelName.toLowerCase();
+  return SPAN_SAMPLER_HONORING_MODEL_PREFIXES.some((prefix) => lower.startsWith(prefix));
+}
+function buildSpanSamplerHeader(plan) {
+  if (!plan || plan.overrides.length === 0)
+    return;
+  const overrides = plan.overrides.map((o) => {
+    const wire = {
+      span_index: o.spanIndex,
+      temperature: o.temperature
+    };
+    if (typeof o.topK === "number")
+      wire.top_k = o.topK;
+    if (typeof o.topP === "number")
+      wire.top_p = o.topP;
+    return wire;
+  });
+  const body = { overrides };
+  if (plan.strict === true)
+    body.strict = true;
+  return JSON.stringify(body);
+}
+function extractCostUsd(usage, response) {
+  const fromBody = firstNumber(asRecord2(usage).cost_usd, asRecord2(usage).costUsd, asRecord2(usage).cost);
+  if (typeof fromBody === "number" && Number.isFinite(fromBody)) {
+    return fromBody;
+  }
+  const header = response?.headers?.get?.("X-Eliza-Cost-Usd");
+  if (header) {
+    const parsed = Number(header);
+    if (Number.isFinite(parsed))
+      return parsed;
   }
-  return content;
+  return;
 }
 function isReasoningModel(modelName) {
   const lower = modelName.toLowerCase();
   return REASONING_MODEL_PATTERNS.some((pattern) => lower.includes(pattern));
 }
-function supportsStopSequences(modelName) {
-  const lower = modelName.toLowerCase();
-  return !RESPONSES_ROUTED_PREFIXES.some((prefix) => lower.startsWith(prefix));
+function isCerebrasServedModel(modelName) {
+  return modelName.toLowerCase().includes("gpt-oss");
 }
 function isRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -371,26 +460,39 @@ function unwrapJsonSchema(value) {
   const record = asRecord2(value);
   return record.schema ?? record.jsonSchema ?? value;
 }
+function normalizeNativeToolEntry(rawTool, fallbackName) {
+  const tool = asRecord2(rawTool);
+  const nested = asRecord2(tool.function);
+  const name = firstString(nested.name, tool.name, fallbackName);
+  if (!name) {
+    return;
+  }
+  const description = firstString(nested.description, tool.description);
+  const inputSchema = unwrapJsonSchema(nested.parameters ?? tool.inputSchema ?? tool.parameters ?? tool.schema ?? { type: "object" });
+  return {
+    type: "function",
+    function: {
+      name,
+      ...description ? { description } : {},
+      parameters: inputSchema
+    }
+  };
+}
 function normalizeNativeTools(tools) {
   if (!tools) {
     return;
   }
   if (Array.isArray(tools)) {
-    return tools;
+    const normalized2 = tools.map((tool) => normalizeNativeToolEntry(tool)).filter((tool) => tool !== undefined);
+    return normalized2.length > 0 ? normalized2 : undefined;
   }
   const toolSet = asRecord2(tools);
   const normalized = [];
   for (const [name, rawTool] of Object.entries(toolSet)) {
-    const tool = asRecord2(rawTool);
-    const inputSchema = unwrapJsonSchema(tool.inputSchema ?? tool.parameters ?? tool.schema ?? { type: "object" });
-    normalized.push({
-      type: "function",
-      function: {
-        name,
-        ...typeof tool.description === "string" ? { description: tool.description } : {},
-        parameters: inputSchema
-      }
-    });
+    const entry = normalizeNativeToolEntry(rawTool, name);
+    if (entry) {
+      normalized.push(entry);
+    }
   }
   return normalized.length > 0 ? normalized : undefined;
 }
@@ -403,7 +505,15 @@ function normalizeNativeToolChoice(toolChoice) {
   }
   const choice = asRecord2(toolChoice);
   if (choice.type === "function") {
-    return toolChoice;
+    const functionChoice2 = recordAt(choice, "function");
+    const toolName2 = firstString(functionChoice2.name, choice.name, choice.toolName);
+    return toolName2 ? {
+      type: "function",
+      function: {
+        ...functionChoice2,
+        name: toolName2
+      }
+    } : undefined;
   }
   if (choice.type === "tool") {
     const toolName2 = firstString(choice.toolName, choice.name);
@@ -413,10 +523,13 @@ function normalizeNativeToolChoice(toolChoice) {
   const toolName = firstString(choice.toolName, choice.name, functionChoice.name);
   return toolName ? { type: "function", function: { name: toolName } } : toolChoice;
 }
-function buildNativeResponseFormat(responseSchema) {
+function buildNativeResponseFormat(responseSchema, modelName) {
   if (!responseSchema) {
     return;
   }
+  if (isCerebrasServedModel(modelName)) {
+    return { type: "json_object" };
+  }
   const schemaRecord = asRecord2(responseSchema);
   if (schemaRecord.responseFormat) {
     return schemaRecord.responseFormat;
@@ -494,15 +607,20 @@ function buildNativeRequestBody(params, modelName, promptText, systemPrompt) {
   const promptCacheKey = providerOptions ? resolvePromptCacheKey(providerOptions) : undefined;
   const tools = normalizeNativeTools(params.tools);
   const toolChoice = normalizeNativeToolChoice(params.toolChoice);
-  const responseFormat = buildNativeResponseFormat(params.responseSchema);
+  const responseFormat = buildNativeResponseFormat(params.responseSchema, modelName);
   const requestBody = {
     model: modelName,
-    messages: buildNativeMessages(params, promptText, systemPrompt),
-    max_tokens: params.maxTokens ?? 8192
+    messages: buildNativeMessages(params, promptText, systemPrompt)
   };
+  if (!params.omitMaxTokens) {
+    requestBody.max_tokens = params.maxTokens ?? 8192;
+  }
   if (!isReasoningModel(modelName) && typeof params.temperature === "number") {
     requestBody.temperature = params.temperature;
   }
+  if (isCerebrasServedModel(modelName) && recordAt(asRecord2(params.providerOptions), "eliza").thinking === "off") {
+    requestBody.reasoning_effort = "low";
+  }
   if (tools) {
     requestBody.tools = tools;
   }
@@ -616,16 +734,8 @@ function getModelNameForType(runtime, modelType) {
   }
 }
 function buildGenerateParams(runtime, modelType, params) {
-  const paramsWithAttachments = params;
   const prompt = params.prompt ?? "";
-  const maxTokens = params.maxTokens ?? 8192;
-  const openai = createOpenAIClient(runtime);
   const modelName = getModelNameForType(runtime, modelType);
-  const experimentalTelemetry = getExperimentalTelemetry(runtime);
-  const userContent = (paramsWithAttachments.attachments?.length ?? 0) > 0 ? buildUserContent(paramsWithAttachments) : undefined;
-  const model = openai.chat(modelName);
-  const reasoning = isReasoningModel(modelName);
-  const stopSequences = !reasoning && supportsStopSequences(modelName) && Array.isArray(params.stopSequences) && params.stopSequences.length > 0 ? params.stopSequences : undefined;
   const systemPrompt = resolveEffectiveSystemPrompt({
     params,
     fallback: buildCanonicalSystemPrompt({ character: runtime.character })
@@ -633,28 +743,24 @@ function buildGenerateParams(runtime, modelType, params) {
   const promptText = renderChatMessagesForPrompt(params.messages, {
     omitDuplicateSystem: systemPrompt
   }) ?? prompt;
-  const generateParams = {
-    model,
-    ...userContent ? { messages: [{ role: "user", content: userContent }] } : { prompt: promptText },
-    system: systemPrompt,
-    ...stopSequences ? { stopSequences } : {},
-    maxOutputTokens: maxTokens,
-    experimental_telemetry: {
-      isEnabled: experimentalTelemetry
-    }
-  };
-  return { generateParams, modelName, modelType, prompt: promptText, systemPrompt };
+  return { modelName, modelType, prompt: promptText, systemPrompt };
 }
 async function generateTextWithModel(runtime, modelType, params) {
   const { modelName, prompt, systemPrompt } = buildGenerateParams(runtime, modelType, params);
   const paramsWithNative = params;
   logger2.debug(`[ELIZAOS_CLOUD] Generating text with ${modelType} model: ${modelName}`);
-  if (params.stream) {
-    logger2.debug("[ELIZAOS_CLOUD] Streaming text disabled for responses compatibility; falling back to buffered response.");
-  }
+  const paramsStreaming = params;
+  const wantsStream = Boolean(paramsStreaming.stream) && paramsStreaming.streamStructured === true && resolveStreamingEnabled();
   logger2.log(`[ELIZAOS_CLOUD] Using ${modelType} model: ${modelName}`);
   logger2.log(prompt);
   if (hasNativeTransportOptions(paramsWithNative)) {
+    if (wantsStream) {
+      return streamNativeChatCompletion(runtime, modelType, paramsWithNative, {
+        modelName,
+        prompt,
+        systemPrompt
+      });
+    }
     const nativeResult = await generateNativeChatCompletion(runtime, modelType, paramsWithNative, {
       modelName,
       prompt,
@@ -676,19 +782,29 @@ async function generateTextWithModel(runtime, modelType, params) {
   });
   const requestBody = {
     model: modelName,
-    input,
-    max_output_tokens: params.maxTokens ?? 8192
+    input
   };
+  if (!params.omitMaxTokens) {
+    requestBody.max_output_tokens = params.maxTokens ?? 8192;
+  }
   if (!reasoning && typeof params.temperature === "number") {
     requestBody.temperature = params.temperature;
   }
-  const response = await createCloudApiClient(runtime).requestRaw("POST", "/responses", {
-    headers: {
-      "X-Eliza-Llm-Purpose": getPurposeForModelType(modelType),
-      "X-Eliza-Model-Type": modelType
-    },
-    json: requestBody
-  });
+  const responsesHeaders = {
+    "X-Eliza-Llm-Purpose": getPurposeForModelType(modelType),
+    "X-Eliza-Model-Type": modelType
+  };
+  if (isSpanSamplerHonoringModel(modelName)) {
+    const samplerHeader = buildSpanSamplerHeader(params.spanSamplerPlan);
+    if (samplerHeader) {
+      responsesHeaders["x-eliza-span-samplers"] = samplerHeader;
+    }
+  }
+  const response = await withNativeChatLimit(() => createCloudApiClient(runtime).requestRaw("POST", "/responses", {
+    headers: responsesHeaders,
+    json: requestBody,
+    timeoutMs: resolveTextTimeoutMs()
+  }), "responses");
   const responseText = await response.text();
   let data = {};
   if (responseText) {
@@ -713,6 +829,12 @@ async function generateTextWithModel(runtime, modelType, params) {
       inputTokens: data.usage.input_tokens ?? 0,
       outputTokens: data.usage.output_tokens ?? 0,
       totalTokens: data.usage.total_tokens ?? 0
+    }, {
+      modelName: getModelNameForType(runtime, modelType),
+      ...(() => {
+        const costUsd = extractCostUsd(data.usage, response);
+        return typeof costUsd === "number" ? { costUsd } : {};
+      })()
     });
   }
   const text = extractResponsesOutputText(data);
@@ -723,13 +845,21 @@ async function generateTextWithModel(runtime, modelType, params) {
 }
 async function generateNativeChatCompletion(runtime, modelType, params, context) {
   const requestBody = buildNativeRequestBody(params, context.modelName, context.prompt, context.systemPrompt);
-  const response = await createCloudApiClient(runtime).requestRaw("POST", "/chat/completions", {
-    headers: {
-      "X-Eliza-Llm-Purpose": getPurposeForModelType(modelType),
-      "X-Eliza-Model-Type": modelType
-    },
-    json: requestBody
-  });
+  const headers = {
+    "X-Eliza-Llm-Purpose": getPurposeForModelType(modelType),
+    "X-Eliza-Model-Type": modelType
+  };
+  if (isSpanSamplerHonoringModel(context.modelName)) {
+    const samplerHeader = buildSpanSamplerHeader(params.spanSamplerPlan);
+    if (samplerHeader) {
+      headers["x-eliza-span-samplers"] = samplerHeader;
+    }
+  }
+  const response = await withNativeChatLimit(() => createCloudApiClient(runtime).requestRaw("POST", "/chat/completions", {
+    headers,
+    json: requestBody,
+    timeoutMs: resolveTextTimeoutMs()
+  }), "chat/completions");
   const responseText = await response.text();
   let data = {};
   if (responseText) {
@@ -751,7 +881,13 @@ async function generateNativeChatCompletion(runtime, modelType, params, context)
   }
   const usage = convertNativeUsage(data.usage);
   if (usage) {
-    emitModelUsageEvent(runtime, modelType, context.prompt, usage);
+    emitModelUsageEvent(runtime, modelType, context.prompt, usage, {
+      modelName: context.modelName,
+      ...(() => {
+        const costUsd = extractCostUsd(data.usage, response);
+        return typeof costUsd === "number" ? { costUsd } : {};
+      })()
+    });
   }
   const text = extractChatCompletionText(data);
   const toolCalls = extractNativeToolCalls(data);
@@ -769,6 +905,251 @@ async function generateNativeChatCompletion(runtime, modelType, params, context)
     }
   };
 }
+function deferred() {
+  let resolve;
+  const promise = new Promise((r) => {
+    resolve = r;
+  });
+  return { promise, resolve };
+}
+async function* parseOpenAiSseStream(body) {
+  const reader = body.getReader();
+  const decoder = new TextDecoder;
+  let buffer = "";
+  const handle = (line) => {
+    const trimmed = line.trimStart();
+    if (!trimmed.startsWith("data:"))
+      return null;
+    const payload = trimmed.slice(5).trim();
+    if (payload === "")
+      return null;
+    if (payload === "[DONE]")
+      return "DONE";
+    try {
+      return JSON.parse(payload);
+    } catch {
+      return null;
+    }
+  };
+  try {
+    for (;; ) {
+      const { value, done } = await reader.read();
+      if (done)
+        break;
+      buffer += decoder.decode(value, { stream: true });
+      let nl;
+      while ((nl = buffer.indexOf(`
+`)) >= 0) {
+        const line = buffer.slice(0, nl);
+        buffer = buffer.slice(nl + 1);
+        const frame = handle(line);
+        if (frame === "DONE")
+          return;
+        if (frame)
+          yield frame;
+      }
+    }
+    const tail = handle(buffer);
+    if (tail && tail !== "DONE")
+      yield tail;
+  } finally {
+    try {
+      await reader.cancel();
+    } catch {}
+  }
+}
+function accumulateToolCallDeltas(acc, deltas) {
+  if (!Array.isArray(deltas))
+    return;
+  for (const raw of deltas) {
+    const d = asRecord2(raw);
+    const index = typeof d.index === "number" ? d.index : 0;
+    const cur = acc.get(index) ?? { args: "" };
+    const id = firstString(d.id);
+    if (id)
+      cur.id = id;
+    const fn = recordAt(d, "function");
+    const name = firstString(fn.name);
+    if (name)
+      cur.name = name;
+    if (typeof fn.arguments === "string")
+      cur.args += fn.arguments;
+    acc.set(index, cur);
+  }
+}
+function finalizeStreamedToolCalls(acc) {
+  const out = [];
+  for (const [index, c] of [...acc.entries()].sort((a, b) => a[0] - b[0])) {
+    if (!c.name)
+      continue;
+    out.push({
+      type: "tool-call",
+      toolCallId: c.id ?? `call_${c.name}_${index}`,
+      toolName: c.name,
+      input: parseJsonIfPossible(c.args.trim() === "" ? "{}" : c.args)
+    });
+  }
+  return out;
+}
+async function streamNativeChatCompletion(runtime, modelType, params, context) {
+  const requestBody = buildNativeRequestBody(params, context.modelName, context.prompt, context.systemPrompt);
+  requestBody.stream = true;
+  requestBody.stream_options = { include_usage: true };
+  const headers = {
+    "X-Eliza-Llm-Purpose": getPurposeForModelType(modelType),
+    "X-Eliza-Model-Type": modelType
+  };
+  if (isSpanSamplerHonoringModel(context.modelName)) {
+    const samplerHeader = buildSpanSamplerHeader(params.spanSamplerPlan);
+    if (samplerHeader) {
+      headers["x-eliza-span-samplers"] = samplerHeader;
+    }
+  }
+  const abortSignal = params.signal;
+  const signal = buildStreamAbortSignal(abortSignal, resolveTextTimeoutMs());
+  const limiter = getNativeChatLimiter();
+  const waitStartedAt = Date.now();
+  await limiter.acquire();
+  recordInferenceSpan("cloud.semaphore-wait", Date.now() - waitStartedAt, {
+    route: "chat/completions:stream"
+  });
+  let permitReleased = false;
+  const releasePermit = () => {
+    if (!permitReleased) {
+      permitReleased = true;
+      limiter.release();
+    }
+  };
+  let response;
+  try {
+    response = await createCloudApiClient(runtime).requestRaw("POST", "/chat/completions", {
+      headers,
+      json: requestBody,
+      ...signal ? { signal } : {}
+    });
+  } catch (err) {
+    releasePermit();
+    throw err;
+  }
+  if (!response.ok) {
+    let errorBody;
+    try {
+      const errText = await response.text();
+      if (errText) {
+        errorBody = JSON.parse(errText).error;
+      }
+    } catch {}
+    releasePermit();
+    const message = typeof errorBody?.message === "string" && errorBody.message.trim() ? errorBody.message.trim() : `elizaOS Cloud error ${response.status}`;
+    const requestError = new Error(message);
+    requestError.status = response.status;
+    if (errorBody)
+      requestError.error = errorBody;
+    throw requestError;
+  }
+  const contentType = response.headers.get("content-type") ?? "";
+  const isSse = contentType.includes("text/event-stream") && response.body !== null;
+  if (!isSse) {
+    const bufferedText = await response.text();
+    releasePermit();
+    let data = {};
+    if (bufferedText) {
+      try {
+        data = JSON.parse(bufferedText);
+      } catch (parseErr) {
+        logger2.error(`[ELIZAOS_CLOUD] Failed to parse buffered chat completions JSON: ${parseErr instanceof Error ? parseErr.message : String(parseErr)}`);
+      }
+    }
+    const text = extractChatCompletionText(data);
+    const toolCalls = extractNativeToolCalls(data);
+    const usage = convertNativeUsage(data.usage);
+    if (usage) {
+      emitModelUsageEvent(runtime, modelType, context.prompt, usage, {
+        modelName: context.modelName,
+        ...(() => {
+          const costUsd = extractCostUsd(data.usage, response);
+          return typeof costUsd === "number" ? { costUsd } : {};
+        })()
+      });
+    }
+    if (!text.trim() && toolCalls.length === 0) {
+      throw new Error("elizaOS Cloud returned no text or tool calls");
+    }
+    async function* single() {
+      if (text)
+        yield text;
+    }
+    return {
+      textStream: single(),
+      text: Promise.resolve(text),
+      usage: Promise.resolve(usage),
+      finishReason: Promise.resolve(data.choices?.[0]?.finish_reason),
+      toolCalls: Promise.resolve(toolCalls),
+      providerMetadata: { modelName: context.modelName, usage: data.usage }
+    };
+  }
+  const body = response.body;
+  const toolAcc = new Map;
+  let accumulated = "";
+  let nativeUsage;
+  let rawUsage;
+  let finishReason;
+  const textD = deferred();
+  const usageD = deferred();
+  const finishD = deferred();
+  const toolCallsD = deferred();
+  async function* generate() {
+    try {
+      for await (const frame of parseOpenAiSseStream(body)) {
+        if (frame.error) {
+          const message = asRecord2(frame.error).message;
+          throw new Error(typeof message === "string" && message.trim() ? message.trim() : "elizaOS Cloud stream error");
+        }
+        const choices = Array.isArray(frame.choices) ? frame.choices : [];
+        const choice = asRecord2(choices[0]);
+        const delta = recordAt(choice, "delta");
+        if (typeof delta.content === "string" && delta.content.length > 0) {
+          accumulated += delta.content;
+          yield delta.content;
+        }
+        if (delta.tool_calls) {
+          accumulateToolCallDeltas(toolAcc, delta.tool_calls);
+        }
+        const fr = firstString(choice.finish_reason);
+        if (fr)
+          finishReason = fr;
+        if (frame.usage) {
+          rawUsage = frame.usage;
+          nativeUsage = convertNativeUsage(frame.usage);
+        }
+      }
+    } finally {
+      releasePermit();
+      const toolCalls = finalizeStreamedToolCalls(toolAcc);
+      textD.resolve(accumulated);
+      usageD.resolve(nativeUsage);
+      finishD.resolve(finishReason);
+      toolCallsD.resolve(toolCalls);
+      if (nativeUsage) {
+        emitModelUsageEvent(runtime, modelType, context.prompt, nativeUsage, {
+          modelName: context.modelName,
+          ...(() => {
+            const costUsd = extractCostUsd(rawUsage, response);
+            return typeof costUsd === "number" ? { costUsd } : {};
+          })()
+        });
+      }
+    }
+  }
+  return {
+    textStream: generate(),
+    text: textD.promise,
+    usage: usageD.promise,
+    finishReason: finishD.promise,
+    toolCalls: toolCallsD.promise,
+    providerMetadata: { modelName: context.modelName }
+  };
+}
 async function handleTextSmall(runtime, params) {
   return generateTextWithModel(runtime, TEXT_SMALL_MODEL_TYPE, params);
 }
@@ -791,13 +1172,25 @@ async function handleActionPlanner(runtime, params) {
   return generateTextWithModel(runtime, ACTION_PLANNER_MODEL_TYPE, params);
 }
 export {
+  withNativeChatLimit,
+  streamNativeChatCompletion,
+  resolveTextTimeoutMs,
+  resolveStreamingEnabled,
+  parseOpenAiSseStream,
+  normalizeNativeTools,
+  normalizeNativeToolChoice,
   handleTextSmall,
   handleTextNano,
   handleTextMega,
   handleTextMedium,
   handleTextLarge,
   handleResponseHandler,
-  handleActionPlanner
+  handleActionPlanner,
+  generateNativeChatCompletion,
+  finalizeStreamedToolCalls,
+  buildStreamAbortSignal,
+  accumulateToolCallDeltas,
+  __resetNativeChatLimiterForTests
 };
 
-//# debugId=DF0E0E9E46BB9DE664756E2164756E21
+//# debugId=8C7301DC53E50E9164756E2164756E21