@elizaos/plugin-elizacloud 2.0.0-alpha.8 → 2.0.11-beta.7

package/dist/models/index.js

@@ -0,0 +1,1896 @@
+import { createRequire } from "node:module";
+var __defProp = Object.defineProperty;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+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 = "zai-glm-4.7";
+function getEnvValue(key) {
+  if (typeof process === "undefined") {
+    return;
+  }
+  const value = process.env[key];
+  return value === undefined ? undefined : String(value);
+}
+function getSetting(runtime, key, defaultValue) {
+  const value = runtime.getSetting(key);
+  if (value !== undefined && value !== null) {
+    return String(value);
+  }
+  return getEnvValue(key) ?? defaultValue;
+}
+function isBrowser() {
+  return typeof globalThis !== "undefined" && typeof globalThis.document !== "undefined";
+}
+function isProxyMode(runtime) {
+  return isBrowser() && !!getSetting(runtime, "ELIZAOS_CLOUD_BROWSER_BASE_URL");
+}
+function getBaseURL(runtime) {
+  const browserURL = getSetting(runtime, "ELIZAOS_CLOUD_BROWSER_BASE_URL");
+  const baseURL = isBrowser() && browserURL ? browserURL : getSetting(runtime, "ELIZAOS_CLOUD_BASE_URL", "https://www.elizacloud.ai/api/v1");
+  return baseURL;
+}
+function getEmbeddingBaseURL(runtime) {
+  const embeddingURL = isBrowser() ? getSetting(runtime, "ELIZAOS_CLOUD_BROWSER_EMBEDDING_URL") || getSetting(runtime, "ELIZAOS_CLOUD_BROWSER_BASE_URL") : getSetting(runtime, "ELIZAOS_CLOUD_EMBEDDING_URL");
+  if (embeddingURL) {
+    logger.debug(`[ELIZAOS_CLOUD] Using specific embedding base URL: ${embeddingURL}`);
+    return embeddingURL;
+  }
+  logger.debug("[ELIZAOS_CLOUD] Falling back to general base URL for embeddings.");
+  return getBaseURL(runtime);
+}
+function getApiKey(runtime) {
+  return getSetting(runtime, "ELIZAOS_CLOUD_API_KEY");
+}
+function getEmbeddingApiKey(runtime) {
+  const embeddingApiKey = getSetting(runtime, "ELIZAOS_CLOUD_EMBEDDING_API_KEY");
+  if (embeddingApiKey) {
+    logger.debug("[ELIZAOS_CLOUD] Using specific embedding API key (present)");
+    return embeddingApiKey;
+  }
+  logger.debug("[ELIZAOS_CLOUD] Falling back to general API key for embeddings.");
+  return getApiKey(runtime);
+}
+function getSmallModel(runtime) {
+  return getSetting(runtime, "ELIZAOS_CLOUD_SMALL_MODEL") ?? getSetting(runtime, "SMALL_MODEL", DEFAULT_ELIZA_CLOUD_TEXT_MODEL);
+}
+function getNanoModel(runtime) {
+  return getSetting(runtime, "ELIZAOS_CLOUD_NANO_MODEL") ?? getSetting(runtime, "NANO_MODEL") ?? getSmallModel(runtime);
+}
+function getMediumModel(runtime) {
+  return getSetting(runtime, "ELIZAOS_CLOUD_MEDIUM_MODEL") ?? getSetting(runtime, "MEDIUM_MODEL") ?? getSmallModel(runtime);
+}
+function getLargeModel(runtime) {
+  return getSetting(runtime, "ELIZAOS_CLOUD_LARGE_MODEL") ?? getSetting(runtime, "LARGE_MODEL", DEFAULT_ELIZA_CLOUD_LARGE_MODEL);
+}
+function getMegaModel(runtime) {
+  return getSetting(runtime, "ELIZAOS_CLOUD_MEGA_MODEL") ?? getSetting(runtime, "MEGA_MODEL") ?? getLargeModel(runtime);
+}
+function getResponseHandlerModel(runtime) {
+  return getSetting(runtime, "ELIZAOS_CLOUD_RESPONSE_HANDLER_MODEL") ?? getSetting(runtime, "ELIZAOS_CLOUD_SHOULD_RESPOND_MODEL") ?? getSetting(runtime, "RESPONSE_HANDLER_MODEL") ?? getSetting(runtime, "SHOULD_RESPOND_MODEL") ?? getSmallModel(runtime);
+}
+function getActionPlannerModel(runtime) {
+  return getSetting(runtime, "ELIZAOS_CLOUD_ACTION_PLANNER_MODEL") ?? getSetting(runtime, "ELIZAOS_CLOUD_PLANNER_MODEL") ?? getSetting(runtime, "ACTION_PLANNER_MODEL") ?? getSetting(runtime, "PLANNER_MODEL") ?? getLargeModel(runtime);
+}
+function getResponseModel(runtime) {
+  return getSetting(runtime, "ELIZAOS_CLOUD_RESPONSE_MODEL") ?? getSetting(runtime, "RESPONSE_MODEL") ?? getLargeModel(runtime);
+}
+function getImageDescriptionModel(runtime) {
+  return getSetting(runtime, "ELIZAOS_CLOUD_IMAGE_DESCRIPTION_MODEL", "gpt-5.4-mini");
+}
+function getImageGenerationModel(runtime) {
+  return getSetting(runtime, "ELIZAOS_CLOUD_IMAGE_GENERATION_MODEL", "google/gemini-2.5-flash-image") ?? "google/gemini-2.5-flash-image";
+}
+function getResearchModel(runtime) {
+  return getSetting(runtime, "ELIZAOS_CLOUD_RESEARCH_MODEL") ?? getSetting(runtime, "RESEARCH_MODEL", "o3-deep-research");
+}
+function getTTSModel(runtime) {
+  return getSetting(runtime, "ELIZAOS_CLOUD_TTS_MODEL", "gpt-5-mini-tts");
+}
+function getTranscriptionModel(runtime) {
+  return getSetting(runtime, "ELIZAOS_CLOUD_TRANSCRIPTION_MODEL", "gpt-5-mini-transcribe");
+}
+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 { ElizaCloudClient } from "@elizaos/cloud-sdk";
+function trimTrailingSlash(value) {
+  return value.replace(/\/+$/, "");
+}
+function apiBaseToSiteBaseUrl(apiBaseUrl) {
+  const trimmed = trimTrailingSlash(apiBaseUrl);
+  return trimmed.endsWith("/api/v1") ? trimmed.slice(0, -"/api/v1".length) : trimmed;
+}
+function apiKeyForRuntime(runtime, embedding = false) {
+  if (isBrowser())
+    return;
+  return embedding ? getEmbeddingApiKey(runtime) : getApiKey(runtime);
+}
+function createCloudApiClient(runtime, embedding = false) {
+  const baseUrl = embedding ? getEmbeddingBaseURL(runtime) : getBaseURL(runtime);
+  return new ElizaCloudClient({
+    apiBaseUrl: trimTrailingSlash(baseUrl),
+    baseUrl: apiBaseToSiteBaseUrl(baseUrl),
+    apiKey: apiKeyForRuntime(runtime, embedding)
+  }).v1;
+}
+function createElizaCloudClient(runtime) {
+  const apiBaseUrl = trimTrailingSlash(getBaseURL(runtime));
+  return new ElizaCloudClient({
+    apiBaseUrl,
+    baseUrl: apiBaseToSiteBaseUrl(apiBaseUrl),
+    apiKey: apiKeyForRuntime(runtime)
+  });
+}
+
+// src/utils/events.ts
+import {
+  EventType
+} from "@elizaos/core";
+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);
+  const payload = {
+    runtime,
+    source: "elizacloud",
+    type,
+    tokens: {
+      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/models/embeddings.ts
+import {
+  logger as logger2,
+  ModelType,
+  timeInferenceSpan,
+  VECTOR_DIMS
+} from "@elizaos/core";
+var MAX_BATCH_SIZE = 100;
+var EMBED_MAX_ATTEMPTS = 2;
+var EMBED_BACKOFF_BASE_MS = 1000;
+var EMBED_BACKOFF_CAP_MS = 8000;
+var EMBED_REQUEST_TIMEOUT_MS = 60000;
+function embeddingBackoffMs(attempt, retryAfterSec) {
+  const exp = EMBED_BACKOFF_BASE_MS * 2 ** attempt;
+  const serverHint = typeof retryAfterSec === "number" && retryAfterSec > 0 ? retryAfterSec * 1000 : 0;
+  const base = Math.min(EMBED_BACKOFF_CAP_MS, Math.max(exp, serverHint));
+  return Math.round(base * (1 + Math.random() * 0.25));
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function extractRateLimitInfo(response) {
+  return {
+    remainingRequests: parseInt(response.headers.get("x-ratelimit-remaining-requests") || "", 10) || undefined,
+    remainingTokens: parseInt(response.headers.get("x-ratelimit-remaining-tokens") || "", 10) || undefined,
+    limitRequests: parseInt(response.headers.get("x-ratelimit-limit-requests") || "", 10) || undefined,
+    limitTokens: parseInt(response.headers.get("x-ratelimit-limit-tokens") || "", 10) || undefined,
+    resetRequests: response.headers.get("x-ratelimit-reset-requests") || undefined,
+    resetTokens: response.headers.get("x-ratelimit-reset-tokens") || undefined,
+    retryAfter: parseInt(response.headers.get("retry-after") || "", 10) || undefined
+  };
+}
+function getEmbeddingConfig(runtime) {
+  const embeddingModelName = getSetting(runtime, "ELIZAOS_CLOUD_EMBEDDING_MODEL", "text-embedding-3-small");
+  const embeddingDimension = Number.parseInt(getSetting(runtime, "ELIZAOS_CLOUD_EMBEDDING_DIMENSIONS", "1536") || "1536", 10);
+  if (!Object.values(VECTOR_DIMS).includes(embeddingDimension)) {
+    const errorMsg = `Invalid embedding dimension: ${embeddingDimension}. Must be one of: ${Object.values(VECTOR_DIMS).join(", ")}`;
+    logger2.error(errorMsg);
+    throw new Error(errorMsg);
+  }
+  return { embeddingModelName, embeddingDimension };
+}
+function createInitProbeVector(dimension) {
+  const vector = Array(dimension).fill(0);
+  vector[0] = 0.1;
+  return vector;
+}
+async function handleTextEmbedding(runtime, params) {
+  const { embeddingDimension } = getEmbeddingConfig(runtime);
+  if (params === null) {
+    logger2.debug("Creating test embedding for initialization");
+    return createInitProbeVector(embeddingDimension);
+  }
+  let text;
+  if (typeof params === "string") {
+    text = params;
+  } else if (typeof params === "object" && params.text) {
+    text = params.text;
+  } else {
+    throw new Error("Invalid input format for embedding: expected string or { text: string }");
+  }
+  if (!text.trim()) {
+    throw new Error("Cannot generate embedding for empty text");
+  }
+  const results = await handleBatchTextEmbedding(runtime, [text]);
+  return results[0];
+}
+async function handleBatchTextEmbedding(runtime, texts) {
+  const { embeddingModelName, embeddingDimension } = getEmbeddingConfig(runtime);
+  const client = createCloudApiClient(runtime, true);
+  if (!texts || texts.length === 0) {
+    return [];
+  }
+  const validTexts = [];
+  for (let i = 0;i < texts.length; i++) {
+    const text = texts[i]?.trim();
+    if (!text) {
+      throw new Error(`Cannot generate embedding for empty text at index ${i}`);
+    }
+    validTexts.push({ text, originalIndex: i });
+  }
+  const results = new Array(texts.length);
+  for (let batchStart = 0;batchStart < validTexts.length; batchStart += MAX_BATCH_SIZE) {
+    const batchEnd = Math.min(batchStart + MAX_BATCH_SIZE, validTexts.length);
+    const batch = validTexts.slice(batchStart, batchEnd);
+    const batchTexts = batch.map((b) => b.text);
+    logger2.info(`[BatchEmbeddings] Processing batch ${Math.floor(batchStart / MAX_BATCH_SIZE) + 1}/${Math.ceil(validTexts.length / MAX_BATCH_SIZE)}: ${batch.length} texts`);
+    try {
+      let response = null;
+      for (let attempt = 0;attempt < EMBED_MAX_ATTEMPTS; attempt++) {
+        const resp = await timeInferenceSpan("cloud.embedding", () => client.requestRaw("POST", "/embeddings", {
+          json: {
+            model: embeddingModelName,
+            input: batchTexts
+          },
+          timeoutMs: EMBED_REQUEST_TIMEOUT_MS
+        }), { batch: batchTexts.length, attempt });
+        const rateLimitInfo = extractRateLimitInfo(resp);
+        if (rateLimitInfo.remainingRequests !== undefined && rateLimitInfo.remainingRequests < 50) {
+          logger2.warn(`[BatchEmbeddings] Rate limit: ${rateLimitInfo.remainingRequests}/${rateLimitInfo.limitRequests} requests remaining`);
+        }
+        const transient = resp.status === 429 || resp.status === 502 || resp.status === 503 || resp.status === 504;
+        if (transient && attempt < EMBED_MAX_ATTEMPTS - 1) {
+          const delay = embeddingBackoffMs(attempt, rateLimitInfo.retryAfter);
+          logger2.warn(`[BatchEmbeddings] ${resp.status} (attempt ${attempt + 1}/${EMBED_MAX_ATTEMPTS}) — backing off ${delay}ms`);
+          await resp.text().catch(() => {
+            return;
+          });
+          await sleep(delay);
+          continue;
+        }
+        response = resp;
+        break;
+      }
+      if (!response) {
+        throw new Error("[BatchEmbeddings] No response after retry loop");
+      }
+      if (!response.ok) {
+        if (response.status === 401 || response.status === 403) {
+          throw new Error(`[BatchEmbeddings] Authentication failed (${response.status}). ` + `Check ELIZAOS_CLOUD_API_KEY or ELIZAOS_CLOUD_EMBEDDING_API_KEY — ` + `the current key is not authorized for the embedding endpoint.`);
+        }
+        throw new Error(`[BatchEmbeddings] API error: ${response.status} ${response.statusText}`);
+      }
+      const data = await response.json();
+      if (!data?.data || !Array.isArray(data.data)) {
+        throw new Error("[BatchEmbeddings] API returned invalid response structure");
+      }
+      for (const item of data.data) {
+        const originalIndex = batch[item.index].originalIndex;
+        results[originalIndex] = item.embedding;
+      }
+      if (data.usage) {
+        const usage = {
+          inputTokens: data.usage.prompt_tokens,
+          outputTokens: 0,
+          totalTokens: data.usage.total_tokens
+        };
+        emitModelUsageEvent(runtime, ModelType.TEXT_EMBEDDING, `batch:${batch.length}`, usage);
+      }
+      logger2.debug(`[BatchEmbeddings] Got ${batch.length} embeddings (${embeddingDimension}d)`);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      logger2.error(`[BatchEmbeddings] Batch failed: ${message}`);
+      throw error instanceof Error ? error : new Error(message);
+    }
+  }
+  return results;
+}
+
+// src/utils/helpers.ts
+import { logger as logger3 } from "@elizaos/core";
+import { JSONParseError } from "ai";
+function getJsonRepairFunction() {
+  return async ({ text, error }) => {
+    try {
+      if (error instanceof JSONParseError) {
+        const cleanedText = text.replace(/```json\n|\n```|```/g, "");
+        JSON.parse(cleanedText);
+        return cleanedText;
+      }
+      return null;
+    } catch (jsonError) {
+      const message = jsonError instanceof Error ? jsonError.message : String(jsonError);
+      logger3.warn(`Failed to repair JSON text: ${message}`);
+      return null;
+    }
+  };
+}
+function detectAudioMimeType(buffer) {
+  if (buffer.length < 12) {
+    return "application/octet-stream";
+  }
+  if (buffer[0] === 82 && buffer[1] === 73 && buffer[2] === 70 && buffer[3] === 70 && buffer[8] === 87 && buffer[9] === 65 && buffer[10] === 86 && buffer[11] === 69) {
+    return "audio/wav";
+  }
+  if (buffer[0] === 73 && buffer[1] === 68 && buffer[2] === 51 || buffer[0] === 255 && (buffer[1] & 224) === 224) {
+    return "audio/mpeg";
+  }
+  if (buffer[0] === 79 && buffer[1] === 103 && buffer[2] === 103 && buffer[3] === 83) {
+    return "audio/ogg";
+  }
+  if (buffer[0] === 102 && buffer[1] === 76 && buffer[2] === 97 && buffer[3] === 67) {
+    return "audio/flac";
+  }
+  if (buffer[4] === 102 && buffer[5] === 116 && buffer[6] === 121 && buffer[7] === 112) {
+    return "audio/mp4";
+  }
+  if (buffer[0] === 26 && buffer[1] === 69 && buffer[2] === 223 && buffer[3] === 163) {
+    return "audio/webm";
+  }
+  logger3.warn("Could not detect audio format from buffer, using generic binary type");
+  return "application/octet-stream";
+}
+async function webStreamToNodeStream(webStream) {
+  try {
+    const { Readable } = await import("node:stream");
+    const reader = webStream.getReader();
+    return new Readable({
+      async read() {
+        try {
+          const { done, value } = await reader.read();
+          if (done) {
+            this.push(null);
+          } else {
+            this.push(value);
+          }
+        } catch (error) {
+          this.destroy(error);
+        }
+      },
+      destroy(error, callback) {
+        reader.cancel().finally(() => callback(error));
+      }
+    });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    logger3.error(`Failed to load node:stream module: ${message}`);
+    throw new Error(`Cannot convert stream: node:stream module unavailable. This feature requires a Node.js environment.`);
+  }
+}
+function parseImageDescriptionResponse(responseText) {
+  const titleMatch = responseText.match(/title[:\s]+(.+?)(?:\n|$)/i);
+  const title = titleMatch?.[1]?.trim() || "Image Analysis";
+  const description = responseText.replace(/title[:\s]+(.+?)(?:\n|$)/i, "").trim();
+  return { title, description };
+}
+
+// src/models/image.ts
+import { logger as logger4, ModelType as ModelType2 } from "@elizaos/core";
+async function handleImageGeneration(runtime, params) {
+  const numImages = params.count || 1;
+  const size = params.size || "1024x1024";
+  const prompt = params.prompt;
+  const modelName = getImageGenerationModel(runtime);
+  logger4.log(`[ELIZAOS_CLOUD] Using IMAGE model: ${modelName}`);
+  const aspectRatioMap = {
+    "1024x1024": "1:1",
+    "1792x1024": "16:9",
+    "1024x1792": "9:16"
+  };
+  const aspectRatio = aspectRatioMap[size] || "1:1";
+  try {
+    const requestBody = {
+      prompt,
+      numImages,
+      aspectRatio,
+      model: modelName
+    };
+    const typedData = await createElizaCloudClient(runtime).generateImage(requestBody);
+    const result = typedData.images.map((img) => ({
+      url: img.url ?? img.image ?? ""
+    }));
+    return result;
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    logger4.error(`[ELIZAOS_CLOUD] Image generation error: ${message}`);
+    throw error;
+  }
+}
+async function handleImageDescription(runtime, params) {
+  const disableSetting = getSetting(runtime, "DISABLE_IMAGE_DESCRIPTION", "");
+  const disabled = [disableSetting, process.env.DISABLE_IMAGE_DESCRIPTION].some((value) => {
+    const normalized = value?.trim().toLowerCase();
+    return normalized === "1" || normalized === "true" || normalized === "yes" || normalized === "on";
+  });
+  if (disabled) {
+    logger4.debug("[ELIZAOS_CLOUD] IMAGE_DESCRIPTION skipped — DISABLE_IMAGE_DESCRIPTION is set");
+    return {
+      title: "Image description disabled",
+      description: "Image description is disabled by configuration."
+    };
+  }
+  let imageUrl;
+  let promptText;
+  const modelName = getImageDescriptionModel(runtime);
+  logger4.log(`[ELIZAOS_CLOUD] Using IMAGE_DESCRIPTION model: ${modelName}`);
+  const maxTokens = Number.parseInt(getSetting(runtime, "ELIZAOS_CLOUD_IMAGE_DESCRIPTION_MAX_TOKENS", "8192") || "8192", 10);
+  if (typeof params === "string") {
+    imageUrl = params;
+    promptText = "Please analyze this image and provide a title and detailed description.";
+  } else {
+    imageUrl = params.imageUrl;
+    promptText = params.prompt || "Please analyze this image and provide a title and detailed description.";
+  }
+  const messages = [
+    {
+      role: "user",
+      content: [
+        { type: "text", text: promptText },
+        { type: "image_url", image_url: { url: imageUrl } }
+      ]
+    }
+  ];
+  const client = createElizaCloudClient(runtime);
+  try {
+    const requestBody = {
+      model: modelName,
+      messages,
+      max_tokens: maxTokens
+    };
+    let response = null;
+    let attemptedRetry = false;
+    for (let attempt = 0;attempt < 2; attempt++) {
+      const attemptResponse = await client.routes.postApiV1ChatCompletionsRaw({
+        json: requestBody,
+        timeoutMs: resolveCloudTimeoutMs("ELIZAOS_CLOUD_IMAGE_TIMEOUT_MS", 120000)
+      });
+      if (!attemptResponse) {
+        continue;
+      }
+      response = attemptResponse;
+      if (attemptResponse.status !== 429 || attemptedRetry)
+        break;
+      const headerValue = attemptResponse.headers.get("retry-after");
+      const headerRetryAfter = headerValue !== null && Number.isFinite(Number(headerValue)) ? Number(headerValue) : undefined;
+      let bodyRetryAfter;
+      try {
+        const peek = await attemptResponse.clone().json();
+        bodyRetryAfter = typeof peek?.retryAfter === "number" && Number.isFinite(peek.retryAfter) ? peek.retryAfter : undefined;
+      } catch {}
+      const retryAfter = headerRetryAfter ?? bodyRetryAfter ?? 0;
+      if (retryAfter > 0 && retryAfter <= 5) {
+        logger4.warn(`[ELIZAOS_CLOUD] Image analysis rate-limited (429), retrying once after ${retryAfter}s...`);
+        await new Promise((r) => setTimeout(r, retryAfter * 1000));
+        attemptedRetry = true;
+        continue;
+      }
+      logger4.warn(`[ELIZAOS_CLOUD] Image analysis rate-limited (429); upstream retryAfter=${retryAfter || "unknown"}s — failing fast`);
+      break;
+    }
+    if (!response) {
+      throw new Error("ElizaOS Cloud API did not return a response");
+    }
+    const finalResponse = response;
+    if (!finalResponse.ok) {
+      const status = finalResponse.status;
+      if (status === 402) {
+        throw new Error("Eliza Cloud credits exhausted — top up at https://www.elizacloud.ai/dashboard/settings?tab=billing");
+      }
+      if (status === 429) {
+        throw new Error("Eliza Cloud rate limit exceeded for image description — try again in a minute");
+      }
+      throw new Error(`ElizaOS Cloud API error: ${status}`);
+    }
+    const typedResult = await finalResponse.json();
+    const content = typedResult.choices?.[0]?.message?.content;
+    if (typedResult.usage) {
+      emitModelUsageEvent(runtime, ModelType2.IMAGE_DESCRIPTION, typeof params === "string" ? params : params.prompt || "", {
+        inputTokens: typedResult.usage.prompt_tokens,
+        outputTokens: typedResult.usage.completion_tokens,
+        totalTokens: typedResult.usage.total_tokens
+      });
+    }
+    if (!content) {
+      return {
+        title: "Failed to analyze image",
+        description: "No response from API"
+      };
+    }
+    return parseImageDescriptionResponse(content);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    logger4.error(`Error analyzing image: ${message}`);
+    return {
+      title: "Failed to analyze image",
+      description: `Error: ${message}`
+    };
+  }
+}
+
+// src/models/research.ts
+import { logger as logger5, ModelType as ModelType3 } from "@elizaos/core";
+var DEFAULT_RESEARCH_TIMEOUT_MS = 600000;
+function normalizeInput(input) {
+  if (typeof input !== "string") {
+    return input;
+  }
+  return [
+    {
+      role: "user",
+      content: [
+        {
+          type: "input_text",
+          text: input
+        }
+      ]
+    }
+  ];
+}
+function buildResearchApiError(status, errorText) {
+  try {
+    const parsed = JSON.parse(errorText);
+    const message = parsed.error?.message;
+    const param = parsed.error?.param;
+    if (param === "tools.0.type" && message?.includes('expected "function"')) {
+      return new Error(`Research API error: ${status} Eliza Cloud /responses rejected deep-research tool types; the provider currently only accepts function tools on this route`);
+    }
+  } catch {}
+  return new Error(`Research API error: ${status} ${errorText}`);
+}
+function parseAnnotations(raw) {
+  return raw.filter((a) => a.url !== undefined).map((a) => ({
+    url: a.url,
+    title: a.title ?? "",
+    startIndex: a.start_index ?? 0,
+    endIndex: a.end_index ?? 0
+  }));
+}
+function parseOutputItems(raw) {
+  const items = [];
+  for (const item of raw) {
+    switch (item.type) {
+      case "web_search_call":
+        items.push({
+          id: item.id ?? "",
+          type: "web_search_call",
+          status: item.status ?? "completed",
+          action: {
+            type: item.action?.type ?? "search",
+            query: item.action?.query,
+            url: item.action?.url
+          }
+        });
+        break;
+      case "file_search_call":
+        items.push({
+          id: item.id ?? "",
+          type: "file_search_call",
+          status: item.status ?? "completed",
+          query: item.query ?? "",
+          results: item.results?.map((r) => ({
+            fileId: r.file_id,
+            fileName: r.file_name,
+            score: r.score
+          }))
+        });
+        break;
+      case "code_interpreter_call":
+        items.push({
+          id: item.id ?? "",
+          type: "code_interpreter_call",
+          status: item.status ?? "completed",
+          code: item.code ?? "",
+          output: item.output
+        });
+        break;
+      case "mcp_tool_call":
+        items.push({
+          id: item.id ?? "",
+          type: "mcp_tool_call",
+          status: item.status ?? "completed",
+          serverLabel: item.server_label ?? "",
+          toolName: item.tool_name ?? "",
+          arguments: item.arguments ?? {},
+          result: item.result
+        });
+        break;
+      case "message": {
+        const content = item.content ?? [];
+        items.push({
+          type: "message",
+          content: content.filter((c) => c.type === "output_text").map((c) => ({
+            type: "output_text",
+            text: c.text ?? "",
+            annotations: parseAnnotations(c.annotations ?? [])
+          }))
+        });
+        break;
+      }
+    }
+  }
+  return items;
+}
+async function handleResearch(runtime, params) {
+  const modelName = params.model ?? getResearchModel(runtime);
+  logger5.log(`[ELIZAOS_CLOUD] Using RESEARCH model: ${modelName}`);
+  const tools = params.tools ?? [{ type: "web_search_preview" }];
+  const requestBody = {
+    model: modelName,
+    input: normalizeInput(params.input),
+    tools
+  };
+  if (params.instructions) {
+    requestBody.instructions = params.instructions;
+  }
+  if (params.background !== undefined) {
+    requestBody.background = params.background;
+  }
+  if (params.maxToolCalls !== undefined) {
+    requestBody.max_tool_calls = params.maxToolCalls;
+  }
+  if (params.reasoningSummary) {
+    requestBody.reasoning = { summary: params.reasoningSummary };
+  }
+  const response = await createCloudApiClient(runtime).requestRaw("POST", "/responses", {
+    json: requestBody,
+    timeoutMs: resolveCloudTimeoutMs("ELIZAOS_CLOUD_RESEARCH_TIMEOUT_MS", DEFAULT_RESEARCH_TIMEOUT_MS)
+  });
+  if (!response.ok) {
+    const errorText = await response.text();
+    throw buildResearchApiError(response.status, errorText);
+  }
+  const data = await response.json();
+  if (data.usage) {
+    emitModelUsageEvent(runtime, ModelType3.RESEARCH, params.input, {
+      inputTokens: data.usage.input_tokens,
+      outputTokens: data.usage.output_tokens,
+      totalTokens: data.usage.total_tokens
+    });
+  }
+  const outputItems = parseOutputItems(data.output);
+  let text = "";
+  const annotations = [];
+  for (const item of outputItems) {
+    if (item.type === "message") {
+      for (const content of item.content) {
+        if (content.type === "output_text") {
+          text += content.text;
+          annotations.push(...content.annotations);
+        }
+      }
+    }
+  }
+  return {
+    id: data.id,
+    text,
+    annotations,
+    outputItems,
+    status: data.status
+  };
+}
+
+// src/models/speech.ts
+import { isCloudConnected, logger as logger6, toRuntimeSettings } from "@elizaos/core";
+var cloudTtsClientFactory = (runtime) => createElizaCloudClient(runtime);
+function setCloudTtsClientFactoryForTesting(factory) {
+  if (factory === null) {
+    cloudTtsClientFactory = (runtime) => createElizaCloudClient(runtime);
+  } else {
+    cloudTtsClientFactory = factory;
+  }
+}
+
+class CloudTtsUnavailableError extends Error {
+  constructor(message = "Eliza Cloud is not connected") {
+    super(message);
+    this.name = "CloudTtsUnavailableError";
+  }
+}
+function normalizeTextInput(input) {
+  if (typeof input === "string")
+    return { text: input };
+  return input;
+}
+function resolveModelId(options) {
+  if (options.modelId && options.modelId.trim()) {
+    return options.modelId.trim();
+  }
+  const model = options.model?.trim();
+  if (!model)
+    return;
+  if (model.startsWith("elevenlabs/")) {
+    return model.split("/").slice(1).join("/");
+  }
+  if (model.startsWith("eleven_")) {
+    return model;
+  }
+  return;
+}
+function resolveVoiceId(options) {
+  if (options.voiceId && options.voiceId.trim()) {
+    return options.voiceId.trim();
+  }
+  const voice = options.voice?.trim();
+  if (!voice)
+    return;
+  if (voice === "nova")
+    return;
+  return voice;
+}
+async function fetchTextToSpeech(runtime, options) {
+  const format = options.format || "mp3";
+  const modelId = resolveModelId(options);
+  const voiceId = resolveVoiceId(options);
+  try {
+    const res = await cloudTtsClientFactory(runtime).routes.postApiV1VoiceTts({
+      headers: {
+        ...format === "mp3" ? { Accept: "audio/mpeg" } : {}
+      },
+      json: {
+        text: options.text,
+        ...voiceId ? { voiceId } : {},
+        ...modelId ? { modelId } : {}
+      },
+      timeoutMs: resolveCloudTimeoutMs("ELIZAOS_CLOUD_TTS_TIMEOUT_MS", 60000)
+    });
+    if (!res.ok) {
+      const err = await res.text();
+      throw new Error(`ElizaOS Cloud TTS error ${res.status}: ${err}`);
+    }
+    if (!res.body) {
+      throw new Error("ElizaOS Cloud TTS response body is null");
+    }
+    if (!isBrowser()) {
+      return await webStreamToNodeStream(res.body);
+    }
+    return res.body;
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    throw new Error(`Failed to fetch speech from ElizaOS Cloud TTS: ${message}`);
+  }
+}
+function toUint8Array(chunk) {
+  if (chunk instanceof Uint8Array)
+    return chunk;
+  if (chunk instanceof ArrayBuffer)
+    return new Uint8Array(chunk);
+  if (typeof chunk === "string")
+    return new TextEncoder().encode(chunk);
+  throw new TypeError(`Unexpected TTS chunk type: ${typeof chunk}`);
+}
+function concatChunks(chunks) {
+  const total = chunks.reduce((sum, chunk) => sum + chunk.byteLength, 0);
+  const out = new Uint8Array(total);
+  let offset = 0;
+  for (const chunk of chunks) {
+    out.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  return out;
+}
+async function webStreamToUint8Array(stream) {
+  const reader = stream.getReader();
+  const chunks = [];
+  try {
+    while (true) {
+      const result = await reader.read();
+      if (result.done)
+        break;
+      chunks.push(toUint8Array(result.value));
+    }
+  } finally {
+    reader.releaseLock();
+  }
+  return concatChunks(chunks);
+}
+async function nodeStreamToUint8Array(stream) {
+  const chunks = [];
+  for await (const chunk of stream) {
+    chunks.push(toUint8Array(chunk));
+  }
+  return concatChunks(chunks);
+}
+function isReadableStream(stream) {
+  return typeof stream.getReader === "function";
+}
+async function ttsStreamToBytes(stream) {
+  if (isReadableStream(stream)) {
+    return webStreamToUint8Array(stream);
+  }
+  return nodeStreamToUint8Array(stream);
+}
+function buildAudioStreamResult(stream, mimeType) {
+  const collected = [];
+  let resolveBytes;
+  let rejectBytes;
+  const bytes = new Promise((resolve, reject) => {
+    resolveBytes = resolve;
+    rejectBytes = reject;
+  });
+  async function* generate() {
+    try {
+      if (isReadableStream(stream)) {
+        const reader = stream.getReader();
+        try {
+          for (;; ) {
+            const { value, done } = await reader.read();
+            if (done)
+              break;
+            const chunk = toUint8Array(value);
+            collected.push(chunk);
+            yield chunk;
+          }
+        } finally {
+          reader.releaseLock();
+        }
+      } else {
+        for await (const value of stream) {
+          const chunk = toUint8Array(value);
+          collected.push(chunk);
+          yield chunk;
+        }
+      }
+      resolveBytes(concatChunks(collected));
+    } catch (err) {
+      rejectBytes(err);
+      throw err;
+    }
+  }
+  return { audioStream: generate(), bytes, mimeType };
+}
+async function handleTextToSpeech(runtime, input) {
+  if (!isCloudConnected(toRuntimeSettings(runtime))) {
+    throw new CloudTtsUnavailableError("Eliza Cloud is not connected — falling through to next TTS handler");
+  }
+  const options = normalizeTextInput(input);
+  const wantsStream = typeof input === "object" && input !== null && input.audioStream === true;
+  const resolvedModel = options.modelId || options.model || getSetting(runtime, "ELIZAOS_CLOUD_TTS_MODEL", "eleven_flash_v2_5");
+  logger6.log(`[ELIZAOS_CLOUD] Using TEXT_TO_SPEECH model: ${resolvedModel}`);
+  try {
+    const speechStream = await fetchTextToSpeech(runtime, options);
+    if (wantsStream) {
+      const format = options.format || "mp3";
+      const mimeType = format === "mp3" ? "audio/mpeg" : `audio/${format}`;
+      return buildAudioStreamResult(speechStream, mimeType);
+    }
+    return ttsStreamToBytes(speechStream);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    logger6.error(`Error in TEXT_TO_SPEECH: ${message}`);
+    throw error;
+  }
+}
+// src/utils/responses-output.ts
+function asRecord(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return null;
+  }
+  return value;
+}
+function normalizeContentItems(value) {
+  if (Array.isArray(value))
+    return value;
+  if (typeof value === "string")
+    return [{ type: "text", text: value }];
+  return value && typeof value === "object" ? [value] : [];
+}
+function extractTextFromContentItem(value) {
+  if (typeof value === "string") {
+    return [value];
+  }
+  const record = asRecord(value);
+  if (!record)
+    return [];
+  const text = typeof record.text === "string" ? record.text : typeof record.output_text === "string" ? record.output_text : typeof record.content === "string" ? record.content : "";
+  const type = typeof record.type === "string" ? record.type : undefined;
+  if (text && (!type || type === "output_text" || type === "text")) {
+    return [text];
+  }
+  return [];
+}
+function extractTextFromOutputItem(value) {
+  const record = asRecord(value);
+  if (!record)
+    return [];
+  const directContent = normalizeContentItems(record.content);
+  if (directContent.length > 0) {
+    return directContent.flatMap(extractTextFromContentItem);
+  }
+  const nestedMessage = asRecord(record.message);
+  if (nestedMessage) {
+    return normalizeContentItems(nestedMessage.content).flatMap(extractTextFromContentItem);
+  }
+  const type = typeof record.type === "string" ? record.type : undefined;
+  const text = typeof record.text === "string" ? record.text : typeof record.output_text === "string" ? record.output_text : "";
+  if (text && (type === "output_text" || type === "text")) {
+    return [text];
+  }
+  return [];
+}
+function extractTextFromChoice(value) {
+  const record = asRecord(value);
+  if (!record)
+    return [];
+  if (typeof record.text === "string" && record.text) {
+    return [record.text];
+  }
+  const message = asRecord(record.message);
+  if (!message) {
+    return [];
+  }
+  return normalizeContentItems(message.content).flatMap(extractTextFromContentItem);
+}
+function extractResponsesOutputText(data) {
+  const record = asRecord(data);
+  if (!record)
+    return "";
+  if (typeof record.output_text === "string" && record.output_text.trim()) {
+    return record.output_text;
+  }
+  if (Array.isArray(record.output)) {
+    const fromOutput = record.output.flatMap(extractTextFromOutputItem).join("");
+    if (fromOutput.trim())
+      return fromOutput;
+  }
+  if (Array.isArray(record.choices)) {
+    const fromChoices = record.choices.flatMap(extractTextFromChoice).join("");
+    if (fromChoices.trim())
+      return fromChoices;
+  }
+  return "";
+}
+
+// src/models/text.ts
+import {
+  buildCanonicalSystemPrompt,
+  logger as logger7,
+  ModelType as ModelType4,
+  recordInferenceSpan,
+  renderChatMessagesForPrompt,
+  resolveEffectiveSystemPrompt,
+  Semaphore,
+  timeInferenceSpan as timeInferenceSpan2
+} from "@elizaos/core";
+var TEXT_NANO_MODEL_TYPE = ModelType4.TEXT_NANO ?? "TEXT_NANO";
+var TEXT_MEDIUM_MODEL_TYPE = ModelType4.TEXT_MEDIUM ?? "TEXT_MEDIUM";
+var TEXT_SMALL_MODEL_TYPE = ModelType4.TEXT_SMALL;
+var TEXT_LARGE_MODEL_TYPE = ModelType4.TEXT_LARGE;
+var TEXT_MEGA_MODEL_TYPE = ModelType4.TEXT_MEGA ?? "TEXT_MEGA";
+var RESPONSE_HANDLER_MODEL_TYPE = ModelType4.RESPONSE_HANDLER ?? "RESPONSE_HANDLER";
+var ACTION_PLANNER_MODEL_TYPE = ModelType4.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 timeInferenceSpan2(`cloud.http:${label}`, fn, { route: label });
+  } finally {
+    limiter.release();
+  }
+}
+function __resetNativeChatLimiterForTests() {
+  nativeChatLimiter = null;
+}
+var REASONING_MODEL_PATTERNS = [
+  "o1",
+  "o3",
+  "o4",
+  "deepseek-r1",
+  "deepseek-reasoner",
+  "claude-opus-4.7",
+  "claude-opus-4-7",
+  "gpt-5"
+];
+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;
+}
+function isReasoningModel(modelName) {
+  const lower = modelName.toLowerCase();
+  return REASONING_MODEL_PATTERNS.some((pattern) => lower.includes(pattern));
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function asRecord2(value) {
+  return isRecord(value) ? value : {};
+}
+function recordAt(value, key) {
+  return asRecord2(value[key]);
+}
+function firstString(...values) {
+  for (const value of values) {
+    if (typeof value === "string" && value.trim().length > 0) {
+      return value.trim();
+    }
+  }
+  return;
+}
+function firstNumber(...values) {
+  for (const value of values) {
+    if (typeof value === "number" && Number.isFinite(value)) {
+      return value;
+    }
+    if (typeof value === "string" && value.trim().length > 0) {
+      const parsed = Number(value);
+      if (Number.isFinite(parsed)) {
+        return parsed;
+      }
+    }
+  }
+  return;
+}
+function parseJsonIfPossible(value) {
+  if (typeof value !== "string") {
+    return value ?? {};
+  }
+  try {
+    return JSON.parse(value);
+  } catch {
+    return value;
+  }
+}
+function stringifyMessageContent(content) {
+  if (typeof content === "string") {
+    return content;
+  }
+  if (content == null) {
+    return "";
+  }
+  return typeof content === "object" ? JSON.stringify(content) : String(content);
+}
+function hasNativeTransportOptions(params) {
+  return Boolean(params.messages || params.tools || params.toolChoice || params.responseSchema || params.providerOptions);
+}
+function shouldReturnNativeResult(params) {
+  return Boolean(params.messages || params.tools || params.toolChoice || params.responseSchema);
+}
+function buildNativeMessages(params, promptText, systemPrompt) {
+  if (Array.isArray(params.messages) && params.messages.length > 0) {
+    const messages2 = params.messages.map((message) => isRecord(message) ? { ...message } : { role: "user", content: stringifyMessageContent(message) });
+    const first = asRecord2(messages2[0]);
+    if (systemPrompt && first.role !== "system") {
+      return [{ role: "system", content: systemPrompt }, ...messages2];
+    }
+    return messages2;
+  }
+  const messages = [];
+  if (systemPrompt) {
+    messages.push({ role: "system", content: systemPrompt });
+  }
+  messages.push({ role: "user", content: promptText });
+  return messages;
+}
+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)) {
+    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 entry = normalizeNativeToolEntry(rawTool, name);
+    if (entry) {
+      normalized.push(entry);
+    }
+  }
+  return normalized.length > 0 ? normalized : undefined;
+}
+function normalizeNativeToolChoice(toolChoice) {
+  if (!toolChoice) {
+    return;
+  }
+  if (typeof toolChoice === "string" && (toolChoice === "auto" || toolChoice === "none" || toolChoice === "required")) {
+    return toolChoice;
+  }
+  const choice = asRecord2(toolChoice);
+  if (choice.type === "function") {
+    return toolChoice;
+  }
+  if (choice.type === "tool") {
+    const toolName2 = firstString(choice.toolName, choice.name);
+    return toolName2 ? { type: "function", function: { name: toolName2 } } : toolChoice;
+  }
+  const functionChoice = asRecord2(choice.function);
+  const toolName = firstString(choice.toolName, choice.name, functionChoice.name);
+  return toolName ? { type: "function", function: { name: toolName } } : toolChoice;
+}
+function buildNativeResponseFormat(responseSchema) {
+  if (!responseSchema) {
+    return;
+  }
+  const schemaRecord = asRecord2(responseSchema);
+  if (schemaRecord.responseFormat) {
+    return schemaRecord.responseFormat;
+  }
+  const schemaOptions = "schema" in schemaRecord ? {
+    schema: schemaRecord.schema,
+    name: firstString(schemaRecord.name) ?? "structured_response",
+    description: firstString(schemaRecord.description)
+  } : { schema: responseSchema, name: "structured_response", description: undefined };
+  return {
+    type: "json_schema",
+    json_schema: {
+      name: schemaOptions.name,
+      ...schemaOptions.description ? { description: schemaOptions.description } : {},
+      schema: schemaOptions.schema
+    }
+  };
+}
+function resolvePromptCacheKey(providerOptions) {
+  const eliza = recordAt(providerOptions, "eliza");
+  const openrouter = recordAt(providerOptions, "openrouter");
+  const openai = recordAt(providerOptions, "openai");
+  const cerebras = recordAt(providerOptions, "cerebras");
+  return firstString(providerOptions.promptCacheKey, providerOptions.prompt_cache_key, eliza.promptCacheKey, eliza.prompt_cache_key, openrouter.promptCacheKey, openrouter.prompt_cache_key, openai.promptCacheKey, openai.prompt_cache_key, cerebras.promptCacheKey, cerebras.prompt_cache_key);
+}
+function resolveNativeProviderOptions(params) {
+  const raw = asRecord2(params.providerOptions);
+  if (Object.keys(raw).length === 0) {
+    return;
+  }
+  const { agentName: _agentName, eliza: _eliza, ...rest } = raw;
+  const providerOptions = { ...rest };
+  const promptCacheKey = resolvePromptCacheKey(raw);
+  if (promptCacheKey) {
+    providerOptions.openai = {
+      ...recordAt(providerOptions, "openai"),
+      promptCacheKey,
+      prompt_cache_key: promptCacheKey
+    };
+    providerOptions.openrouter = {
+      ...recordAt(providerOptions, "openrouter"),
+      promptCacheKey,
+      prompt_cache_key: promptCacheKey
+    };
+    providerOptions.cerebras = {
+      ...recordAt(providerOptions, "cerebras"),
+      prompt_cache_key: promptCacheKey
+    };
+  }
+  return Object.keys(providerOptions).length > 0 ? providerOptions : undefined;
+}
+function applyOpenRouterPassthroughFields(requestBody, providerOptions) {
+  if (!providerOptions) {
+    return;
+  }
+  const openrouter = recordAt(providerOptions, "openrouter");
+  if (Object.keys(openrouter).length > 0) {
+    const provider = openrouter.provider;
+    if (provider !== undefined) {
+      requestBody.provider = provider;
+    }
+    for (const key of ["models", "route", "transforms", "reasoning"]) {
+      if (openrouter[key] !== undefined) {
+        requestBody[key] = openrouter[key];
+      }
+    }
+  }
+  const gateway = providerOptions.gateway;
+  if (gateway !== undefined) {
+    requestBody.gateway = gateway;
+  }
+}
+function buildNativeRequestBody(params, modelName, promptText, systemPrompt) {
+  const providerOptions = resolveNativeProviderOptions(params);
+  const promptCacheKey = providerOptions ? resolvePromptCacheKey(providerOptions) : undefined;
+  const tools = normalizeNativeTools(params.tools);
+  const toolChoice = normalizeNativeToolChoice(params.toolChoice);
+  const responseFormat = buildNativeResponseFormat(params.responseSchema);
+  const requestBody = {
+    model: modelName,
+    messages: buildNativeMessages(params, promptText, systemPrompt),
+    max_tokens: params.maxTokens ?? 8192
+  };
+  if (!isReasoningModel(modelName) && typeof params.temperature === "number") {
+    requestBody.temperature = params.temperature;
+  }
+  if (tools) {
+    requestBody.tools = tools;
+  }
+  if (toolChoice) {
+    requestBody.tool_choice = toolChoice;
+  }
+  if (responseFormat) {
+    requestBody.response_format = responseFormat;
+  }
+  if (providerOptions) {
+    requestBody.providerOptions = providerOptions;
+    requestBody.provider_options = providerOptions;
+  }
+  if (promptCacheKey) {
+    requestBody.promptCacheKey = promptCacheKey;
+    requestBody.prompt_cache_key = promptCacheKey;
+  }
+  applyOpenRouterPassthroughFields(requestBody, providerOptions);
+  return requestBody;
+}
+function extractTextFromContent(content) {
+  if (typeof content === "string") {
+    return content;
+  }
+  if (!Array.isArray(content)) {
+    return "";
+  }
+  return content.map((item) => {
+    if (typeof item === "string")
+      return item;
+    const record = asRecord2(item);
+    return firstString(record.text, record.output_text, record.content) ?? "";
+  }).join("");
+}
+function extractChatCompletionText(data) {
+  const firstChoice = data.choices?.[0];
+  if (!firstChoice) {
+    return "";
+  }
+  return firstString(firstChoice.text, extractTextFromContent(firstChoice.message?.content)) ?? "";
+}
+function extractNativeToolCalls(data) {
+  const rawCalls = data.choices?.[0]?.message?.tool_calls ?? [];
+  if (!Array.isArray(rawCalls)) {
+    return [];
+  }
+  return rawCalls.map((rawCall) => {
+    const call = asRecord2(rawCall);
+    const fn = recordAt(call, "function");
+    const toolName = firstString(call.name, call.toolName, fn.name);
+    if (!toolName) {
+      return;
+    }
+    return {
+      type: "tool-call",
+      toolCallId: firstString(call.id, call.toolCallId) ?? `call_${toolName}`,
+      toolName,
+      input: parseJsonIfPossible(call.input ?? call.arguments ?? fn.arguments ?? {})
+    };
+  }).filter((call) => call !== undefined);
+}
+function convertNativeUsage(usage) {
+  const root = asRecord2(usage);
+  if (Object.keys(root).length === 0) {
+    return;
+  }
+  const inputTokenDetails = recordAt(root, "inputTokenDetails");
+  const promptTokenDetails = recordAt(root, "prompt_tokens_details");
+  const inputTokenDetailsSnake = recordAt(root, "input_tokens_details");
+  const promptTokens = firstNumber(root.inputTokens, root.input_tokens, root.promptTokens, root.prompt_tokens) ?? 0;
+  const completionTokens = firstNumber(root.outputTokens, root.output_tokens, root.completionTokens, root.completion_tokens) ?? 0;
+  const cacheReadInputTokens = firstNumber(root.cacheReadInputTokens, root.cache_read_input_tokens, root.cachedInputTokens, root.cached_input_tokens, root.cachedTokens, root.cached_tokens, inputTokenDetails.cacheReadTokens, inputTokenDetails.cachedInputTokens, inputTokenDetails.cachedTokens, promptTokenDetails.cached_tokens, inputTokenDetailsSnake.cache_read_input_tokens, inputTokenDetailsSnake.cached_tokens);
+  const cacheCreationInputTokens = firstNumber(root.cacheCreationInputTokens, root.cache_creation_input_tokens, root.cacheWriteInputTokens, root.cache_write_input_tokens, inputTokenDetails.cacheCreationInputTokens, inputTokenDetails.cacheCreationTokens, inputTokenDetails.cacheWriteTokens, inputTokenDetailsSnake.cache_creation_input_tokens);
+  return {
+    promptTokens,
+    completionTokens,
+    totalTokens: firstNumber(root.totalTokens, root.total_tokens) ?? promptTokens + completionTokens,
+    cachedPromptTokens: cacheReadInputTokens,
+    cacheReadInputTokens,
+    cacheCreationInputTokens
+  };
+}
+function getPurposeForModelType(modelType) {
+  switch (modelType) {
+    case RESPONSE_HANDLER_MODEL_TYPE:
+      return "should_respond";
+    case ACTION_PLANNER_MODEL_TYPE:
+      return "action_planner";
+    default:
+      return "response";
+  }
+}
+function getModelNameForType(runtime, modelType) {
+  switch (modelType) {
+    case TEXT_NANO_MODEL_TYPE:
+      return getNanoModel(runtime);
+    case TEXT_MEDIUM_MODEL_TYPE:
+      return getMediumModel(runtime);
+    case TEXT_SMALL_MODEL_TYPE:
+      return getSmallModel(runtime);
+    case TEXT_LARGE_MODEL_TYPE:
+      return getLargeModel(runtime);
+    case TEXT_MEGA_MODEL_TYPE:
+      return getMegaModel(runtime);
+    case RESPONSE_HANDLER_MODEL_TYPE:
+      return getResponseHandlerModel(runtime);
+    case ACTION_PLANNER_MODEL_TYPE:
+      return getActionPlannerModel(runtime);
+    default:
+      return getLargeModel(runtime);
+  }
+}
+function buildGenerateParams(runtime, modelType, params) {
+  const prompt = params.prompt ?? "";
+  const modelName = getModelNameForType(runtime, modelType);
+  const systemPrompt = resolveEffectiveSystemPrompt({
+    params,
+    fallback: buildCanonicalSystemPrompt({ character: runtime.character })
+  });
+  const promptText = renderChatMessagesForPrompt(params.messages, {
+    omitDuplicateSystem: systemPrompt
+  }) ?? prompt;
+  return { modelName, modelType, prompt: promptText, systemPrompt };
+}
+async function generateTextWithModel(runtime, modelType, params) {
+  const { modelName, prompt, systemPrompt } = buildGenerateParams(runtime, modelType, params);
+  const paramsWithNative = params;
+  logger7.debug(`[ELIZAOS_CLOUD] Generating text with ${modelType} model: ${modelName}`);
+  const paramsStreaming = params;
+  const wantsStream = Boolean(paramsStreaming.stream) && paramsStreaming.streamStructured === true && resolveStreamingEnabled();
+  logger7.log(`[ELIZAOS_CLOUD] Using ${modelType} model: ${modelName}`);
+  logger7.log(prompt);
+  if (hasNativeTransportOptions(paramsWithNative)) {
+    if (wantsStream) {
+      return streamNativeChatCompletion(runtime, modelType, paramsWithNative, {
+        modelName,
+        prompt,
+        systemPrompt
+      });
+    }
+    const nativeResult = await generateNativeChatCompletion(runtime, modelType, paramsWithNative, {
+      modelName,
+      prompt,
+      systemPrompt
+    });
+    return shouldReturnNativeResult(paramsWithNative) ? nativeResult : nativeResult.text;
+  }
+  const reasoning = isReasoningModel(modelName);
+  const input = [];
+  if (systemPrompt) {
+    input.push({
+      role: "system",
+      content: [{ type: "input_text", text: systemPrompt }]
+    });
+  }
+  input.push({
+    role: "user",
+    content: [{ type: "input_text", text: prompt }]
+  });
+  const requestBody = {
+    model: modelName,
+    input,
+    max_output_tokens: params.maxTokens ?? 8192
+  };
+  if (!reasoning && typeof params.temperature === "number") {
+    requestBody.temperature = params.temperature;
+  }
+  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) {
+    try {
+      data = JSON.parse(responseText);
+    } catch (parseErr) {
+      logger7.error(`[ELIZAOS_CLOUD] Failed to parse responses JSON: ${parseErr instanceof Error ? parseErr.message : String(parseErr)}`);
+    }
+  }
+  if (!response.ok) {
+    const errorBody = typeof data === "object" && data ? data.error : undefined;
+    const errorMessage = typeof errorBody?.message === "string" && errorBody.message.trim() ? errorBody.message.trim() : `elizaOS Cloud error ${response.status}`;
+    const requestError = new Error(errorMessage);
+    requestError.status = response.status;
+    if (errorBody) {
+      requestError.error = errorBody;
+    }
+    throw requestError;
+  }
+  if (data.usage) {
+    emitModelUsageEvent(runtime, modelType, prompt, {
+      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);
+  if (!text.trim()) {
+    throw new Error("elizaOS Cloud returned no text response");
+  }
+  return text;
+}
+async function generateNativeChatCompletion(runtime, modelType, params, context) {
+  const requestBody = buildNativeRequestBody(params, context.modelName, context.prompt, context.systemPrompt);
+  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) {
+    try {
+      data = JSON.parse(responseText);
+    } catch (parseErr) {
+      logger7.error(`[ELIZAOS_CLOUD] Failed to parse chat completions JSON: ${parseErr instanceof Error ? parseErr.message : String(parseErr)}`);
+    }
+  }
+  if (!response.ok) {
+    const errorBody = typeof data === "object" && data ? data.error : undefined;
+    const errorMessage = typeof errorBody?.message === "string" && errorBody.message.trim() ? errorBody.message.trim() : `elizaOS Cloud error ${response.status}`;
+    const requestError = new Error(errorMessage);
+    requestError.status = response.status;
+    if (errorBody) {
+      requestError.error = errorBody;
+    }
+    throw requestError;
+  }
+  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 } : {};
+      })()
+    });
+  }
+  const text = extractChatCompletionText(data);
+  const toolCalls = extractNativeToolCalls(data);
+  if (!text.trim() && toolCalls.length === 0) {
+    throw new Error("elizaOS Cloud returned no text or tool calls");
+  }
+  return {
+    text,
+    toolCalls,
+    finishReason: data.choices?.[0]?.finish_reason,
+    usage,
+    providerMetadata: {
+      modelName: context.modelName,
+      usage: data.usage
+    }
+  };
+}
+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) {
+        logger7.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);
+}
+async function handleTextNano(runtime, params) {
+  return generateTextWithModel(runtime, TEXT_NANO_MODEL_TYPE, params);
+}
+async function handleTextMedium(runtime, params) {
+  return generateTextWithModel(runtime, TEXT_MEDIUM_MODEL_TYPE, params);
+}
+async function handleTextLarge(runtime, params) {
+  return generateTextWithModel(runtime, TEXT_LARGE_MODEL_TYPE, params);
+}
+async function handleTextMega(runtime, params) {
+  return generateTextWithModel(runtime, TEXT_MEGA_MODEL_TYPE, params);
+}
+async function handleResponseHandler(runtime, params) {
+  return generateTextWithModel(runtime, RESPONSE_HANDLER_MODEL_TYPE, params);
+}
+async function handleActionPlanner(runtime, params) {
+  return generateTextWithModel(runtime, ACTION_PLANNER_MODEL_TYPE, params);
+}
+export {
+  handleTranscription,
+  handleTokenizerEncode,
+  handleTokenizerDecode,
+  handleTextToSpeech,
+  handleTextSmall,
+  handleTextNano,
+  handleTextMega,
+  handleTextMedium,
+  handleTextLarge,
+  handleTextEmbedding,
+  handleResponseHandler,
+  handleResearch,
+  handleImageGeneration,
+  handleImageDescription,
+  handleBatchTextEmbedding,
+  handleActionPlanner,
+  fetchTextToSpeech
+};
+
+//# debugId=14309D70FEEE136A64756E2164756E21