@khoralabs/chat 0.1.0

package/dist/http/server.js

@@ -0,0 +1,973 @@
+import { createRequire } from "node:module";
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// src/errors.ts
+class ChatError extends Error {
+  code;
+  constructor(code, message) {
+    super(message);
+    this.name = "ChatError";
+    this.code = code;
+  }
+}
+
+class ChatNotFoundError extends ChatError {
+  resource;
+  resourceId;
+  constructor(resource, resourceId) {
+    super("not_found", `${resource} not found: ${resourceId}`);
+    this.name = "ChatNotFoundError";
+    this.resource = resource;
+    this.resourceId = resourceId;
+  }
+}
+
+class ChatConflictError extends ChatError {
+  reason;
+  constructor(reason, message) {
+    super("conflict", message);
+    this.name = "ChatConflictError";
+    this.reason = reason;
+  }
+}
+
+class ChatValidationError extends ChatError {
+  constructor(message) {
+    super("validation", message);
+    this.name = "ChatValidationError";
+  }
+}
+
+class ChatPermissionError extends ChatError {
+  constructor(message) {
+    super("permission_denied", message);
+    this.name = "ChatPermissionError";
+  }
+}
+// src/hash.ts
+function sha256Hex(input) {
+  const hasher = new Bun.CryptoHasher("sha256");
+  hasher.update(input);
+  return hasher.digest("hex");
+}
+function stableStringify(value) {
+  if (value === undefined) {
+    return "null";
+  }
+  if (value === null || typeof value !== "object") {
+    return JSON.stringify(value);
+  }
+  if (Array.isArray(value)) {
+    return `[${value.map((item) => stableStringify(item)).join(",")}]`;
+  }
+  const record = value;
+  const keys = Object.keys(record).sort();
+  return `{${keys.map((key) => `${JSON.stringify(key)}:${stableStringify(record[key])}`).join(",")}}`;
+}
+function canonicalPostVersionPayload(input) {
+  return stableStringify({
+    postId: input.postId,
+    versionId: input.versionId,
+    threadId: input.threadId,
+    author: input.author,
+    role: input.role,
+    parts: input.parts,
+    metadata: input.metadata ?? null,
+    mentions: input.mentions ?? null,
+    model: input.model ?? null,
+    usage: input.usage ?? null,
+    parentVersionId: input.parentVersionId ?? null,
+    previousPostVersionId: input.previousPostVersionId ?? null
+  });
+}
+function computeContentHash(payload) {
+  return sha256Hex(canonicalPostVersionPayload(payload));
+}
+function computeLineageHash(input) {
+  return sha256Hex(stableStringify({
+    previousLineageHash: input.previousLineageHash,
+    contentHash: input.contentHash,
+    postId: input.postId,
+    versionId: input.versionId
+  }));
+}
+function canonicalAclEventPayload(input) {
+  return stableStringify({
+    type: input.type,
+    targetType: input.targetType,
+    targetId: input.targetId,
+    scope: input.scope ?? null,
+    role: input.role ?? null,
+    actor: input.actor,
+    previousAclEventId: input.previousAclEventId ?? null
+  });
+}
+function computeAclEventContentHash(payload) {
+  return sha256Hex(canonicalAclEventPayload(payload));
+}
+function signedPayloadBytes(payload) {
+  return new TextEncoder().encode(payload);
+}
+function canonicalSignedPostVersionPayload(input) {
+  return stableStringify({
+    contentHash: input.contentHash,
+    lineageHash: input.lineageHash,
+    payload: JSON.parse(canonicalPostVersionPayload(input))
+  });
+}
+function canonicalSignedAclEventPayload(input) {
+  return stableStringify({
+    contentHash: input.contentHash,
+    payload: JSON.parse(canonicalAclEventPayload(input.payload))
+  });
+}
+async function maybeSignPayload(payload, signer, sign) {
+  return sign(signedPayloadBytes(payload), signer);
+}
+// src/ids.ts
+function createId() {
+  return crypto.randomUUID();
+}
+function scopeKey(scope) {
+  return `${scope.type}:${scope.id}`;
+}
+function scopeRefFromKey(key) {
+  const separatorIndex = key.indexOf(":");
+  if (separatorIndex === -1) {
+    throw new Error(`Invalid scope key: ${key}`);
+  }
+  return {
+    type: key.slice(0, separatorIndex),
+    id: key.slice(separatorIndex + 1)
+  };
+}
+// src/lineage.ts
+function walkLineageFromHead(headVersionId, versionsById) {
+  const lineage = [];
+  let currentId = headVersionId;
+  const seenPostIds = new Set;
+  while (currentId) {
+    const version = versionsById.get(currentId);
+    if (!version)
+      break;
+    if (!seenPostIds.has(version.postId)) {
+      lineage.push(version);
+      seenPostIds.add(version.postId);
+    }
+    currentId = version.previousPostVersionId;
+  }
+  return lineage.reverse();
+}
+function lineageBetween(headVersionId, ancestorVersionId, versionsById) {
+  const lineage = walkLineageFromHead(headVersionId, versionsById);
+  const startIndex = lineage.findIndex((version) => version.id === ancestorVersionId);
+  if (startIndex === -1)
+    return null;
+  return lineage.slice(startIndex);
+}
+function postFromVersion(version, index, deletedAtMs) {
+  return {
+    ...version,
+    id: version.postId,
+    status: "complete",
+    versionId: version.id,
+    previousVersionId: version.parentVersionId ?? null,
+    index,
+    updatedAtMs: version.parentVersionId ? version.createdAtMs : null,
+    deletedAtMs: deletedAtMs ?? null
+  };
+}
+// src/stream.ts
+function rebuildStreamCacheFromEvents(events) {
+  const sorted = [...events].sort((a, b) => a.revision - b.revision);
+  let message = null;
+  let mentions;
+  let model;
+  let usage;
+  let revision = 0;
+  for (const event of sorted) {
+    if (event.eventType === "stream.started") {
+      if (!event.message) {
+        throw new Error(`stream.started event ${event.id} missing message`);
+      }
+      message = event.message;
+      mentions = event.mentions;
+      model = event.model;
+      usage = event.usage;
+      revision = event.revision;
+      continue;
+    }
+    if (event.eventType === "stream.delta") {
+      if (!event.message) {
+        throw new Error(`stream.delta event ${event.id} missing message`);
+      }
+      message = event.message;
+      if (event.mentions !== undefined)
+        mentions = event.mentions;
+      if (event.model !== undefined)
+        model = event.model;
+      if (event.usage !== undefined)
+        usage = event.usage;
+      revision = event.revision;
+      continue;
+    }
+    if (event.eventType === "stream.completed" || event.eventType === "stream.aborted") {
+      revision = event.revision;
+    }
+  }
+  if (!message) {
+    throw new Error("stream events did not produce a message");
+  }
+  return { message, mentions, model, usage, revision };
+}
+function streamingPostFromCache(input) {
+  return {
+    ...input.message,
+    id: input.postId,
+    status: "streaming",
+    threadId: input.threadId,
+    author: input.author,
+    mentions: input.mentions,
+    model: input.model,
+    usage: input.usage,
+    index: input.index,
+    streamRevision: input.streamRevision,
+    createdAtMs: input.createdAtMs,
+    updatedAtMs: input.updatedAtMs ?? null,
+    deletedAtMs: input.deletedAtMs ?? null
+  };
+}
+function mergeThreadPostsForList(lineagePosts, activePosts) {
+  const byIndex = new Map;
+  for (const item of lineagePosts) {
+    byIndex.set(item.index, item.post);
+  }
+  for (const post of activePosts) {
+    if (post.status === "streaming" || post.status === "aborted") {
+      byIndex.set(post.index, post);
+    }
+  }
+  return [...byIndex.entries()].sort(([a], [b]) => a - b).map(([, post]) => post);
+}
+// src/validation.ts
+function assertThreadRoot(root) {
+  if (root.type === "channel") {
+    if (!root.channelId.trim()) {
+      throw new ChatValidationError("channel root requires channelId");
+    }
+    return;
+  }
+  if (!root.postId.trim()) {
+    throw new ChatValidationError("post root requires postId");
+  }
+}
+function assertNonEmptyString(value, label) {
+  if (!value.trim()) {
+    throw new ChatValidationError(`${label} is required`);
+  }
+}
+// src/http/routes.ts
+function json(value, init) {
+  return Response.json(value, init);
+}
+function extractBearerToken(req) {
+  const auth = req.headers.get("authorization")?.trim() ?? "";
+  const match = /^Bearer\s+(.+)$/i.exec(auth);
+  const headerToken = match?.[1]?.trim() ?? "";
+  if (headerToken.length > 0)
+    return headerToken;
+  const url = new URL(req.url);
+  return url.searchParams.get("token")?.trim() ?? "";
+}
+function requireInternalToken(req, expected) {
+  const token = extractBearerToken(req);
+  if (token.length === 0 || token !== expected) {
+    return json({ error: "Unauthorized" }, { status: 401 });
+  }
+  return null;
+}
+function createTokenAuthorizer(token) {
+  return (req) => requireInternalToken(req, token);
+}
+async function readJson(req) {
+  try {
+    return await req.json();
+  } catch {
+    return null;
+  }
+}
+function stringField(body, key) {
+  const value = body[key];
+  return typeof value === "string" && value.length > 0 ? value : null;
+}
+function errorResponse(error) {
+  if (error instanceof ChatNotFoundError) {
+    return json({ error: error.message }, { status: 404 });
+  }
+  const message = error instanceof Error ? error.message : String(error);
+  return json({ error: message }, { status: 500 });
+}
+function resolveAuthorize(options) {
+  if (options.authorize !== undefined)
+    return options.authorize;
+  if (options.token !== undefined && options.token.length > 0) {
+    return createTokenAuthorizer(options.token);
+  }
+  throw new Error("createChatRoutes requires token or authorize");
+}
+function createChatRoutes(chat, tokenOrOptions) {
+  const options = typeof tokenOrOptions === "string" ? { token: tokenOrOptions } : tokenOrOptions;
+  const authorized = resolveAuthorize(options);
+  return {
+    "GET /health": async () => json({ ok: true }),
+    "POST /channels/get": async (req) => {
+      const error = await authorized(req);
+      if (error !== null)
+        return error;
+      const body = await readJson(req);
+      const channelId = body === null ? null : stringField(body, "channelId");
+      if (channelId === null)
+        return json({ error: "channelId is required" }, { status: 400 });
+      try {
+        return json(await chat.getChannel(channelId));
+      } catch (err) {
+        return errorResponse(err);
+      }
+    },
+    "POST /channels/create": async (req) => {
+      const error = await authorized(req);
+      if (error !== null)
+        return error;
+      const body = await readJson(req);
+      const id = body === null ? null : stringField(body, "id");
+      if (id === null)
+        return json({ error: "id is required" }, { status: 400 });
+      try {
+        return json(await chat.createChannel({
+          id,
+          metadata: body?.metadata
+        }));
+      } catch (err) {
+        return errorResponse(err);
+      }
+    },
+    "POST /threads/get": async (req) => {
+      const error = await authorized(req);
+      if (error !== null)
+        return error;
+      const body = await readJson(req);
+      const threadId = body === null ? null : stringField(body, "threadId");
+      if (threadId === null)
+        return json({ error: "threadId is required" }, { status: 400 });
+      try {
+        return json(await chat.getThread(threadId));
+      } catch (err) {
+        return errorResponse(err);
+      }
+    },
+    "POST /threads/create": async (req) => {
+      const error = await authorized(req);
+      if (error !== null)
+        return error;
+      const body = await readJson(req);
+      if (body?.id === undefined || body.root === undefined) {
+        return json({ error: "id and root are required" }, { status: 400 });
+      }
+      try {
+        return json(await chat.createThread({
+          id: body.id,
+          root: body.root,
+          metadata: body.metadata
+        }));
+      } catch (err) {
+        return errorResponse(err);
+      }
+    },
+    "POST /threads/list": async (req) => {
+      const error = await authorized(req);
+      if (error !== null)
+        return error;
+      const body = await readJson(req);
+      if (body?.channelId === undefined) {
+        return json({ error: "channelId is required" }, { status: 400 });
+      }
+      try {
+        return json(await chat.listThreads({
+          channelId: body.channelId,
+          participant: body.participant,
+          limit: body.limit,
+          cursor: body.cursor
+        }));
+      } catch (err) {
+        return errorResponse(err);
+      }
+    },
+    "POST /threads/list-posts": async (req) => {
+      const error = await authorized(req);
+      if (error !== null)
+        return error;
+      const body = await readJson(req);
+      if (body?.threadId === undefined) {
+        return json({ error: "threadId is required" }, { status: 400 });
+      }
+      try {
+        return json(await chat.listPosts({ threadId: body.threadId, limit: body.limit, cursor: body.cursor }));
+      } catch (err) {
+        return errorResponse(err);
+      }
+    },
+    "POST /threads/tip": async (req) => {
+      const error = await authorized(req);
+      if (error !== null)
+        return error;
+      const body = await readJson(req);
+      const threadId = body === null ? null : stringField(body, "threadId");
+      if (threadId === null)
+        return json({ error: "threadId is required" }, { status: 400 });
+      try {
+        return json({ tip: await chat.getThreadTip(threadId) });
+      } catch (err) {
+        return errorResponse(err);
+      }
+    },
+    "POST /threads/list-participants": async (req) => {
+      const error = await authorized(req);
+      if (error !== null)
+        return error;
+      const body = await readJson(req);
+      const threadId = body === null ? null : stringField(body, "threadId");
+      if (threadId === null)
+        return json({ error: "threadId is required" }, { status: 400 });
+      try {
+        return json({ participants: await chat.listThreadParticipants(threadId) });
+      } catch (err) {
+        return errorResponse(err);
+      }
+    },
+    "POST /threads/add-participant": async (req) => {
+      const error = await authorized(req);
+      if (error !== null)
+        return error;
+      const body = await readJson(req);
+      if (body?.threadId === undefined || body.scope === undefined || body.actor === undefined) {
+        return json({ error: "threadId, scope, and actor are required" }, { status: 400 });
+      }
+      try {
+        return json(await chat.addThreadParticipant({
+          threadId: body.threadId,
+          scope: body.scope,
+          role: body.role ?? "participant",
+          actor: body.actor
+        }));
+      } catch (err) {
+        return errorResponse(err);
+      }
+    },
+    "POST /threads/append-post": async (req) => {
+      const error = await authorized(req);
+      if (error !== null)
+        return error;
+      const body = await readJson(req);
+      if (body?.threadId === undefined || body.author === undefined || body.message === undefined) {
+        return json({ error: "threadId, author, and message are required" }, { status: 400 });
+      }
+      try {
+        return json(await chat.appendPost({
+          threadId: body.threadId,
+          author: body.author,
+          message: body.message,
+          expectedHeadPostVersionId: body.expectedHeadPostVersionId,
+          versionId: body.versionId,
+          createdAtMs: body.createdAtMs,
+          signature: body.signature
+        }));
+      } catch (err) {
+        return errorResponse(err);
+      }
+    },
+    "POST /posts/set-signature": async (req) => {
+      const error = await authorized(req);
+      if (error !== null)
+        return error;
+      const body = await readJson(req);
+      if (body?.versionId === undefined || body.signature === undefined) {
+        return json({ error: "versionId and signature are required" }, { status: 400 });
+      }
+      try {
+        await chat.setPostVersionSignature(body.versionId, body.signature);
+        return json({ ok: true });
+      } catch (err) {
+        return errorResponse(err);
+      }
+    },
+    "POST /internal/chat/streamed-posts": async (req) => {
+      const error = await authorized(req);
+      if (error !== null)
+        return error;
+      const body = await readJson(req);
+      if (body?.author === undefined || body.message === undefined || body.threadId === undefined) {
+        return json({ error: "threadId, author, and message are required" }, { status: 400 });
+      }
+      try {
+        return json(await chat.startStreamedPost({
+          threadId: body.threadId,
+          author: body.author,
+          idempotencyKey: body.idempotencyKey,
+          message: body.message
+        }));
+      } catch (err) {
+        return errorResponse(err);
+      }
+    },
+    "POST /internal/chat/posts/:postId/deltas": async (req) => {
+      const error = await authorized(req);
+      if (error !== null)
+        return error;
+      const url = new URL(req.url);
+      const postId = url.pathname.split("/").at(-2);
+      if (postId === undefined)
+        return json({ error: "postId is required" }, { status: 400 });
+      const body = await readJson(req);
+      if (body?.message === undefined) {
+        return json({ error: "message is required" }, { status: 400 });
+      }
+      try {
+        return json(await chat.applyPostDelta({
+          postId,
+          expectedRevision: body.expectedRevision,
+          message: body.message,
+          model: body.model,
+          usage: body.usage
+        }));
+      } catch (err) {
+        return errorResponse(err);
+      }
+    },
+    "POST /internal/chat/posts/:postId/complete": async (req) => {
+      const error = await authorized(req);
+      if (error !== null)
+        return error;
+      const url = new URL(req.url);
+      const postId = url.pathname.split("/").at(-2);
+      if (postId === undefined)
+        return json({ error: "postId is required" }, { status: 400 });
+      const body = await readJson(req);
+      try {
+        return json(await chat.completeStreamedPost({
+          postId,
+          expectedRevision: body?.expectedRevision,
+          idempotencyKey: body?.idempotencyKey
+        }));
+      } catch (err) {
+        return errorResponse(err);
+      }
+    },
+    "POST /internal/chat/posts/:postId/abort": async (req) => {
+      const error = await authorized(req);
+      if (error !== null)
+        return error;
+      const url = new URL(req.url);
+      const postId = url.pathname.split("/").at(-2);
+      if (postId === undefined)
+        return json({ error: "postId is required" }, { status: 400 });
+      try {
+        const post = await chat.abortStreamedPost({ postId });
+        return json({ post });
+      } catch (err) {
+        return errorResponse(err);
+      }
+    }
+  };
+}
+function createChatRoutesWithParams(chat, tokenOrOptions) {
+  const options = typeof tokenOrOptions === "string" ? { token: tokenOrOptions } : tokenOrOptions;
+  const base = createChatRoutes(chat, options);
+  const authorized = resolveAuthorize(options);
+  return {
+    ...base,
+    "POST /internal/chat/threads/:threadId/streamed-posts": async (req) => {
+      const error = await authorized(req);
+      if (error !== null)
+        return error;
+      const url = new URL(req.url);
+      const parts = url.pathname.split("/");
+      const threadIdx = parts.indexOf("threads");
+      const threadId = threadIdx >= 0 ? decodeURIComponent(parts[threadIdx + 1] ?? "") : undefined;
+      const body = await readJson(req);
+      if (threadId === undefined || threadId.length === 0 || body?.author === undefined || body.message === undefined) {
+        return json({ error: "threadId, author, and message are required" }, { status: 400 });
+      }
+      try {
+        return json(await chat.startStreamedPost({
+          threadId,
+          author: body.author,
+          idempotencyKey: body.idempotencyKey,
+          message: body.message
+        }));
+      } catch (err) {
+        return errorResponse(err);
+      }
+    }
+  };
+}
+async function dispatchChatRoute(routes, req) {
+  const url = new URL(req.url);
+  const paramPaths = [
+    "POST /internal/chat/threads/:threadId/streamed-posts",
+    "POST /internal/chat/posts/:postId/deltas",
+    "POST /internal/chat/posts/:postId/complete",
+    "POST /internal/chat/posts/:postId/abort"
+  ];
+  for (const pattern of paramPaths) {
+    const [method, pathPattern] = pattern.split(" ");
+    if (req.method !== method || pathPattern === undefined)
+      continue;
+    const regex = new RegExp(`^${pathPattern.replace(/:[^/]+/g, "[^/]+")}$`);
+    if (regex.test(url.pathname)) {
+      const handler2 = routes[pattern];
+      if (handler2 !== undefined)
+        return handler2(req);
+    }
+  }
+  const key = `${req.method} ${url.pathname}`;
+  const handler = routes[key];
+  if (handler === undefined)
+    return json({ error: "Not found" }, { status: 404 });
+  return handler(req);
+}
+
+// src/http/service.ts
+import {
+  closeLocalSqliteDatabase,
+  createLocalSqliteDatabase,
+  createTursoChatPersistence,
+  createTursoDatabase,
+  ensureChatSchema
+} from "@khoralabs/chat/turso-serverless";
+
+// src/service.ts
+function createChatService(persistence, options = {}) {
+  const emit = (event) => {
+    options.onEvent?.(event);
+  };
+  async function requireChannel(id) {
+    const channel = await persistence.getChannel(id);
+    if (!channel)
+      throw new ChatNotFoundError("channel", id);
+    return channel;
+  }
+  async function requireThread(id) {
+    const thread = await persistence.getThread(id);
+    if (!thread)
+      throw new ChatNotFoundError("thread", id);
+    return thread;
+  }
+  async function requirePost(id) {
+    const post = await persistence.getPost(id);
+    if (!post)
+      throw new ChatNotFoundError("post", id);
+    return post;
+  }
+  return {
+    async createChannel(input) {
+      const channel = await persistence.createChannel({
+        ...input,
+        id: input.id ?? options.generateId?.() ?? createId()
+      });
+      emit({ type: "channel.created", channel });
+      return channel;
+    },
+    async createThread(input) {
+      const thread = await persistence.createThread({
+        ...input,
+        id: input.id ?? options.generateId?.() ?? createId()
+      });
+      emit({ type: "thread.created", thread });
+      return thread;
+    },
+    getChannel: requireChannel,
+    getThread: requireThread,
+    getPost: requirePost,
+    listThreads: (input) => persistence.listThreads(input),
+    listPosts: (input) => persistence.listPosts(input),
+    getThreadTip: (threadId) => persistence.getThreadTip(threadId),
+    async appendPost(input) {
+      const result = await persistence.appendPost(input);
+      if (!result.ok) {
+        throw new ChatConflictError("head_conflict", `head conflict: expected ${input.expectedHeadPostVersionId ?? "null"}, current ${result.currentHead.headPostVersionId}`);
+      }
+      emit({
+        type: "post.appended",
+        threadId: input.threadId,
+        post: result.post
+      });
+      return { post: result.post, head: result.head };
+    },
+    async editPost(input) {
+      const result = await persistence.editPost(input);
+      if (!result.ok) {
+        throw new ChatConflictError("head_conflict", `head conflict during edit: current ${result.currentHead.headPostVersionId}`);
+      }
+      emit({
+        type: "post.updated",
+        threadId: result.post.threadId,
+        post: result.post
+      });
+      return { post: result.post, head: result.head };
+    },
+    async deletePost(input) {
+      const post = await persistence.deletePost(input);
+      emit({
+        type: "post.deleted",
+        threadId: post.threadId,
+        postId: post.id,
+        deletedAtMs: post.deletedAtMs ?? Date.now()
+      });
+      return post;
+    },
+    addChannelMember: (input) => persistence.addChannelMember(input),
+    removeChannelMember: (input) => persistence.removeChannelMember(input),
+    async addThreadParticipant(input) {
+      const event = await persistence.addThreadParticipant(input);
+      emit({
+        type: "participant.added",
+        threadId: input.threadId,
+        scope: input.scope,
+        role: input.role
+      });
+      return event;
+    },
+    removeThreadParticipant: (input) => persistence.removeThreadParticipant(input),
+    createThreadHead: (input) => persistence.createThreadHead(input),
+    listChannelMembers: (channelId) => persistence.listChannelMembers(channelId),
+    listThreadParticipants: (threadId) => persistence.listThreadParticipants(threadId),
+    async startStreamedPost(input) {
+      const result = await persistence.startStreamedPost(input);
+      emit({
+        type: "post.stream.started",
+        threadId: input.threadId,
+        post: result.post,
+        revision: result.revision
+      });
+      return result;
+    },
+    async applyPostDelta(input) {
+      const record = await persistence.getPost(input.postId);
+      if (!record)
+        throw new ChatNotFoundError("post", input.postId);
+      const result = await persistence.applyPostDelta(input);
+      emit({
+        type: "post.stream.delta",
+        threadId: record.threadId,
+        post: result.post,
+        revision: result.revision
+      });
+      return result;
+    },
+    async completeStreamedPost(input) {
+      const record = await persistence.getPost(input.postId);
+      if (!record)
+        throw new ChatNotFoundError("post", input.postId);
+      const streamRevision = record.status === "streaming" ? record.streamRevision : input.expectedRevision;
+      const result = await persistence.completeStreamedPost(input);
+      if (!result.ok) {
+        throw new ChatConflictError("head_conflict", `head conflict during stream completion: current ${result.currentHead.headPostVersionId}`);
+      }
+      emit({
+        type: "post.stream.completed",
+        threadId: record.threadId,
+        post: result.post,
+        head: result.head,
+        revision: typeof streamRevision === "number" ? streamRevision + 1 : 0
+      });
+      return { post: result.post, head: result.head };
+    },
+    async abortStreamedPost(input) {
+      const record = await persistence.getPost(input.postId);
+      if (!record)
+        throw new ChatNotFoundError("post", input.postId);
+      const result = await persistence.abortStreamedPost(input);
+      emit({
+        type: "post.stream.aborted",
+        threadId: record.threadId,
+        postId: input.postId,
+        revision: result.post.streamRevision,
+        deletedAtMs: result.post.deletedAtMs ?? Date.now()
+      });
+      return result.post;
+    },
+    setPostVersionSignature(versionId, signature) {
+      return persistence.setPostVersionSignature(versionId, signature);
+    }
+  };
+}
+
+// src/http/service.ts
+function createChatHttpRuntime(options) {
+  const subscribers = new Map;
+  const service = createChatService(options.persistence, {
+    onEvent(event) {
+      options.onEvent?.(event);
+      if (!("threadId" in event))
+        return;
+      for (const send of subscribers.get(event.threadId) ?? [])
+        send(event);
+    }
+  });
+  return {
+    service,
+    subscribeToThread(threadId, send) {
+      const set = subscribers.get(threadId) ?? new Set;
+      set.add(send);
+      subscribers.set(threadId, set);
+      return () => {
+        set.delete(send);
+        if (set.size === 0)
+          subscribers.delete(threadId);
+      };
+    },
+    close() {
+      subscribers.clear();
+    }
+  };
+}
+async function createChatStorage(config) {
+  if (config.kind === "custom") {
+    return {
+      persistence: config.persistence,
+      close() {
+        config.close?.();
+      }
+    };
+  }
+  if (config.kind === "turso") {
+    const db2 = createTursoDatabase({
+      url: config.url,
+      authToken: config.authToken
+    });
+    await ensureChatSchema(db2);
+    return {
+      persistence: createTursoChatPersistence(db2),
+      close() {
+        closeLocalSqliteDatabase(db2);
+      }
+    };
+  }
+  const db = createLocalSqliteDatabase(config.dbPath);
+  return {
+    persistence: createTursoChatPersistence(db),
+    close() {
+      closeLocalSqliteDatabase(db);
+    }
+  };
+}
+function isChatNotFound(error) {
+  return error instanceof ChatNotFoundError;
+}
+
+// src/http/server.ts
+import { serve } from "bun";
+
+// src/http/config.ts
+import path from "node:path";
+function resolveChatDataDir() {
+  const raw = process.env.CHAT_DATA_DIR?.trim();
+  if (raw !== undefined && raw.length > 0)
+    return raw;
+  return path.join(process.cwd(), "data");
+}
+function resolveChatDbPath() {
+  const raw = process.env.CHAT_DB_PATH?.trim();
+  if (raw !== undefined && raw.length > 0)
+    return raw;
+  return path.join(resolveChatDataDir(), "chat.db");
+}
+function chatInternalToken() {
+  const value = process.env.CHAT_INTERNAL_TOKEN?.trim();
+  if (value === undefined || value.length === 0) {
+    throw new Error("CHAT_INTERNAL_TOKEN must be set");
+  }
+  return value;
+}
+function chatHttpPort() {
+  return Number(process.env.PORT?.trim() || "3002");
+}
+
+// src/http/server.ts
+async function startChatHttpServer(opts) {
+  const storage = await createChatStorage(opts.storage);
+  const runtime = createChatHttpRuntime({
+    persistence: storage.persistence,
+    onEvent: opts.onEvent
+  });
+  const routes = createChatRoutesWithParams(runtime.service, opts.token);
+  const token = opts.token;
+  const server = serve({
+    port: opts.port ?? 0,
+    fetch(req, bunServer) {
+      const url = new URL(req.url);
+      if (req.method === "GET" && url.pathname === "/health") {
+        return Response.json({ ok: true });
+      }
+      if (url.pathname.startsWith("/ws/threads/")) {
+        const authError = requireInternalToken(req, token);
+        if (authError !== null)
+          return authError;
+        const threadId = decodeURIComponent(url.pathname.slice("/ws/threads/".length));
+        if (threadId.length === 0) {
+          return Response.json({ error: "threadId is required" }, { status: 400 });
+        }
+        const upgraded = bunServer.upgrade(req, { data: { threadId } });
+        if (upgraded)
+          return;
+        return new Response("WebSocket upgrade failed", { status: 500 });
+      }
+      return dispatchChatRoute(routes, req);
+    },
+    websocket: {
+      open(ws) {
+        ws.data.unsubscribe = runtime.subscribeToThread(ws.data.threadId, (event) => {
+          ws.send(JSON.stringify(event));
+        });
+      },
+      message() {},
+      close(ws) {
+        ws.data.unsubscribe?.();
+      }
+    }
+  });
+  const port = server.port ?? opts.port ?? 0;
+  return {
+    port,
+    baseUrl: `http://127.0.0.1:${port}`,
+    token,
+    service: runtime.service,
+    stop() {
+      server.stop(true);
+      runtime.close();
+      storage.close();
+    }
+  };
+}
+function storageConfigFromEnv() {
+  const tursoUrl = process.env.TURSO_DATABASE_URL?.trim();
+  if (tursoUrl !== undefined && tursoUrl.length > 0) {
+    const authToken = process.env.TURSO_AUTH_TOKEN?.trim();
+    if (authToken === undefined || authToken.length === 0) {
+      throw new Error("TURSO_AUTH_TOKEN must be set when TURSO_DATABASE_URL is set");
+    }
+    return { kind: "turso", url: tursoUrl, authToken };
+  }
+  return { kind: "local-sqlite", dbPath: resolveChatDbPath() };
+}
+if (__require.main == __require.module) {
+  const handle = await startChatHttpServer({
+    storage: storageConfigFromEnv(),
+    token: chatInternalToken(),
+    port: chatHttpPort()
+  });
+  console.log(`chat-http listening on ${handle.port}`);
+}
+export {
+  startChatHttpServer
+};