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

package/dist/models/text.js

@@ -0,0 +1,803 @@
+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 = "deepseek/deepseek-v4-pro";
+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";
+}
+
+// src/utils/sdk-client.ts
+import { CloudApiClient, 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 CloudApiClient(trimTrailingSlash(baseUrl), apiKeyForRuntime(runtime, embedding));
+}
+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) {
+  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
+    }
+  };
+  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)) {
+    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 logger2,
+  ModelType,
+  renderChatMessagesForPrompt,
+  resolveEffectiveSystemPrompt
+} from "@elizaos/core";
+var TEXT_NANO_MODEL_TYPE = ModelType.TEXT_NANO ?? "TEXT_NANO";
+var TEXT_MEDIUM_MODEL_TYPE = ModelType.TEXT_MEDIUM ?? "TEXT_MEDIUM";
+var TEXT_SMALL_MODEL_TYPE = ModelType.TEXT_SMALL;
+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 REASONING_MODEL_PATTERNS = [
+  "o1",
+  "o3",
+  "o4",
+  "deepseek-r1",
+  "deepseek-reasoner",
+  "claude-opus-4.7",
+  "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 } : {}
+    });
+  }
+  return content;
+}
+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 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 normalizeNativeTools(tools) {
+  if (!tools) {
+    return;
+  }
+  if (Array.isArray(tools)) {
+    return tools;
+  }
+  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
+      }
+    });
+  }
+  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 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 })
+  });
+  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 };
+}
+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.");
+  }
+  logger2.log(`[ELIZAOS_CLOUD] Using ${modelType} model: ${modelName}`);
+  logger2.log(prompt);
+  if (hasNativeTransportOptions(paramsWithNative)) {
+    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 response = await createCloudApiClient(runtime).requestRaw("POST", "/responses", {
+    headers: {
+      "X-Eliza-Llm-Purpose": getPurposeForModelType(modelType),
+      "X-Eliza-Model-Type": modelType
+    },
+    json: requestBody
+  });
+  const responseText = await response.text();
+  let data = {};
+  if (responseText) {
+    try {
+      data = JSON.parse(responseText);
+    } catch (parseErr) {
+      logger2.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
+    });
+  }
+  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 response = await createCloudApiClient(runtime).requestRaw("POST", "/chat/completions", {
+    headers: {
+      "X-Eliza-Llm-Purpose": getPurposeForModelType(modelType),
+      "X-Eliza-Model-Type": modelType
+    },
+    json: requestBody
+  });
+  const responseText = await response.text();
+  let data = {};
+  if (responseText) {
+    try {
+      data = JSON.parse(responseText);
+    } catch (parseErr) {
+      logger2.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);
+  }
+  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
+    }
+  };
+}
+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 {
+  handleTextSmall,
+  handleTextNano,
+  handleTextMega,
+  handleTextMedium,
+  handleTextLarge,
+  handleResponseHandler,
+  handleActionPlanner
+};
+
+//# debugId=DF0E0E9E46BB9DE664756E2164756E21