@golba98/codexa 1.0.1

package/src/core/providerRuntime/lmstudio.test.ts

@@ -0,0 +1,168 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { deriveLmStudioApiRoot, fetchLmStudioModelInfo, fetchLmStudioModels, parseLmStudioModelsResponse } from "./lmstudio.js";
+
+const FIXTURE = {
+  id: "google/gemma-4-26b-a4b",
+  object: "model",
+  type: "vlm",
+  publisher: "google",
+  arch: "gemma4",
+  compatibility_type: "gguf",
+  quantization: "Q4_K_M",
+  state: "loaded",
+  max_context_length: 262144,
+  loaded_context_length: 64000,
+  capabilities: ["tool_use"],
+};
+
+const LIST_FIXTURE = {
+  data: [
+    {
+      id: "qwen/qwen3.6-27b",
+      object: "model",
+      type: "vlm",
+      publisher: "qwen",
+      arch: "qwen35",
+      compatibility_type: "gguf",
+      quantization: "Q4_K_M",
+      state: "loaded",
+      max_context_length: 262144,
+      loaded_context_length: 32000,
+      capabilities: [
+        "tool_use",
+      ],
+    },
+  ],
+  object: "list",
+};
+
+test("deriveLmStudioApiRoot strips /v1 path", () => {
+  assert.equal(deriveLmStudioApiRoot("http://localhost:1234/v1"), "http://localhost:1234/api/v0");
+});
+
+test("deriveLmStudioApiRoot strips trailing slash from /v1/", () => {
+  assert.equal(deriveLmStudioApiRoot("http://localhost:1234/v1/"), "http://localhost:1234/api/v0");
+});
+
+test("deriveLmStudioApiRoot works with arbitrary host and port", () => {
+  assert.equal(
+    deriveLmStudioApiRoot("http://my-server.local:8080/api/v1"),
+    "http://my-server.local:8080/api/v0",
+  );
+});
+
+test("deriveLmStudioApiRoot returns null for invalid URL", () => {
+  assert.equal(deriveLmStudioApiRoot("not-a-url"), null);
+});
+
+test("fetchLmStudioModelInfo URL-encodes model IDs containing slashes", async () => {
+  let capturedUrl = "";
+  const mockFetch = async (url: string) => {
+    capturedUrl = url;
+    return new Response(JSON.stringify(FIXTURE), { status: 200 });
+  };
+
+  await fetchLmStudioModelInfo({
+    apiRoot: "http://localhost:1234/api/v0",
+    modelId: "google/gemma-4-26b-a4b",
+    fetchImpl: mockFetch as typeof fetch,
+  });
+
+  assert.match(capturedUrl, /google%2Fgemma-4-26b-a4b/);
+  assert.doesNotMatch(capturedUrl, /google\/gemma/);
+});
+
+test("fetchLmStudioModelInfo returns fixture values on success", async () => {
+  const mockFetch = async () => new Response(JSON.stringify(FIXTURE), { status: 200 });
+
+  const result = await fetchLmStudioModelInfo({
+    apiRoot: "http://localhost:1234/api/v0",
+    modelId: "google/gemma-4-26b-a4b",
+    fetchImpl: mockFetch as typeof fetch,
+  });
+
+  assert.deepEqual(result, FIXTURE);
+});
+
+test("fetchLmStudioModelInfo returns null on non-2xx response", async () => {
+  const mockFetch = async () => new Response("Not Found", { status: 404 });
+
+  const result = await fetchLmStudioModelInfo({
+    apiRoot: "http://localhost:1234/api/v0",
+    modelId: "some-model",
+    fetchImpl: mockFetch as typeof fetch,
+  });
+
+  assert.equal(result, null);
+});
+
+test("fetchLmStudioModelInfo returns null on network error", async () => {
+  const mockFetch = async (): Promise<Response> => {
+    throw new Error("ECONNREFUSED");
+  };
+
+  const result = await fetchLmStudioModelInfo({
+    apiRoot: "http://localhost:1234/api/v0",
+    modelId: "some-model",
+    fetchImpl: mockFetch as typeof fetch,
+  });
+
+  assert.equal(result, null);
+});
+
+test("fetchLmStudioModelInfo returns null on invalid JSON", async () => {
+  const mockFetch = async () => new Response("not json{{{", { status: 200 });
+
+  const result = await fetchLmStudioModelInfo({
+    apiRoot: "http://localhost:1234/api/v0",
+    modelId: "some-model",
+    fetchImpl: mockFetch as typeof fetch,
+  });
+
+  assert.equal(result, null);
+});
+
+test("fetchLmStudioModelInfo returns null when response is missing id field", async () => {
+  const mockFetch = async () =>
+    new Response(JSON.stringify({ object: "model", type: "vlm" }), { status: 200 });
+
+  const result = await fetchLmStudioModelInfo({
+    apiRoot: "http://localhost:1234/api/v0",
+    modelId: "some-model",
+    fetchImpl: mockFetch as typeof fetch,
+  });
+
+  assert.equal(result, null);
+});
+
+test("parseLmStudioModelsResponse parses LM Studio data array list response", () => {
+  const parsed = parseLmStudioModelsResponse(LIST_FIXTURE);
+
+  assert.equal(parsed?.object, "list");
+  assert.equal(parsed?.data[0]?.id, "qwen/qwen3.6-27b");
+  assert.equal(parsed?.data[0]?.state, "loaded");
+  assert.equal(parsed?.data[0]?.loaded_context_length, 32000);
+  assert.equal(parsed?.data[0]?.max_context_length, 262144);
+  assert.deepEqual(parsed?.data[0]?.capabilities, ["tool_use"]);
+});
+
+test("parseLmStudioModelsResponse does not expect the response itself to be an array", () => {
+  assert.equal(parseLmStudioModelsResponse([LIST_FIXTURE.data[0]]), null);
+});
+
+test("fetchLmStudioModels reads native /api/v0/models list endpoint", async () => {
+  let capturedUrl = "";
+  const mockFetch = async (url: string) => {
+    capturedUrl = url;
+    return new Response(JSON.stringify(LIST_FIXTURE), { status: 200 });
+  };
+
+  const result = await fetchLmStudioModels({
+    apiRoot: "http://localhost:1234/api/v0",
+    fetchImpl: mockFetch as typeof fetch,
+  });
+
+  assert.equal(capturedUrl, "http://localhost:1234/api/v0/models");
+  assert.equal(result?.data[0]?.id, "qwen/qwen3.6-27b");
+});

package/src/core/providerRuntime/lmstudio.ts

@@ -0,0 +1,118 @@
+export interface LmStudioModelInfo {
+  id: string;
+  object?: string;
+  type?: string;
+  publisher?: string;
+  arch?: string;
+  compatibility_type?: string;
+  quantization?: string;
+  state?: string;
+  max_context_length?: number;
+  loaded_context_length?: number;
+  capabilities?: string[];
+}
+
+export interface LmStudioModelList {
+  data: LmStudioModelInfo[];
+  object?: string;
+}
+
+export function deriveLmStudioApiRoot(baseUrl: string): string | null {
+  try {
+    return `${new URL(baseUrl).origin}/api/v0`;
+  } catch {
+    return null;
+  }
+}
+
+export async function fetchLmStudioModelInfo(options: {
+  apiRoot: string;
+  modelId: string;
+  fetchImpl?: typeof fetch;
+  signal?: AbortSignal;
+}): Promise<LmStudioModelInfo | null> {
+  const { apiRoot, modelId, signal } = options;
+  const fetchImpl = options.fetchImpl ?? globalThis.fetch;
+  try {
+    const url = `${apiRoot}/models/${encodeURIComponent(modelId)}`;
+    const response = await fetchImpl(url, { method: "GET", signal });
+    if (!response.ok) return null;
+    let parsed: unknown;
+    try {
+      parsed = await response.json();
+    } catch {
+      return null;
+    }
+    if (
+      typeof parsed !== "object"
+      || parsed === null
+      || typeof (parsed as { id?: unknown }).id !== "string"
+    ) {
+      return null;
+    }
+    return parsed as LmStudioModelInfo;
+  } catch {
+    return null;
+  }
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function parseModelInfo(value: unknown): LmStudioModelInfo | null {
+  if (!isRecord(value) || typeof value.id !== "string" || !value.id.trim()) {
+    return null;
+  }
+  return {
+    id: value.id,
+    ...(typeof value.object === "string" ? { object: value.object } : {}),
+    ...(typeof value.type === "string" ? { type: value.type } : {}),
+    ...(typeof value.publisher === "string" ? { publisher: value.publisher } : {}),
+    ...(typeof value.arch === "string" ? { arch: value.arch } : {}),
+    ...(typeof value.compatibility_type === "string" ? { compatibility_type: value.compatibility_type } : {}),
+    ...(typeof value.quantization === "string" ? { quantization: value.quantization } : {}),
+    ...(typeof value.state === "string" ? { state: value.state } : {}),
+    ...(typeof value.max_context_length === "number" ? { max_context_length: value.max_context_length } : {}),
+    ...(typeof value.loaded_context_length === "number" ? { loaded_context_length: value.loaded_context_length } : {}),
+    ...(Array.isArray(value.capabilities)
+      ? { capabilities: value.capabilities.filter((item): item is string => typeof item === "string") }
+      : {}),
+  };
+}
+
+export function parseLmStudioModelsResponse(body: unknown): LmStudioModelList | null {
+  if (!isRecord(body) || !Array.isArray(body.data)) {
+    return null;
+  }
+  return {
+    object: typeof body.object === "string" ? body.object : undefined,
+    data: body.data
+      .map(parseModelInfo)
+      .filter((model): model is LmStudioModelInfo => model !== null),
+  };
+}
+
+export async function fetchLmStudioModels(options: {
+  apiRoot: string;
+  fetchImpl?: typeof fetch;
+  signal?: AbortSignal;
+}): Promise<LmStudioModelList | null> {
+  const fetchImpl = options.fetchImpl ?? globalThis.fetch;
+  try {
+    const response = await fetchImpl(`${options.apiRoot}/models`, {
+      method: "GET",
+      signal: options.signal,
+    });
+    if (!response.ok) return null;
+    let parsed: unknown;
+    try {
+      parsed = await response.json();
+    } catch {
+      return null;
+    }
+    return parseLmStudioModelsResponse(parsed);
+  } catch {
+    return null;
+  }
+}