@elizaos/plugin-lmstudio 2.0.3-beta.6 → 2.0.3-beta.7

package/dist/cjs/index.node.cjs

@@ -0,0 +1,879 @@
+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, {
+  shouldAutoDetect: () => shouldAutoDetect,
+  parseModelsResponse: () => parseModelsResponse,
+  lmStudioPlugin: () => lmStudioPlugin,
+  getSmallModel: () => getSmallModel,
+  getSetting: () => getSetting,
+  getLargeModel: () => getLargeModel,
+  getEmbeddingModel: () => getEmbeddingModel,
+  getBaseURL: () => getBaseURL,
+  getApiKey: () => getApiKey,
+  getApiBase: () => getApiBase,
+  detectLMStudio: () => detectLMStudio,
+  default: () => index_node_default,
+  DEFAULT_LMSTUDIO_URL: () => DEFAULT_LMSTUDIO_URL
+});
+module.exports = __toCommonJS(exports_index_node);
+
+// plugin.ts
+var import_core4 = require("@elizaos/core");
+
+// models/embedding.ts
+var import_core2 = require("@elizaos/core");
+var import_ai = require("ai");
+
+// utils/client.ts
+var import_openai_compatible = require("@ai-sdk/openai-compatible");
+
+// utils/config.ts
+var DEFAULT_LMSTUDIO_URL = "http://localhost:1234/v1";
+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);
+  }
+  return getEnvValue(key) ?? defaultValue;
+}
+function getBaseURL(runtime) {
+  const raw = getSetting(runtime, "LMSTUDIO_BASE_URL") ?? DEFAULT_LMSTUDIO_URL;
+  const trimmed = raw.trim().replace(/\/+$/, "");
+  if (trimmed === "") {
+    return DEFAULT_LMSTUDIO_URL;
+  }
+  if (/\/v\d+$/.test(trimmed)) {
+    return trimmed;
+  }
+  return `${trimmed}/v1`;
+}
+function getApiBase(runtime) {
+  const baseURL = getBaseURL(runtime);
+  return baseURL.replace(/\/v\d+$/, "");
+}
+function getApiKey(runtime) {
+  const value = getSetting(runtime, "LMSTUDIO_API_KEY");
+  if (!value || value.trim() === "") {
+    return;
+  }
+  return value.trim();
+}
+function getSmallModel(runtime) {
+  return getSetting(runtime, "LMSTUDIO_SMALL_MODEL") ?? getSetting(runtime, "SMALL_MODEL") ?? undefined;
+}
+function getLargeModel(runtime) {
+  return getSetting(runtime, "LMSTUDIO_LARGE_MODEL") ?? getSetting(runtime, "LARGE_MODEL") ?? undefined;
+}
+function getEmbeddingModel(runtime) {
+  return getSetting(runtime, "LMSTUDIO_EMBEDDING_MODEL") ?? undefined;
+}
+function shouldAutoDetect(runtime) {
+  const value = getSetting(runtime, "LMSTUDIO_AUTO_DETECT", "true")?.trim().toLowerCase();
+  if (value === undefined || value === "") {
+    return true;
+  }
+  return value === "1" || value === "true" || value === "yes" || value === "on";
+}
+
+// utils/client.ts
+function createLMStudioClient(runtime) {
+  const baseURL = getBaseURL(runtime);
+  const apiKey = getApiKey(runtime);
+  return import_openai_compatible.createOpenAICompatible({
+    name: "lmstudio",
+    baseURL,
+    ...apiKey ? { apiKey } : {},
+    ...runtime.fetch ? { fetch: runtime.fetch } : {},
+    includeUsage: true
+  });
+}
+
+// utils/model-usage.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: "lmstudio",
+    provider: "lmstudio",
+    type,
+    model,
+    modelName: model,
+    tokens: {
+      prompt: usage.promptTokens,
+      completion: usage.completionTokens,
+      total: usage.totalTokens,
+      ...usage.estimated ? { estimated: true } : {}
+    },
+    ...usage.estimated ? { usageEstimated: true } : {}
+  });
+}
+
+// models/embedding.ts
+var DEFAULT_ZERO_VECTOR_DIM = 1536;
+function extractText(params) {
+  if (params === null) {
+    return "";
+  }
+  if (typeof params === "string") {
+    return params;
+  }
+  if (typeof params === "object" && typeof params.text === "string") {
+    return params.text;
+  }
+  return "";
+}
+async function handleTextEmbedding(runtime, params) {
+  const modelName = getEmbeddingModel(runtime);
+  if (!modelName) {
+    import_core2.logger.warn("[LMStudio] LMSTUDIO_EMBEDDING_MODEL not set — returning zero vector. Set it to a loaded embedding model in LM Studio.");
+    return new Array(DEFAULT_ZERO_VECTOR_DIM).fill(0);
+  }
+  let text = extractText(params);
+  const maxChars = 8000 * 4;
+  if (text.length > maxChars) {
+    import_core2.logger.warn(`[LMStudio] 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 client = createLMStudioClient(runtime);
+    const { embedding, usage } = await import_ai.embed({
+      model: client.textEmbeddingModel(modelName),
+      value: embeddingText
+    });
+    emitModelUsed(runtime, import_core2.ModelType.TEXT_EMBEDDING, modelName, normalizeTokenUsage(usage) ?? estimateEmbeddingUsage(embeddingText));
+    return embedding;
+  } catch (error) {
+    import_core2.logger.error({ error }, "[LMStudio] Error generating embedding");
+    throw error;
+  }
+}
+
+// models/text.ts
+var import_core3 = require("@elizaos/core");
+var import_ai2 = require("ai");
+
+// utils/detect.ts
+function normalizeBaseURL(input) {
+  const raw = (input ?? DEFAULT_LMSTUDIO_URL).replace(/\/+$/, "");
+  if (/\/v\d+$/.test(raw)) {
+    return raw;
+  }
+  return `${raw}/v1`;
+}
+function parseModelsResponse(body) {
+  if (Array.isArray(body)) {
+    return body.filter((entry) => {
+      return Boolean(entry) && typeof entry.id === "string";
+    });
+  }
+  if (body && typeof body === "object") {
+    const shaped = body;
+    if (Array.isArray(shaped.data)) {
+      return shaped.data.filter((entry) => {
+        return Boolean(entry) && typeof entry.id === "string";
+      });
+    }
+  }
+  return null;
+}
+async function detectLMStudio(options = {}) {
+  const baseURL = normalizeBaseURL(options.baseURL);
+  const fetcher = options.fetcher ?? fetch;
+  const timeoutMs = options.timeoutMs ?? 1500;
+  const controller = new AbortController;
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    const headers = { "Content-Type": "application/json" };
+    if (options.apiKey) {
+      headers.Authorization = `Bearer ${options.apiKey}`;
+    }
+    const response = await fetcher(`${baseURL}/models`, {
+      method: "GET",
+      headers,
+      signal: controller.signal
+    });
+    if (!response.ok) {
+      return {
+        available: false,
+        baseURL,
+        error: `HTTP ${response.status} ${response.statusText}`
+      };
+    }
+    const body = await response.json();
+    const models = parseModelsResponse(body);
+    if (!models) {
+      return {
+        available: false,
+        baseURL,
+        error: "unexpected /v1/models response shape"
+      };
+    }
+    return { available: true, baseURL, models };
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return { available: false, baseURL, error: message };
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+// models/text.ts
+var TEXT_NANO_MODEL_TYPE = import_core3.ModelType.TEXT_NANO;
+var TEXT_MEDIUM_MODEL_TYPE = import_core3.ModelType.TEXT_MEDIUM;
+var TEXT_MEGA_MODEL_TYPE = import_core3.ModelType.TEXT_MEGA;
+var RESPONSE_HANDLER_MODEL_TYPE = import_core3.ModelType.RESPONSE_HANDLER;
+var ACTION_PLANNER_MODEL_TYPE = import_core3.ModelType.ACTION_PLANNER;
+var _firstModelIdCache = new WeakMap;
+async function resolveModelForType(runtime, modelType) {
+  if (modelType === import_core3.ModelType.TEXT_LARGE || modelType === TEXT_MEGA_MODEL_TYPE || modelType === ACTION_PLANNER_MODEL_TYPE) {
+    const large = getLargeModel(runtime);
+    if (large)
+      return large;
+  } else {
+    const small = getSmallModel(runtime);
+    if (small)
+      return small;
+  }
+  let pending = _firstModelIdCache.get(runtime);
+  if (!pending) {
+    pending = (async () => {
+      const result = await detectLMStudio({
+        baseURL: getBaseURL(runtime),
+        ...runtime.fetch ? { fetcher: runtime.fetch } : {}
+      });
+      if (!result.available || !result.models || result.models.length === 0) {
+        return null;
+      }
+      const first = result.models[0];
+      return first.id;
+    })();
+    _firstModelIdCache.set(runtime, pending);
+  }
+  const resolved = await pending;
+  if (resolved) {
+    return resolved;
+  }
+  throw new Error("[LMStudio] No model configured and `GET /v1/models` returned no entries. Set LMSTUDIO_SMALL_MODEL / LMSTUDIO_LARGE_MODEL or load a model in LM Studio.");
+}
+function summarizeAiSdkError(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.url === "string")
+    out.requestUrl = e.url;
+  if (typeof e.statusCode === "number")
+    out.httpStatus = e.statusCode;
+  if (typeof e.responseBody === "string")
+    out.lmstudioResponseBody = e.responseBody;
+  if (e.cause != null && typeof e.cause === "object") {
+    out.cause = summarizeAiSdkError(e.cause, depth + 1);
+  }
+  return out;
+}
+function logTextFailure(phase, modelType, modelId, endpoint, error) {
+  import_core3.logger.error({
+    src: "plugin:lmstudio:text",
+    phase,
+    modelType,
+    modelId,
+    lmstudioBaseURL: endpoint,
+    ...summarizeAiSdkError(error)
+  }, `[LMStudio] ${phase} failed (${modelType}, model=${modelId}).`);
+}
+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_ai2.Output.object({
+    schema: import_ai2.jsonSchema(schemaOptions.schema),
+    ...schemaOptions.name ? { name: schemaOptions.name } : {},
+    ...schemaOptions.description ? { description: schemaOptions.description } : {}
+  });
+}
+function serializeStructuredResult(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("[LMStudio] Structured generation returned no text or output.");
+}
+function asRecord(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+function firstString(...values) {
+  for (const value of values) {
+    if (typeof value === "string" && value.length > 0) {
+      return value;
+    }
+  }
+  return;
+}
+function parseJsonIfPossible(value) {
+  if (typeof value !== "string") {
+    return value;
+  }
+  try {
+    return JSON.parse(value);
+  } catch {
+    return value;
+  }
+}
+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 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 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("[LMStudio] 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 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") {
+    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 };
+    }
+  }
+  return toolChoice;
+}
+function stringifyMessageContent(content) {
+  if (typeof content === "string")
+    return content;
+  if (content == null)
+    return "";
+  if (typeof content === "object") {
+    try {
+      return JSON.stringify(content);
+    } catch {
+      return "[unserializable content]";
+    }
+  }
+  return String(content);
+}
+function normalizeUserContent(content) {
+  if (Array.isArray(content)) {
+    return content;
+  }
+  return stringifyMessageContent(content);
+}
+function normalizeNativeMessage(message) {
+  const raw = asRecord(message);
+  if (raw.role === "system") {
+    return {
+      role: "system",
+      content: stringifyMessageContent(raw.content)
+    };
+  }
+  if (raw.role === "assistant") {
+    return {
+      role: "assistant",
+      content: typeof raw.content === "string" || Array.isArray(raw.content) ? raw.content : ""
+    };
+  }
+  if (raw.role === "tool") {
+    return {
+      role: "tool",
+      content: Array.isArray(raw.content) ? raw.content : [
+        {
+          type: "tool-result",
+          toolCallId: String(firstString(raw.toolCallId, raw.id) ?? "tool-call"),
+          toolName: String(firstString(raw.toolName, raw.name) ?? "tool"),
+          output: {
+            type: "text",
+            value: stringifyMessageContent(raw.content)
+          }
+        }
+      ]
+    };
+  }
+  return {
+    role: "user",
+    content: normalizeUserContent(raw.content)
+  };
+}
+function normalizeNativeMessages(messages) {
+  if (!Array.isArray(messages)) {
+    return;
+  }
+  return messages.map((m) => normalizeNativeMessage(m));
+}
+function mapToolCalls(toolCalls) {
+  if (!Array.isArray(toolCalls) || toolCalls.length === 0) {
+    return [];
+  }
+  const out = [];
+  for (const raw of toolCalls) {
+    const r = asRecord(raw);
+    const id = String(firstString(r.toolCallId, r.id) ?? "");
+    const name = String(firstString(r.toolName, r.name) ?? "").trim();
+    if (!name)
+      continue;
+    const rawInput = r.input ?? r.arguments ?? r.args;
+    let args;
+    if (typeof rawInput === "string") {
+      const parsed = parseJsonIfPossible(rawInput);
+      args = parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : rawInput;
+    } else if (rawInput && typeof rawInput === "object" && !Array.isArray(rawInput)) {
+      args = rawInput;
+    } else {
+      args = {};
+    }
+    out.push({ id, name, arguments: args });
+  }
+  return out;
+}
+function buildNativeResultCast(result, modelName, usage) {
+  const payload = {
+    text: result.text,
+    toolCalls: mapToolCalls(result.toolCalls),
+    finishReason: String(result.finishReason),
+    usage,
+    providerMetadata: { modelName }
+  };
+  return payload;
+}
+function buildStreamResult(args) {
+  const streamResult = import_ai2.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 (err) {
+      logTextFailure("streamText.textStream", args.modelType, args.model, args.endpoint, err);
+      throw err;
+    } finally {
+      if (completed) {
+        await usagePromise.catch(() => {
+          return;
+        });
+      }
+    }
+  }
+  return {
+    textStream: textStreamWithUsage(),
+    text: textPromise,
+    usage: usagePromise,
+    finishReason: finishReasonPromise
+  };
+}
+async function handleTextWithModelType(runtime, modelType, params) {
+  const extended = params;
+  const responseSchema = extended.responseSchema;
+  const tools = normalizeNativeTools(extended.tools);
+  const {
+    prompt,
+    maxTokens = 8192,
+    temperature = 0.7,
+    frequencyPenalty = 0.7,
+    presencePenalty = 0.7
+  } = params;
+  let modelIdForLog = "";
+  const baseURL = getBaseURL(runtime);
+  try {
+    const client = createLMStudioClient(runtime);
+    const model = await resolveModelForType(runtime, modelType);
+    modelIdForLog = model;
+    import_core3.logger.log(`[LMStudio] Using ${modelType} model: ${model}`);
+    const system = import_core3.resolveEffectiveSystemPrompt({
+      params,
+      fallback: import_core3.buildCanonicalSystemPrompt({ character: runtime.character })
+    });
+    let outputSpec = responseSchema !== undefined && responseSchema !== null ? buildStructuredOutput(responseSchema) : undefined;
+    if (tools && outputSpec) {
+      import_core3.logger.debug("[LMStudio] tools and responseSchema both present — omitting structured output for this call.");
+      outputSpec = undefined;
+    }
+    const wireRaw = import_core3.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_core3.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 baseArgs = {
+      model: client(model),
+      ...promptOrMessages,
+      ...system ? { system } : {},
+      temperature,
+      maxOutputTokens: maxTokens,
+      frequencyPenalty,
+      presencePenalty,
+      ...resolvedStopSequences ? { stopSequences: resolvedStopSequences } : {},
+      ...tools ? { tools, ...toolChoice ? { toolChoice } : {} } : {},
+      ...outputSpec ? { output: outputSpec } : {}
+    };
+    if (params.stream && !outputSpec && !(extended.toolChoice && !tools)) {
+      return buildStreamResult({
+        runtime,
+        modelType,
+        model,
+        endpoint: baseURL,
+        streamParams: baseArgs,
+        promptForEstimate: promptForUsageEstimate
+      });
+    }
+    const result = await import_ai2.generateText(baseArgs);
+    const usage = normalizeTokenUsage(result.usage) ?? estimateUsage(promptForUsageEstimate, result.text);
+    emitModelUsed(runtime, modelType, model, usage);
+    if (shouldReturnNative) {
+      if (outputSpec !== undefined) {
+        return serializeStructuredResult(result);
+      }
+      return buildNativeResultCast(result, model, usage);
+    }
+    return result.text;
+  } catch (error) {
+    logTextFailure("generateText", modelType, modelIdForLog || "(unknown)", baseURL, error);
+    throw error;
+  }
+}
+async function handleTextSmall(runtime, params) {
+  return handleTextWithModelType(runtime, import_core3.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_core3.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
+function getProcessEnv() {
+  if (typeof process === "undefined" || !process.env) {
+    return {};
+  }
+  return process.env;
+}
+var env = getProcessEnv();
+var TEXT_NANO_MODEL_TYPE2 = import_core4.ModelType.TEXT_NANO;
+var TEXT_MEDIUM_MODEL_TYPE2 = import_core4.ModelType.TEXT_MEDIUM;
+var TEXT_MEGA_MODEL_TYPE2 = import_core4.ModelType.TEXT_MEGA;
+var RESPONSE_HANDLER_MODEL_TYPE2 = import_core4.ModelType.RESPONSE_HANDLER;
+var ACTION_PLANNER_MODEL_TYPE2 = import_core4.ModelType.ACTION_PLANNER;
+var lmStudioPlugin = {
+  name: "lmstudio",
+  description: "LM Studio provider for local LLM inference via the OpenAI-compatible API",
+  autoEnable: {
+    envKeys: ["LMSTUDIO_BASE_URL"],
+    shouldEnable: async () => {
+      try {
+        const result = await detectLMStudio({ timeoutMs: 750 });
+        return result.available;
+      } catch {
+        return false;
+      }
+    }
+  },
+  config: {
+    LMSTUDIO_BASE_URL: env.LMSTUDIO_BASE_URL ?? null,
+    LMSTUDIO_API_KEY: env.LMSTUDIO_API_KEY ?? null,
+    LMSTUDIO_SMALL_MODEL: env.LMSTUDIO_SMALL_MODEL ?? null,
+    LMSTUDIO_LARGE_MODEL: env.LMSTUDIO_LARGE_MODEL ?? null,
+    LMSTUDIO_EMBEDDING_MODEL: env.LMSTUDIO_EMBEDDING_MODEL ?? null,
+    LMSTUDIO_AUTO_DETECT: env.LMSTUDIO_AUTO_DETECT ?? null,
+    SMALL_MODEL: env.SMALL_MODEL ?? null,
+    LARGE_MODEL: env.LARGE_MODEL ?? null
+  },
+  async init(_config, runtime) {
+    const baseURL = getBaseURL(runtime);
+    if (!shouldAutoDetect(runtime)) {
+      import_core4.logger.debug("[LMStudio] LMSTUDIO_AUTO_DETECT disabled — skipping init probe.");
+      return;
+    }
+    const apiKey = getApiKey(runtime);
+    const result = await detectLMStudio({
+      baseURL,
+      ...apiKey ? { apiKey } : {},
+      ...runtime.fetch ? { fetcher: runtime.fetch } : {},
+      timeoutMs: 2000
+    });
+    if (!result.available) {
+      import_core4.logger.warn({ src: "plugin:lmstudio", baseURL, error: result.error }, "[LMStudio] /v1/models probe failed — plugin will only succeed once LM Studio is running.");
+      return;
+    }
+    const modelCount = result.models?.length ?? 0;
+    import_core4.logger.info(`[LMStudio] Detected ${modelCount} model${modelCount === 1 ? "" : "s"} at ${baseURL}`);
+  },
+  models: {
+    [import_core4.ModelType.TEXT_EMBEDDING]: async (runtime, params) => {
+      return handleTextEmbedding(runtime, params);
+    },
+    [TEXT_NANO_MODEL_TYPE2]: async (runtime, params) => {
+      return handleTextNano(runtime, params);
+    },
+    [import_core4.ModelType.TEXT_SMALL]: async (runtime, params) => {
+      return handleTextSmall(runtime, params);
+    },
+    [TEXT_MEDIUM_MODEL_TYPE2]: async (runtime, params) => {
+      return handleTextMedium(runtime, params);
+    },
+    [import_core4.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: "lmstudio_plugin_tests",
+      tests: [
+        {
+          name: "lmstudio_test_models_endpoint",
+          fn: async (runtime) => {
+            const apiKey = getApiKey(runtime);
+            const result = await detectLMStudio({
+              baseURL: getBaseURL(runtime),
+              ...apiKey ? { apiKey } : {},
+              ...runtime.fetch ? { fetcher: runtime.fetch } : {}
+            });
+            if (!result.available) {
+              import_core4.logger.error({ result }, "[LMStudio] /v1/models probe failed");
+              return;
+            }
+            import_core4.logger.log({ models: result.models?.length ?? 0 }, "[LMStudio] /v1/models OK");
+          }
+        }
+      ]
+    }
+  ]
+};
+// index.node.ts
+var defaultLMStudioPlugin = lmStudioPlugin;
+var index_node_default = defaultLMStudioPlugin;
+
+//# debugId=84CB05477B08554A64756E2164756E21
+//# sourceMappingURL=index.node.cjs.map