@abassey/aid 0.1.0

package/dist/serve/index.cjs

@@ -0,0 +1,545 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } var _class;
+
+var _chunkAUR2BBB5cjs = require('../chunk-AUR2BBB5.cjs');
+
+
+
+var _chunk3LGKZRGYcjs = require('../chunk-3LGKZRGY.cjs');
+
+// src/serve/index.ts
+var _http = require('http'); var _http2 = _interopRequireDefault(_http);
+
+// src/serve/router.ts
+function matchRoute(routes, method, url) {
+  const path = (_nullishCoalesce(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 _chunk3LGKZRGYcjs.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 _chunk3LGKZRGYcjs.AidError ? err.code : "provider_error";
+      sendEvent(res, { type: "error", code, message });
+    }
+  } finally {
+    cleanup();
+    if (!closed) {
+      res.end();
+    }
+  }
+}
+
+// src/serve/chat-store.ts
+var _crypto = require('crypto');
+var InMemoryChatStore = (_class = class {
+  __init() {this.sessions = /* @__PURE__ */ new Map()}
+  
+  
+  
+  constructor(options) {;_class.prototype.__init.call(this);
+    this.maxSessions = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _ => _.maxSessions]), () => ( 1e3));
+    this.sessionTtl = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _2 => _2.sessionTtl]), () => ( 36e5));
+    this.chatConfig = {
+      system: _optionalChain([options, 'optionalAccess', _3 => _3.system]),
+      model: _optionalChain([options, 'optionalAccess', _4 => _4.model]),
+      maxHistory: _optionalChain([options, 'optionalAccess', _5 => _5.maxHistory])
+    };
+  }
+  create(options) {
+    if (this.sessions.size >= this.maxSessions) {
+      this.evictOldest();
+    }
+    const system = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _6 => _6.system]), () => ( this.chatConfig.system));
+    const model = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _7 => _7.model]), () => ( this.chatConfig.model));
+    const conversation = _chunkAUR2BBB5cjs.ai.conversation({
+      system,
+      model,
+      maxHistory: this.chatConfig.maxHistory
+    });
+    const now = Date.now();
+    const session = {
+      id: _crypto.randomUUID.call(void 0, ),
+      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);
+    }
+  }
+}, _class);
+
+// 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 (0, _chunk3LGKZRGYcjs.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 = _nullishCoalesce(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 _chunkAUR2BBB5cjs.ai.call(void 0, 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 = _chunkAUR2BBB5cjs.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: _nullishCoalesce(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 } = _nullishCoalesce(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 = _chunkAUR2BBB5cjs.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(_chunk3LGKZRGYcjs.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 = _nullishCoalesce(req.method, () => ( "GET"));
+    const url = _nullishCoalesce(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 _chunk3LGKZRGYcjs.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 _chunk3LGKZRGYcjs.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 = _nullishCoalesce(config.port, () => ( 3e3));
+  let server = null;
+  return {
+    handler,
+    async listen() {
+      server = _http2.default.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;
+      });
+    }
+  };
+}
+
+
+
+
+exports.InMemoryChatStore = InMemoryChatStore; exports.createHandler = createHandler; exports.serve = serve;

package/dist/serve/index.d.cts

@@ -0,0 +1,69 @@
+import { IncomingMessage, ServerResponse } from 'node:http';
+import { a as Agent } from '../types-CguX3F16.cjs';
+import { j as Conversation } from '../types-BJReASS-.cjs';
+import '../errors-zAPbTlpe.cjs';
+
+interface ServeConfig {
+    ai?: boolean;
+    agents?: Record<string, Agent>;
+    chat?: boolean | ChatConfig;
+    port?: number;
+    cors?: boolean | CorsConfig;
+}
+interface ChatConfig {
+    system?: string;
+    model?: string;
+    maxHistory?: number;
+    maxSessions?: number;
+    sessionTtl?: number;
+}
+interface CorsConfig {
+    origins: string[];
+}
+interface ServeApp {
+    listen(): Promise<void>;
+    close(): Promise<void>;
+    handler: RequestHandler;
+}
+type RequestHandler = (req: IncomingMessage, res: ServerResponse) => void;
+interface ChatSession {
+    id: string;
+    conversation: Conversation;
+    createdAt: number;
+    lastActiveAt: number;
+    model?: string;
+    system?: string;
+}
+interface ChatSessionMeta {
+    id: string;
+    createdAt: number;
+    lastActiveAt: number;
+}
+
+declare function createHandler(config: ServeConfig): RequestHandler;
+
+declare class InMemoryChatStore {
+    private sessions;
+    private maxSessions;
+    private sessionTtl;
+    private chatConfig;
+    constructor(options?: {
+        maxSessions?: number;
+        sessionTtl?: number;
+        system?: string;
+        model?: string;
+        maxHistory?: number;
+    });
+    create(options?: {
+        system?: string;
+        model?: string;
+    }): ChatSession;
+    get(id: string): ChatSession | undefined;
+    delete(id: string): boolean;
+    list(): ChatSessionMeta[];
+    private evictOldest;
+}
+
+declare function serve(config?: ServeConfig): ServeApp;
+
+export { type ChatConfig, type ChatSession, type ChatSessionMeta, type CorsConfig, InMemoryChatStore, type RequestHandler, type ServeApp, type ServeConfig, createHandler, serve };

package/dist/serve/index.d.ts

@@ -0,0 +1,69 @@
+import { IncomingMessage, ServerResponse } from 'node:http';
+import { a as Agent } from '../types-DvdzPmW0.js';
+import { j as Conversation } from '../types-BJReASS-.js';
+import '../errors-CUVTnseb.js';
+
+interface ServeConfig {
+    ai?: boolean;
+    agents?: Record<string, Agent>;
+    chat?: boolean | ChatConfig;
+    port?: number;
+    cors?: boolean | CorsConfig;
+}
+interface ChatConfig {
+    system?: string;
+    model?: string;
+    maxHistory?: number;
+    maxSessions?: number;
+    sessionTtl?: number;
+}
+interface CorsConfig {
+    origins: string[];
+}
+interface ServeApp {
+    listen(): Promise<void>;
+    close(): Promise<void>;
+    handler: RequestHandler;
+}
+type RequestHandler = (req: IncomingMessage, res: ServerResponse) => void;
+interface ChatSession {
+    id: string;
+    conversation: Conversation;
+    createdAt: number;
+    lastActiveAt: number;
+    model?: string;
+    system?: string;
+}
+interface ChatSessionMeta {
+    id: string;
+    createdAt: number;
+    lastActiveAt: number;
+}
+
+declare function createHandler(config: ServeConfig): RequestHandler;
+
+declare class InMemoryChatStore {
+    private sessions;
+    private maxSessions;
+    private sessionTtl;
+    private chatConfig;
+    constructor(options?: {
+        maxSessions?: number;
+        sessionTtl?: number;
+        system?: string;
+        model?: string;
+        maxHistory?: number;
+    });
+    create(options?: {
+        system?: string;
+        model?: string;
+    }): ChatSession;
+    get(id: string): ChatSession | undefined;
+    delete(id: string): boolean;
+    list(): ChatSessionMeta[];
+    private evictOldest;
+}
+
+declare function serve(config?: ServeConfig): ServeApp;
+
+export { type ChatConfig, type ChatSession, type ChatSessionMeta, type CorsConfig, InMemoryChatStore, type RequestHandler, type ServeApp, type ServeConfig, createHandler, serve };