@khoralabs/chat 0.1.0

package/dist/http/service.d.ts

@@ -0,0 +1,34 @@
+import type { ChatEvent, ChatPersistence } from "../domain.js";
+import { ChatNotFoundError } from "../domain.js";
+import { type ChatService } from "../service.js";
+export type ChatHttpRuntime = {
+    service: ChatService;
+    subscribeToThread(threadId: string, send: (event: ChatEvent) => void): () => void;
+    close(): void;
+};
+export type CreateChatHttpRuntimeOptions = {
+    persistence: ChatPersistence;
+    onEvent?: (event: ChatEvent) => void;
+};
+export type ChatStorageConfig = {
+    kind: "local-sqlite";
+    dbPath: string;
+} | {
+    kind: "turso";
+    url: string;
+    authToken: string;
+} | {
+    kind: "custom";
+    persistence: ChatPersistence;
+    close?: () => void;
+};
+export type ChatStorage = {
+    persistence: ChatPersistence;
+    close(): void;
+};
+/** Build a ChatService + in-process thread event fanout from host-provided persistence. */
+export declare function createChatHttpRuntime(options: CreateChatHttpRuntimeOptions): ChatHttpRuntime;
+/** Open host-selected storage and return persistence + cleanup. */
+export declare function createChatStorage(config: ChatStorageConfig): Promise<ChatStorage>;
+export declare function isChatNotFound(error: unknown): error is ChatNotFoundError;
+//# sourceMappingURL=service.d.ts.map

package/dist/http/service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"service.d.ts","sourceRoot":"","sources":["../../src/http/service.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,SAAS,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AAC/D,OAAO,EAAE,iBAAiB,EAAE,MAAM,cAAc,CAAC;AACjD,OAAO,EAAE,KAAK,WAAW,EAAqB,MAAM,eAAe,CAAC;AAEpE,MAAM,MAAM,eAAe,GAAG;IAC5B,OAAO,EAAE,WAAW,CAAC;IACrB,iBAAiB,CAAC,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC,KAAK,EAAE,SAAS,KAAK,IAAI,GAAG,MAAM,IAAI,CAAC;IAClF,KAAK,IAAI,IAAI,CAAC;CACf,CAAC;AAEF,MAAM,MAAM,4BAA4B,GAAG;IACzC,WAAW,EAAE,eAAe,CAAC;IAC7B,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,SAAS,KAAK,IAAI,CAAC;CACtC,CAAC;AAEF,MAAM,MAAM,iBAAiB,GACzB;IAAE,IAAI,EAAE,cAAc,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,GACxC;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,GAAG,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAE,GACjD;IAAE,IAAI,EAAE,QAAQ,CAAC;IAAC,WAAW,EAAE,eAAe,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,IAAI,CAAA;CAAE,CAAC;AAEzE,MAAM,MAAM,WAAW,GAAG;IACxB,WAAW,EAAE,eAAe,CAAC;IAC7B,KAAK,IAAI,IAAI,CAAC;CACf,CAAC;AAEF,2FAA2F;AAC3F,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,4BAA4B,GAAG,eAAe,CA0B5F;AAED,mEAAmE;AACnE,wBAAsB,iBAAiB,CAAC,MAAM,EAAE,iBAAiB,GAAG,OAAO,CAAC,WAAW,CAAC,CA+BvF;AAED,wBAAgB,cAAc,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,iBAAiB,CAEzE"}

package/dist/http/service.js

@@ -0,0 +1,501 @@
+import { createRequire } from "node:module";
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// src/http/service.ts
+import {
+  closeLocalSqliteDatabase,
+  createLocalSqliteDatabase,
+  createTursoChatPersistence,
+  createTursoDatabase,
+  ensureChatSchema
+} from "@khoralabs/chat/turso-serverless";
+
+// 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/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;
+}
+export {
+  isChatNotFound,
+  createChatStorage,
+  createChatHttpRuntime
+};

package/dist/ids.d.ts

@@ -0,0 +1,8 @@
+import type { ScopeRef } from "./types.js";
+export declare function createId(): string;
+export declare function scopeKey(scope: {
+    type: string;
+    id: string;
+}): string;
+export declare function scopeRefFromKey(key: string): ScopeRef;
+//# sourceMappingURL=ids.d.ts.map

package/dist/ids.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ids.d.ts","sourceRoot":"","sources":["../src/ids.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAE3C,wBAAgB,QAAQ,IAAI,MAAM,CAEjC;AAED,wBAAgB,QAAQ,CAAC,KAAK,EAAE;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,MAAM,CAAA;CAAE,GAAG,MAAM,CAEpE;AAED,wBAAgB,eAAe,CAAC,GAAG,EAAE,MAAM,GAAG,QAAQ,CASrD"}

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./domain.js";
+export * from "./service.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAC;AAC5B,cAAc,cAAc,CAAC"}