@elizaos/plugin-ollama 2.0.3-beta.2 → 2.0.3-beta.4

package/dist/cjs/index.node.cjs

@@ -0,0 +1,1108 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toCommonJS = (from) => {
+  var entry = (__moduleCache ??= new WeakMap).get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (var key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(entry, key))
+        __defProp(entry, key, {
+          get: __accessProp.bind(from, key),
+          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+        });
+  }
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __moduleCache;
+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)
+    });
+};
+
+// index.node.ts
+var exports_index_node = {};
+__export(exports_index_node, {
+  ollamaPlugin: () => ollamaPlugin,
+  isOllamaStructuredOutputDisabled: () => isOllamaStructuredOutputDisabled,
+  getSmallModel: () => getSmallModel,
+  getSetting: () => getSetting,
+  getResponseHandlerModel: () => getResponseHandlerModel,
+  getNanoModel: () => getNanoModel,
+  getMegaModel: () => getMegaModel,
+  getMediumModel: () => getMediumModel,
+  getLargeModel: () => getLargeModel,
+  getEmbeddingModel: () => getEmbeddingModel,
+  getBaseURL: () => getBaseURL,
+  getApiBase: () => getApiBase,
+  getActionPlannerModel: () => getActionPlannerModel,
+  default: () => index_node_default,
+  DEFAULT_SMALL_MODEL: () => DEFAULT_SMALL_MODEL,
+  DEFAULT_OLLAMA_URL: () => DEFAULT_OLLAMA_URL,
+  DEFAULT_LARGE_MODEL: () => DEFAULT_LARGE_MODEL,
+  DEFAULT_EMBEDDING_MODEL: () => DEFAULT_EMBEDDING_MODEL
+});
+module.exports = __toCommonJS(exports_index_node);
+
+// plugin.ts
+var import_core5 = require("@elizaos/core");
+
+// models/embedding.ts
+var import_core3 = require("@elizaos/core");
+var import_ai = require("ai");
+var import_ollama_ai_provider_v2 = require("ollama-ai-provider-v2");
+
+// utils/config.ts
+var DEFAULT_OLLAMA_URL = "http://localhost:11434";
+var DEFAULT_SMALL_MODEL = "eliza-1-2b";
+var DEFAULT_LARGE_MODEL = "eliza-1-4b";
+var DEFAULT_EMBEDDING_MODEL = "eliza-1-2b";
+function getEnvValue(key) {
+  if (typeof process === "undefined" || !process.env) {
+    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).trim();
+  }
+  return getEnvValue(key)?.trim() ?? defaultValue;
+}
+function getBaseURL(runtime) {
+  const apiEndpoint = getSetting(runtime, "OLLAMA_API_ENDPOINT") || getSetting(runtime, "OLLAMA_API_URL") || getSetting(runtime, "OLLAMA_BASE_URL") || DEFAULT_OLLAMA_URL;
+  if (!apiEndpoint.endsWith("/api")) {
+    return apiEndpoint.endsWith("/") ? `${apiEndpoint}api` : `${apiEndpoint}/api`;
+  }
+  return apiEndpoint;
+}
+function getApiBase(runtime) {
+  const baseURL = getBaseURL(runtime);
+  return baseURL.endsWith("/api") ? baseURL.slice(0, -4) : baseURL;
+}
+function getSmallModel(runtime) {
+  return getSetting(runtime, "OLLAMA_SMALL_MODEL") || getSetting(runtime, "SMALL_MODEL") || DEFAULT_SMALL_MODEL;
+}
+function getNanoModel(runtime) {
+  return getSetting(runtime, "OLLAMA_NANO_MODEL") || getSetting(runtime, "NANO_MODEL") || getSmallModel(runtime);
+}
+function getMediumModel(runtime) {
+  return getSetting(runtime, "OLLAMA_MEDIUM_MODEL") || getSetting(runtime, "MEDIUM_MODEL") || getSmallModel(runtime);
+}
+function getLargeModel(runtime) {
+  return getSetting(runtime, "OLLAMA_LARGE_MODEL") || getSetting(runtime, "LARGE_MODEL") || DEFAULT_LARGE_MODEL;
+}
+function getMegaModel(runtime) {
+  return getSetting(runtime, "OLLAMA_MEGA_MODEL") || getSetting(runtime, "MEGA_MODEL") || getLargeModel(runtime);
+}
+function getResponseHandlerModel(runtime) {
+  return getSetting(runtime, "OLLAMA_RESPONSE_HANDLER_MODEL") || getSetting(runtime, "OLLAMA_SHOULD_RESPOND_MODEL") || getSetting(runtime, "RESPONSE_HANDLER_MODEL") || getSetting(runtime, "SHOULD_RESPOND_MODEL") || getNanoModel(runtime);
+}
+function getActionPlannerModel(runtime) {
+  return getSetting(runtime, "OLLAMA_ACTION_PLANNER_MODEL") || getSetting(runtime, "OLLAMA_PLANNER_MODEL") || getSetting(runtime, "ACTION_PLANNER_MODEL") || getSetting(runtime, "PLANNER_MODEL") || getMediumModel(runtime);
+}
+function getEmbeddingModel(runtime) {
+  return getSetting(runtime, "OLLAMA_EMBEDDING_MODEL") || DEFAULT_EMBEDDING_MODEL;
+}
+function isOllamaStructuredOutputDisabled(runtime) {
+  const v = getSetting(runtime, "OLLAMA_DISABLE_STRUCTURED_OUTPUT")?.trim().toLowerCase();
+  return v === "1" || v === "true" || v === "yes" || v === "on";
+}
+
+// utils/modelUsage.ts
+var import_core = require("@elizaos/core");
+function toFiniteNumber(value) {
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    return;
+  }
+  return Math.max(0, Math.round(value));
+}
+function normalizeTokenUsage(usage) {
+  if (!usage || typeof usage !== "object") {
+    return null;
+  }
+  const record = usage;
+  const promptTokens = toFiniteNumber(record.inputTokens ?? record.promptTokens);
+  const completionTokens = toFiniteNumber(record.outputTokens ?? record.completionTokens);
+  const totalTokens = toFiniteNumber(record.totalTokens);
+  if (promptTokens === undefined && completionTokens === undefined && totalTokens === undefined) {
+    return null;
+  }
+  const normalizedPromptTokens = promptTokens ?? (completionTokens === undefined && totalTokens !== undefined ? totalTokens : Math.max(0, (totalTokens ?? 0) - (completionTokens ?? 0)));
+  const normalizedCompletionTokens = completionTokens ?? Math.max(0, (totalTokens ?? normalizedPromptTokens) - normalizedPromptTokens);
+  return {
+    promptTokens: normalizedPromptTokens,
+    completionTokens: normalizedCompletionTokens,
+    totalTokens: totalTokens ?? normalizedPromptTokens + normalizedCompletionTokens
+  };
+}
+function estimateTokenCount(text) {
+  return text.length === 0 ? 0 : Math.ceil(text.length / 4);
+}
+function stringifyForUsage(value) {
+  if (typeof value === "string") {
+    return value;
+  }
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return String(value);
+  }
+}
+function estimateUsage(prompt, response) {
+  const promptTokens = estimateTokenCount(prompt);
+  const completionTokens = estimateTokenCount(stringifyForUsage(response));
+  return {
+    promptTokens,
+    completionTokens,
+    totalTokens: promptTokens + completionTokens,
+    estimated: true
+  };
+}
+function estimateEmbeddingUsage(text) {
+  const promptTokens = estimateTokenCount(text);
+  return {
+    promptTokens,
+    completionTokens: 0,
+    totalTokens: promptTokens,
+    estimated: true
+  };
+}
+function emitModelUsed(runtime, type, model, usage) {
+  runtime.emitEvent(import_core.EventType.MODEL_USED, {
+    runtime,
+    source: "ollama",
+    provider: "ollama",
+    type,
+    model,
+    modelName: model,
+    tokens: {
+      prompt: usage.promptTokens,
+      completion: usage.completionTokens,
+      total: usage.totalTokens,
+      ...usage.estimated ? { estimated: true } : {}
+    },
+    ...usage.estimated ? { usageEstimated: true } : {}
+  });
+}
+
+// models/availability.ts
+var import_core2 = require("@elizaos/core");
+async function ensureModelAvailable(model, providedBaseURL, customFetch) {
+  const baseURL = providedBaseURL || "http://localhost:11434/api";
+  const apiBase = baseURL.endsWith("/api") ? baseURL.slice(0, -4) : baseURL;
+  const fetcher = customFetch ?? fetch;
+  try {
+    const showRes = await fetcher(`${apiBase}/api/show`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ model })
+    });
+    if (showRes.ok) {
+      return;
+    }
+    import_core2.logger.info(`[Ollama] Model ${model} not found locally. Downloading...`);
+    const pullRes = await fetcher(`${apiBase}/api/pull`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ model, stream: false })
+    });
+    if (!pullRes.ok) {
+      import_core2.logger.error(`Failed to pull model ${model}: ${pullRes.statusText}`);
+    } else {
+      import_core2.logger.info(`[Ollama] Downloaded model ${model}`);
+    }
+  } catch (err) {
+    import_core2.logger.error({ error: err }, "Error ensuring model availability");
+  }
+}
+
+// models/embedding.ts
+var INIT_PROBE_TEXT = "dimension probe";
+function extractText(params) {
+  if (params === null) {
+    return null;
+  }
+  if (typeof params === "string") {
+    return params;
+  }
+  if (typeof params === "object" && typeof params.text === "string") {
+    return params.text;
+  }
+  throw new Error("Invalid input format for embedding: expected string or { text: string }");
+}
+async function handleTextEmbedding(runtime, params) {
+  const text = extractText(params);
+  const isInitProbe = text === null;
+  if (!isInitProbe && !text.trim()) {
+    throw new Error("Cannot generate embedding for empty text");
+  }
+  try {
+    const baseURL = getBaseURL(runtime);
+    const customFetch = runtime.fetch ?? undefined;
+    const ollama = import_ollama_ai_provider_v2.createOllama({
+      ...customFetch ? { fetch: customFetch } : {},
+      baseURL
+    });
+    const modelName = getEmbeddingModel(runtime);
+    import_core3.logger.log(`[Ollama] Using TEXT_EMBEDDING model: ${modelName}`);
+    await ensureModelAvailable(modelName, baseURL, customFetch);
+    const maxChars = 8000 * 4;
+    let embeddingText = isInitProbe ? INIT_PROBE_TEXT : text;
+    if (embeddingText.length > maxChars) {
+      import_core3.logger.warn(`[Ollama] Embedding input too long (~${Math.ceil(embeddingText.length / 4)} tokens), truncating to ~8000 tokens`);
+      embeddingText = embeddingText.slice(0, maxChars);
+    }
+    const embedParams = {
+      model: ollama.embedding(modelName),
+      value: embeddingText
+    };
+    const { embedding, usage } = await import_ai.embed(embedParams);
+    if (!isInitProbe) {
+      emitModelUsed(runtime, import_core3.ModelType.TEXT_EMBEDDING, modelName, normalizeTokenUsage(usage) ?? estimateEmbeddingUsage(embeddingText));
+    }
+    return embedding;
+  } catch (error) {
+    import_core3.logger.error({ error }, "Error in TEXT_EMBEDDING model");
+    throw error instanceof Error ? error : new Error(String(error));
+  }
+}
+
+// models/text.ts
+var import_core4 = require("@elizaos/core");
+var import_ai3 = require("ai");
+var import_ollama_ai_provider_v22 = require("ollama-ai-provider-v2");
+
+// utils/ai-sdk-wire.ts
+var import_ai2 = require("ai");
+function normalizeNativeTools(tools) {
+  if (!tools) {
+    return;
+  }
+  if (!Array.isArray(tools)) {
+    return tools;
+  }
+  const toolSet = {};
+  for (const rawTool of tools) {
+    const tool = asRecord(rawTool);
+    const functionTool = asRecord(tool.function);
+    const name = firstString(tool.name, functionTool.name);
+    if (!name) {
+      throw new Error("[Ollama] Native tool definition is missing a name.");
+    }
+    const description = firstString(tool.description, functionTool.description);
+    const rawSchema = tool.parameters ?? functionTool.parameters ?? { type: "object" };
+    const inputSchema = sanitizeJsonSchema(rawSchema, true);
+    toolSet[name] = {
+      ...description ? { description } : {},
+      inputSchema: import_ai2.jsonSchema(inputSchema)
+    };
+  }
+  return Object.keys(toolSet).length > 0 ? toolSet : undefined;
+}
+function normalizeNativeMessages(messages) {
+  if (!Array.isArray(messages)) {
+    return;
+  }
+  return messages.map((message) => normalizeNativeMessage(message));
+}
+function normalizeToolChoice(toolChoice) {
+  if (!toolChoice) {
+    return;
+  }
+  if (typeof toolChoice === "string" && (toolChoice === "auto" || toolChoice === "none" || toolChoice === "required")) {
+    return toolChoice;
+  }
+  const choice = asRecord(toolChoice);
+  if (choice.type === "tool") {
+    if (typeof choice.toolName === "string" && choice.toolName.length > 0) {
+      return toolChoice;
+    }
+    const toolName = firstString(choice.toolName, choice.name);
+    if (toolName) {
+      return { type: "tool", toolName };
+    }
+  }
+  if (choice.type === "function") {
+    const fn = asRecord(choice.function);
+    const toolName = firstString(fn.name);
+    if (toolName) {
+      return { type: "tool", toolName };
+    }
+  }
+  const namedTool = firstString(choice.name);
+  if (namedTool) {
+    return { type: "tool", toolName: namedTool };
+  }
+  return toolChoice;
+}
+function parseJsonIfPossible(value) {
+  if (typeof value !== "string") {
+    return value;
+  }
+  try {
+    return JSON.parse(value);
+  } catch {
+    return value;
+  }
+}
+function mapAiSdkToolCallsToCore(toolCalls) {
+  if (!Array.isArray(toolCalls) || toolCalls.length === 0) {
+    return [];
+  }
+  const out = [];
+  for (const tc of toolCalls) {
+    const mapped = mapOneToolCall(tc);
+    if (mapped) {
+      out.push(mapped);
+    }
+  }
+  return out;
+}
+function mapOneToolCall(tc) {
+  const r = asRecord(tc);
+  const id = String(firstString(r.toolCallId, r.id) ?? "");
+  const name = String(firstString(r.toolName, r.name) ?? "").trim();
+  if (!name) {
+    return null;
+  }
+  const rawInput = r.input ?? r.arguments ?? r.args;
+  let args;
+  if (typeof rawInput === "string") {
+    const parsed = parseJsonIfPossible(rawInput);
+    if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+      args = parsed;
+    } else {
+      args = rawInput;
+    }
+  } else if (rawInput && typeof rawInput === "object" && !Array.isArray(rawInput)) {
+    args = rawInput;
+  } else {
+    args = {};
+  }
+  return { id, name, arguments: args };
+}
+function normalizeNativeMessage(message) {
+  const raw = asRecord(message);
+  const providerOptions = asOptionalRecord(raw.providerOptions);
+  if (raw.role === "system") {
+    return {
+      role: "system",
+      content: stringifyMessageContent(raw.content),
+      ...providerOptions ? { providerOptions } : {}
+    };
+  }
+  if (raw.role === "assistant") {
+    return {
+      role: "assistant",
+      content: normalizeAssistantContent(raw),
+      ...providerOptions ? { providerOptions } : {}
+    };
+  }
+  if (raw.role === "tool") {
+    return {
+      role: "tool",
+      content: normalizeToolContent(raw),
+      ...providerOptions ? { providerOptions } : {}
+    };
+  }
+  return {
+    role: "user",
+    content: normalizeUserContent(raw.content),
+    ...providerOptions ? { providerOptions } : {}
+  };
+}
+function normalizeAssistantContent(message) {
+  const toolCalls = Array.isArray(message.toolCalls) ? message.toolCalls : [];
+  if (toolCalls.length === 0) {
+    if (Array.isArray(message.content) || typeof message.content === "string") {
+      return message.content;
+    }
+    return "";
+  }
+  const parts = [];
+  if (typeof message.content === "string" && message.content.length > 0) {
+    parts.push({ type: "text", text: message.content });
+  } else if (Array.isArray(message.content)) {
+    parts.push(...message.content);
+  }
+  for (const toolCall of toolCalls) {
+    const rawCall = asRecord(toolCall);
+    const rawFunction = asRecord(rawCall.function);
+    const toolCallId = firstString(rawCall.toolCallId, rawCall.id);
+    const toolName = firstString(rawCall.toolName, rawCall.name, rawFunction.name);
+    if (!toolCallId || !toolName) {
+      continue;
+    }
+    parts.push({
+      type: "tool-call",
+      toolCallId,
+      toolName,
+      input: parseToolCallInput(rawCall, rawFunction)
+    });
+  }
+  return parts;
+}
+function normalizeToolContent(message) {
+  if (Array.isArray(message.content)) {
+    return message.content;
+  }
+  const toolCallId = firstString(message.toolCallId, message.id) ?? "tool-call";
+  const toolName = firstString(message.toolName, message.name) ?? "tool";
+  const parsed = parseJsonIfPossible(message.content);
+  return [
+    {
+      type: "tool-result",
+      toolCallId,
+      toolName,
+      output: typeof parsed === "string" ? { type: "text", value: parsed } : { type: "json", value: parsed }
+    }
+  ];
+}
+function normalizeUserContent(content) {
+  if (Array.isArray(content)) {
+    return content;
+  }
+  return stringifyMessageContent(content);
+}
+function stringifyMessageContent(content) {
+  if (typeof content === "string") {
+    return content;
+  }
+  if (content == null) {
+    return "";
+  }
+  return typeof content === "object" ? JSON.stringify(content) : String(content);
+}
+function parseToolCallInput(rawCall, rawFunction) {
+  if ("input" in rawCall) {
+    return rawCall.input;
+  }
+  return parseJsonIfPossible(rawCall.arguments ?? rawFunction.arguments ?? {});
+}
+function sanitizeJsonSchema(schema, isRoot = false) {
+  if (!schema || typeof schema !== "object" || Array.isArray(schema)) {
+    return { type: "object" };
+  }
+  const record = schema;
+  const sanitized = { ...record };
+  if (typeof sanitized.type !== "string") {
+    const inferredType = inferJsonSchemaType(sanitized, isRoot);
+    if (inferredType) {
+      sanitized.type = inferredType;
+    }
+  }
+  if (sanitized.properties && typeof sanitized.properties === "object" && !Array.isArray(sanitized.properties)) {
+    const properties = {};
+    for (const [key, value] of Object.entries(sanitized.properties)) {
+      properties[key] = sanitizeJsonSchema(value);
+    }
+    sanitized.properties = properties;
+  }
+  if (sanitized.items) {
+    sanitized.items = Array.isArray(sanitized.items) ? sanitized.items.map((item) => sanitizeJsonSchema(item)) : sanitizeJsonSchema(sanitized.items);
+  }
+  for (const unionKey of ["anyOf", "oneOf", "allOf"]) {
+    const value = sanitized[unionKey];
+    if (Array.isArray(value)) {
+      sanitized[unionKey] = value.map((item) => sanitizeJsonSchema(item));
+    }
+  }
+  return sanitized;
+}
+function inferJsonSchemaType(schema, isRoot) {
+  if ("items" in schema && !("properties" in schema)) {
+    return "array";
+  }
+  if ("properties" in schema || "required" in schema || "additionalProperties" in schema || isRoot) {
+    return "object";
+  }
+  if (Array.isArray(schema.enum) && schema.enum.length > 0) {
+    const types = new Set(schema.enum.map((value) => typeof value));
+    if (types.size === 1) {
+      const [type] = [...types];
+      if (type === "string" || type === "number" || type === "boolean") {
+        return type;
+      }
+    }
+  }
+  return;
+}
+function asRecord(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+function asOptionalRecord(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : undefined;
+}
+function firstString(...values) {
+  for (const value of values) {
+    if (typeof value === "string" && value.length > 0) {
+      return value;
+    }
+  }
+  return;
+}
+
+// models/text.ts
+var TEXT_NANO_MODEL_TYPE = import_core4.ModelType.TEXT_NANO;
+var TEXT_MEDIUM_MODEL_TYPE = import_core4.ModelType.TEXT_MEDIUM;
+var TEXT_MEGA_MODEL_TYPE = import_core4.ModelType.TEXT_MEGA;
+var RESPONSE_HANDLER_MODEL_TYPE = import_core4.ModelType.RESPONSE_HANDLER;
+var ACTION_PLANNER_MODEL_TYPE = import_core4.ModelType.ACTION_PLANNER;
+function summarizeAiSdkErrorForLogs(error, depth = 0) {
+  if (depth > 4) {
+    return { note: "max depth summarizing nested error" };
+  }
+  if (error == null) {
+    return { raw: String(error) };
+  }
+  if (typeof error !== "object") {
+    return { message: String(error) };
+  }
+  const e = error;
+  const out = {};
+  if (typeof e.name === "string")
+    out.errorName = e.name;
+  if (typeof e.message === "string")
+    out.message = e.message;
+  if (typeof e.reason === "string")
+    out.reason = e.reason;
+  if (typeof e.url === "string")
+    out.requestUrl = e.url;
+  if (typeof e.statusCode === "number")
+    out.httpStatus = e.statusCode;
+  if (typeof e.responseBody === "string")
+    out.ollamaResponseBody = e.responseBody;
+  if (Array.isArray(e.errors)) {
+    out.attemptErrors = e.errors.map((sub, i) => ({
+      attempt: i + 1,
+      ...summarizeAiSdkErrorForLogs(sub, depth + 1)
+    }));
+  }
+  if (e.cause != null && typeof e.cause === "object") {
+    out.cause = summarizeAiSdkErrorForLogs(e.cause, depth + 1);
+  }
+  return out;
+}
+function logOllamaTextFailure(phase, modelType, modelId, endpoint, error) {
+  import_core4.logger.error({
+    src: "plugin:ollama:text",
+    phase,
+    modelType,
+    modelId,
+    ollamaApiEndpoint: endpoint,
+    ...summarizeAiSdkErrorForLogs(error)
+  }, `[Ollama] ${phase} failed (${modelType}, model=${modelId}). See ollamaResponseBody / attemptErrors for Ollama’s JSON (e.g. insufficient RAM, model missing).`);
+}
+function buildStructuredOutput(responseSchema) {
+  if (responseSchema && typeof responseSchema === "object" && "responseFormat" in responseSchema && "parseCompleteOutput" in responseSchema) {
+    return responseSchema;
+  }
+  const schemaOptions = responseSchema && typeof responseSchema === "object" && "schema" in responseSchema ? responseSchema : { schema: responseSchema };
+  return import_ai3.Output.object({
+    schema: import_ai3.jsonSchema(schemaOptions.schema),
+    ...schemaOptions.name ? { name: schemaOptions.name } : {},
+    ...schemaOptions.description ? { description: schemaOptions.description } : {}
+  });
+}
+function serializeStructuredGenerateTextResult(result) {
+  if (result.output !== undefined && result.output !== null) {
+    return typeof result.output === "string" ? result.output : JSON.stringify(result.output);
+  }
+  const trimmed = result.text.trim();
+  if (trimmed)
+    return trimmed;
+  throw new Error("[Ollama] Structured generation returned no text or output.");
+}
+function buildNativeResultCast(result, modelName, usage) {
+  const payload = {
+    text: result.text,
+    toolCalls: mapAiSdkToolCallsToCore(result.toolCalls),
+    finishReason: String(result.finishReason),
+    usage,
+    providerMetadata: { modelName }
+  };
+  return payload;
+}
+function buildOllamaStreamTextResult(args) {
+  const streamResult = import_ai3.streamText(args.streamParams);
+  const textPromise = Promise.resolve(streamResult.text).catch(() => "");
+  const finishReasonPromise = Promise.resolve(streamResult.finishReason).catch(() => {
+    return;
+  });
+  const usagePromise = Promise.resolve(streamResult.usage).then(async (usage) => {
+    const fullText = await textPromise;
+    return normalizeTokenUsage(usage) ?? estimateUsage(args.promptForEstimate, fullText);
+  }).catch(() => {
+    return;
+  });
+  async function* textStreamWithUsage() {
+    let completed = false;
+    try {
+      for await (const chunk of streamResult.textStream) {
+        yield chunk;
+      }
+      completed = true;
+    } catch (streamErr) {
+      logOllamaTextFailure("streamText.textStream", String(args.modelType), args.model, args.endpoint, streamErr);
+      throw streamErr;
+    } finally {
+      if (completed) {
+        const usage = await usagePromise.catch(() => {
+          return;
+        });
+        if (usage) {
+          emitModelUsed(args.runtime, args.modelType, args.model, usage);
+        }
+      }
+    }
+  }
+  return {
+    textStream: textStreamWithUsage(),
+    text: textPromise,
+    usage: usagePromise,
+    finishReason: finishReasonPromise
+  };
+}
+function stringifyPlannerToolArgs(arguments_) {
+  if (typeof arguments_ === "string") {
+    return arguments_;
+  }
+  return JSON.stringify(arguments_);
+}
+function buildOllamaStreamWithToolsResult(args) {
+  const streamResult = import_ai3.streamText(args.streamParams);
+  const sdkTextPromise = Promise.resolve(streamResult.text).catch(() => "");
+  const finishReasonPromise = Promise.resolve(streamResult.finishReason).catch(() => {
+    return;
+  });
+  const toolCallsPromise = Promise.resolve(streamResult.toolCalls).then((calls) => mapAiSdkToolCallsToCore(calls)).catch(() => []);
+  const usagePromise = Promise.resolve(streamResult.usage).then(async (usage) => {
+    const fullText = await sdkTextPromise;
+    return normalizeTokenUsage(usage) ?? estimateUsage(args.promptForEstimate, fullText);
+  }).catch(() => {
+    return;
+  });
+  const isNativePlannerType = args.modelType === RESPONSE_HANDLER_MODEL_TYPE || args.modelType === ACTION_PLANNER_MODEL_TYPE;
+  const textPromise = isNativePlannerType ? toolCallsPromise.then(async (mapped) => {
+    const first = mapped[0];
+    if (first) {
+      return stringifyPlannerToolArgs(first.arguments);
+    }
+    return sdkTextPromise;
+  }) : sdkTextPromise;
+  async function* textStreamWithUsage() {
+    let completed = false;
+    try {
+      if (isNativePlannerType) {
+        for await (const _ of streamResult.textStream) {}
+        const mapped = await toolCallsPromise;
+        const first = mapped[0];
+        if (first) {
+          yield stringifyPlannerToolArgs(first.arguments);
+        } else {
+          const fallbackText = await sdkTextPromise;
+          if (fallbackText) {
+            yield fallbackText;
+          }
+        }
+      } else {
+        for await (const chunk of streamResult.textStream) {
+          yield chunk;
+        }
+      }
+      completed = true;
+    } catch (streamErr) {
+      logOllamaTextFailure("streamText.textStream", String(args.modelType), args.model, args.endpoint, streamErr);
+      throw streamErr;
+    } finally {
+      if (completed) {
+        const usage = await usagePromise.catch(() => {
+          return;
+        });
+        if (usage) {
+          emitModelUsed(args.runtime, args.modelType, args.model, usage);
+        }
+      }
+    }
+  }
+  return {
+    textStream: textStreamWithUsage(),
+    text: textPromise,
+    usage: usagePromise,
+    finishReason: finishReasonPromise,
+    toolCalls: toolCallsPromise
+  };
+}
+function getModelNameForType(runtime, modelType) {
+  switch (modelType) {
+    case TEXT_NANO_MODEL_TYPE:
+      return getNanoModel(runtime);
+    case TEXT_MEDIUM_MODEL_TYPE:
+      return getMediumModel(runtime);
+    case import_core4.ModelType.TEXT_SMALL:
+      return getSmallModel(runtime);
+    case import_core4.ModelType.TEXT_LARGE:
+      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);
+  }
+}
+async function handleTextWithModelType(runtime, modelType, params) {
+  const extended = params;
+  const { prompt, temperature = 0.7, frequencyPenalty = 0.7, presencePenalty = 0.7 } = params;
+  const maxTokens = params.omitMaxTokens ? undefined : params.maxTokens ?? 8192;
+  let modelIdForLog = "";
+  try {
+    const structuredDisabled = isOllamaStructuredOutputDisabled(runtime);
+    let responseSchema = extended.responseSchema;
+    if (structuredDisabled && extended.responseSchema) {
+      import_core4.logger.debug("[Ollama] OLLAMA_DISABLE_STRUCTURED_OUTPUT is set — ignoring responseSchema for this call.");
+      responseSchema = undefined;
+    }
+    const tools = normalizeNativeTools(extended.tools);
+    const baseURL = getBaseURL(runtime);
+    const customFetch = runtime.fetch ?? undefined;
+    const ollama = import_ollama_ai_provider_v22.createOllama({
+      ...customFetch ? { fetch: customFetch } : {},
+      baseURL
+    });
+    const model = getModelNameForType(runtime, modelType);
+    modelIdForLog = model;
+    import_core4.logger.log(`[Ollama] Using ${modelType} model: ${model}`);
+    await ensureModelAvailable(model, baseURL, customFetch);
+    const system = import_core4.resolveEffectiveSystemPrompt({
+      params,
+      fallback: import_core4.buildCanonicalSystemPrompt({ character: runtime.character })
+    });
+    let outputSpec = responseSchema !== undefined && responseSchema !== null ? buildStructuredOutput(responseSchema) : undefined;
+    if (tools && outputSpec) {
+      import_core4.logger.debug("[Ollama] tools and responseSchema both present — omitting structured output for this call.");
+      outputSpec = undefined;
+    }
+    const wireRaw = import_core4.dropDuplicateLeadingSystemMessage(extended.messages, system);
+    const normalizedMessages = normalizeNativeMessages(wireRaw);
+    const hasChatMessages = Array.isArray(normalizedMessages) && normalizedMessages.length > 0;
+    const toolChoice = tools ? normalizeToolChoice(extended.toolChoice) : undefined;
+    const shouldReturnNative = Boolean(hasChatMessages || tools || extended.toolChoice || outputSpec !== undefined);
+    const renderedPrompt = hasChatMessages ? "" : import_core4.renderChatMessagesForPrompt(params.messages, {
+      ...system ? { omitDuplicateSystem: system } : {}
+    }) ?? prompt ?? "";
+    const promptOrMessages = hasChatMessages ? { messages: normalizedMessages } : { prompt: renderedPrompt };
+    const resolvedStopSequences = Array.isArray(params.stopSequences) && params.stopSequences.length > 0 ? params.stopSequences : undefined;
+    const promptForUsageEstimate = hasChatMessages ? JSON.stringify(normalizedMessages) : renderedPrompt;
+    const baseGenerateArgs = {
+      model: ollama(model),
+      ...promptOrMessages,
+      system,
+      temperature,
+      frequencyPenalty,
+      presencePenalty,
+      ...typeof maxTokens === "number" ? { maxOutputTokens: maxTokens } : {},
+      ...resolvedStopSequences ? { stopSequences: resolvedStopSequences } : {},
+      ...tools ? { tools, ...toolChoice ? { toolChoice } : {} } : {},
+      ...outputSpec ? { output: outputSpec } : {}
+    };
+    if (params.stream) {
+      if (tools) {
+        return buildOllamaStreamWithToolsResult({
+          runtime,
+          modelType,
+          model,
+          endpoint: baseURL,
+          streamParams: baseGenerateArgs,
+          promptForEstimate: promptForUsageEstimate
+        });
+      }
+      if (!extended.toolChoice) {
+        if (!outputSpec) {
+          return buildOllamaStreamTextResult({
+            runtime,
+            modelType,
+            model,
+            endpoint: baseURL,
+            streamParams: baseGenerateArgs,
+            promptForEstimate: promptForUsageEstimate
+          });
+        }
+        import_core4.logger.debug({ src: "plugin:ollama:text", modelType }, "[Ollama] stream=true with responseSchema (no tools) — using generateText. Why: ollama-ai-provider-v2 does not support structured JSON output on the streamText path for this adapter.");
+      } else {
+        import_core4.logger.debug({ src: "plugin:ollama:text", modelType }, "[Ollama] stream=true with toolChoice but no tools on wire — using generateText. Why: streamText+tools requires a ToolSet; callers should pass tools alongside toolChoice.");
+      }
+    }
+    const result = await import_ai3.generateText(baseGenerateArgs);
+    const usage = normalizeTokenUsage(result.usage) ?? estimateUsage(promptForUsageEstimate, result.text);
+    emitModelUsed(runtime, modelType, model, usage);
+    if (shouldReturnNative) {
+      if (outputSpec !== undefined) {
+        return serializeStructuredGenerateTextResult(result);
+      }
+      return buildNativeResultCast(result, model, usage);
+    }
+    return result.text;
+  } catch (error) {
+    let endpoint = "";
+    try {
+      endpoint = getBaseURL(runtime);
+    } catch {}
+    logOllamaTextFailure("generateText", String(modelType), modelIdForLog || "(unknown)", endpoint, error);
+    throw error;
+  }
+}
+async function handleTextSmall(runtime, params) {
+  return handleTextWithModelType(runtime, import_core4.ModelType.TEXT_SMALL, params);
+}
+async function handleTextNano(runtime, params) {
+  return handleTextWithModelType(runtime, TEXT_NANO_MODEL_TYPE, params);
+}
+async function handleTextMedium(runtime, params) {
+  return handleTextWithModelType(runtime, TEXT_MEDIUM_MODEL_TYPE, params);
+}
+async function handleTextLarge(runtime, params) {
+  return handleTextWithModelType(runtime, import_core4.ModelType.TEXT_LARGE, params);
+}
+async function handleTextMega(runtime, params) {
+  return handleTextWithModelType(runtime, TEXT_MEGA_MODEL_TYPE, params);
+}
+async function handleResponseHandler(runtime, params) {
+  return handleTextWithModelType(runtime, RESPONSE_HANDLER_MODEL_TYPE, params);
+}
+async function handleActionPlanner(runtime, params) {
+  return handleTextWithModelType(runtime, ACTION_PLANNER_MODEL_TYPE, params);
+}
+
+// plugin.ts
+var _globalThis = globalThis;
+_globalThis.AI_SDK_LOG_WARNINGS ??= false;
+function getProcessEnv() {
+  if (typeof process === "undefined" || !process.env) {
+    return {};
+  }
+  return process.env;
+}
+var env = getProcessEnv();
+var TEXT_NANO_MODEL_TYPE2 = import_core5.ModelType.TEXT_NANO;
+var TEXT_MEDIUM_MODEL_TYPE2 = import_core5.ModelType.TEXT_MEDIUM;
+var TEXT_MEGA_MODEL_TYPE2 = import_core5.ModelType.TEXT_MEGA;
+var RESPONSE_HANDLER_MODEL_TYPE2 = import_core5.ModelType.RESPONSE_HANDLER;
+var ACTION_PLANNER_MODEL_TYPE2 = import_core5.ModelType.ACTION_PLANNER;
+var ollamaPlugin = {
+  name: "ollama",
+  description: "Ollama plugin for local LLM inference",
+  autoEnable: {
+    envKeys: ["OLLAMA_BASE_URL"]
+  },
+  config: {
+    OLLAMA_API_ENDPOINT: env.OLLAMA_API_ENDPOINT ?? null,
+    OLLAMA_NANO_MODEL: env.OLLAMA_NANO_MODEL ?? null,
+    OLLAMA_SMALL_MODEL: env.OLLAMA_SMALL_MODEL ?? null,
+    OLLAMA_MEDIUM_MODEL: env.OLLAMA_MEDIUM_MODEL ?? null,
+    OLLAMA_LARGE_MODEL: env.OLLAMA_LARGE_MODEL ?? null,
+    OLLAMA_MEGA_MODEL: env.OLLAMA_MEGA_MODEL ?? null,
+    OLLAMA_RESPONSE_HANDLER_MODEL: env.OLLAMA_RESPONSE_HANDLER_MODEL ?? null,
+    OLLAMA_SHOULD_RESPOND_MODEL: env.OLLAMA_SHOULD_RESPOND_MODEL ?? null,
+    OLLAMA_ACTION_PLANNER_MODEL: env.OLLAMA_ACTION_PLANNER_MODEL ?? null,
+    OLLAMA_PLANNER_MODEL: env.OLLAMA_PLANNER_MODEL ?? null,
+    NANO_MODEL: env.NANO_MODEL ?? null,
+    MEDIUM_MODEL: env.MEDIUM_MODEL ?? null,
+    SMALL_MODEL: env.SMALL_MODEL ?? null,
+    LARGE_MODEL: env.LARGE_MODEL ?? null,
+    MEGA_MODEL: env.MEGA_MODEL ?? null,
+    RESPONSE_HANDLER_MODEL: env.RESPONSE_HANDLER_MODEL ?? null,
+    SHOULD_RESPOND_MODEL: env.SHOULD_RESPOND_MODEL ?? null,
+    ACTION_PLANNER_MODEL: env.ACTION_PLANNER_MODEL ?? null,
+    PLANNER_MODEL: env.PLANNER_MODEL ?? null,
+    OLLAMA_EMBEDDING_MODEL: env.OLLAMA_EMBEDDING_MODEL ?? null,
+    OLLAMA_DISABLE_STRUCTURED_OUTPUT: env.OLLAMA_DISABLE_STRUCTURED_OUTPUT ?? null
+  },
+  async init(_config, runtime) {
+    const baseURL = getBaseURL(runtime);
+    const apiBase = getApiBase(runtime);
+    if (!baseURL || baseURL === "http://localhost:11434/api") {
+      const endpoint = runtime.getSetting("OLLAMA_API_ENDPOINT");
+      if (!endpoint) {
+        import_core5.logger.warn("OLLAMA_API_ENDPOINT not set, using default localhost:11434");
+      }
+    }
+    try {
+      const fetchImpl = runtime.fetch ?? fetch;
+      const response = await fetchImpl(`${apiBase}/api/tags`, {
+        method: "GET",
+        headers: { "Content-Type": "application/json" }
+      });
+      if (!response.ok) {
+        import_core5.logger.warn(`Ollama API validation failed: ${response.statusText}`);
+      }
+    } catch (fetchError) {
+      const message = fetchError instanceof Error ? fetchError.message : String(fetchError);
+      import_core5.logger.warn(`Ollama API validation error: ${message}`);
+    }
+  },
+  models: {
+    [import_core5.ModelType.TEXT_EMBEDDING]: async (runtime, params) => {
+      return handleTextEmbedding(runtime, params);
+    },
+    [TEXT_NANO_MODEL_TYPE2]: async (runtime, params) => {
+      return handleTextNano(runtime, params);
+    },
+    [import_core5.ModelType.TEXT_SMALL]: async (runtime, params) => {
+      return handleTextSmall(runtime, params);
+    },
+    [TEXT_MEDIUM_MODEL_TYPE2]: async (runtime, params) => {
+      return handleTextMedium(runtime, params);
+    },
+    [import_core5.ModelType.TEXT_LARGE]: async (runtime, params) => {
+      return handleTextLarge(runtime, params);
+    },
+    [TEXT_MEGA_MODEL_TYPE2]: async (runtime, params) => {
+      return handleTextMega(runtime, params);
+    },
+    [RESPONSE_HANDLER_MODEL_TYPE2]: async (runtime, params) => {
+      return handleResponseHandler(runtime, params);
+    },
+    [ACTION_PLANNER_MODEL_TYPE2]: async (runtime, params) => {
+      return handleActionPlanner(runtime, params);
+    }
+  },
+  tests: [
+    {
+      name: "ollama_plugin_tests",
+      tests: [
+        {
+          name: "ollama_test_url_validation",
+          fn: async (runtime) => {
+            try {
+              const apiBase = getApiBase(runtime);
+              const response = await fetch(`${apiBase}/api/tags`);
+              if (!response.ok) {
+                import_core5.logger.error(`Failed to validate Ollama API: ${response.statusText}`);
+              }
+            } catch (error) {
+              import_core5.logger.error({ error }, "Error in ollama_test_url_validation");
+            }
+          }
+        },
+        {
+          name: "ollama_test_text_embedding",
+          fn: async (runtime) => {
+            try {
+              const runModel = runtime.useModel.bind(runtime);
+              const embedding = await runModel(import_core5.ModelType.TEXT_EMBEDDING, {
+                text: "Hello, world!"
+              });
+              import_core5.logger.log({ embedding }, "Generated embedding");
+            } catch (error) {
+              import_core5.logger.error({ error }, "Error in test_text_embedding");
+            }
+          }
+        },
+        {
+          name: "ollama_test_text_large",
+          fn: async (runtime) => {
+            try {
+              const runModel = runtime.useModel.bind(runtime);
+              const text = await runModel(import_core5.ModelType.TEXT_LARGE, {
+                prompt: "What is the nature of reality in 10 words?"
+              });
+              if (text.length === 0) {
+                import_core5.logger.error("Failed to generate text");
+                return;
+              }
+              import_core5.logger.log({ text }, "Generated with test_text_large");
+            } catch (error) {
+              import_core5.logger.error({ error }, "Error in test_text_large");
+            }
+          }
+        },
+        {
+          name: "ollama_test_text_small",
+          fn: async (runtime) => {
+            try {
+              const runModel = runtime.useModel.bind(runtime);
+              const text = await runModel(import_core5.ModelType.TEXT_SMALL, {
+                prompt: "What is the nature of reality in 10 words?"
+              });
+              if (text.length === 0) {
+                import_core5.logger.error("Failed to generate text");
+                return;
+              }
+              import_core5.logger.log({ text }, "Generated with test_text_small");
+            } catch (error) {
+              import_core5.logger.error({ error }, "Error in test_text_small");
+            }
+          }
+        },
+        {
+          name: "ollama_test_structured_output_via_text_small",
+          fn: async (runtime) => {
+            try {
+              const runModel = runtime.useModel.bind(runtime);
+              const result = await runModel(import_core5.ModelType.TEXT_SMALL, {
+                prompt: "Generate a JSON object representing a user profile with name, age, and hobbies",
+                temperature: 0.7,
+                responseSchema: {
+                  type: "object",
+                  properties: {
+                    name: { type: "string" },
+                    age: { type: "number" },
+                    hobbies: { type: "array", items: { type: "string" } }
+                  },
+                  required: ["name", "age", "hobbies"]
+                }
+              });
+              import_core5.logger.log({ result }, "Generated structured output via TEXT_SMALL");
+            } catch (error) {
+              import_core5.logger.error({ error }, "Error in test_structured_output_via_text_small");
+            }
+          }
+        },
+        {
+          name: "ollama_test_structured_output_via_text_large",
+          fn: async (runtime) => {
+            try {
+              const runModel = runtime.useModel.bind(runtime);
+              const result = await runModel(import_core5.ModelType.TEXT_LARGE, {
+                prompt: "Generate a detailed JSON object representing a restaurant with name, cuisine type, menu items with prices, and customer reviews",
+                temperature: 0.7,
+                responseSchema: { type: "object" }
+              });
+              import_core5.logger.log({ result }, "Generated structured output via TEXT_LARGE");
+            } catch (error) {
+              import_core5.logger.error({ error }, "Error in test_structured_output_via_text_large");
+            }
+          }
+        }
+      ]
+    }
+  ]
+};
+// index.node.ts
+var defaultOllamaPlugin = ollamaPlugin;
+var index_node_default = defaultOllamaPlugin;
+
+//# debugId=88040C7A9C8949A364756E2164756E21
+//# sourceMappingURL=index.node.cjs.map