@leoustc/service-llm 0.1.0 → 0.2.0

package/README.md

@@ -61,7 +61,7 @@ If necessary, add it to your shell path with `export PATH="$HOME/.bin:$PATH"`. R
 - `POST /v1/responses`, including typed SSE responses
 - `POST /mcp`, providing the MCP `ask` tool. `ask` accepts a prompt plus optional `model`, `tools`, and `tool_choice`, and returns model tool calls without executing them.
 
-The default model is `gpt-5.4`. A different Codex model can be selected with the request's `model` field.
+At login, the available Codex model catalog is saved to `~/.service-llm/models.json`. The lowest-cost available model is selected by default with low reasoning effort. A valid model can be selected with the request's `model` field; unknown model IDs safely fall back to that default, and responses report the model actually used.
 
 ## Development
 
@@ -73,5 +73,7 @@ make publish
 make clean
 ```
 
+`make publish` validates `VERSION`, synchronizes it into `package.json` and `package-lock.json`, then builds and publishes that version.
+
 Each test run also saves its complete output under `test/logs/` using a timestamped filename.
 The suite sends the live `Write a short story.` prompt through Chat Completions, Responses, and MCP `ask`. Override the HTTP request model with `make test TEST_MODEL=gpt-5.4-mini`.

package/VERSION

@@ -0,0 +1 @@
+0.2.0

package/dist/auth.js

@@ -1,4 +1,5 @@
 import { chmod, mkdir, readFile, rename, writeFile } from "node:fs/promises";
+import { randomUUID } from "node:crypto";
 import { homedir } from "node:os";
 import { dirname, join } from "node:path";
 import {
@@ -6,16 +7,50 @@ import {
   loginOpenAICodexDeviceCode,
   refreshOpenAICodexToken,
 } from "@earendil-works/pi-ai/oauth";
+import { getModels } from "@earendil-works/pi-ai/compat";
 
 export const authPath = join(homedir(), ".service-llm", "auth.json");
+export const modelsPath = join(homedir(), ".service-llm", "models.json");
 let pendingDeviceLogin;
+let refreshPromise;
+let writeQueue = Promise.resolve();
+
+function smallestModel(models) {
+  return [...models].sort((left, right) => {
+    const leftCost = (left.cost?.input ?? Infinity) + (left.cost?.output ?? Infinity);
+    const rightCost = (right.cost?.input ?? Infinity) + (right.cost?.output ?? Infinity);
+    return leftCost - rightCost || left.id.localeCompare(right.id);
+  })[0];
+}
+
+async function saveModelCatalog() {
+  const models = getModels("openai-codex");
+  const fallback = smallestModel(models);
+  if (!fallback) throw new Error("No OpenAI Codex models are available");
+  const catalog = {
+    updated_at: new Date().toISOString(),
+    default_model: fallback.id,
+    default_reasoning_effort: "low",
+    models: models.map((model) => ({ id: model.id, name: model.name })),
+  };
+  await writeSecureJson(modelsPath, catalog);
+  return catalog;
+}
+
+async function writeSecureJson(path, data) {
+  const operation = writeQueue.then(async () => {
+    await mkdir(dirname(path), { recursive: true, mode: 0o700 });
+    const temporaryPath = `${path}.${process.pid}.${randomUUID()}.tmp`;
+    await writeFile(temporaryPath, `${JSON.stringify(data, null, 2)}\n`, { mode: 0o600 });
+    await rename(temporaryPath, path);
+    await chmod(path, 0o600);
+  });
+  writeQueue = operation.catch(() => {});
+  return operation;
+}
 
 async function saveAuth(data) {
-  await mkdir(dirname(authPath), { recursive: true, mode: 0o700 });
-  const temporaryPath = `${authPath}.${process.pid}.tmp`;
-  await writeFile(temporaryPath, `${JSON.stringify(data, null, 2)}\n`, { mode: 0o600 });
-  await rename(temporaryPath, authPath);
-  await chmod(authPath, 0o600);
+  await writeSecureJson(authPath, data);
 }
 
 async function readAuth() {
@@ -46,7 +81,9 @@ export async function login({ deviceCode = false } = {}) {
   const data = await readAuth();
   data["openai-codex"] = { type: "oauth", ...credentials };
   await saveAuth(data);
+  const catalog = await saveModelCatalog();
   console.error(`Authentication saved to ${authPath}`);
+  console.error(`Loaded ${catalog.models.length} models; default is ${catalog.default_model} with low reasoning`);
 }
 
 export class DeviceLoginRequiredError extends Error {
@@ -86,6 +123,7 @@ async function beginDeviceLogin() {
       const data = await readAuth();
       data["openai-codex"] = { type: "oauth", ...credentials };
       await saveAuth(data);
+      await saveModelCatalog();
       console.error(`Authentication completed and saved to ${authPath}`);
     })
     .catch((error) => {
@@ -107,9 +145,21 @@ export async function getAccessToken() {
   }
 
   if (Date.now() >= credentials.expires - 60_000) {
-    credentials = { type: "oauth", ...(await refreshOpenAICodexToken(credentials.refresh)) };
-    data["openai-codex"] = credentials;
-    await saveAuth(data);
+    if (!refreshPromise) {
+      refreshPromise = (async () => {
+        const latest = await readAuth();
+        const latestCredentials = latest["openai-codex"];
+        if (!latestCredentials?.refresh) throw new Error("Stored OpenAI Codex refresh token is missing; log in again");
+        if (latestCredentials?.access && Date.now() < latestCredentials.expires - 60_000) return latestCredentials;
+        const refreshed = { type: "oauth", ...(await refreshOpenAICodexToken(latestCredentials.refresh)) };
+        latest["openai-codex"] = refreshed;
+        await saveAuth(latest);
+        return refreshed;
+      })().finally(() => {
+        refreshPromise = undefined;
+      });
+    }
+    credentials = await refreshPromise;
   }
   return credentials.access;
 }

package/dist/backend.js

@@ -1,20 +1,75 @@
-import { getModel, stream } from "@earendil-works/pi-ai/compat";
-import { getAccessToken } from "./auth.js";
+import { readFile } from "node:fs/promises";
+import { getModel, getModels, stream } from "@earendil-works/pi-ai/compat";
+import { getAccessToken, modelsPath } from "./auth.js";
 
-export const defaultModel = "gpt-5.4";
+const zeroUsage = {
+  input: 0,
+  output: 0,
+  cacheRead: 0,
+  cacheWrite: 0,
+  totalTokens: 0,
+  cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
+};
+
+function smallestBuiltinModel() {
+  return [...getModels("openai-codex")].sort((left, right) => {
+    const leftCost = (left.cost?.input ?? Infinity) + (left.cost?.output ?? Infinity);
+    const rightCost = (right.cost?.input ?? Infinity) + (right.cost?.output ?? Infinity);
+    return leftCost - rightCost || left.id.localeCompare(right.id);
+  })[0];
+}
+
+export const defaultModel = smallestBuiltinModel()?.id ?? "gpt-5.4-mini";
+
+async function configuredModels() {
+  try {
+    const catalog = JSON.parse(await readFile(modelsPath, "utf8"));
+    return {
+      ids: new Set(catalog.models.map((model) => model.id)),
+      defaultModel: catalog.default_model,
+      reasoningEffort: catalog.default_reasoning_effort ?? "low",
+    };
+  } catch (error) {
+    if (error?.code !== "ENOENT") console.error(`Unable to read ${modelsPath}: ${error.message}`);
+    const models = getModels("openai-codex");
+    return { ids: new Set(models.map((model) => model.id)), defaultModel, reasoningEffort: "low" };
+  }
+}
+
+export async function resolveModel(requestedModel) {
+  const catalog = await configuredModels();
+  const selectedId = requestedModel && catalog.ids.has(requestedModel) ? requestedModel : catalog.defaultModel;
+  const model = getModel("openai-codex", selectedId);
+  if (!model) throw new Error("No usable OpenAI Codex model is available");
+  return { model, requestedModel, fallback: Boolean(requestedModel && requestedModel !== selectedId), reasoningEffort: catalog.reasoningEffort };
+}
 
 function textFromContent(content) {
   if (typeof content === "string") return content;
   if (!Array.isArray(content)) return "";
   return content
-    .filter((part) => part?.type === "text" || part?.type === "input_text")
+    .filter((part) => ["text", "input_text", "output_text"].includes(part?.type))
     .map((part) => part.text ?? "")
     .join("\n");
 }
 
-export function messagesFromChat(messages = []) {
+function assistantMessage(content, model) {
+  return {
+    role: "assistant",
+    content,
+    api: "openai-codex-responses",
+    provider: "openai-codex",
+    model,
+    usage: structuredClone(zeroUsage),
+    stopReason: content.some((part) => part.type === "toolCall") ? "toolUse" : "stop",
+    timestamp: Date.now(),
+  };
+}
+
+export function messagesFromChat(messages = [], model = defaultModel) {
   let systemPrompt;
   const result = [];
+  const toolNames = new Map();
   for (const message of messages) {
     const text = textFromContent(message.content);
     if (message.role === "system" || message.role === "developer") {
@@ -22,14 +77,27 @@ export function messagesFromChat(messages = []) {
     } else if (message.role === "user") {
       result.push({ role: "user", content: text, timestamp: Date.now() });
     } else if (message.role === "assistant") {
+      const content = text ? [{ type: "text", text }] : [];
+      for (const call of message.tool_calls ?? []) {
+        const fn = call.function;
+        if (!call.id || !fn?.name) continue;
+        let args;
+        try {
+          args = typeof fn.arguments === "string" ? JSON.parse(fn.arguments) : (fn.arguments ?? {});
+        } catch {
+          args = { raw: fn.arguments };
+        }
+        content.push({ type: "toolCall", id: call.id, name: fn.name, arguments: args });
+        toolNames.set(call.id, fn.name);
+      }
+      result.push(assistantMessage(content, model));
+    } else if (message.role === "tool") {
       result.push({
-        role: "assistant",
+        role: "toolResult",
+        toolCallId: message.tool_call_id,
+        toolName: message.name ?? toolNames.get(message.tool_call_id) ?? "tool",
         content: [{ type: "text", text }],
-        api: "openai-codex-responses",
-        provider: "openai-codex",
-        model: defaultModel,
-        usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, totalTokens: 0, cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 } },
-        stopReason: "stop",
+        isError: false,
         timestamp: Date.now(),
       });
     }
@@ -37,35 +105,63 @@ export function messagesFromChat(messages = []) {
   return { systemPrompt, messages: result };
 }
 
-export function messagesFromResponses(input) {
-  if (typeof input === "string") {
-    return { messages: [{ role: "user", content: input, timestamp: Date.now() }] };
+export function messagesFromResponses(input, model = defaultModel) {
+  if (typeof input === "string") return { messages: [{ role: "user", content: input, timestamp: Date.now() }] };
+  if (!Array.isArray(input)) return { messages: [] };
+
+  const result = [];
+  const toolNames = new Map();
+  let systemPrompt;
+  for (const item of input) {
+    if (item.type === "function_call") {
+      let args;
+      try {
+        args = typeof item.arguments === "string" ? JSON.parse(item.arguments) : (item.arguments ?? {});
+      } catch {
+        args = { raw: item.arguments };
+      }
+      const callId = item.call_id ?? item.id;
+      toolNames.set(callId, item.name);
+      result.push(assistantMessage([{ type: "toolCall", id: callId, name: item.name, arguments: args }], model));
+    } else if (item.type === "function_call_output") {
+      result.push({
+        role: "toolResult",
+        toolCallId: item.call_id,
+        toolName: toolNames.get(item.call_id) ?? "tool",
+        content: [{ type: "text", text: textFromContent(item.output) || String(item.output ?? "") }],
+        isError: false,
+        timestamp: Date.now(),
+      });
+    } else {
+      const converted = messagesFromChat([item], model);
+      if (converted.systemPrompt) systemPrompt = systemPrompt ? `${systemPrompt}\n\n${converted.systemPrompt}` : converted.systemPrompt;
+      result.push(...converted.messages);
+    }
   }
-  return messagesFromChat(Array.isArray(input) ? input : []);
+  return { systemPrompt, messages: result };
 }
 
 function toolsFromOpenAI(tools) {
   if (!Array.isArray(tools)) return undefined;
   return tools.flatMap((tool) => {
     const fn = tool.type === "function" ? (tool.function ?? tool) : null;
-    return fn?.name
-      ? [{ name: fn.name, description: fn.description ?? "", parameters: fn.parameters ?? { type: "object", properties: {} } }]
-      : [];
+    return fn?.name ? [{ name: fn.name, description: fn.description ?? "", parameters: fn.parameters ?? { type: "object", properties: {} } }] : [];
   });
 }
 
-export async function createCompletionStream({ context, model = defaultModel, tools, toolChoice, signal }) {
-  const selectedModel = getModel("openai-codex", model) ?? getModel("openai-codex", defaultModel);
-  if (!selectedModel) throw new Error(`Unknown Codex model: ${model}`);
+export async function createCompletionStream({ context, model, tools, toolChoice, signal }) {
+  const resolved = await resolveModel(model);
   const apiKey = await getAccessToken();
-  return stream(selectedModel, { ...context, tools: toolsFromOpenAI(tools) }, {
+  const events = stream(resolved.model, { ...context, tools: toolsFromOpenAI(tools) }, {
     apiKey,
     signal,
+    reasoningEffort: resolved.reasoningEffort,
     onPayload(payload) {
       if (!toolChoice || !payload || typeof payload !== "object") return payload;
       return { ...payload, tool_choice: toolChoice };
     },
   });
+  return { events, model: resolved.model.id, fallback: resolved.fallback, requestedModel: resolved.requestedModel };
 }
 
 export function contentFromMessage(message) {

package/dist/cli.js

@@ -10,7 +10,10 @@ function usage() {
 
 function valueAfter(args, names, fallback) {
   const index = args.findIndex((arg) => names.includes(arg));
-  return index < 0 ? fallback : args[index + 1];
+  if (index < 0) return fallback;
+  const value = args[index + 1];
+  if (!value || value.startsWith("-")) throw new Error(`${args[index]} requires a value`);
+  return value;
 }
 
 const args = process.argv.slice(2);

package/dist/http.js

@@ -1,6 +1,7 @@
 import { createServer } from "node:http";
 import { randomUUID } from "node:crypto";
 import { DeviceLoginRequiredError } from "./auth.js";
+import { version } from "./version.js";
 import {
   contentFromMessage,
   createCompletionStream,
@@ -47,9 +48,9 @@ function isAuthorized(request, apiKeys) {
   return typeof token === "string" && apiKeys.has(token);
 }
 
-function sse(response, event) {
+function sse(response, event, named = false) {
   debug("response SSE", event);
-  response.write(`data: ${JSON.stringify(event)}\n\n`);
+  response.write(`${named && event.type ? `event: ${event.type}\n` : ""}data: ${JSON.stringify(event)}\n\n`);
 }
 
 async function collect(streamResult) {
@@ -64,18 +65,23 @@ async function collect(streamResult) {
 
 async function chatCompletions(request, response, body) {
   const id = `chatcmpl-${randomUUID().replaceAll("-", "")}`;
-  const model = body.model || defaultModel;
-  const streamResult = await createCompletionStream({
-    context: messagesFromChat(body.messages), model, tools: body.tools, toolChoice: body.tool_choice,
+  const completion = await createCompletionStream({
+    context: messagesFromChat(body.messages, body.model), model: body.model, tools: body.tools, toolChoice: body.tool_choice,
   });
+  const { events: streamResult, model } = completion;
   if (body.stream) {
     response.writeHead(200, { "content-type": "text/event-stream", "cache-control": "no-cache", connection: "keep-alive" });
     sse(response, { id, object: "chat.completion.chunk", created: Math.floor(Date.now() / 1000), model, choices: [{ index: 0, delta: { role: "assistant" }, finish_reason: null }] });
-    for await (const event of streamResult) {
-      if (event.type === "text_delta") sse(response, { id, object: "chat.completion.chunk", created: Math.floor(Date.now() / 1000), model, choices: [{ index: 0, delta: { content: event.delta }, finish_reason: null }] });
-      if (event.type === "toolcall_end") sse(response, { id, object: "chat.completion.chunk", created: Math.floor(Date.now() / 1000), model, choices: [{ index: 0, delta: { tool_calls: [{ index: event.contentIndex, id: event.toolCall.id, type: "function", function: { name: event.toolCall.name, arguments: JSON.stringify(event.toolCall.arguments) } }] }, finish_reason: null }] });
-      if (event.type === "done") sse(response, { id, object: "chat.completion.chunk", created: Math.floor(Date.now() / 1000), model, choices: [{ index: 0, delta: {}, finish_reason: event.reason === "toolUse" ? "tool_calls" : event.reason }] });
-      if (event.type === "error") throw new Error(event.error.errorMessage ?? "Model request failed");
+    let toolIndex = 0;
+    try {
+      for await (const event of streamResult) {
+        if (event.type === "text_delta") sse(response, { id, object: "chat.completion.chunk", created: Math.floor(Date.now() / 1000), model, choices: [{ index: 0, delta: { content: event.delta }, finish_reason: null }] });
+        if (event.type === "toolcall_end") sse(response, { id, object: "chat.completion.chunk", created: Math.floor(Date.now() / 1000), model, choices: [{ index: 0, delta: { tool_calls: [{ index: toolIndex++, id: event.toolCall.id, type: "function", function: { name: event.toolCall.name, arguments: JSON.stringify(event.toolCall.arguments) } }] }, finish_reason: null }] });
+        if (event.type === "done") sse(response, { id, object: "chat.completion.chunk", created: Math.floor(Date.now() / 1000), model, choices: [{ index: 0, delta: {}, finish_reason: event.reason === "toolUse" ? "tool_calls" : event.reason }] });
+        if (event.type === "error") throw new Error(event.error.errorMessage ?? "Model request failed");
+      }
+    } catch (error) {
+      sse(response, { error: { message: error.message ?? String(error), type: "service_error" } });
     }
     debug("response SSE", "[DONE]");
     response.end("data: [DONE]\n\n");
@@ -96,19 +102,47 @@ function responseObject(id, model, message, status = "completed") {
 
 async function responses(request, response, body) {
   const id = `resp_${randomUUID().replaceAll("-", "")}`;
-  const model = body.model || defaultModel;
-  const streamResult = await createCompletionStream({ context: messagesFromResponses(body.input), model, tools: body.tools, toolChoice: body.tool_choice });
+  const completion = await createCompletionStream({ context: messagesFromResponses(body.input, body.model), model: body.model, tools: body.tools, toolChoice: body.tool_choice });
+  const { events: streamResult, model } = completion;
   if (body.stream) {
     response.writeHead(200, { "content-type": "text/event-stream", "cache-control": "no-cache", connection: "keep-alive" });
     const created = { id, object: "response", created_at: Math.floor(Date.now() / 1000), status: "in_progress", model, output: [] };
-    sse(response, { type: "response.created", response: created });
+    sse(response, { type: "response.created", sequence_number: 0, response: created }, true);
     let sequenceNumber = 0;
     let outputIndex = 0;
-    for await (const event of streamResult) {
-      if (event.type === "text_delta") sse(response, { type: "response.output_text.delta", sequence_number: sequenceNumber++, output_index: 0, content_index: 0, delta: event.delta });
-      if (event.type === "toolcall_end") sse(response, { type: "response.output_item.done", sequence_number: sequenceNumber++, output_index: outputIndex++, item: { type: "function_call", id: event.toolCall.id, call_id: event.toolCall.id, name: event.toolCall.name, arguments: JSON.stringify(event.toolCall.arguments), status: "completed" } });
-      if (event.type === "done") sse(response, { type: "response.completed", sequence_number: sequenceNumber++, response: responseObject(id, model, event.message) });
-      if (event.type === "error") throw new Error(event.error.errorMessage ?? "Model request failed");
+    let textStarted = false;
+    let text = "";
+    let textItem;
+    try {
+      for await (const event of streamResult) {
+        if (event.type === "text_delta") {
+          if (!textStarted) {
+            textStarted = true;
+            textItem = { id: `msg_${randomUUID().replaceAll("-", "")}`, type: "message", status: "in_progress", role: "assistant", content: [] };
+            sse(response, { type: "response.output_item.added", sequence_number: ++sequenceNumber, output_index: outputIndex, item: textItem }, true);
+            sse(response, { type: "response.content_part.added", sequence_number: ++sequenceNumber, output_index: outputIndex, item_id: textItem.id, content_index: 0, part: { type: "output_text", text: "", annotations: [] } }, true);
+          }
+          text += event.delta;
+          sse(response, { type: "response.output_text.delta", sequence_number: ++sequenceNumber, output_index: outputIndex, item_id: textItem.id, content_index: 0, delta: event.delta }, true);
+        }
+        if (event.type === "toolcall_end") {
+          const item = { type: "function_call", id: event.toolCall.id, call_id: event.toolCall.id, name: event.toolCall.name, arguments: JSON.stringify(event.toolCall.arguments), status: "completed" };
+          sse(response, { type: "response.output_item.added", sequence_number: ++sequenceNumber, output_index, item: { ...item, status: "in_progress", arguments: "" } }, true);
+          sse(response, { type: "response.function_call_arguments.done", sequence_number: ++sequenceNumber, output_index, item_id: item.id, arguments: item.arguments }, true);
+          sse(response, { type: "response.output_item.done", sequence_number: ++sequenceNumber, output_index: outputIndex++, item }, true);
+        }
+        if (event.type === "done") {
+          if (textStarted) {
+            sse(response, { type: "response.output_text.done", sequence_number: ++sequenceNumber, output_index, item_id: textItem.id, content_index: 0, text }, true);
+            sse(response, { type: "response.content_part.done", sequence_number: ++sequenceNumber, output_index, item_id: textItem.id, content_index: 0, part: { type: "output_text", text, annotations: [] } }, true);
+            sse(response, { type: "response.output_item.done", sequence_number: ++sequenceNumber, output_index: outputIndex++, item: { ...textItem, status: "completed", content: [{ type: "output_text", text, annotations: [] }] } }, true);
+          }
+          sse(response, { type: "response.completed", sequence_number: ++sequenceNumber, response: responseObject(id, model, event.message) }, true);
+        }
+        if (event.type === "error") throw new Error(event.error.errorMessage ?? "Model request failed");
+      }
+    } catch (error) {
+      sse(response, { type: "error", sequence_number: ++sequenceNumber, error: { message: error.message ?? String(error), type: "service_error" } }, true);
     }
     debug("response SSE", "<stream closed>");
     response.end();
@@ -118,19 +152,19 @@ async function responses(request, response, body) {
 }
 
 async function ask({ prompt, model = defaultModel, tools, toolChoice }) {
-  const streamResult = await createCompletionStream({
+  const completion = await createCompletionStream({
     context: messagesFromResponses(prompt),
     model,
     tools,
     toolChoice,
   });
-  const message = await collect(streamResult);
-  return { text: contentFromMessage(message), toolCalls: toolCallsFromMessage(message), model };
+  const message = await collect(completion.events);
+  return { text: contentFromMessage(message), toolCalls: toolCallsFromMessage(message), model: completion.model };
 }
 
 async function mcp(response, body) {
   const base = { jsonrpc: "2.0", id: body.id };
-  if (body.method === "initialize") return sendJson(response, 200, { ...base, result: { protocolVersion: body.params?.protocolVersion ?? "2025-03-26", capabilities: { tools: {} }, serverInfo: { name: "service-llm", version: "0.1.0" } } });
+  if (body.method === "initialize") return sendJson(response, 200, { ...base, result: { protocolVersion: body.params?.protocolVersion ?? "2025-03-26", capabilities: { tools: {} }, serverInfo: { name: "service-llm", version } } });
   if (body.method === "notifications/initialized") return response.writeHead(202).end();
   if (body.method === "ping") return sendJson(response, 200, { ...base, result: {} });
   if (body.method === "tools/list") return sendJson(response, 200, { ...base, result: { tools: [{ name: "ask", description: "Ask a Codex model a question and optionally allow it to return function tool calls. Tool calls are never executed.", inputSchema: { type: "object", properties: { prompt: { type: "string" }, model: { type: "string" }, tools: { type: "array", items: { type: "object" } }, tool_choice: {} }, required: ["prompt"], additionalProperties: false } }] } });

package/dist/index.js

@@ -1,3 +1,4 @@
 export { authPath, getAccessToken, login } from "./auth.js";
 export { defaultModel } from "./backend.js";
 export { startServer } from "./http.js";
+export { version } from "./version.js";

package/dist/version.js

@@ -0,0 +1,3 @@
+import { readFileSync } from "node:fs";
+
+export const version = readFileSync(new URL("../VERSION", import.meta.url), "utf8").trim();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@leoustc/service-llm",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Expose a Codex subscription through OpenAI-compatible and MCP endpoints.",
   "type": "module",
   "main": "./dist/index.js",
@@ -11,7 +11,8 @@
     ".": "./dist/index.js"
   },
   "files": [
-    "dist"
+    "dist",
+    "VERSION"
   ],
   "scripts": {
     "build": "node ./scripts/build.mjs",