@agentskit/chat-server 0.1.0

package/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2026 AgentsKit
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+

package/README.md

@@ -0,0 +1,13 @@
+# @agentskit/chat-server
+
+Web-standard request handler for AgentsKit Chat definitions. It composes the canonical AgentsKit controller and memory with AgentsKit Chat protocol/session contracts.
+
+```ts
+const POST = createChatHandler({
+  authenticate: async request => ({ ok: true, context: await authenticate(request) }),
+  resolveDefinition: context => chats.forTenant(context.tenantId),
+  sessionStorage: context => sessions.forTenant(context.tenantId),
+})
+```
+
+The returned function accepts a standard `Request` and returns a standard streaming `Response`.

package/dist/index.cjs

@@ -0,0 +1,249 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  ChatHandlerError: () => ChatHandlerError,
+  createChatHandler: () => createChatHandler
+});
+module.exports = __toCommonJS(index_exports);
+var import_core = require("@agentskit/core");
+var import_chat = require("@agentskit/chat");
+var import_chat_protocol = require("@agentskit/chat-protocol");
+var ChatHandlerError = class extends Error {
+  status;
+  code;
+  retryable;
+  constructor(options) {
+    super(options.message);
+    this.name = "ChatHandlerError";
+    this.status = options.status;
+    this.code = options.code;
+    this.retryable = options.retryable ?? false;
+  }
+};
+var encoder = new TextEncoder();
+var decoder = new TextDecoder();
+var json = (diagnostic, status) => new Response(JSON.stringify({ error: diagnostic }), {
+  status,
+  headers: { "content-type": "application/json; charset=utf-8", "cache-control": "no-store" }
+});
+var safeError = (error) => error instanceof ChatHandlerError ? { status: error.status, diagnostic: { version: 1, code: error.code, message: error.message, retryable: error.retryable } } : error instanceof import_chat.SessionConflictError ? { status: 409, diagnostic: { version: 1, code: "SESSION_CONFLICT", message: "Another turn is active for this session.", retryable: true } } : { status: 500, diagnostic: { version: 1, code: "SERVER_INTERNAL", message: "The chat request failed.", retryable: true } };
+var fail = (status, code, message, retryable = false) => {
+  throw new ChatHandlerError({ status, code, message, retryable });
+};
+var withSignal = async (operation, signal) => {
+  if (signal.aborted) throw signal.reason;
+  let rejectAbort;
+  const abort = () => rejectAbort?.(signal.reason);
+  const aborted = new Promise((_resolve, reject) => {
+    rejectAbort = reject;
+  });
+  signal.addEventListener("abort", abort, { once: true });
+  try {
+    return await Promise.race([Promise.resolve(operation), aborted]);
+  } finally {
+    signal.removeEventListener("abort", abort);
+  }
+};
+var readBody = async (request, maxBodyBytes, signal) => {
+  const declared = Number(request.headers.get("content-length"));
+  if (Number.isFinite(declared) && declared > maxBodyBytes) fail(413, "REQUEST_TOO_LARGE", "Request body is too large.");
+  const reader = request.body?.getReader();
+  if (!reader) return fail(400, "REQUEST_INVALID_JSON", "Request body is not valid JSON.");
+  const chunks = [];
+  let size = 0;
+  try {
+    while (true) {
+      const result = await withSignal(reader.read(), signal);
+      if (result.done) break;
+      size += result.value.byteLength;
+      if (size > maxBodyBytes) {
+        await reader.cancel();
+        return fail(413, "REQUEST_TOO_LARGE", "Request body is too large.");
+      }
+      chunks.push(result.value);
+    }
+  } finally {
+    reader.releaseLock();
+  }
+  const bytes = new Uint8Array(size);
+  let offset = 0;
+  for (const chunk of chunks) {
+    bytes.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  try {
+    return JSON.parse(decoder.decode(bytes));
+  } catch {
+    return fail(400, "REQUEST_INVALID_JSON", "Request body is not valid JSON.");
+  }
+};
+var snapshotStatus = (state) => state.status === "error" ? "error" : state.status === "streaming" ? "streaming" : state.messages.length === 0 ? "idle" : "complete";
+var createChatHandler = (options) => {
+  const timeoutMs = options.timeoutMs ?? 3e4;
+  const cleanupTimeoutMs = options.cleanupTimeoutMs ?? 5e3;
+  const maxBodyBytes = options.maxBodyBytes ?? 64 * 1024;
+  if (![timeoutMs, cleanupTimeoutMs, maxBodyBytes].every((value) => Number.isSafeInteger(value) && value > 0)) fail(500, "SERVER_INVALID_CONFIG", "Chat handler configuration is invalid.");
+  const leaseMs = timeoutMs + 3 * cleanupTimeoutMs;
+  if (!Number.isSafeInteger(leaseMs)) fail(500, "SERVER_INVALID_CONFIG", "Chat handler configuration is invalid.");
+  const createId = options.createId ?? (() => crypto.randomUUID());
+  return async (request) => {
+    const deadline = AbortSignal.timeout(timeoutMs);
+    const signal = AbortSignal.any([request.signal, deadline]);
+    try {
+      if (request.method !== "POST") fail(405, "REQUEST_METHOD_NOT_ALLOWED", "Only POST is supported.");
+      if (!request.headers.get("content-type")?.toLowerCase().startsWith("application/json")) fail(415, "REQUEST_UNSUPPORTED_MEDIA_TYPE", "Content-Type must be application/json.");
+      let context;
+      if (options.authenticate) {
+        const authenticated = await withSignal(options.authenticate(request, signal), signal);
+        if (!authenticated.ok) return authenticated.response;
+        context = authenticated.context;
+      }
+      const decoded = (0, import_chat_protocol.decodeTurnEvent)(await readBody(request, maxBodyBytes, signal));
+      if (!decoded.ok || decoded.event.event !== "client.turn.submit") return fail(400, "REQUEST_INVALID_EVENT", "Request body must be a valid turn submission.");
+      const submission = decoded.event;
+      const definition = await withSignal(options.resolveDefinition(context, submission.sessionId, signal), signal);
+      const storage = options.sessionStorage(context, signal);
+      const session = await withSignal((0, import_chat.resumeChatSession)(definition, { sessionId: submission.sessionId, storage, signal, ...options.now ? { now: options.now } : {} }), signal);
+      if (!await withSignal(session.claimTurn(submission.turnId, leaseMs, signal), signal)) return json({ version: 1, code: "SESSION_BUSY", message: "Another turn is active for this session.", retryable: true }, 409);
+      const memory = definition.chat.memory;
+      const loaded = memory ? await withSignal(memory.load({ signal }), signal) : definition.chat.initialMessages ?? [];
+      const messages = loaded.length > 0 ? loaded : definition.chat.initialMessages ?? [];
+      const { memory: _memory, ...chat } = definition.chat;
+      const controller = (0, import_core.createChatController)(session.updateChat({ ...chat, initialMessages: [...messages] }));
+      let pending;
+      let wake;
+      let done = false;
+      let closed = false;
+      const push = () => {
+        const state = controller.getState();
+        pending = { ...state, messages: [...state.messages], usage: { ...state.usage } };
+        wake?.();
+        wake = void 0;
+      };
+      const unsubscribe = controller.subscribe(push);
+      let cleanup = async () => void 0;
+      const abort = () => {
+        controller.stop();
+        void cleanup(true).catch(() => void 0);
+      };
+      signal.addEventListener("abort", abort, { once: true });
+      const send = controller.send(submission.payload.input).finally(() => {
+        done = true;
+        wake?.();
+        wake = void 0;
+      });
+      cleanup = async (stop) => {
+        if (closed) return;
+        closed = true;
+        unsubscribe();
+        signal.removeEventListener("abort", abort);
+        if (stop && !signal.aborted) controller.stop();
+        const settleSignal = AbortSignal.timeout(cleanupTimeoutMs);
+        await withSignal(send.catch(() => void 0), settleSignal).catch(() => void 0);
+        const saveSignal = AbortSignal.timeout(cleanupTimeoutMs);
+        let outcome = "completed";
+        try {
+          await withSignal(memory?.save(controller.getState().messages, { signal: saveSignal }), saveSignal);
+        } catch (error) {
+          outcome = "indeterminate";
+          throw error;
+        } finally {
+          const releaseSignal = AbortSignal.timeout(cleanupTimeoutMs);
+          await withSignal(session.releaseTurn(submission.turnId, outcome, releaseSignal), releaseSignal);
+        }
+      };
+      const diagnosticLine = (code, message) => {
+        const event = import_chat_protocol.TurnEventSchema.parse({
+          protocol: "agentskit.chat.turn",
+          version: 1,
+          eventId: createId(),
+          sessionId: submission.sessionId,
+          turnId: submission.turnId,
+          sequence: session.getCursor() + 1,
+          emittedAt: (options.now?.() ?? /* @__PURE__ */ new Date()).toISOString(),
+          event: "server.turn.diagnostic",
+          payload: { version: 1, code, message, retryable: true }
+        });
+        return encoder.encode(`${(0, import_chat_protocol.encodeTurnEvent)(event)}
+`);
+      };
+      const body = new ReadableStream({
+        async pull(stream) {
+          try {
+            while (!pending && !done && !signal.aborted) await new Promise((resolve) => {
+              wake = resolve;
+            });
+            if (signal.aborted) {
+              stream.enqueue(diagnosticLine(deadline.aborted ? "SERVER_TIMEOUT" : "REQUEST_CANCELLED", deadline.aborted ? "The chat request timed out." : "The chat request was cancelled."));
+              await cleanup(true);
+              stream.close();
+              return;
+            }
+            if (pending) {
+              const state = pending;
+              pending = void 0;
+              await withSignal(session.persist(signal), signal);
+              const event = (0, import_chat_protocol.createSnapshotEvent)({
+                eventId: createId(),
+                sessionId: submission.sessionId,
+                turnId: submission.turnId,
+                sequence: session.getCursor(),
+                emittedAt: (options.now?.() ?? /* @__PURE__ */ new Date()).toISOString(),
+                messages: state.messages,
+                status: snapshotStatus(state),
+                usage: state.usage,
+                lineage: { operation: "submit" },
+                ...state.error ? { error: { version: 1, code: "CHAT_TURN_FAILED", message: "The chat turn failed.", retryable: true } } : {}
+              });
+              stream.enqueue(encoder.encode(`${(0, import_chat_protocol.encodeTurnEvent)(event)}
+`));
+              return;
+            }
+            await cleanup(false);
+            stream.close();
+          } catch (error) {
+            const safe = safeError(error);
+            try {
+              stream.enqueue(diagnosticLine(safe.diagnostic.code, safe.diagnostic.message));
+            } catch {
+            }
+            await cleanup(true).catch(() => void 0);
+            stream.close();
+          }
+        },
+        async cancel() {
+          await cleanup(true).catch(() => void 0);
+        }
+      });
+      return new Response(body, { status: 200, headers: { "content-type": "application/x-ndjson; charset=utf-8", "cache-control": "no-store", "x-content-type-options": "nosniff" } });
+    } catch (error) {
+      if (signal.aborted) return json({ version: 1, code: deadline.aborted ? "SERVER_TIMEOUT" : "REQUEST_CANCELLED", message: deadline.aborted ? "The chat request timed out." : "The chat request was cancelled.", retryable: true }, deadline.aborted ? 408 : 499);
+      const safe = safeError(error);
+      return json(safe.diagnostic, safe.status);
+    }
+  };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ChatHandlerError,
+  createChatHandler
+});

package/dist/index.d.cts

@@ -0,0 +1,34 @@
+import { ChatDefinition, SessionStorage } from '@agentskit/chat';
+
+type ChatHandler = (request: Request) => Promise<Response>;
+type AuthenticationResult<TContext> = {
+    readonly ok: true;
+    readonly context: TContext;
+} | {
+    readonly ok: false;
+    readonly response: Response;
+};
+interface ChatHandlerOptions<TContext = undefined> {
+    readonly authenticate?: (request: Request, signal: AbortSignal) => AuthenticationResult<TContext> | Promise<AuthenticationResult<TContext>>;
+    readonly resolveDefinition: (context: TContext | undefined, sessionId: string, signal: AbortSignal) => ChatDefinition | Promise<ChatDefinition>;
+    readonly sessionStorage: (context: TContext | undefined, signal: AbortSignal) => SessionStorage;
+    readonly timeoutMs?: number;
+    readonly cleanupTimeoutMs?: number;
+    readonly maxBodyBytes?: number;
+    readonly now?: () => Date;
+    readonly createId?: () => string;
+}
+declare class ChatHandlerError extends Error {
+    readonly status: number;
+    readonly code: string;
+    readonly retryable: boolean;
+    constructor(options: {
+        readonly status: number;
+        readonly code: string;
+        readonly message: string;
+        readonly retryable?: boolean;
+    });
+}
+declare const createChatHandler: <TContext = undefined>(options: ChatHandlerOptions<TContext>) => ChatHandler;
+
+export { type AuthenticationResult, type ChatHandler, ChatHandlerError, type ChatHandlerOptions, createChatHandler };

package/dist/index.d.ts

@@ -0,0 +1,34 @@
+import { ChatDefinition, SessionStorage } from '@agentskit/chat';
+
+type ChatHandler = (request: Request) => Promise<Response>;
+type AuthenticationResult<TContext> = {
+    readonly ok: true;
+    readonly context: TContext;
+} | {
+    readonly ok: false;
+    readonly response: Response;
+};
+interface ChatHandlerOptions<TContext = undefined> {
+    readonly authenticate?: (request: Request, signal: AbortSignal) => AuthenticationResult<TContext> | Promise<AuthenticationResult<TContext>>;
+    readonly resolveDefinition: (context: TContext | undefined, sessionId: string, signal: AbortSignal) => ChatDefinition | Promise<ChatDefinition>;
+    readonly sessionStorage: (context: TContext | undefined, signal: AbortSignal) => SessionStorage;
+    readonly timeoutMs?: number;
+    readonly cleanupTimeoutMs?: number;
+    readonly maxBodyBytes?: number;
+    readonly now?: () => Date;
+    readonly createId?: () => string;
+}
+declare class ChatHandlerError extends Error {
+    readonly status: number;
+    readonly code: string;
+    readonly retryable: boolean;
+    constructor(options: {
+        readonly status: number;
+        readonly code: string;
+        readonly message: string;
+        readonly retryable?: boolean;
+    });
+}
+declare const createChatHandler: <TContext = undefined>(options: ChatHandlerOptions<TContext>) => ChatHandler;
+
+export { type AuthenticationResult, type ChatHandler, ChatHandlerError, type ChatHandlerOptions, createChatHandler };

package/dist/index.js

@@ -0,0 +1,223 @@
+// src/index.ts
+import { createChatController } from "@agentskit/core";
+import { resumeChatSession, SessionConflictError } from "@agentskit/chat";
+import { createSnapshotEvent, decodeTurnEvent, encodeTurnEvent, TurnEventSchema } from "@agentskit/chat-protocol";
+var ChatHandlerError = class extends Error {
+  status;
+  code;
+  retryable;
+  constructor(options) {
+    super(options.message);
+    this.name = "ChatHandlerError";
+    this.status = options.status;
+    this.code = options.code;
+    this.retryable = options.retryable ?? false;
+  }
+};
+var encoder = new TextEncoder();
+var decoder = new TextDecoder();
+var json = (diagnostic, status) => new Response(JSON.stringify({ error: diagnostic }), {
+  status,
+  headers: { "content-type": "application/json; charset=utf-8", "cache-control": "no-store" }
+});
+var safeError = (error) => error instanceof ChatHandlerError ? { status: error.status, diagnostic: { version: 1, code: error.code, message: error.message, retryable: error.retryable } } : error instanceof SessionConflictError ? { status: 409, diagnostic: { version: 1, code: "SESSION_CONFLICT", message: "Another turn is active for this session.", retryable: true } } : { status: 500, diagnostic: { version: 1, code: "SERVER_INTERNAL", message: "The chat request failed.", retryable: true } };
+var fail = (status, code, message, retryable = false) => {
+  throw new ChatHandlerError({ status, code, message, retryable });
+};
+var withSignal = async (operation, signal) => {
+  if (signal.aborted) throw signal.reason;
+  let rejectAbort;
+  const abort = () => rejectAbort?.(signal.reason);
+  const aborted = new Promise((_resolve, reject) => {
+    rejectAbort = reject;
+  });
+  signal.addEventListener("abort", abort, { once: true });
+  try {
+    return await Promise.race([Promise.resolve(operation), aborted]);
+  } finally {
+    signal.removeEventListener("abort", abort);
+  }
+};
+var readBody = async (request, maxBodyBytes, signal) => {
+  const declared = Number(request.headers.get("content-length"));
+  if (Number.isFinite(declared) && declared > maxBodyBytes) fail(413, "REQUEST_TOO_LARGE", "Request body is too large.");
+  const reader = request.body?.getReader();
+  if (!reader) return fail(400, "REQUEST_INVALID_JSON", "Request body is not valid JSON.");
+  const chunks = [];
+  let size = 0;
+  try {
+    while (true) {
+      const result = await withSignal(reader.read(), signal);
+      if (result.done) break;
+      size += result.value.byteLength;
+      if (size > maxBodyBytes) {
+        await reader.cancel();
+        return fail(413, "REQUEST_TOO_LARGE", "Request body is too large.");
+      }
+      chunks.push(result.value);
+    }
+  } finally {
+    reader.releaseLock();
+  }
+  const bytes = new Uint8Array(size);
+  let offset = 0;
+  for (const chunk of chunks) {
+    bytes.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  try {
+    return JSON.parse(decoder.decode(bytes));
+  } catch {
+    return fail(400, "REQUEST_INVALID_JSON", "Request body is not valid JSON.");
+  }
+};
+var snapshotStatus = (state) => state.status === "error" ? "error" : state.status === "streaming" ? "streaming" : state.messages.length === 0 ? "idle" : "complete";
+var createChatHandler = (options) => {
+  const timeoutMs = options.timeoutMs ?? 3e4;
+  const cleanupTimeoutMs = options.cleanupTimeoutMs ?? 5e3;
+  const maxBodyBytes = options.maxBodyBytes ?? 64 * 1024;
+  if (![timeoutMs, cleanupTimeoutMs, maxBodyBytes].every((value) => Number.isSafeInteger(value) && value > 0)) fail(500, "SERVER_INVALID_CONFIG", "Chat handler configuration is invalid.");
+  const leaseMs = timeoutMs + 3 * cleanupTimeoutMs;
+  if (!Number.isSafeInteger(leaseMs)) fail(500, "SERVER_INVALID_CONFIG", "Chat handler configuration is invalid.");
+  const createId = options.createId ?? (() => crypto.randomUUID());
+  return async (request) => {
+    const deadline = AbortSignal.timeout(timeoutMs);
+    const signal = AbortSignal.any([request.signal, deadline]);
+    try {
+      if (request.method !== "POST") fail(405, "REQUEST_METHOD_NOT_ALLOWED", "Only POST is supported.");
+      if (!request.headers.get("content-type")?.toLowerCase().startsWith("application/json")) fail(415, "REQUEST_UNSUPPORTED_MEDIA_TYPE", "Content-Type must be application/json.");
+      let context;
+      if (options.authenticate) {
+        const authenticated = await withSignal(options.authenticate(request, signal), signal);
+        if (!authenticated.ok) return authenticated.response;
+        context = authenticated.context;
+      }
+      const decoded = decodeTurnEvent(await readBody(request, maxBodyBytes, signal));
+      if (!decoded.ok || decoded.event.event !== "client.turn.submit") return fail(400, "REQUEST_INVALID_EVENT", "Request body must be a valid turn submission.");
+      const submission = decoded.event;
+      const definition = await withSignal(options.resolveDefinition(context, submission.sessionId, signal), signal);
+      const storage = options.sessionStorage(context, signal);
+      const session = await withSignal(resumeChatSession(definition, { sessionId: submission.sessionId, storage, signal, ...options.now ? { now: options.now } : {} }), signal);
+      if (!await withSignal(session.claimTurn(submission.turnId, leaseMs, signal), signal)) return json({ version: 1, code: "SESSION_BUSY", message: "Another turn is active for this session.", retryable: true }, 409);
+      const memory = definition.chat.memory;
+      const loaded = memory ? await withSignal(memory.load({ signal }), signal) : definition.chat.initialMessages ?? [];
+      const messages = loaded.length > 0 ? loaded : definition.chat.initialMessages ?? [];
+      const { memory: _memory, ...chat } = definition.chat;
+      const controller = createChatController(session.updateChat({ ...chat, initialMessages: [...messages] }));
+      let pending;
+      let wake;
+      let done = false;
+      let closed = false;
+      const push = () => {
+        const state = controller.getState();
+        pending = { ...state, messages: [...state.messages], usage: { ...state.usage } };
+        wake?.();
+        wake = void 0;
+      };
+      const unsubscribe = controller.subscribe(push);
+      let cleanup = async () => void 0;
+      const abort = () => {
+        controller.stop();
+        void cleanup(true).catch(() => void 0);
+      };
+      signal.addEventListener("abort", abort, { once: true });
+      const send = controller.send(submission.payload.input).finally(() => {
+        done = true;
+        wake?.();
+        wake = void 0;
+      });
+      cleanup = async (stop) => {
+        if (closed) return;
+        closed = true;
+        unsubscribe();
+        signal.removeEventListener("abort", abort);
+        if (stop && !signal.aborted) controller.stop();
+        const settleSignal = AbortSignal.timeout(cleanupTimeoutMs);
+        await withSignal(send.catch(() => void 0), settleSignal).catch(() => void 0);
+        const saveSignal = AbortSignal.timeout(cleanupTimeoutMs);
+        let outcome = "completed";
+        try {
+          await withSignal(memory?.save(controller.getState().messages, { signal: saveSignal }), saveSignal);
+        } catch (error) {
+          outcome = "indeterminate";
+          throw error;
+        } finally {
+          const releaseSignal = AbortSignal.timeout(cleanupTimeoutMs);
+          await withSignal(session.releaseTurn(submission.turnId, outcome, releaseSignal), releaseSignal);
+        }
+      };
+      const diagnosticLine = (code, message) => {
+        const event = TurnEventSchema.parse({
+          protocol: "agentskit.chat.turn",
+          version: 1,
+          eventId: createId(),
+          sessionId: submission.sessionId,
+          turnId: submission.turnId,
+          sequence: session.getCursor() + 1,
+          emittedAt: (options.now?.() ?? /* @__PURE__ */ new Date()).toISOString(),
+          event: "server.turn.diagnostic",
+          payload: { version: 1, code, message, retryable: true }
+        });
+        return encoder.encode(`${encodeTurnEvent(event)}
+`);
+      };
+      const body = new ReadableStream({
+        async pull(stream) {
+          try {
+            while (!pending && !done && !signal.aborted) await new Promise((resolve) => {
+              wake = resolve;
+            });
+            if (signal.aborted) {
+              stream.enqueue(diagnosticLine(deadline.aborted ? "SERVER_TIMEOUT" : "REQUEST_CANCELLED", deadline.aborted ? "The chat request timed out." : "The chat request was cancelled."));
+              await cleanup(true);
+              stream.close();
+              return;
+            }
+            if (pending) {
+              const state = pending;
+              pending = void 0;
+              await withSignal(session.persist(signal), signal);
+              const event = createSnapshotEvent({
+                eventId: createId(),
+                sessionId: submission.sessionId,
+                turnId: submission.turnId,
+                sequence: session.getCursor(),
+                emittedAt: (options.now?.() ?? /* @__PURE__ */ new Date()).toISOString(),
+                messages: state.messages,
+                status: snapshotStatus(state),
+                usage: state.usage,
+                lineage: { operation: "submit" },
+                ...state.error ? { error: { version: 1, code: "CHAT_TURN_FAILED", message: "The chat turn failed.", retryable: true } } : {}
+              });
+              stream.enqueue(encoder.encode(`${encodeTurnEvent(event)}
+`));
+              return;
+            }
+            await cleanup(false);
+            stream.close();
+          } catch (error) {
+            const safe = safeError(error);
+            try {
+              stream.enqueue(diagnosticLine(safe.diagnostic.code, safe.diagnostic.message));
+            } catch {
+            }
+            await cleanup(true).catch(() => void 0);
+            stream.close();
+          }
+        },
+        async cancel() {
+          await cleanup(true).catch(() => void 0);
+        }
+      });
+      return new Response(body, { status: 200, headers: { "content-type": "application/x-ndjson; charset=utf-8", "cache-control": "no-store", "x-content-type-options": "nosniff" } });
+    } catch (error) {
+      if (signal.aborted) return json({ version: 1, code: deadline.aborted ? "SERVER_TIMEOUT" : "REQUEST_CANCELLED", message: deadline.aborted ? "The chat request timed out." : "The chat request was cancelled.", retryable: true }, deadline.aborted ? 408 : 499);
+      const safe = safeError(error);
+      return json(safe.diagnostic, safe.status);
+    }
+  };
+};
+export {
+  ChatHandlerError,
+  createChatHandler
+};

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "@agentskit/chat-server",
+  "version": "0.1.0",
+  "description": "Web-standard server handler for AgentsKit Chat applications.",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/AgentsKit-io/agentskit-chat.git",
+    "directory": "packages/server"
+  },
+  "homepage": "https://github.com/AgentsKit-io/agentskit-chat#readme",
+  "bugs": {
+    "url": "https://github.com/AgentsKit-io/agentskit-chat/issues"
+  },
+  "type": "module",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "@agentskit/chat": "0.1.0",
+    "@agentskit/chat-protocol": "0.1.0"
+  },
+  "peerDependencies": {
+    "@agentskit/core": "^1.12.2"
+  },
+  "devDependencies": {
+    "@agentskit/core": "^1.12.2",
+    "tsup": "^8.5.1"
+  },
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
+  "scripts": {
+    "build": "tsup src/index.ts --format esm,cjs --dts --clean",
+    "lint": "tsc --noEmit",
+    "test": "pnpm --filter @agentskit/chat build && pnpm --filter @agentskit/chat-protocol build && vitest run --coverage"
+  }
+}