agent-mockingbird 0.0.1

package/apps/server/src/backend/http/boundedQueue.ts

@@ -0,0 +1,92 @@
+interface BoundedQueueOptions<T> {
+  maxSize: number;
+  drainDelayMs?: number;
+  tryWrite: (value: T) => boolean;
+  onOverflow: () => void;
+  onWriteError?: (error: unknown) => void;
+}
+
+export interface BoundedQueue<T> {
+  enqueue: (value: T) => boolean;
+  close: () => void;
+  size: () => number;
+}
+
+export function createBoundedQueue<T>(options: BoundedQueueOptions<T>): BoundedQueue<T> {
+  const drainDelayMs = Math.max(1, options.drainDelayMs ?? 25);
+  const queue: T[] = [];
+  let closed = false;
+  let draining = false;
+  let drainTimer: ReturnType<typeof setTimeout> | null = null;
+
+  const clearDrainTimer = () => {
+    if (!drainTimer) return;
+    clearTimeout(drainTimer);
+    drainTimer = null;
+  };
+
+  const scheduleDrain = () => {
+    if (closed || draining || drainTimer) return;
+    drainTimer = setTimeout(() => {
+      drainTimer = null;
+      drain();
+    }, drainDelayMs);
+  };
+
+  const handleWriteError = (error: unknown) => {
+    if (closed) return;
+    closed = true;
+    queue.length = 0;
+    clearDrainTimer();
+    options.onWriteError?.(error);
+  };
+
+  const drain = () => {
+    if (closed || draining) return;
+    draining = true;
+    try {
+      while (!closed && queue.length > 0) {
+        const next = queue[0] as T;
+        let wrote = false;
+        try {
+          wrote = options.tryWrite(next);
+        } catch (error) {
+          handleWriteError(error);
+          return;
+        }
+        if (!wrote) {
+          scheduleDrain();
+          return;
+        }
+        queue.shift();
+      }
+    } finally {
+      draining = false;
+    }
+  };
+
+  return {
+    enqueue(value: T) {
+      if (closed) return false;
+      if (queue.length >= options.maxSize) {
+        closed = true;
+        queue.length = 0;
+        clearDrainTimer();
+        options.onOverflow();
+        return false;
+      }
+      queue.push(value);
+      drain();
+      scheduleDrain();
+      return true;
+    },
+    close() {
+      closed = true;
+      queue.length = 0;
+      clearDrainTimer();
+    },
+    size() {
+      return queue.length;
+    },
+  };
+}

package/apps/server/src/backend/http/parsers.ts

@@ -0,0 +1,40 @@
+import type { MemoryRecordSource } from "../memory/types";
+
+export function parseStringListBody(body: unknown, field: string): string[] | null {
+  if (!body || typeof body !== "object") return null;
+  const value = (body as Record<string, unknown>)[field];
+  if (!Array.isArray(value) || value.some(item => typeof item !== "string")) {
+    return null;
+  }
+  return value;
+}
+
+export function parseMemoryRememberBody(body: unknown) {
+  if (!body || typeof body !== "object") return null;
+  const value = body as Record<string, unknown>;
+  const source = typeof value.source === "string" ? value.source.trim() : "user";
+  const content = typeof value.content === "string" ? value.content.trim() : "";
+  const sessionId = typeof value.sessionId === "string" ? value.sessionId.trim() : undefined;
+  const topic = typeof value.topic === "string" ? value.topic.trim() : undefined;
+  const ttl = typeof value.ttl === "number" ? value.ttl : undefined;
+  const entities = Array.isArray(value.entities)
+    ? value.entities.filter((item): item is string => typeof item === "string")
+    : [];
+  const supersedes = Array.isArray(value.supersedes)
+    ? value.supersedes.filter((item): item is string => typeof item === "string")
+    : [];
+  const confidence = typeof value.confidence === "number" ? value.confidence : undefined;
+  if (!content) return null;
+  const allowedSources = ["user", "assistant", "system"] as const;
+  if (!allowedSources.includes(source as MemoryRecordSource)) return null;
+  return {
+    source: source as MemoryRecordSource,
+    content,
+    entities,
+    supersedes,
+    confidence,
+    sessionId: sessionId || undefined,
+    topic: topic || undefined,
+    ttl,
+  };
+}

package/apps/server/src/backend/http/router.ts

@@ -0,0 +1,61 @@
+interface RouteRequest<TParams extends Record<string, string> = Record<string, string>>
+  extends Request {
+  params: TParams;
+}
+
+type RouteMethod<TParams extends Record<string, string> = Record<string, string>> = {
+  bivarianceHack(req: RouteRequest<TParams>): Response | Promise<Response>;
+}["bivarianceHack"];
+
+interface RouteHandler {
+  GET?: RouteMethod;
+  POST?: RouteMethod;
+  PUT?: RouteMethod;
+  PATCH?: RouteMethod;
+  DELETE?: RouteMethod;
+  OPTIONS?: RouteMethod;
+}
+
+export type RouteEntry = RouteHandler | RouteMethod;
+
+export type RouteTable = Record<string, RouteEntry>;
+
+function matchPattern(pattern: string, pathname: string) {
+  const patternParts = pattern.split("/").filter(Boolean);
+  const pathParts = pathname.split("/").filter(Boolean);
+  if (patternParts.length !== pathParts.length) return null;
+
+  const params: Record<string, string> = {};
+  for (let index = 0; index < patternParts.length; index += 1) {
+    const patternPart = patternParts[index]!;
+    const pathPart = pathParts[index]!;
+    if (patternPart.startsWith(":")) {
+      params[patternPart.slice(1)] = decodeURIComponent(pathPart);
+      continue;
+    }
+    if (patternPart !== pathPart) return null;
+  }
+  return params;
+}
+
+export async function dispatchRoute(table: RouteTable, req: Request) {
+  const url = new URL(req.url);
+  const pathname = url.pathname;
+  const method = req.method.toUpperCase() as keyof RouteHandler;
+
+  for (const [pattern, handlers] of Object.entries(table)) {
+    const params = matchPattern(pattern, pathname);
+    if (!params) continue;
+    const request = Object.assign(req, { params }) as RouteRequest;
+    if (typeof handlers === "function") {
+      return handlers(request);
+    }
+    const handler = handlers[method];
+    if (!handler) {
+      return new Response("Method not allowed", { status: 405 });
+    }
+    return handler(request);
+  }
+
+  return null;
+}

package/apps/server/src/backend/http/routes/agentRoutes.ts

@@ -0,0 +1,67 @@
+import {
+  getOpencodeAgentStorageInfo,
+  listOpencodeAgentTypes,
+  patchOpencodeAgentTypes,
+  validateOpencodeAgentPatch,
+} from "../../agents/opencodeConfig";
+
+export function createAgentRoutes() {
+  return {
+    "/api/mockingbird/agents": {
+      GET: async () => {
+        try {
+          const payload = await listOpencodeAgentTypes();
+          return Response.json(payload);
+        } catch (error) {
+          const storage = getOpencodeAgentStorageInfo();
+          const message = error instanceof Error ? error.message : "Failed to load OpenCode agents";
+          return Response.json(
+            {
+              agentTypes: [],
+              hash: "",
+              storage,
+              error: message,
+            },
+            { status: 502 },
+          );
+        }
+      },
+      PATCH: async (req: Request) => {
+        const body = (await req.json()) as {
+          upserts?: unknown;
+          deletes?: unknown;
+          expectedHash?: unknown;
+        };
+        if (typeof body.expectedHash !== "string" || !body.expectedHash.trim()) {
+          return Response.json({ error: "expectedHash is required" }, { status: 400 });
+        }
+
+        const validation = await validateOpencodeAgentPatch({
+          upserts: body.upserts ?? [],
+          deletes: body.deletes ?? [],
+        });
+        if (!validation.ok) {
+          return Response.json(validation, { status: 422 });
+        }
+
+        const result = await patchOpencodeAgentTypes({
+          upserts: validation.normalized.upserts,
+          deletes: validation.normalized.deletes,
+          expectedHash: body.expectedHash,
+        });
+        return Response.json(result, { status: result.ok ? 200 : result.status });
+      },
+    },
+
+    "/api/mockingbird/agents/validate": {
+      POST: async (req: Request) => {
+        const body = (await req.json()) as { upserts?: unknown; deletes?: unknown };
+        const result = await validateOpencodeAgentPatch({
+          upserts: body.upserts ?? [],
+          deletes: body.deletes ?? [],
+        });
+        return Response.json(result, { status: result.ok ? 200 : 422 });
+      },
+    },
+  };
+}

package/apps/server/src/backend/http/routes/backgroundRoutes.ts

@@ -0,0 +1,203 @@
+import type { RuntimeEngine , RuntimeInputPart } from "../../contracts/runtime";
+import { getSessionById } from "../../db/repository";
+
+function parseBoolean(value: string | null) {
+  if (!value) return false;
+  const normalized = value.trim().toLowerCase();
+  return normalized === "1" || normalized === "true" || normalized === "yes";
+}
+
+function normalizeRuntimeInputParts(value: unknown): RuntimeInputPart[] {
+  if (!Array.isArray(value)) return [];
+  const parts: RuntimeInputPart[] = [];
+  for (const raw of value) {
+    if (!raw || typeof raw !== "object" || Array.isArray(raw)) continue;
+    const record = raw as Record<string, unknown>;
+    if (record.type === "text") {
+      const text = typeof record.text === "string" ? record.text : "";
+      if (!text.trim()) continue;
+      parts.push({ type: "text", text });
+      continue;
+    }
+    if (record.type === "file") {
+      const mime = typeof record.mime === "string" ? record.mime.trim() : "";
+      const url = typeof record.url === "string" ? record.url.trim() : "";
+      const filename = typeof record.filename === "string" ? record.filename.trim() || undefined : undefined;
+      if (!mime || !url) continue;
+      parts.push({ type: "file", mime, url, filename });
+    }
+  }
+  return parts;
+}
+
+export function createBackgroundRoutes(runtime: RuntimeEngine) {
+  return {
+    "/api/background": {
+      GET: async (req: Request) => {
+        if (!runtime.listBackgroundRuns) {
+          return Response.json({ error: "Runtime does not support background listing" }, { status: 501 });
+        }
+        try {
+          const url = new URL(req.url);
+          const parentSessionId = url.searchParams.get("sessionId")?.trim() || undefined;
+          const limitRaw = Number(url.searchParams.get("limit") ?? "100");
+          const limit = Number.isFinite(limitRaw) ? Math.max(1, Math.min(500, Math.floor(limitRaw))) : 100;
+          const inFlightOnly = parseBoolean(url.searchParams.get("inFlightOnly"));
+          const runs = await runtime.listBackgroundRuns({
+            parentSessionId,
+            limit,
+            inFlightOnly,
+          });
+          return Response.json({ runs });
+        } catch (error) {
+          const message = error instanceof Error ? error.message : "Failed to list background runs";
+          return Response.json({ error: message }, { status: 502 });
+        }
+      },
+      POST: async (req: Request) => {
+        if (!runtime.spawnBackgroundSession) {
+          return Response.json({ error: "Runtime does not support background sessions" }, { status: 501 });
+        }
+
+        const body = (await req.json()) as {
+          sessionId?: string;
+          title?: string;
+          requestedBy?: string;
+          prompt?: string;
+          parts?: RuntimeInputPart[];
+          model?: string;
+          system?: string;
+          agent?: string;
+          noReply?: boolean;
+        };
+        const sessionId = body.sessionId?.trim();
+        if (!sessionId) {
+          return Response.json({ error: "sessionId is required" }, { status: 400 });
+        }
+        if (!getSessionById(sessionId)) {
+          return Response.json({ error: "Unknown session" }, { status: 404 });
+        }
+
+        const parts = normalizeRuntimeInputParts(body.parts);
+        try {
+          const run = await runtime.spawnBackgroundSession({
+            parentSessionId: sessionId,
+            title: body.title,
+            requestedBy: body.requestedBy,
+            prompt: body.prompt,
+          });
+          if (body.prompt?.trim() || parts.length > 0) {
+            if (!runtime.promptBackgroundAsync) {
+              return Response.json({ error: "Runtime does not support background prompting" }, { status: 501 });
+            }
+            const updated = await runtime.promptBackgroundAsync({
+              runId: run.runId,
+              content: body.prompt?.trim() ?? "",
+              parts,
+              model: body.model,
+              system: body.system,
+              agent: body.agent,
+              noReply: body.noReply,
+            });
+            return Response.json({ run: updated }, { status: 202 });
+          }
+          return Response.json({ run }, { status: 202 });
+        } catch (error) {
+          const message = error instanceof Error ? error.message : "Failed to spawn background run";
+          return Response.json({ error: message }, { status: 502 });
+        }
+      },
+    },
+
+    "/api/background/:id": {
+      GET: async (req: Request & { params: { id: string } }) => {
+        if (!runtime.getBackgroundStatus) {
+          return Response.json({ error: "Runtime does not support background status" }, { status: 501 });
+        }
+        try {
+          const run = await runtime.getBackgroundStatus(req.params.id);
+          if (!run) {
+            return Response.json({ error: "Unknown background run" }, { status: 404 });
+          }
+          return Response.json({ run });
+        } catch (error) {
+          const message = error instanceof Error ? error.message : "Failed to fetch background run";
+          return Response.json({ error: message }, { status: 502 });
+        }
+      },
+    },
+
+    "/api/background/:id/abort": {
+      POST: async (req: Request & { params: { id: string } }) => {
+        if (!runtime.abortBackground) {
+          return Response.json({ error: "Runtime does not support background abort" }, { status: 501 });
+        }
+        try {
+          const aborted = await runtime.abortBackground(req.params.id);
+          return Response.json({ aborted });
+        } catch (error) {
+          const message = error instanceof Error ? error.message : "Failed to abort background run";
+          return Response.json({ error: message }, { status: 502 });
+        }
+      },
+    },
+
+    "/api/background/:id/steer": {
+      POST: async (req: Request & { params: { id: string } }) => {
+        if (!runtime.promptBackgroundAsync) {
+          return Response.json({ error: "Runtime does not support background steering" }, { status: 501 });
+        }
+        const body = (await req.json()) as {
+          content?: string;
+          parts?: RuntimeInputPart[];
+          model?: string;
+          system?: string;
+          agent?: string;
+          noReply?: boolean;
+        };
+        const content = body.content?.trim();
+        const parts = normalizeRuntimeInputParts(body.parts);
+        if (!content && parts.length === 0) {
+          return Response.json({ error: "content or parts is required" }, { status: 400 });
+        }
+        try {
+          const run = await runtime.promptBackgroundAsync({
+            runId: req.params.id,
+            content: content ?? "",
+            parts,
+            model: body.model,
+            system: body.system,
+            agent: body.agent,
+            noReply: body.noReply,
+          });
+          return Response.json({ run }, { status: 202 });
+        } catch (error) {
+          const message = error instanceof Error ? error.message : "Failed to steer background run";
+          return Response.json({ error: message }, { status: 502 });
+        }
+      },
+    },
+
+    "/api/sessions/:id/background": {
+      GET: async (req: Request & { params: { id: string } }) => {
+        if (!runtime.listBackgroundRuns) {
+          return Response.json({ error: "Runtime does not support background listing" }, { status: 501 });
+        }
+        const session = getSessionById(req.params.id);
+        if (!session) {
+          return Response.json({ error: "Unknown session" }, { status: 404 });
+        }
+        try {
+          const runs = await runtime.listBackgroundRuns({
+            parentSessionId: req.params.id,
+            limit: 200,
+          });
+          return Response.json({ runs });
+        } catch (error) {
+          const message = error instanceof Error ? error.message : "Failed to list session background runs";
+          return Response.json({ error: message }, { status: 502 });
+        }
+      },
+    },
+  };
+}

package/apps/server/src/backend/http/routes/chatRoutes.ts

@@ -0,0 +1,107 @@
+import type { RuntimeEngine } from "../../contracts/runtime";
+import { getSessionById } from "../../db/repository";
+import { RuntimeSessionBusyError, RuntimeSessionNotFoundError, RuntimeTurnTimeoutError } from "../../runtime";
+
+function preflightFailureStatusCode(name: string | undefined, message: string | undefined) {
+  if (
+    name === "RuntimeProviderAuthError" ||
+    name === "RuntimeProviderQuotaError" ||
+    name === "RuntimeProviderRateLimitError"
+  ) {
+    return 502;
+  }
+  if (message && /timed out/i.test(message)) {
+    return 504;
+  }
+  return 503;
+}
+
+export function createChatRoutes(runtime: RuntimeEngine) {
+  return {
+    "/api/chat": {
+      POST: async (req: Request) => {
+        const body = (await req.json()) as { sessionId?: string; content?: string };
+        const content = body.content?.trim();
+        if (!body.sessionId || !content) {
+          return Response.json({ error: "sessionId and content are required" }, { status: 400 });
+        }
+
+        if (runtime.checkHealth) {
+          try {
+            const health = await runtime.checkHealth();
+            if (!health.ok) {
+              const message = health.error?.message ?? "Runtime health check failed";
+              const status = preflightFailureStatusCode(health.error?.name, health.error?.message);
+              return Response.json(
+                {
+                  error: `Runtime preflight failed: ${message}`,
+                  health,
+                },
+                { status },
+              );
+            }
+          } catch (error) {
+            const message = error instanceof Error ? error.message : "Runtime health check failed";
+            return Response.json({ error: `Runtime preflight failed: ${message}` }, { status: 503 });
+          }
+        }
+
+        let ack;
+        try {
+          ack = await runtime.sendUserMessage({
+            sessionId: body.sessionId,
+            content,
+          });
+        } catch (error) {
+          if (error instanceof RuntimeSessionNotFoundError) {
+            return Response.json({ error: "Unknown session" }, { status: 404 });
+          }
+          if (error instanceof RuntimeSessionBusyError) {
+            return Response.json({ error: "Session is already processing a request" }, { status: 409 });
+          }
+          if (error instanceof RuntimeTurnTimeoutError) {
+            return Response.json({ error: "Runtime timed out waiting for OpenCode to finish" }, { status: 504 });
+          }
+          const message = error instanceof Error ? error.message : "Runtime request failed";
+          return Response.json({ error: message }, { status: 502 });
+        }
+
+        const session = getSessionById(ack.sessionId);
+        if (!session) {
+          return Response.json({ error: "Unknown session" }, { status: 404 });
+        }
+
+        return Response.json({
+          messages: ack.messages,
+          session,
+        });
+      },
+    },
+    "/api/chat/:id/abort": {
+      POST: async (req: Request & { params: { id: string } }) => {
+        if (!runtime.abortSession) {
+          return Response.json({ error: "Runtime does not support abort" }, { status: 501 });
+        }
+        const session = getSessionById(req.params.id);
+        if (!session) {
+          return Response.json({ error: "Unknown session" }, { status: 404 });
+        }
+        const aborted = await runtime.abortSession(session.id);
+        return Response.json({ aborted });
+      },
+    },
+    "/api/chat/:id/compact": {
+      POST: async (req: Request & { params: { id: string } }) => {
+        if (!runtime.compactSession) {
+          return Response.json({ error: "Runtime does not support compaction" }, { status: 501 });
+        }
+        const session = getSessionById(req.params.id);
+        if (!session) {
+          return Response.json({ error: "Unknown session" }, { status: 404 });
+        }
+        const compacted = await runtime.compactSession(session.id);
+        return Response.json({ compacted });
+      },
+    },
+  };
+}