@elizaos/plugin-ollama 2.0.0-alpha.9 → 2.0.0-beta.1

package/dist/cjs/index.node.cjs

@@ -36,37 +36,43 @@ var __export = (target, all) => {
     });
 };
 
-// index.ts
-var exports_typescript = {};
-__export(exports_typescript, {
+// 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,
-  default: () => ollamaPlugin,
+  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_typescript);
+module.exports = __toCommonJS(exports_index_node);
 
 // plugin.ts
 var import_core5 = require("@elizaos/core");
 
 // models/embedding.ts
-var import_core2 = require("@elizaos/core");
+var import_core3 = require("@elizaos/core");
 var import_ai = require("ai");
-var import_ollama_ai_provider = require("ollama-ai-provider");
+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 = "gemma3:latest";
-var DEFAULT_LARGE_MODEL = "gemma3:latest";
-var DEFAULT_EMBEDDING_MODEL = "nomic-embed-text:latest";
+var DEFAULT_SMALL_MODEL = "eliza-1-2b";
+var DEFAULT_LARGE_MODEL = "eliza-1-9b";
+var DEFAULT_EMBEDDING_MODEL = "eliza-1-2b";
 function getEnvValue(key) {
   if (typeof process === "undefined" || !process.env) {
     return;
@@ -95,15 +101,111 @@ function getApiBase(runtime) {
 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";
+}
 
-// models/availability.ts
+// 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;
@@ -117,19 +219,19 @@ async function ensureModelAvailable(model, providedBaseURL, customFetch) {
     if (showRes.ok) {
       return;
     }
-    import_core.logger.info(`[Ollama] Model ${model} not found locally. Downloading...`);
+    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_core.logger.error(`Failed to pull model ${model}: ${pullRes.statusText}`);
+      import_core2.logger.error(`Failed to pull model ${model}: ${pullRes.statusText}`);
     } else {
-      import_core.logger.info(`[Ollama] Downloaded model ${model}`);
+      import_core2.logger.info(`[Ollama] Downloaded model ${model}`);
     }
   } catch (err) {
-    import_core.logger.error({ error: err }, "Error ensuring model availability");
+    import_core2.logger.error({ error: err }, "Error ensuring model availability");
   }
 }
 
@@ -138,170 +240,644 @@ async function handleTextEmbedding(runtime, params) {
   try {
     const baseURL = getBaseURL(runtime);
     const customFetch = runtime.fetch ?? undefined;
-    const ollama = import_ollama_ai_provider.createOllama({
+    const ollama = import_ollama_ai_provider_v2.createOllama({
       fetch: customFetch,
       baseURL
     });
     const modelName = getEmbeddingModel(runtime);
-    import_core2.logger.log(`[Ollama] Using TEXT_EMBEDDING model: ${modelName}`);
+    import_core3.logger.log(`[Ollama] Using TEXT_EMBEDDING model: ${modelName}`);
     await ensureModelAvailable(modelName, baseURL, customFetch);
-    const text = typeof params === "string" ? params : params ? params.text || "" : "";
+    let text = typeof params === "string" ? params : params ? params.text || "" : "";
+    const maxChars = 8000 * 4;
+    if (text.length > maxChars) {
+      import_core3.logger.warn(`[Ollama] Embedding input too long (~${Math.ceil(text.length / 4)} tokens), truncating to ~8000 tokens`);
+      text = text.slice(0, maxChars);
+    }
     const embeddingText = text || "test";
     try {
       const embedParams = {
         model: ollama.embedding(modelName),
         value: embeddingText
       };
-      const { embedding } = await import_ai.embed(embedParams);
+      const { embedding, usage } = await import_ai.embed(embedParams);
+      emitModelUsed(runtime, import_core3.ModelType.TEXT_EMBEDDING, modelName, normalizeTokenUsage(usage) ?? estimateEmbeddingUsage(embeddingText));
       return embedding;
     } catch (embeddingError) {
-      import_core2.logger.error({ error: embeddingError }, "Error generating embedding");
+      import_core3.logger.error({ error: embeddingError }, "Error generating embedding");
       return Array(1536).fill(0);
     }
   } catch (error) {
-    import_core2.logger.error({ error }, "Error in TEXT_EMBEDDING model");
+    import_core3.logger.error({ error }, "Error in TEXT_EMBEDDING model");
     return Array(1536).fill(0);
   }
 }
 
-// models/object.ts
-var import_core3 = require("@elizaos/core");
+// 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");
-var import_ollama_ai_provider2 = require("ollama-ai-provider");
-async function generateOllamaObject(ollama, model, params) {
-  try {
-    const generateParams = {
-      model: ollama(model),
-      output: "no-schema",
-      prompt: params.prompt,
-      temperature: params.temperature
+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)
     };
-    const { object } = await import_ai2.generateObject(generateParams);
-    return object;
-  } catch (error) {
-    import_core3.logger.error({ error }, "Error generating object");
-    return {};
   }
+  return Object.keys(toolSet).length > 0 ? toolSet : undefined;
 }
-async function handleObjectSmall(runtime, params) {
-  try {
-    const baseURL = getBaseURL(runtime);
-    const customFetch = runtime.fetch ?? undefined;
-    const ollama = import_ollama_ai_provider2.createOllama({
-      fetch: customFetch,
-      baseURL
-    });
-    const model = getSmallModel(runtime);
-    import_core3.logger.log(`[Ollama] Using OBJECT_SMALL model: ${model}`);
-    await ensureModelAvailable(model, baseURL, customFetch);
-    return await generateOllamaObject(ollama, model, params);
-  } catch (error) {
-    import_core3.logger.error({ error }, "Error in OBJECT_SMALL model");
-    return {};
+function normalizeNativeMessages(messages) {
+  if (!Array.isArray(messages)) {
+    return;
   }
+  return messages.map((message) => normalizeNativeMessage(message));
 }
-async function handleObjectLarge(runtime, params) {
+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 {
-    const baseURL = getBaseURL(runtime);
-    const customFetch = runtime.fetch ?? undefined;
-    const ollama = import_ollama_ai_provider2.createOllama({
-      fetch: customFetch,
-      baseURL
+    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)
     });
-    const model = getLargeModel(runtime);
-    import_core3.logger.log(`[Ollama] Using OBJECT_LARGE model: ${model}`);
-    await ensureModelAvailable(model, baseURL, customFetch);
-    return await generateOllamaObject(ollama, model, params);
-  } catch (error) {
-    import_core3.logger.error({ error }, "Error in OBJECT_LARGE model");
-    return {};
   }
+  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 import_core4 = require("@elizaos/core");
-var import_ai3 = require("ai");
-var import_ollama_ai_provider3 = require("ollama-ai-provider");
-async function generateOllamaText(ollama, model, params) {
-  try {
-    const generateParams = {
-      model: ollama(model),
-      prompt: params.prompt,
-      system: params.system,
-      temperature: params.temperature,
-      maxTokens: params.maxTokens,
-      frequencyPenalty: params.frequencyPenalty,
-      presencePenalty: params.presencePenalty,
-      stopSequences: params.stopSequences
-    };
-    const { text: ollamaResponse } = await import_ai3.generateText(generateParams);
-    return ollamaResponse;
-  } catch (error) {
-    import_core4.logger.error({ error }, "Error in generateOllamaText");
-    return "Error generating text. Please try again later.";
+var TEXT_NANO_MODEL_TYPE = import_core4.ModelType.TEXT_NANO ?? "TEXT_NANO";
+var TEXT_MEDIUM_MODEL_TYPE = import_core4.ModelType.TEXT_MEDIUM ?? "TEXT_MEDIUM";
+var TEXT_MEGA_MODEL_TYPE = import_core4.ModelType.TEXT_MEGA ?? "TEXT_MEGA";
+var RESPONSE_HANDLER_MODEL_TYPE = import_core4.ModelType.RESPONSE_HANDLER ?? "RESPONSE_HANDLER";
+var ACTION_PLANNER_MODEL_TYPE = import_core4.ModelType.ACTION_PLANNER ?? "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;
 }
-async function handleTextSmall(runtime, { prompt, stopSequences = [] }) {
-  try {
-    const temperature = 0.7;
-    const frequency_penalty = 0.7;
-    const presence_penalty = 0.7;
-    const max_response_length = 8000;
-    const baseURL = getBaseURL(runtime);
-    const customFetch = runtime.fetch ?? undefined;
-    const ollama = import_ollama_ai_provider3.createOllama({
-      fetch: customFetch,
-      baseURL
-    });
-    const model = getSmallModel(runtime);
-    import_core4.logger.log(`[Ollama] Using TEXT_SMALL model: ${model}`);
-    await ensureModelAvailable(model, baseURL, customFetch);
-    return await generateOllamaText(ollama, model, {
-      prompt,
-      system: runtime.character?.system ?? undefined,
-      temperature,
-      maxTokens: max_response_length,
-      frequencyPenalty: frequency_penalty,
-      presencePenalty: presence_penalty,
-      stopSequences
-    });
-  } catch (error) {
-    import_core4.logger.error({ error }, "Error in TEXT_SMALL model");
-    return "Error generating text. Please try again later.";
+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;
 }
-async function handleTextLarge(runtime, {
-  prompt,
-  stopSequences = [],
-  maxTokens = 8192,
-  temperature = 0.7,
-  frequencyPenalty = 0.7,
-  presencePenalty = 0.7
-}) {
+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;
+    const normalized = normalizeTokenUsage(usage) ?? estimateUsage(args.promptForEstimate, fullText);
+    emitModelUsed(args.runtime, args.modelType, args.model, normalized);
+    return normalized;
+  }).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) {
+        await usagePromise.catch(() => {
+          return;
+        });
+      }
+    }
+  }
+  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;
+    const normalized = normalizeTokenUsage(usage) ?? estimateUsage(args.promptForEstimate, fullText);
+    emitModelUsed(args.runtime, args.modelType, args.model, normalized);
+    return normalized;
+  }).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 {
+        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) {
+        await usagePromise.catch(() => {
+          return;
+        });
+      }
+    }
+  }
+  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 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 {
+    prompt,
+    maxTokens = 8192,
+    temperature = 0.7,
+    frequencyPenalty = 0.7,
+    presencePenalty = 0.7
+  } = params;
+  let modelIdForLog = "";
   try {
-    const model = getLargeModel(runtime);
     const baseURL = getBaseURL(runtime);
     const customFetch = runtime.fetch ?? undefined;
-    const ollama = import_ollama_ai_provider3.createOllama({
+    const ollama = import_ollama_ai_provider_v22.createOllama({
       fetch: customFetch,
       baseURL
     });
-    import_core4.logger.log(`[Ollama] Using TEXT_LARGE model: ${model}`);
+    const model = getModelNameForType(runtime, modelType);
+    modelIdForLog = model;
+    import_core4.logger.log(`[Ollama] Using ${modelType} model: ${model}`);
     await ensureModelAvailable(model, baseURL, customFetch);
-    return await generateOllamaText(ollama, model, {
-      prompt,
-      system: runtime.character?.system ?? undefined,
+    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, {
+      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,
-      maxTokens,
+      maxOutputTokens: maxTokens,
       frequencyPenalty,
       presencePenalty,
-      stopSequences
-    });
+      ...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) {
-    import_core4.logger.error({ error }, "Error in TEXT_LARGE model");
+    let endpoint = "";
+    try {
+      endpoint = getBaseURL(runtime);
+    } catch {}
+    logOllamaTextFailure("generateText", String(modelType), modelIdForLog || "(unknown)", endpoint, error);
     return "Error generating text. Please try again later.";
   }
 }
+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;
@@ -313,15 +889,39 @@ function getProcessEnv() {
   return process.env;
 }
 var env = getProcessEnv();
+var TEXT_NANO_MODEL_TYPE2 = import_core5.ModelType.TEXT_NANO ?? "TEXT_NANO";
+var TEXT_MEDIUM_MODEL_TYPE2 = import_core5.ModelType.TEXT_MEDIUM ?? "TEXT_MEDIUM";
+var TEXT_MEGA_MODEL_TYPE2 = import_core5.ModelType.TEXT_MEGA ?? "TEXT_MEGA";
+var RESPONSE_HANDLER_MODEL_TYPE2 = import_core5.ModelType.RESPONSE_HANDLER ?? "RESPONSE_HANDLER";
+var ACTION_PLANNER_MODEL_TYPE2 = import_core5.ModelType.ACTION_PLANNER ?? "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_EMBEDDING_MODEL: env.OLLAMA_EMBEDDING_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);
@@ -349,17 +949,26 @@ var ollamaPlugin = {
     [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);
     },
-    [import_core5.ModelType.OBJECT_SMALL]: async (runtime, params) => {
-      return handleObjectSmall(runtime, params);
+    [TEXT_MEGA_MODEL_TYPE2]: async (runtime, params) => {
+      return handleTextMega(runtime, params);
+    },
+    [RESPONSE_HANDLER_MODEL_TYPE2]: async (runtime, params) => {
+      return handleResponseHandler(runtime, params);
     },
-    [import_core5.ModelType.OBJECT_LARGE]: async (runtime, params) => {
-      return handleObjectLarge(runtime, params);
+    [ACTION_PLANNER_MODEL_TYPE2]: async (runtime, params) => {
+      return handleActionPlanner(runtime, params);
     }
   },
   tests: [
@@ -384,7 +993,8 @@ var ollamaPlugin = {
           name: "ollama_test_text_embedding",
           fn: async (runtime) => {
             try {
-              const embedding = await runtime.useModel(import_core5.ModelType.TEXT_EMBEDDING, {
+              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");
@@ -397,7 +1007,8 @@ var ollamaPlugin = {
           name: "ollama_test_text_large",
           fn: async (runtime) => {
             try {
-              const text = await runtime.useModel(import_core5.ModelType.TEXT_LARGE, {
+              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) {
@@ -414,7 +1025,8 @@ var ollamaPlugin = {
           name: "ollama_test_text_small",
           fn: async (runtime) => {
             try {
-              const text = await runtime.useModel(import_core5.ModelType.TEXT_SMALL, {
+              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) {
@@ -428,32 +1040,42 @@ var ollamaPlugin = {
           }
         },
         {
-          name: "ollama_test_object_small",
+          name: "ollama_test_structured_output_via_text_small",
           fn: async (runtime) => {
             try {
-              const object = await runtime.useModel(import_core5.ModelType.OBJECT_SMALL, {
+              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,
-                schema: undefined
+                responseSchema: {
+                  type: "object",
+                  properties: {
+                    name: { type: "string" },
+                    age: { type: "number" },
+                    hobbies: { type: "array", items: { type: "string" } }
+                  },
+                  required: ["name", "age", "hobbies"]
+                }
               });
-              import_core5.logger.log({ object }, "Generated object");
+              import_core5.logger.log({ result }, "Generated structured output via TEXT_SMALL");
             } catch (error) {
-              import_core5.logger.error({ error }, "Error in test_object_small");
+              import_core5.logger.error({ error }, "Error in test_structured_output_via_text_small");
             }
           }
         },
         {
-          name: "ollama_test_object_large",
+          name: "ollama_test_structured_output_via_text_large",
           fn: async (runtime) => {
             try {
-              const object = await runtime.useModel(import_core5.ModelType.OBJECT_LARGE, {
+              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,
-                schema: undefined
+                responseSchema: { type: "object" }
               });
-              import_core5.logger.log({ object }, "Generated object");
+              import_core5.logger.log({ result }, "Generated structured output via TEXT_LARGE");
             } catch (error) {
-              import_core5.logger.error({ error }, "Error in test_object_large");
+              import_core5.logger.error({ error }, "Error in test_structured_output_via_text_large");
             }
           }
         }
@@ -461,6 +1083,9 @@ var ollamaPlugin = {
     }
   ]
 };
+// index.node.ts
+var defaultOllamaPlugin = ollamaPlugin;
+var index_node_default = defaultOllamaPlugin;
 
-//# debugId=70C8419794B857FF64756E2164756E21
+//# debugId=067D163DA297C55B64756E2164756E21
 //# sourceMappingURL=index.node.cjs.map