chatkit-bun 0.0.2

package/src/agents/types.ts

@@ -0,0 +1,30 @@
+import type { Store } from "../store";
+import type { JsonValue } from "../serialization";
+import type { ThreadMetadata } from "../types/core";
+import type { ResponseStreamConverter } from "./annotations";
+
+export interface AgentContextOptions<TContext> {
+  thread: ThreadMetadata;
+  store: Store<TContext>;
+  context: TContext;
+  previousResponseId?: string | null;
+  now?: () => Date | string;
+}
+
+export interface AgentStreamInput {
+  [Symbol.asyncIterator]?: () => AsyncIterator<unknown>;
+  toStream?: () => AsyncIterable<unknown>;
+}
+
+export interface StreamAgentResponseOptions {
+  converter?: ResponseStreamConverter;
+}
+
+export interface ToolCallMetadata {
+  itemId: string | null;
+  callId: string | null;
+}
+
+export type { JsonValue } from "../serialization";
+
+export type JsonObject = { [key: string]: JsonValue };

package/src/agents/workflows.ts

@@ -0,0 +1,220 @@
+import {
+  TaskSchema,
+  WorkflowSchema,
+  type Task,
+  type ThreadItem,
+  type Workflow,
+  type WorkflowSummary,
+} from "../types/core";
+import type { ThreadStreamEvent } from "../types/server";
+import type { AgentContext } from "./context";
+
+export type WorkflowItem = Extract<ThreadItem, { type: "workflow" }>;
+export type ThoughtTask = Extract<WorkflowItem["workflow"]["tasks"][number], { type: "thought" }>;
+export type ThreadItemAddedEvent = Extract<ThreadStreamEvent, { type: "thread.item.added" }>;
+export type ThreadItemDoneEvent = Extract<ThreadStreamEvent, { type: "thread.item.done" }>;
+export type ThreadItemUpdatedEvent = Extract<ThreadStreamEvent, { type: "thread.item.updated" }>;
+
+export function isWorkflowItem(item: ThreadItem | undefined): item is WorkflowItem {
+  return item?.type === "workflow";
+}
+
+export function createWorkflowItem<TContext>(
+  context: AgentContext<TContext>,
+  workflow: Workflow,
+): WorkflowItem {
+  const parsedWorkflow = WorkflowSchema.parse(workflow);
+
+  return {
+    id: context.store.generateItemId("workflow", context.thread, context.context),
+    thread_id: context.thread.id,
+    created_at: context.createdAt(),
+    type: "workflow",
+    workflow: parsedWorkflow,
+  };
+}
+
+export function createReasoningWorkflowItem<TContext>(
+  context: AgentContext<TContext>,
+): WorkflowItem {
+  return createWorkflowItem(context, {
+    type: "reasoning",
+    tasks: [],
+    expanded: false,
+  });
+}
+
+export function shouldEmitWorkflowAdded(workflow: Workflow): boolean {
+  return workflow.type === "reasoning" || workflow.tasks.length > 0;
+}
+
+export function workflowAddedEvent(workflow: WorkflowItem): ThreadItemAddedEvent {
+  return {
+    type: "thread.item.added",
+    item: workflow,
+  };
+}
+
+export function resumeWorkflowFromThreadItems<TContext>(
+  context: AgentContext<TContext>,
+  items: readonly ThreadItem[],
+): void {
+  const latest = items[0];
+  const secondLatest = items[1];
+
+  if (isWorkflowItem(latest)) {
+    context.workflowItem = latest;
+    return;
+  }
+
+  if (latest?.type === "client_tool_call" && isWorkflowItem(secondLatest)) {
+    context.workflowItem = secondLatest;
+  }
+}
+
+export function shouldAutoEndWorkflowForItem<TContext>(
+  context: AgentContext<TContext>,
+  item: ThreadItem,
+): boolean {
+  const workflow = context.workflowItem;
+
+  return (
+    workflow !== null &&
+    item.id !== workflow.id &&
+    item.type !== "client_tool_call" &&
+    item.type !== "hidden_context_item" &&
+    item.type !== "sdk_hidden_context"
+  );
+}
+
+export function createThoughtTask(content: string): ThoughtTask {
+  return {
+    type: "thought",
+    content,
+    status_indicator: "none",
+  };
+}
+
+export function workflowTaskAddedEvent(
+  workflow: WorkflowItem,
+  task: Task,
+  taskIndex: number,
+): ThreadItemUpdatedEvent {
+  return {
+    type: "thread.item.updated",
+    item_id: workflow.id,
+    update: {
+      type: "workflow.task.added",
+      task_index: taskIndex,
+      task,
+    },
+  };
+}
+
+export function workflowTaskUpdatedEvent(
+  workflow: WorkflowItem,
+  task: Task,
+  taskIndex: number,
+): ThreadItemUpdatedEvent {
+  return {
+    type: "thread.item.updated",
+    item_id: workflow.id,
+    update: {
+      type: "workflow.task.updated",
+      task_index: taskIndex,
+      task,
+    },
+  };
+}
+
+export function normalizeWorkflowTask(task: Task): Task {
+  return TaskSchema.parse(task);
+}
+
+export function appendWorkflowTask(workflow: WorkflowItem, task: Task): ThreadItemUpdatedEvent {
+  const parsedTask = normalizeWorkflowTask(task);
+  workflow.workflow.tasks.push(parsedTask);
+  return workflowTaskAddedEvent(workflow, parsedTask, workflow.workflow.tasks.length - 1);
+}
+
+export function updateWorkflowTaskEvent(
+  workflow: WorkflowItem,
+  task: Task,
+  taskIndex: number,
+): ThreadItemUpdatedEvent {
+  if (
+    !Number.isInteger(taskIndex) ||
+    taskIndex < 0 ||
+    taskIndex >= workflow.workflow.tasks.length
+  ) {
+    throw new RangeError("Workflow task index is out of range");
+  }
+
+  const parsedTask = normalizeWorkflowTask(task);
+  workflow.workflow.tasks[taskIndex] = parsedTask;
+  return workflowTaskUpdatedEvent(workflow, parsedTask, taskIndex);
+}
+
+export function durationSeconds(startedAt: string, endedAt: string): number {
+  const started = Date.parse(startedAt);
+  const ended = Date.parse(endedAt);
+
+  if (!Number.isFinite(started) || !Number.isFinite(ended)) {
+    return 0;
+  }
+
+  return Math.max(0, Math.floor((ended - started) / 1000));
+}
+
+export function finishWorkflow<TContext>(
+  context: AgentContext<TContext>,
+  summary?: WorkflowSummary,
+  expanded = false,
+): ThreadItemDoneEvent | null {
+  const workflow = context.workflowItem;
+
+  if (!workflow) {
+    return null;
+  }
+
+  if (workflow.workflow.type !== "reasoning" && workflow.workflow.tasks.length === 0) {
+    context.workflowItem = null;
+    return null;
+  }
+
+  const endedAt = context.createdAt();
+  const doneItem: WorkflowItem = {
+    ...workflow,
+    workflow: {
+      ...workflow.workflow,
+      summary:
+        summary ??
+        workflow.workflow.summary ??
+        { duration: durationSeconds(workflow.created_at, endedAt) },
+      expanded,
+    },
+  };
+  context.workflowItem = null;
+
+  return {
+    type: "thread.item.done",
+    item: doneItem,
+  };
+}
+
+export async function persistOpenWorkflow<TContext>(
+  context: AgentContext<TContext>,
+): Promise<void> {
+  const workflow = context.workflowItem;
+
+  if (!workflow) {
+    return;
+  }
+
+  await context.store.saveItem(
+    context.thread.id,
+    { ...workflow, created_at: context.createdAt() },
+    context.context,
+  );
+  context.workflowItem = null;
+}

package/src/errors.ts

@@ -0,0 +1,19 @@
+export class ChatKitError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = new.target.name;
+  }
+}
+
+export class NotFoundError extends ChatKitError {}
+
+export class UnsupportedOperationError extends ChatKitError {}
+
+export class ValidationError extends ChatKitError {
+  constructor(
+    message: string,
+    override readonly cause?: unknown,
+  ) {
+    super(message);
+  }
+}

package/src/http.ts

@@ -0,0 +1,60 @@
+import { NonStreamingResult, StreamingResult, type ChatKitServer } from "./server";
+
+export interface ChatKitHandlerOptions<TContext> {
+  getContext?: (request: Request) => TContext | Promise<TContext>;
+}
+
+export type ChatKitHandler = (request: Request) => Promise<Response>;
+
+export function createChatKitHandler<TContext = undefined>(
+  server: ChatKitServer<TContext>,
+  options: ChatKitHandlerOptions<TContext> = {},
+): ChatKitHandler {
+  return async (request) => {
+    const context = options.getContext
+      ? await options.getContext(request)
+      : (undefined as TContext);
+    const result = await server.process(await request.arrayBuffer(), context);
+
+    if (result instanceof NonStreamingResult) {
+      return new Response(result.json, {
+        headers: {
+          "content-type": "application/json",
+        },
+      });
+    }
+
+    if (result instanceof StreamingResult) {
+      return new Response(toReadableStream(result), {
+        headers: {
+          "content-type": "text/event-stream",
+          "cache-control": "no-cache",
+        },
+      });
+    }
+
+    const _exhaustive: never = result;
+    return _exhaustive;
+  };
+}
+
+function toReadableStream(iterable: AsyncIterable<Uint8Array>): ReadableStream<Uint8Array> {
+  let iterator: AsyncIterator<Uint8Array> | undefined;
+
+  return new ReadableStream<Uint8Array>({
+    async pull(controller) {
+      iterator ??= iterable[Symbol.asyncIterator]();
+      const next = await iterator.next();
+
+      if (next.done) {
+        controller.close();
+        return;
+      }
+
+      controller.enqueue(next.value);
+    },
+    async cancel() {
+      await iterator?.return?.();
+    },
+  });
+}

package/src/index.ts

@@ -0,0 +1,11 @@
+export * from "./actions";
+export * from "./agents";
+export * from "./errors";
+export * from "./http";
+export * from "./serialization";
+export * from "./server";
+export * from "./sqlite-store";
+export * from "./store";
+export * from "./types/core";
+export * from "./types/server";
+export * from "./widgets";

package/src/serialization.ts

@@ -0,0 +1,75 @@
+import { ValidationError } from "./errors";
+
+const encoder = new TextEncoder();
+const decoder = new TextDecoder("utf-8", { fatal: true });
+
+export type JsonValue =
+  | string
+  | number
+  | boolean
+  | null
+  | JsonValue[]
+  | { [key: string]: JsonValue };
+
+export function encodeJsonBytes(value: unknown): Uint8Array {
+  let json: string | undefined;
+  try {
+    json = JSON.stringify(omitUndefinedDeep(value));
+  } catch (error) {
+    throw new ValidationError("Invalid JSON payload", error);
+  }
+  if (typeof json !== "string") {
+    throw new ValidationError("Invalid JSON payload");
+  }
+  return encoder.encode(json);
+}
+
+export function decodeJsonBytes(input: string | Uint8Array | ArrayBuffer): unknown {
+  let text: string;
+  try {
+    text =
+      typeof input === "string"
+        ? input
+        : input instanceof Uint8Array
+          ? decoder.decode(input)
+          : decoder.decode(new Uint8Array(input));
+  } catch (error) {
+    throw new ValidationError("Invalid JSON payload", error);
+  }
+
+  try {
+    return JSON.parse(text);
+  } catch (error) {
+    throw new ValidationError("Invalid JSON payload", error);
+  }
+}
+
+export function omitUndefinedDeep(value: unknown): unknown {
+  if (Array.isArray(value)) {
+    return value.map((item) => omitUndefinedDeep(item));
+  }
+
+  if (value && typeof value === "object" && !(value instanceof Date)) {
+    const result: Record<string, unknown> = {};
+    for (const [key, child] of Object.entries(value)) {
+      if (child !== undefined) {
+        result[key] = omitUndefinedDeep(child);
+      }
+    }
+    return result;
+  }
+
+  return value;
+}
+
+export function parseDate(value: string | Date): Date {
+  const date = value instanceof Date ? value : new Date(value);
+  if (Number.isNaN(date.valueOf())) {
+    throw new ValidationError(`Invalid datetime: ${String(value)}`);
+  }
+  return date;
+}
+
+export function serializeDate(value: string | Date): string {
+  return parseDate(value).toISOString();
+}