@abassey/aid 0.1.0

package/dist/serve/index.js

@@ -0,0 +1,545 @@
+import {
+  ai
+} from "../chunk-YNIEOBDF.js";
+import {
+  AidError,
+  MODEL_MAP
+} from "../chunk-2TNYBUNK.js";
+
+// src/serve/index.ts
+import http from "http";
+
+// src/serve/router.ts
+function matchRoute(routes, method, url) {
+  const path = (url.split("?")[0] ?? url).replace(/\/+$/, "") || "/";
+  const pathSegments = path.split("/").filter(Boolean);
+  const patternMatches = [];
+  for (const route of routes) {
+    const patternSegments = route.pattern.split("/").filter(Boolean);
+    if (patternSegments.length !== pathSegments.length) continue;
+    const params = {};
+    let isMatch = true;
+    for (let i = 0; i < patternSegments.length; i++) {
+      const seg = patternSegments[i];
+      if (seg.startsWith(":")) {
+        params[seg.slice(1)] = pathSegments[i];
+      } else if (seg !== pathSegments[i]) {
+        isMatch = false;
+        break;
+      }
+    }
+    if (isMatch) {
+      patternMatches.push({ route, params });
+    }
+  }
+  if (patternMatches.length === 0) {
+    return { matched: false, params: {}, status: 404 };
+  }
+  const methodMatch = patternMatches.find(
+    (m) => m.route.method === method
+  );
+  if (methodMatch) {
+    return {
+      matched: true,
+      route: methodMatch.route,
+      params: methodMatch.params
+    };
+  }
+  const allowedMethods = [
+    ...new Set(patternMatches.map((m) => m.route.method))
+  ];
+  return {
+    matched: false,
+    params: {},
+    status: 405,
+    allowedMethods
+  };
+}
+
+// src/serve/sse.ts
+var SSE_HEADERS = {
+  "Content-Type": "text/event-stream",
+  "Cache-Control": "no-cache",
+  "Connection": "keep-alive"
+};
+function sendEvent(res, data) {
+  res.write(`data: ${JSON.stringify(data)}
+
+`);
+}
+async function writeStreamSSE(res, stream) {
+  res.writeHead(200, SSE_HEADERS);
+  let closed = false;
+  res.on("close", () => {
+    closed = true;
+    stream.abort();
+  });
+  try {
+    for await (const chunk of stream) {
+      if (closed) break;
+      if (chunk.done && chunk.response) {
+        sendEvent(res, {
+          type: "done",
+          text: chunk.response.text,
+          model: chunk.response.model,
+          tokens: chunk.response.tokens,
+          cost: chunk.response.cost,
+          latencyMs: chunk.response.latencyMs
+        });
+      } else {
+        sendEvent(res, { type: "text", text: chunk.delta });
+      }
+    }
+  } catch (err) {
+    if (!closed) {
+      const message = err instanceof Error ? err.message : String(err);
+      const code = err instanceof AidError ? err.code : "provider_error";
+      sendEvent(res, { type: "error", code, message });
+    }
+  } finally {
+    if (!closed) {
+      res.end();
+    }
+  }
+}
+async function writeAgentSSE(res, agent, task) {
+  res.writeHead(200, SSE_HEADERS);
+  let closed = false;
+  res.on("close", () => {
+    closed = true;
+  });
+  const send = (data) => {
+    if (!closed) sendEvent(res, data);
+  };
+  const onStepStart = (payload) => {
+    send({ type: "step:start", step: payload.step });
+  };
+  const onStepEnd = (payload) => {
+    send({ type: "step:end", step: payload.step });
+  };
+  const onToolCall = (payload) => {
+    send({ type: "tool:call", name: payload.name, args: payload.args });
+  };
+  const onToolResult = (payload) => {
+    send({ type: "tool:result", name: payload.name, result: payload.result });
+  };
+  const onMessage = (payload) => {
+    send({ type: "text", text: payload.content });
+  };
+  const onError = (payload) => {
+    send({ type: "error", code: payload.error.code, message: payload.error.message });
+  };
+  agent.on("step:start", onStepStart);
+  agent.on("step:end", onStepEnd);
+  agent.on("tool:call", onToolCall);
+  agent.on("tool:result", onToolResult);
+  agent.on("message", onMessage);
+  agent.on("error", onError);
+  const cleanup = () => {
+    agent.off("step:start", onStepStart);
+    agent.off("step:end", onStepEnd);
+    agent.off("tool:call", onToolCall);
+    agent.off("tool:result", onToolResult);
+    agent.off("message", onMessage);
+    agent.off("error", onError);
+  };
+  try {
+    const result = await agent.run(task);
+    if (!closed) {
+      sendEvent(res, {
+        type: "done",
+        text: result.text,
+        tokens: result.tokens,
+        cost: result.cost,
+        steps: result.steps.length
+      });
+    }
+  } catch (err) {
+    if (!closed) {
+      const message = err instanceof Error ? err.message : String(err);
+      const code = err instanceof AidError ? err.code : "provider_error";
+      sendEvent(res, { type: "error", code, message });
+    }
+  } finally {
+    cleanup();
+    if (!closed) {
+      res.end();
+    }
+  }
+}
+
+// src/serve/chat-store.ts
+import { randomUUID } from "crypto";
+var InMemoryChatStore = class {
+  sessions = /* @__PURE__ */ new Map();
+  maxSessions;
+  sessionTtl;
+  chatConfig;
+  constructor(options) {
+    this.maxSessions = options?.maxSessions ?? 1e3;
+    this.sessionTtl = options?.sessionTtl ?? 36e5;
+    this.chatConfig = {
+      system: options?.system,
+      model: options?.model,
+      maxHistory: options?.maxHistory
+    };
+  }
+  create(options) {
+    if (this.sessions.size >= this.maxSessions) {
+      this.evictOldest();
+    }
+    const system = options?.system ?? this.chatConfig.system;
+    const model = options?.model ?? this.chatConfig.model;
+    const conversation = ai.conversation({
+      system,
+      model,
+      maxHistory: this.chatConfig.maxHistory
+    });
+    const now = Date.now();
+    const session = {
+      id: randomUUID(),
+      conversation,
+      createdAt: now,
+      lastActiveAt: now,
+      model,
+      system
+    };
+    this.sessions.set(session.id, session);
+    return session;
+  }
+  get(id) {
+    const session = this.sessions.get(id);
+    if (!session) return void 0;
+    if (Date.now() - session.lastActiveAt > this.sessionTtl) {
+      this.sessions.delete(id);
+      return void 0;
+    }
+    return session;
+  }
+  delete(id) {
+    return this.sessions.delete(id);
+  }
+  list() {
+    return Array.from(this.sessions.values()).map((s) => ({
+      id: s.id,
+      createdAt: s.createdAt,
+      lastActiveAt: s.lastActiveAt
+    }));
+  }
+  evictOldest() {
+    let oldest;
+    for (const session of this.sessions.values()) {
+      if (!oldest || session.lastActiveAt < oldest.lastActiveAt) {
+        oldest = session;
+      }
+    }
+    if (oldest) {
+      this.sessions.delete(oldest.id);
+    }
+  }
+};
+
+// src/serve/handler.ts
+var MAX_BODY_SIZE = 1048576;
+function sendJson(res, status, data) {
+  const body = JSON.stringify(data);
+  res.writeHead(status, {
+    "Content-Type": "application/json",
+    "Content-Length": Buffer.byteLength(body)
+  });
+  res.end(body);
+}
+function sendError(res, status, code, message) {
+  sendJson(res, status, { error: { code, message } });
+}
+function errorToStatus(code) {
+  switch (code) {
+    case "invalid_request":
+      return 400;
+    case "auth_error":
+      return 401;
+    case "not_found":
+      return 404;
+    case "rate_limit":
+      return 429;
+    case "timeout":
+      return 504;
+    default:
+      return 500;
+  }
+}
+async function readBody(req) {
+  return new Promise((resolve, reject) => {
+    const chunks = [];
+    let size = 0;
+    req.on("data", (chunk) => {
+      size += chunk.length;
+      if (size > MAX_BODY_SIZE) {
+        req.destroy();
+        reject(new AidError("invalid_request", "Request body too large"));
+        return;
+      }
+      chunks.push(chunk);
+    });
+    req.on("end", () => resolve(Buffer.concat(chunks).toString("utf8")));
+    req.on("error", reject);
+  });
+}
+function applyCors(req, res, cors) {
+  if (!cors) return false;
+  if (cors === true) {
+    res.setHeader("Access-Control-Allow-Origin", "*");
+    res.setHeader("Access-Control-Allow-Methods", "GET, POST, DELETE, OPTIONS");
+    res.setHeader("Access-Control-Allow-Headers", "Content-Type");
+  } else {
+    const origin = req.headers.origin;
+    if (origin && cors.origins.includes(origin)) {
+      res.setHeader("Access-Control-Allow-Origin", origin);
+      res.setHeader("Access-Control-Allow-Methods", "GET, POST, DELETE, OPTIONS");
+      res.setHeader("Access-Control-Allow-Headers", "Content-Type");
+    }
+  }
+  if (req.method === "OPTIONS") {
+    res.writeHead(204);
+    res.end();
+    return true;
+  }
+  return false;
+}
+function createHandler(config) {
+  const routes = [];
+  const agents = config.agents ?? {};
+  const chatConfig = config.chat === true ? {} : config.chat ? config.chat : void 0;
+  const chatStore = chatConfig ? new InMemoryChatStore({
+    maxSessions: chatConfig.maxSessions,
+    sessionTtl: chatConfig.sessionTtl,
+    system: chatConfig.system,
+    model: chatConfig.model,
+    maxHistory: chatConfig.maxHistory
+  }) : void 0;
+  const handleAi = async (_req, res, _params, body) => {
+    const { prompt, model, system, temperature, maxTokens } = body;
+    if (!prompt || typeof prompt !== "string") {
+      sendError(res, 400, "invalid_request", "Missing required field: prompt");
+      return;
+    }
+    const response = await ai(prompt, { model, system, temperature, maxTokens });
+    sendJson(res, 200, {
+      text: response.text,
+      model: response.model,
+      tokens: response.tokens,
+      cost: response.cost,
+      latencyMs: response.latencyMs
+    });
+  };
+  const handleAiStream = async (_req, res, _params, body) => {
+    const { prompt, model, system, temperature, maxTokens } = body;
+    if (!prompt || typeof prompt !== "string") {
+      sendError(res, 400, "invalid_request", "Missing required field: prompt");
+      return;
+    }
+    const stream = ai.stream(prompt, { model, system, temperature, maxTokens });
+    await writeStreamSSE(res, stream);
+  };
+  const handleAgent = async (_req, res, params, body) => {
+    const agentName = params.name;
+    const agentInstance = agents[agentName];
+    if (!agentInstance) {
+      sendError(res, 404, "not_found", `Agent '${agentName}' not found`);
+      return;
+    }
+    const { task } = body;
+    if (!task || typeof task !== "string") {
+      sendError(res, 400, "invalid_request", "Missing required field: task");
+      return;
+    }
+    const result = await agentInstance.run(task);
+    sendJson(res, 200, {
+      text: result.text,
+      model: agentInstance.config.model ?? "default",
+      tokens: result.tokens,
+      cost: result.cost,
+      steps: result.steps.length
+    });
+  };
+  const handleAgentStream = async (_req, res, params, body) => {
+    const agentName = params.name;
+    const agentInstance = agents[agentName];
+    if (!agentInstance) {
+      sendError(res, 404, "not_found", `Agent '${agentName}' not found`);
+      return;
+    }
+    const { task } = body;
+    if (!task || typeof task !== "string") {
+      sendError(res, 400, "invalid_request", "Missing required field: task");
+      return;
+    }
+    await writeAgentSSE(res, agentInstance, task);
+  };
+  const handleChatCreate = async (_req, res, _params, body) => {
+    const { system, model } = body ?? {};
+    const session = chatStore.create({ system, model });
+    sendJson(res, 201, { sessionId: session.id });
+  };
+  const handleChatMessage = async (_req, res, params, body) => {
+    const session = chatStore.get(params.id);
+    if (!session) {
+      sendError(res, 404, "not_found", `Session '${params.id}' not found`);
+      return;
+    }
+    const { message } = body;
+    if (!message || typeof message !== "string") {
+      sendError(res, 400, "invalid_request", "Missing required field: message");
+      return;
+    }
+    session.lastActiveAt = Date.now();
+    const response = await session.conversation.say(message);
+    sendJson(res, 200, {
+      text: response.text,
+      model: response.model,
+      tokens: response.tokens,
+      cost: response.cost
+    });
+  };
+  const handleChatStream = async (_req, res, params, body) => {
+    const session = chatStore.get(params.id);
+    if (!session) {
+      sendError(res, 404, "not_found", `Session '${params.id}' not found`);
+      return;
+    }
+    const { message } = body;
+    if (!message || typeof message !== "string") {
+      sendError(res, 400, "invalid_request", "Missing required field: message");
+      return;
+    }
+    session.lastActiveAt = Date.now();
+    const saved = session.conversation.save();
+    const messages = [...saved.messages, { role: "user", content: message }];
+    const stream = ai.stream(message, {
+      system: saved.system || void 0,
+      model: session.model,
+      _messages: messages
+    });
+    await writeStreamSSE(res, stream);
+  };
+  const handleChatHistory = async (_req, res, params) => {
+    const session = chatStore.get(params.id);
+    if (!session) {
+      sendError(res, 404, "not_found", `Session '${params.id}' not found`);
+      return;
+    }
+    const saved = session.conversation.save();
+    sendJson(res, 200, {
+      sessionId: session.id,
+      messages: saved.messages,
+      createdAt: session.createdAt,
+      lastActiveAt: session.lastActiveAt
+    });
+  };
+  const handleChatDelete = async (_req, res, params) => {
+    const deleted = chatStore.delete(params.id);
+    if (!deleted) {
+      sendError(res, 404, "not_found", `Session '${params.id}' not found`);
+      return;
+    }
+    sendJson(res, 200, { deleted: true });
+  };
+  const handleHealth = async (_req, res) => {
+    sendJson(res, 200, { status: "ok" });
+  };
+  const handleModels = async (_req, res) => {
+    const models = Object.entries(MODEL_MAP).map(([alias, entry]) => ({
+      alias,
+      provider: entry.provider,
+      model: entry.model
+    }));
+    sendJson(res, 200, { models });
+  };
+  routes.push({ method: "GET", pattern: "/health", handler: handleHealth });
+  routes.push({ method: "GET", pattern: "/models", handler: handleModels });
+  if (config.ai) {
+    routes.push({ method: "POST", pattern: "/ai", handler: handleAi });
+    routes.push({ method: "POST", pattern: "/ai/stream", handler: handleAiStream });
+  }
+  if (config.agents && Object.keys(config.agents).length > 0) {
+    routes.push({ method: "POST", pattern: "/agents/:name", handler: handleAgent });
+    routes.push({ method: "POST", pattern: "/agents/:name/stream", handler: handleAgentStream });
+  }
+  if (chatStore) {
+    routes.push({ method: "POST", pattern: "/chat", handler: handleChatCreate });
+    routes.push({ method: "POST", pattern: "/chat/:id", handler: handleChatMessage });
+    routes.push({ method: "POST", pattern: "/chat/:id/stream", handler: handleChatStream });
+    routes.push({ method: "GET", pattern: "/chat/:id", handler: handleChatHistory });
+    routes.push({ method: "DELETE", pattern: "/chat/:id", handler: handleChatDelete });
+  }
+  return (req, res) => {
+    const handled = applyCors(req, res, config.cors);
+    if (handled) return;
+    const method = req.method ?? "GET";
+    const url = req.url ?? "/";
+    const match = matchRoute(routes, method, url);
+    if (!match.matched) {
+      if (match.status === 405 && match.allowedMethods) {
+        res.setHeader("Allow", match.allowedMethods.join(", "));
+        sendError(res, 405, "invalid_request", "Method not allowed");
+      } else {
+        sendError(res, 404, "not_found", "Not found");
+      }
+      return;
+    }
+    const needsBody = ["POST", "PUT", "PATCH"].includes(method);
+    const dispatch = async () => {
+      let body = {};
+      if (needsBody) {
+        try {
+          const raw = await readBody(req);
+          body = raw.length > 0 ? JSON.parse(raw) : {};
+        } catch (err) {
+          if (err instanceof AidError) {
+            sendError(res, 400, err.code, err.message);
+          } else {
+            sendError(res, 400, "invalid_request", "Invalid JSON in request body");
+          }
+          return;
+        }
+      }
+      await match.route.handler(req, res, match.params, body);
+    };
+    dispatch().catch((err) => {
+      if (err instanceof AidError) {
+        sendError(res, errorToStatus(err.code), err.code, err.message);
+      } else {
+        const message = err instanceof Error ? err.message : "Internal server error";
+        sendError(res, 500, "serve_error", message);
+      }
+    });
+  };
+}
+
+// src/serve/index.ts
+function serve(config = {}) {
+  const handler = createHandler(config);
+  const port = config.port ?? 3e3;
+  let server = null;
+  return {
+    handler,
+    async listen() {
+      server = http.createServer(handler);
+      return new Promise((resolve) => {
+        server.listen(port, resolve);
+      });
+    },
+    async close() {
+      if (!server) return;
+      return new Promise((resolve, reject) => {
+        server.close((err) => err ? reject(err) : resolve());
+        server = null;
+      });
+    }
+  };
+}
+export {
+  InMemoryChatStore,
+  createHandler,
+  serve
+};