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

package/dist/node/index.node.js

@@ -1,16 +1,16 @@
 // plugin.ts
-import { logger as logger5, ModelType } from "@elizaos/core";
+import { logger as logger4, ModelType as ModelType3 } from "@elizaos/core";
 
 // models/embedding.ts
-import { logger as logger2 } from "@elizaos/core";
+import { logger as logger2, ModelType } from "@elizaos/core";
 import { embed } from "ai";
-import { createOllama } from "ollama-ai-provider";
+import { createOllama } from "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;
@@ -39,12 +39,108 @@ 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";
+}
+
+// utils/modelUsage.ts
+import { EventType } from "@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(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
 import { logger } from "@elizaos/core";
@@ -89,14 +185,20 @@ async function handleTextEmbedding(runtime, params) {
     const modelName = getEmbeddingModel(runtime);
     logger2.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) {
+      logger2.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 embed(embedParams);
+      const { embedding, usage } = await embed(embedParams);
+      emitModelUsed(runtime, ModelType.TEXT_EMBEDDING, modelName, normalizeTokenUsage(usage) ?? estimateEmbeddingUsage(embeddingText));
       return embedding;
     } catch (embeddingError) {
       logger2.error({ error: embeddingError }, "Error generating embedding");
@@ -108,144 +210,626 @@ async function handleTextEmbedding(runtime, params) {
   }
 }
 
-// models/object.ts
-import { logger as logger3 } from "@elizaos/core";
-import { generateObject } from "ai";
-import { createOllama as createOllama2 } from "ollama-ai-provider";
-async function generateOllamaObject(ollama, model, params) {
-  try {
-    const generateParams = {
-      model: ollama(model),
-      output: "no-schema",
-      prompt: params.prompt,
-      temperature: params.temperature
+// models/text.ts
+import {
+  buildCanonicalSystemPrompt,
+  dropDuplicateLeadingSystemMessage,
+  logger as logger3,
+  ModelType as ModelType2,
+  renderChatMessagesForPrompt,
+  resolveEffectiveSystemPrompt
+} from "@elizaos/core";
+import {
+  generateText,
+  jsonSchema as jsonSchema2,
+  Output,
+  streamText
+} from "ai";
+import { createOllama as createOllama2 } from "ollama-ai-provider-v2";
+
+// utils/ai-sdk-wire.ts
+import {
+  jsonSchema
+} from "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: jsonSchema(inputSchema)
     };
-    const { object } = await generateObject(generateParams);
-    return object;
-  } catch (error) {
-    logger3.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 = createOllama2({
-      fetch: customFetch,
-      baseURL
-    });
-    const model = getSmallModel(runtime);
-    logger3.log(`[Ollama] Using OBJECT_SMALL model: ${model}`);
-    await ensureModelAvailable(model, baseURL, customFetch);
-    return await generateOllamaObject(ollama, model, params);
-  } catch (error) {
-    logger3.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 = createOllama2({
-      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);
-    logger3.log(`[Ollama] Using OBJECT_LARGE model: ${model}`);
-    await ensureModelAvailable(model, baseURL, customFetch);
-    return await generateOllamaObject(ollama, model, params);
-  } catch (error) {
-    logger3.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
-import { logger as logger4 } from "@elizaos/core";
-import { generateText } from "ai";
-import { createOllama as createOllama3 } from "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 generateText(generateParams);
-    return ollamaResponse;
-  } catch (error) {
-    logger4.error({ error }, "Error in generateOllamaText");
-    return "Error generating text. Please try again later.";
+var TEXT_NANO_MODEL_TYPE = ModelType2.TEXT_NANO ?? "TEXT_NANO";
+var TEXT_MEDIUM_MODEL_TYPE = ModelType2.TEXT_MEDIUM ?? "TEXT_MEDIUM";
+var TEXT_MEGA_MODEL_TYPE = ModelType2.TEXT_MEGA ?? "TEXT_MEGA";
+var RESPONSE_HANDLER_MODEL_TYPE = ModelType2.RESPONSE_HANDLER ?? "RESPONSE_HANDLER";
+var ACTION_PLANNER_MODEL_TYPE = ModelType2.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 = createOllama3({
-      fetch: customFetch,
-      baseURL
-    });
-    const model = getSmallModel(runtime);
-    logger4.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) {
-    logger4.error({ error }, "Error in TEXT_SMALL model");
-    return "Error generating text. Please try again later.";
+function logOllamaTextFailure(phase, modelType, modelId, endpoint, error) {
+  logger3.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 Output.object({
+    schema: jsonSchema2(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 = 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 = 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 ModelType2.TEXT_SMALL:
+      return getSmallModel(runtime);
+    case ModelType2.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 handleTextLarge(runtime, {
-  prompt,
-  stopSequences = [],
-  maxTokens = 8192,
-  temperature = 0.7,
-  frequencyPenalty = 0.7,
-  presencePenalty = 0.7
-}) {
+async function handleTextWithModelType(runtime, modelType, params) {
+  const extended = params;
+  const structuredDisabled = isOllamaStructuredOutputDisabled(runtime);
+  let responseSchema = extended.responseSchema;
+  if (structuredDisabled && extended.responseSchema) {
+    logger3.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 = createOllama3({
+    const ollama = createOllama2({
       fetch: customFetch,
       baseURL
     });
-    logger4.log(`[Ollama] Using TEXT_LARGE model: ${model}`);
+    const model = getModelNameForType(runtime, modelType);
+    modelIdForLog = model;
+    logger3.log(`[Ollama] Using ${modelType} model: ${model}`);
     await ensureModelAvailable(model, baseURL, customFetch);
-    return await generateOllamaText(ollama, model, {
-      prompt,
-      system: runtime.character?.system ?? undefined,
+    const system = resolveEffectiveSystemPrompt({
+      params,
+      fallback: buildCanonicalSystemPrompt({ character: runtime.character })
+    });
+    let outputSpec = responseSchema !== undefined && responseSchema !== null ? buildStructuredOutput(responseSchema) : undefined;
+    if (tools && outputSpec) {
+      logger3.debug("[Ollama] tools and responseSchema both present — omitting structured output for this call.");
+      outputSpec = undefined;
+    }
+    const wireRaw = 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 ? "" : 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
+          });
+        }
+        logger3.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 {
+        logger3.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 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) {
-    logger4.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, ModelType2.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, ModelType2.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;
@@ -257,15 +841,39 @@ function getProcessEnv() {
   return process.env;
 }
 var env = getProcessEnv();
+var TEXT_NANO_MODEL_TYPE2 = ModelType3.TEXT_NANO ?? "TEXT_NANO";
+var TEXT_MEDIUM_MODEL_TYPE2 = ModelType3.TEXT_MEDIUM ?? "TEXT_MEDIUM";
+var TEXT_MEGA_MODEL_TYPE2 = ModelType3.TEXT_MEGA ?? "TEXT_MEGA";
+var RESPONSE_HANDLER_MODEL_TYPE2 = ModelType3.RESPONSE_HANDLER ?? "RESPONSE_HANDLER";
+var ACTION_PLANNER_MODEL_TYPE2 = ModelType3.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);
@@ -273,7 +881,7 @@ var ollamaPlugin = {
     if (!baseURL || baseURL === "http://localhost:11434/api") {
       const endpoint = runtime.getSetting("OLLAMA_API_ENDPOINT");
       if (!endpoint) {
-        logger5.warn("OLLAMA_API_ENDPOINT not set, using default localhost:11434");
+        logger4.warn("OLLAMA_API_ENDPOINT not set, using default localhost:11434");
       }
     }
     try {
@@ -282,28 +890,37 @@ var ollamaPlugin = {
         headers: { "Content-Type": "application/json" }
       });
       if (!response.ok) {
-        logger5.warn(`Ollama API validation failed: ${response.statusText}`);
+        logger4.warn(`Ollama API validation failed: ${response.statusText}`);
       }
     } catch (fetchError) {
       const message = fetchError instanceof Error ? fetchError.message : String(fetchError);
-      logger5.warn(`Ollama API validation error: ${message}`);
+      logger4.warn(`Ollama API validation error: ${message}`);
     }
   },
   models: {
-    [ModelType.TEXT_EMBEDDING]: async (runtime, params) => {
+    [ModelType3.TEXT_EMBEDDING]: async (runtime, params) => {
       return handleTextEmbedding(runtime, params);
     },
-    [ModelType.TEXT_SMALL]: async (runtime, params) => {
+    [TEXT_NANO_MODEL_TYPE2]: async (runtime, params) => {
+      return handleTextNano(runtime, params);
+    },
+    [ModelType3.TEXT_SMALL]: async (runtime, params) => {
       return handleTextSmall(runtime, params);
     },
-    [ModelType.TEXT_LARGE]: async (runtime, params) => {
+    [TEXT_MEDIUM_MODEL_TYPE2]: async (runtime, params) => {
+      return handleTextMedium(runtime, params);
+    },
+    [ModelType3.TEXT_LARGE]: async (runtime, params) => {
       return handleTextLarge(runtime, params);
     },
-    [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);
     },
-    [ModelType.OBJECT_LARGE]: async (runtime, params) => {
-      return handleObjectLarge(runtime, params);
+    [ACTION_PLANNER_MODEL_TYPE2]: async (runtime, params) => {
+      return handleActionPlanner(runtime, params);
     }
   },
   tests: [
@@ -317,10 +934,10 @@ var ollamaPlugin = {
               const apiBase = getApiBase(runtime);
               const response = await fetch(`${apiBase}/api/tags`);
               if (!response.ok) {
-                logger5.error(`Failed to validate Ollama API: ${response.statusText}`);
+                logger4.error(`Failed to validate Ollama API: ${response.statusText}`);
               }
             } catch (error) {
-              logger5.error({ error }, "Error in ollama_test_url_validation");
+              logger4.error({ error }, "Error in ollama_test_url_validation");
             }
           }
         },
@@ -328,12 +945,13 @@ var ollamaPlugin = {
           name: "ollama_test_text_embedding",
           fn: async (runtime) => {
             try {
-              const embedding = await runtime.useModel(ModelType.TEXT_EMBEDDING, {
+              const runModel = runtime.useModel.bind(runtime);
+              const embedding = await runModel(ModelType3.TEXT_EMBEDDING, {
                 text: "Hello, world!"
               });
-              logger5.log({ embedding }, "Generated embedding");
+              logger4.log({ embedding }, "Generated embedding");
             } catch (error) {
-              logger5.error({ error }, "Error in test_text_embedding");
+              logger4.error({ error }, "Error in test_text_embedding");
             }
           }
         },
@@ -341,16 +959,17 @@ var ollamaPlugin = {
           name: "ollama_test_text_large",
           fn: async (runtime) => {
             try {
-              const text = await runtime.useModel(ModelType.TEXT_LARGE, {
+              const runModel = runtime.useModel.bind(runtime);
+              const text = await runModel(ModelType3.TEXT_LARGE, {
                 prompt: "What is the nature of reality in 10 words?"
               });
               if (text.length === 0) {
-                logger5.error("Failed to generate text");
+                logger4.error("Failed to generate text");
                 return;
               }
-              logger5.log({ text }, "Generated with test_text_large");
+              logger4.log({ text }, "Generated with test_text_large");
             } catch (error) {
-              logger5.error({ error }, "Error in test_text_large");
+              logger4.error({ error }, "Error in test_text_large");
             }
           }
         },
@@ -358,46 +977,57 @@ var ollamaPlugin = {
           name: "ollama_test_text_small",
           fn: async (runtime) => {
             try {
-              const text = await runtime.useModel(ModelType.TEXT_SMALL, {
+              const runModel = runtime.useModel.bind(runtime);
+              const text = await runModel(ModelType3.TEXT_SMALL, {
                 prompt: "What is the nature of reality in 10 words?"
               });
               if (text.length === 0) {
-                logger5.error("Failed to generate text");
+                logger4.error("Failed to generate text");
                 return;
               }
-              logger5.log({ text }, "Generated with test_text_small");
+              logger4.log({ text }, "Generated with test_text_small");
             } catch (error) {
-              logger5.error({ error }, "Error in test_text_small");
+              logger4.error({ error }, "Error in test_text_small");
             }
           }
         },
         {
-          name: "ollama_test_object_small",
+          name: "ollama_test_structured_output_via_text_small",
           fn: async (runtime) => {
             try {
-              const object = await runtime.useModel(ModelType.OBJECT_SMALL, {
+              const runModel = runtime.useModel.bind(runtime);
+              const result = await runModel(ModelType3.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"]
+                }
               });
-              logger5.log({ object }, "Generated object");
+              logger4.log({ result }, "Generated structured output via TEXT_SMALL");
             } catch (error) {
-              logger5.error({ error }, "Error in test_object_small");
+              logger4.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(ModelType.OBJECT_LARGE, {
+              const runModel = runtime.useModel.bind(runtime);
+              const result = await runModel(ModelType3.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" }
               });
-              logger5.log({ object }, "Generated object");
+              logger4.log({ result }, "Generated structured output via TEXT_LARGE");
             } catch (error) {
-              logger5.error({ error }, "Error in test_object_large");
+              logger4.error({ error }, "Error in test_structured_output_via_text_large");
             }
           }
         }
@@ -405,20 +1035,29 @@ var ollamaPlugin = {
     }
   ]
 };
+// index.node.ts
+var defaultOllamaPlugin = ollamaPlugin;
+var index_node_default = defaultOllamaPlugin;
 export {
   ollamaPlugin,
+  isOllamaStructuredOutputDisabled,
   getSmallModel,
   getSetting,
+  getResponseHandlerModel,
+  getNanoModel,
+  getMegaModel,
+  getMediumModel,
   getLargeModel,
   getEmbeddingModel,
   getBaseURL,
   getApiBase,
-  ollamaPlugin as default,
+  getActionPlannerModel,
+  index_node_default as default,
   DEFAULT_SMALL_MODEL,
   DEFAULT_OLLAMA_URL,
   DEFAULT_LARGE_MODEL,
   DEFAULT_EMBEDDING_MODEL
 };
 
-//# debugId=641B4F6356B09A2464756E2164756E21
+//# debugId=28C4D03399E00E1164756E2164756E21
 //# sourceMappingURL=index.node.js.map