phantomllm 0.3.0 → 1.0.0

package/dist/index.cjs

@@ -1,40 +1,13 @@
 'use strict';
 
-var testcontainers = require('testcontainers');
+var Fastify = require('fastify');
+var fp = require('fastify-plugin');
+var crypto = require('crypto');
 
-// src/driver/container.config.ts
-var DEFAULT_IMAGE = "phantomllm-server:latest";
-var DEFAULT_PORT = 8080;
-function resolveContainerConfig(options) {
-  return {
-    image: options?.image ?? process.env["PHANTOMLLM_IMAGE"] ?? DEFAULT_IMAGE,
-    containerPort: options?.containerPort ?? DEFAULT_PORT,
-    reuse: options?.reuse ?? true,
-    startupTimeout: options?.startupTimeout ?? 3e4
-  };
-}
-var ContainerManager = class {
-  constructor(config) {
-    this.config = config;
-  }
-  container = null;
-  async start() {
-    const builder = new testcontainers.GenericContainer(this.config.image).withExposedPorts(this.config.containerPort).withWaitStrategy(
-      testcontainers.Wait.forHttp("/_admin/health", this.config.containerPort).forStatusCode(200)
-    ).withStartupTimeout(this.config.startupTimeout).withLabels({ "com.phantomllm": "true" });
-    this.container = await builder.start();
-    return {
-      host: this.container.getHost(),
-      port: this.container.getMappedPort(this.config.containerPort)
-    };
-  }
-  async stop() {
-    if (this.container) {
-      await this.container.stop();
-      this.container = null;
-    }
-  }
-};
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var Fastify__default = /*#__PURE__*/_interopDefault(Fastify);
+var fp__default = /*#__PURE__*/_interopDefault(fp);
 
 // src/errors/base.ts
 var MockLLMError = class extends Error {
@@ -274,19 +247,483 @@ var ContainerNotStartedError = class extends MockLLMError {
   }
 };
 
+// src/server/stubs/stub.matcher.ts
+function matchModel(matcher, model) {
+  if (matcher.model === void 0) return true;
+  return matcher.model === model;
+}
+function matchContent(matcher, messages) {
+  if (matcher.content === void 0) return true;
+  const needle = matcher.content.toLowerCase();
+  return messages.some(
+    (m) => m.role === "user" && m.content !== null && m.content.toLowerCase().includes(needle)
+  );
+}
+function matchInput(matcher, input) {
+  if (matcher.input === void 0) return true;
+  const needle = matcher.input.toLowerCase();
+  const items = Array.isArray(input) ? input : [input];
+  return items.some((item) => item.toLowerCase().includes(needle));
+}
+function stubMatches(entry, endpoint, model, messages, input) {
+  const { matcher } = entry;
+  if (matcher.endpoint !== void 0 && matcher.endpoint !== endpoint) {
+    return false;
+  }
+  if (!matchModel(matcher, model)) return false;
+  if (messages !== void 0 && !matchContent(matcher, messages)) return false;
+  if (input !== void 0 && !matchInput(matcher, input)) return false;
+  return true;
+}
+function specificity(matcher) {
+  let count = 0;
+  if (matcher.model !== void 0) count++;
+  if (matcher.content !== void 0) count++;
+  if (matcher.input !== void 0) count++;
+  return count;
+}
+
+// src/server/stubs/stub.registry.ts
+var StubRegistry = class {
+  stubs = [];
+  requests = [];
+  register(matcher, response, delay2) {
+    const entry = {
+      id: crypto.randomUUID(),
+      createdAt: Date.now(),
+      matcher,
+      response,
+      delay: delay2 ?? 0,
+      callCount: 0
+    };
+    this.stubs.push(entry);
+    return entry;
+  }
+  findMatch(endpoint, model, messages, input) {
+    const matches = this.stubs.filter(
+      (s) => stubMatches(s, endpoint, model, messages, input)
+    );
+    if (matches.length === 0) return void 0;
+    matches.sort((a, b) => {
+      const specDiff = specificity(b.matcher) - specificity(a.matcher);
+      if (specDiff !== 0) return specDiff;
+      return a.createdAt - b.createdAt;
+    });
+    const match = matches[0];
+    match.callCount++;
+    return match;
+  }
+  clear() {
+    const count = this.stubs.length;
+    this.stubs = [];
+    return count;
+  }
+  getAll() {
+    return this.stubs;
+  }
+  recordRequest(request) {
+    this.requests.push(request);
+  }
+  getRequests() {
+    return this.requests;
+  }
+  clearRequests() {
+    this.requests = [];
+  }
+};
+
+// src/server/plugins/registry.plugin.ts
+var registryPlugin = async (fastify) => {
+  const registry = new StubRegistry();
+  fastify.decorate("stubRegistry", registry);
+};
+var stubRegistryPlugin = fp__default.default(registryPlugin, {
+  name: "stub-registry"
+});
+var authPlugin = async (fastify) => {
+  const config = {
+    apiKey: process.env["PHANTOMLLM_API_KEY"] || void 0
+  };
+  fastify.decorate("authConfig", config);
+  fastify.addHook("onRequest", async (request, reply) => {
+    if (request.url.startsWith("/_admin")) return;
+    if (!fastify.authConfig.apiKey) return;
+    const header = request.headers.authorization;
+    if (!header) {
+      return reply.status(401).send({
+        error: {
+          message: "Missing Authorization header. Expected: Bearer <api-key>",
+          type: "authentication_error",
+          param: null,
+          code: "missing_api_key"
+        }
+      });
+    }
+    const token = header.replace(/^Bearer\s+/i, "");
+    if (token !== fastify.authConfig.apiKey) {
+      return reply.status(401).send({
+        error: {
+          message: "Invalid API key provided.",
+          type: "authentication_error",
+          param: null,
+          code: "invalid_api_key"
+        }
+      });
+    }
+  });
+};
+var apiKeyAuthPlugin = fp__default.default(authPlugin, { name: "api-key-auth" });
+
+// src/server/admin/admin.routes.ts
+var adminRoutes = async (fastify) => {
+  fastify.post(
+    "/_admin/stubs",
+    async (request, reply) => {
+      const { matcher, response, delay: delay2 } = request.body;
+      const stub = fastify.stubRegistry.register(matcher, response, delay2);
+      return reply.status(201).send({ id: stub.id, stub });
+    }
+  );
+  fastify.post(
+    "/_admin/stubs/batch",
+    async (request, reply) => {
+      const { stubs: definitions } = request.body;
+      const created = definitions.map(
+        (def) => fastify.stubRegistry.register(def.matcher, def.response, def.delay)
+      );
+      return reply.status(201).send(created);
+    }
+  );
+  fastify.delete("/_admin/stubs", async (_request, reply) => {
+    const count = fastify.stubRegistry.clear();
+    const body = { cleared: count };
+    return reply.send(body);
+  });
+  fastify.get("/_admin/health", async (_request, reply) => {
+    const body = {
+      status: "ok",
+      stubCount: fastify.stubRegistry.getAll().length,
+      uptime: process.uptime()
+    };
+    return reply.send(body);
+  });
+  fastify.get("/_admin/requests", async (_request, reply) => {
+    return reply.send({ requests: fastify.stubRegistry.getRequests() });
+  });
+  fastify.delete("/_admin/requests", async (_request, reply) => {
+    fastify.stubRegistry.clearRequests();
+    return reply.status(204).send();
+  });
+  fastify.post(
+    "/_admin/config",
+    async (request, reply) => {
+      const { apiKey } = request.body;
+      if (apiKey !== void 0) {
+        fastify.authConfig.apiKey = apiKey ?? void 0;
+      }
+      return reply.send({ ok: true });
+    }
+  );
+};
+function generateChatCompletionId() {
+  return "chatcmpl-" + crypto.randomBytes(18).toString("base64url").slice(0, 24);
+}
+
+// src/server/utils/token.counter.ts
+function estimateTokens(text) {
+  return Math.max(1, Math.ceil(text.length / 4));
+}
+function estimatePromptTokens(messages) {
+  let tokens = 2;
+  for (const msg of messages) {
+    tokens += 4;
+    tokens += estimateTokens(msg.content ?? "");
+  }
+  return tokens;
+}
+
+// src/server/responses/chat.response.ts
+function buildChatCompletion(content, model, messages) {
+  const completionTokens = estimateTokens(content);
+  const promptTokens = messages ? estimatePromptTokens(messages) : 0;
+  return {
+    id: generateChatCompletionId(),
+    object: "chat.completion",
+    created: Math.floor(Date.now() / 1e3),
+    model,
+    system_fingerprint: "fp_mock",
+    choices: [
+      {
+        index: 0,
+        message: { role: "assistant", content },
+        finish_reason: "stop",
+        logprobs: null
+      }
+    ],
+    usage: {
+      prompt_tokens: promptTokens,
+      completion_tokens: completionTokens,
+      total_tokens: promptTokens + completionTokens
+    }
+  };
+}
+
+// src/server/responses/error.response.ts
+function buildErrorResponse(_status, message, type) {
+  return {
+    error: {
+      message,
+      type: type ?? "invalid_request_error",
+      param: null,
+      code: null
+    }
+  };
+}
+function buildNoStubMatchResponse(method, path, model, messages) {
+  const msgSummary = messages !== void 0 ? ` messages=${JSON.stringify(messages)}` : "";
+  return {
+    status: 418,
+    body: buildErrorResponse(
+      418,
+      `No stub matched request: ${method} ${path} model=${model}${msgSummary}`,
+      "stub_not_found"
+    )
+  };
+}
+
+// src/server/chat/chat.streaming.ts
+function buildChunk(id, model, content, finishReason, usage) {
+  return {
+    id,
+    object: "chat.completion.chunk",
+    created: Math.floor(Date.now() / 1e3),
+    model,
+    system_fingerprint: "fp_mock",
+    choices: [
+      {
+        index: 0,
+        delta: finishReason === null ? { role: "assistant", content } : {},
+        finish_reason: finishReason,
+        logprobs: null
+      }
+    ],
+    usage: usage ?? null
+  };
+}
+function writeSSE(reply, chunk) {
+  reply.raw.write(`data: ${JSON.stringify(chunk)}
+
+`);
+}
+function streamChunks(reply, model, chunks, messages, includeUsage) {
+  reply.raw.writeHead(200, {
+    "content-type": "text/event-stream",
+    "cache-control": "no-cache",
+    connection: "keep-alive"
+  });
+  reply.hijack();
+  const id = generateChatCompletionId();
+  for (const word of chunks) {
+    writeSSE(reply, buildChunk(id, model, word, null));
+  }
+  const fullContent = chunks.join("");
+  const completionTokens = estimateTokens(fullContent);
+  const promptTokens = estimatePromptTokens(messages);
+  const usage = includeUsage ? {
+    prompt_tokens: promptTokens,
+    completion_tokens: completionTokens,
+    total_tokens: promptTokens + completionTokens
+  } : void 0;
+  writeSSE(reply, buildChunk(id, model, "", "stop", usage));
+  reply.raw.write("data: [DONE]\n\n");
+  reply.raw.end();
+}
+
+// src/server/chat/chat.handler.ts
+function delay(ms) {
+  return new Promise((resolve) => {
+    setTimeout(resolve, ms);
+  });
+}
+async function handleChatCompletion(request, reply) {
+  const { model, messages, stream, stream_options } = request.body;
+  const registry = request.server.stubRegistry;
+  const recorded = {
+    timestamp: Date.now(),
+    method: request.method,
+    path: request.url,
+    headers: request.headers,
+    body: request.body
+  };
+  registry.recordRequest(recorded);
+  const stub = registry.findMatch("chat", model, messages);
+  if (!stub) {
+    const noMatch = buildNoStubMatchResponse(
+      request.method,
+      request.url,
+      model,
+      messages
+    );
+    return reply.status(noMatch.status).send(noMatch.body);
+  }
+  if (stub.response.type === "error") {
+    return reply.status(stub.response.status).send({
+      error: {
+        message: stub.response.error.message,
+        type: stub.response.error.type,
+        param: null,
+        code: stub.response.error.code
+      }
+    });
+  }
+  if (stub.delay > 0) {
+    await delay(stub.delay);
+  }
+  if (stream === true) {
+    const includeUsage = stream_options?.include_usage === true;
+    const chunks = stub.response.type === "streaming-chat" ? stub.response.chunks : stub.response.type === "chat" ? stub.response.body.split(/(\s+)/).filter((s) => s.length > 0) : [];
+    streamChunks(reply, model, chunks, messages, includeUsage);
+    return;
+  }
+  if (stub.response.type === "chat") {
+    return reply.send(buildChatCompletion(stub.response.body, model, messages));
+  }
+  if (stub.response.type === "streaming-chat") {
+    const fullContent = stub.response.chunks.join("");
+    return reply.send(buildChatCompletion(fullContent, model, messages));
+  }
+}
+
+// src/server/chat/chat.routes.ts
+var chatRoutes = async (fastify) => {
+  fastify.post("/chat/completions", handleChatCompletion);
+};
+
+// src/server/responses/embedding.response.ts
+function buildEmbeddingResponse(vectors, model, input) {
+  const inputs = Array.isArray(input) ? input : [input];
+  const promptTokens = inputs.reduce(
+    (sum, text) => sum + estimateTokens(text),
+    0
+  );
+  return {
+    object: "list",
+    data: vectors.map((embedding, index) => ({
+      object: "embedding",
+      index,
+      embedding
+    })),
+    model,
+    usage: {
+      prompt_tokens: promptTokens,
+      total_tokens: promptTokens
+    }
+  };
+}
+
+// src/server/embeddings/embeddings.handler.ts
+var DEFAULT_DIMENSION = 1536;
+function zeroVector(dim) {
+  return new Array(dim).fill(0);
+}
+async function handleEmbeddings(request, reply) {
+  const { model, input } = request.body;
+  const registry = request.server.stubRegistry;
+  const recorded = {
+    timestamp: Date.now(),
+    method: request.method,
+    path: request.url,
+    headers: request.headers,
+    body: request.body
+  };
+  registry.recordRequest(recorded);
+  const stub = registry.findMatch("embeddings", model, void 0, input);
+  if (stub && stub.response.type === "error") {
+    return reply.status(stub.response.status).send({
+      error: {
+        message: stub.response.error.message,
+        type: stub.response.error.type,
+        param: null,
+        code: stub.response.error.code
+      }
+    });
+  }
+  if (stub && stub.response.type === "embedding") {
+    return reply.send(
+      buildEmbeddingResponse(stub.response.vectors, model, input)
+    );
+  }
+  const inputs = Array.isArray(input) ? input : [input];
+  const vectors = inputs.map(() => zeroVector(DEFAULT_DIMENSION));
+  return reply.send(buildEmbeddingResponse(vectors, model, input));
+}
+
+// src/server/embeddings/embeddings.routes.ts
+var embeddingsRoutes = async (fastify) => {
+  fastify.post("/embeddings", handleEmbeddings);
+};
+
+// src/server/models/models.routes.ts
+var DEFAULT_MODELS = [
+  { id: "gpt-4", object: "model", created: 1687882411, owned_by: "openai" },
+  { id: "gpt-4o", object: "model", created: 1715367049, owned_by: "openai" },
+  {
+    id: "gpt-3.5-turbo",
+    object: "model",
+    created: 1677610602,
+    owned_by: "openai"
+  },
+  {
+    id: "text-embedding-3-small",
+    object: "model",
+    created: 1705948997,
+    owned_by: "openai"
+  }
+];
+var modelsRoutes = async (fastify) => {
+  fastify.get("/models", async (_request, reply) => {
+    const registry = fastify.stubRegistry;
+    const allStubs = registry.getAll();
+    const modelsStub = allStubs.find((s) => s.response.type === "models");
+    if (modelsStub) {
+      modelsStub.callCount++;
+      const config = modelsStub.response;
+      if (config.type !== "models") return;
+      const data = config.models.map((m) => ({
+        id: m.id,
+        object: "model",
+        created: Math.floor(Date.now() / 1e3),
+        owned_by: m.ownedBy ?? "phantomllm"
+      }));
+      const body2 = { object: "list", data };
+      return reply.send(body2);
+    }
+    const body = { object: "list", data: DEFAULT_MODELS };
+    return reply.send(body);
+  });
+};
+
+// src/server/app.ts
+async function buildApp(opts = {}) {
+  const app = Fastify__default.default(opts);
+  await app.register(stubRegistryPlugin);
+  await app.register(apiKeyAuthPlugin);
+  await app.register(adminRoutes);
+  await app.register(chatRoutes, { prefix: "/v1" });
+  await app.register(embeddingsRoutes, { prefix: "/v1" });
+  await app.register(modelsRoutes, { prefix: "/v1" });
+  return app;
+}
+
 // src/driver/mock-llm.ts
 var MockLLM = class {
   state = "idle";
   startPromise = null;
-  containerManager;
+  app = null;
   adminClient = null;
   _given = null;
   _expect = null;
   _baseUrl = null;
-  constructor(options) {
-    const config = resolveContainerConfig(options);
-    this.containerManager = new ContainerManager(config);
-  }
   async start() {
     if (this.state === "running") return;
     if (this.state === "starting" && this.startPromise) return this.startPromise;
@@ -295,8 +732,11 @@ var MockLLM = class {
     return this.startPromise;
   }
   async doStart() {
-    const { host, port } = await this.containerManager.start();
-    this._baseUrl = `http://${host}:${port}`;
+    this.app = await buildApp({ logger: false });
+    await this.app.listen({ port: 0, host: "127.0.0.1" });
+    const address = this.app.server.address();
+    const port = typeof address === "object" && address ? address.port : 0;
+    this._baseUrl = `http://127.0.0.1:${port}`;
     this.adminClient = new AdminClient(this._baseUrl);
     this._given = new GivenStubs(this.adminClient);
     this._expect = new ExpectConditions(this.adminClient);
@@ -306,9 +746,12 @@ var MockLLM = class {
     if (this.state === "stopped" || this.state === "idle") return;
     this.state = "stopping";
     try {
-      await this.containerManager.stop();
+      if (this.app) {
+        await this.app.close();
+      }
     } finally {
       this.state = "stopped";
+      this.app = null;
       this.adminClient = null;
       this._given = null;
       this._expect = null;