@slices.sh/ai-chat 0.1.0

package/dist/services/approval-memory.d.ts

@@ -0,0 +1,9 @@
+type Memory = {
+    snapshot(): readonly string[];
+    watch(listener: () => void): () => void;
+    remember(tool: string): void;
+    forget(tool: string): void;
+};
+/** Consent belongs to this Chat instance, never a user-wide storage key or another tab. */
+export declare function toolApprovalMemory(chat: object): Memory;
+export {};

package/dist/services/approval-memory.js

@@ -0,0 +1,32 @@
+const memories = /* @__PURE__ */ new WeakMap();
+const EMPTY = [];
+function toolApprovalMemory(chat) {
+  const existing = memories.get(chat);
+  if (existing) return existing;
+  let names = EMPTY;
+  const listeners = /* @__PURE__ */ new Set();
+  const update = (next) => {
+    names = next;
+    for (const listener of [...listeners]) listener();
+  };
+  const memory = {
+    snapshot: () => names,
+    watch: (listener) => {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    },
+    remember: (tool) => {
+      if (!names.includes(tool)) update([...names, tool]);
+    },
+    forget: (tool) => {
+      if (names.includes(tool)) update(names.filter((name) => name !== tool));
+    }
+  };
+  memories.set(chat, memory);
+  return memory;
+}
+export {
+  toolApprovalMemory
+};

package/dist/services/approval.d.ts

@@ -0,0 +1,14 @@
+import type { Chat } from "@ai-sdk/react";
+import type { AiChatMessage } from "./messages";
+type ApprovalChat = Pick<Chat<AiChatMessage>, "messages" | "addToolApprovalResponse">;
+/** One decision per native approval id, even when two views share a chat. */
+export declare function respondToApproval(chat: ApprovalChat, id: string, approved: boolean): Promise<void>;
+/** A decision was just made, so the SDK may be about to continue the turn on its own. */
+export declare function approvalDecided(messages: AiChatMessage[]): boolean;
+/**
+ * A follow-up cannot overtake a tool decision. A decision already made holds the next send only
+ * while its turn is still running: once the turn is over there is nothing left to wait for, and
+ * a turn that died after the approval must not hold every later message forever.
+ */
+export declare function awaitingApproval(messages: AiChatMessage[], running?: boolean): boolean;
+export {};

package/dist/services/approval.js

@@ -0,0 +1,37 @@
+import { isToolUIPart } from "ai";
+const claims = /* @__PURE__ */ new WeakMap();
+async function respondToApproval(chat, id, approved) {
+  let pending = claims.get(chat);
+  if (!pending) {
+    pending = /* @__PURE__ */ new Set();
+    claims.set(chat, pending);
+  }
+  if (pending.has(id)) return;
+  const exists = chat.messages.some(
+    (message) => message.parts.some(
+      (part) => isToolUIPart(part) && part.state === "approval-requested" && part.approval.id === id
+    )
+  );
+  if (!exists) return;
+  pending.add(id);
+  try {
+    await chat.addToolApprovalResponse({ id, approved });
+  } finally {
+    pending.delete(id);
+  }
+}
+function approvalDecided(messages) {
+  const last = messages.at(-1);
+  return last?.role === "assistant" && last.parts.some((part) => isToolUIPart(part) && part.state === "approval-responded");
+}
+function awaitingApproval(messages, running = false) {
+  const last = messages.at(-1);
+  return last?.role === "assistant" && last.parts.some(
+    (part) => isToolUIPart(part) && (part.state === "approval-requested" || running && part.state === "approval-responded")
+  );
+}
+export {
+  approvalDecided,
+  awaitingApproval,
+  respondToApproval
+};

package/dist/services/branches.d.ts

@@ -0,0 +1,27 @@
+import type { AiChatMessage } from "./messages";
+export type BranchPage = {
+    id: string;
+    index: number;
+    total: number;
+    anchored: boolean;
+};
+export type BranchLocation = {
+    at: number;
+    role: AiChatMessage["role"];
+    page: BranchPage;
+    parentId: string | null;
+    originId: string;
+};
+export type ConversationBranches = {
+    snapshot: () => readonly BranchLocation[];
+    watch: (listener: () => void) => () => void;
+    fork: (messages: readonly AiChatMessage[], messageId: string) => boolean;
+    page: (messages: readonly AiChatMessage[], messageId: string) => BranchPage | null;
+    move: (messages: readonly AiChatMessage[], groupId: string, delta: number) => AiChatMessage[] | null;
+};
+/** Snapshots and branch choices belong to this Chat object, never to a global/localStorage key. */
+export declare function conversationBranches(chat: object): ConversationBranches;
+/** Preserve files and custom data parts in their original positions when replacing prose. */
+export declare function editedParts(message: AiChatMessage, text: string): AiChatMessage["parts"];
+/** A missing assistant after refusal keeps its previous versions on the preceding user row. */
+export declare function branchPage(messages: readonly AiChatMessage[], messageId: string, locations: readonly BranchLocation[]): BranchPage | null;

package/dist/services/branches.js

@@ -0,0 +1,131 @@
+const memories = /* @__PURE__ */ new WeakMap();
+const clone = (messages) => structuredClone(messages);
+function samePrefix(messages, prefix) {
+  return prefix.length <= messages.length && prefix.every((message, index) => JSON.stringify(message) === JSON.stringify(messages[index]));
+}
+function conversationBranches(chat) {
+  const existing = memories.get(chat);
+  if (existing) return existing;
+  const groups = /* @__PURE__ */ new Map();
+  let active = /* @__PURE__ */ new Map();
+  let locations = [];
+  let serial = 0;
+  const listeners = /* @__PURE__ */ new Set();
+  const emit = () => {
+    locations = [...active].flatMap(([id, index]) => {
+      const group = groups.get(id);
+      return group && group.versions.length > 1 ? [
+        {
+          at: group.at,
+          role: group.role,
+          parentId: group.prefix.at(-1)?.id ?? null,
+          originId: group.originId,
+          page: { id, index: index + 1, total: group.versions.length, anchored: true }
+        }
+      ] : [];
+    });
+    for (const listener of [...listeners]) listener();
+  };
+  const version = (messages) => ({
+    messages: clone(messages),
+    lineage: new Map(active)
+  });
+  const save = (messages) => {
+    const current = version(messages);
+    for (const [id, index] of active) {
+      const group = groups.get(id);
+      if (group) group.versions[index] = current;
+    }
+  };
+  const memory = {
+    snapshot: () => locations,
+    watch: (listener) => {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    },
+    fork: (messages, messageId) => {
+      const at = messages.findIndex((message2) => message2.id === messageId);
+      const message = messages[at];
+      if (!message || !["user", "assistant"].includes(message.role)) return false;
+      save(messages);
+      let group = [...groups.values()].find(
+        (group2) => group2.at === at && group2.role === message.role && samePrefix(messages, group2.prefix)
+      );
+      if (!group) {
+        group = {
+          id: `branch-${++serial}`,
+          originId: message.id,
+          at,
+          role: message.role,
+          prefix: clone(messages.slice(0, at)),
+          versions: []
+        };
+        groups.set(group.id, group);
+        active.set(group.id, 0);
+        group.versions.push(version(messages));
+      } else if (!active.has(group.id)) {
+        const matching = group.versions.findIndex(
+          (version2) => JSON.stringify(version2.messages[at]) === JSON.stringify(message)
+        );
+        const current = matching < 0 ? group.versions.length : matching;
+        active.set(group.id, current);
+        group.versions[current] = version(messages);
+      }
+      for (const id of active.keys()) {
+        const each = groups.get(id);
+        if (each && each.at >= at) active.delete(id);
+      }
+      active.set(group.id, group.versions.length);
+      group.versions.push(version(messages));
+      emit();
+      return true;
+    },
+    page: (messages, messageId) => branchPage(messages, messageId, locations),
+    move: (messages, groupId, delta) => {
+      const group = groups.get(groupId);
+      const current = active.get(groupId);
+      if (!group || current === void 0) return null;
+      const next = Math.max(0, Math.min(group.versions.length - 1, current + delta));
+      if (next === current) return null;
+      save(messages);
+      const target = group.versions[next];
+      active = new Map(target.lineage);
+      active.set(groupId, next);
+      const restored = clone(target.messages);
+      emit();
+      return restored;
+    }
+  };
+  memories.set(chat, memory);
+  return memory;
+}
+function editedParts(message, text) {
+  if (!text) return message.parts.filter((part) => part.type !== "text");
+  let written = false;
+  const parts = message.parts.flatMap((part) => {
+    if (part.type !== "text") return [part];
+    if (written) return [];
+    written = true;
+    return [{ ...part, text }];
+  });
+  return written ? parts : [...parts, { type: "text", text }];
+}
+function branchPage(messages, messageId, locations) {
+  const at = messages.findIndex((message) => message.id === messageId);
+  if (at < 0) return null;
+  const relevant = locations.filter(
+    (location) => (location.at === 0 || messages[location.at - 1]?.id === location.parentId) && (location.role !== "user" || messages[location.at]?.id === location.originId)
+  );
+  const refused = relevant.find(
+    (location) => location.role === "assistant" && location.at === at + 1 && messages[at].role === "user" && messages.length === at + 1
+  );
+  if (refused) return { ...refused.page, anchored: false };
+  return relevant.find((location) => location.at === at && location.role === messages[at].role)?.page ?? null;
+}
+export {
+  branchPage,
+  conversationBranches,
+  editedParts
+};

package/dist/services/chat-session.d.ts

@@ -0,0 +1,20 @@
+import type { ChatTransport } from "ai";
+import type { AiChatClient } from "./ports";
+import type { AiChatMessage } from "./messages";
+import type { ChatChoices, ChatSelection } from "./choices";
+export type ChatSettingsState = {
+    choices: ChatChoices | null;
+    selection: ChatSelection;
+};
+export type ChatSettings = {
+    snapshot(): ChatSettingsState;
+    watch(listener: () => void): () => void;
+    load(): Promise<void>;
+    model(id: string): void;
+    toggle(id: string): void;
+};
+/** Bind one conversation's catalog, controls and transport; custom Chats opt in explicitly. */
+export declare function chatSession(client: AiChatClient, name: string): {
+    transport: ChatTransport<AiChatMessage>;
+    settings: ChatSettings | null;
+};

package/dist/services/chat-session.js

@@ -0,0 +1,61 @@
+const EMPTY = { choices: null, selection: {} };
+function chatSession(client, name) {
+  const transport = client.transportFor(name);
+  if (!client.choicesFor) return { transport, settings: null };
+  let state = EMPTY;
+  let loading;
+  const listeners = /* @__PURE__ */ new Set();
+  const update = (next) => {
+    state = next;
+    for (const listener of [...listeners]) listener();
+  };
+  const settings = {
+    snapshot: () => state,
+    watch(listener) {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    },
+    load() {
+      return loading ??= Promise.resolve().then(() => client.choicesFor(name)).then((choices) => {
+        update({ choices, selection: choices ? {
+          model: "",
+          ...choices.tools ? { tools: choices.tools.filter((tool) => tool.defaultEnabled).map((tool) => tool.id) } : {}
+        } : {} });
+      }).catch(() => {
+      });
+    },
+    model(id) {
+      if (!state.choices?.models?.some((model) => model.id === id)) return;
+      update({ ...state, selection: { ...state.selection, model: id } });
+    },
+    toggle(id) {
+      if (!state.choices?.tools?.some((tool) => tool.id === id)) return;
+      const active = state.selection.tools ?? [];
+      update({ ...state, selection: { ...state.selection, tools: active.includes(id) ? active.filter((tool) => tool !== id) : [...active, id] } });
+    }
+  };
+  const turns = /* @__PURE__ */ new Map();
+  return {
+    settings,
+    transport: {
+      ...transport,
+      reconnectToStream: (request) => transport.reconnectToStream(request),
+      sendMessages(request) {
+        const user = request.messages.findLast((message) => message.role === "user");
+        const key = `${request.chatId}\0${user?.id ?? ""}`;
+        const newTurn = request.trigger === "regenerate-message" || request.messages.at(-1)?.role === "user";
+        const selection = !newTurn && turns.has(key) ? turns.get(key) : {
+          ...state.selection,
+          ...state.selection.tools ? { tools: [...state.selection.tools] } : {}
+        };
+        turns.set(key, selection);
+        return transport.sendMessages({ ...request, body: { ...request.body, selection } });
+      }
+    }
+  };
+}
+export {
+  chatSession
+};

package/dist/services/choices.d.ts

@@ -0,0 +1,31 @@
+import type { ChatConfig, ChatModel } from "./turn";
+export type ChatModelOption = {
+    label: string;
+    model: ChatModel;
+    contextWindow?: number;
+};
+export type ChatToolOption = {
+    id: string;
+    label: string;
+    defaultEnabled?: boolean;
+};
+export type ChatSelection = {
+    model?: string;
+    tools?: readonly string[];
+};
+export type ChatChoices = {
+    /** The empty id selects the existing default model. Null means no picker. */
+    models: readonly {
+        id: string;
+        label: string;
+        contextWindow: number | null;
+    }[] | null;
+    tools: readonly {
+        id: string;
+        label: string;
+        defaultEnabled: boolean;
+    }[] | null;
+};
+export declare function contextWindowOf(value: number | undefined): number | null;
+/** Publish labels and limits only, never model instances, tools, credentials or prompts. */
+export declare function choicesOf(config: ChatConfig): ChatChoices | null;

package/dist/services/choices.js

@@ -0,0 +1,39 @@
+function contextWindowOf(value) {
+  return value !== void 0 && Number.isSafeInteger(value) && value > 0 ? value : null;
+}
+function choicesOf(config) {
+  const models = Object.entries(config.models ?? {}).filter(
+    ([id]) => id.length > 0 && id.length <= 128
+  );
+  const seen = /* @__PURE__ */ new Set();
+  const tools = (config.toolChoices ?? []).filter(({ id }) => {
+    if (!id || seen.has(id) || !Object.hasOwn(config.tools ?? {}, id))
+      return false;
+    seen.add(id);
+    return true;
+  }).map(({ id, label, defaultEnabled = true }) => ({
+    id,
+    label,
+    defaultEnabled
+  }));
+  if (!models.length && !tools.length) return null;
+  return {
+    models: models.length ? [
+      {
+        id: "",
+        label: typeof config.model === "string" ? config.model : config.model.modelId,
+        contextWindow: contextWindowOf(config.contextWindow)
+      },
+      ...models.map(([id, value]) => ({
+        id,
+        label: value.label,
+        contextWindow: contextWindowOf(value.contextWindow)
+      }))
+    ] : null,
+    tools: tools.length ? tools : null
+  };
+}
+export {
+  choicesOf,
+  contextWindowOf
+};

package/dist/services/continue.d.ts

@@ -0,0 +1,8 @@
+import type { AiChatMessage } from "./messages";
+/** Continue only client questions here; server-executed tools have their own step loop. */
+export declare function shouldContinueChat(input: {
+    messages: AiChatMessage[];
+}): boolean;
+/** What holds a queued follow-up back besides a running turn: the person, or a tool still at work. */
+export type Blocker = "question" | "approval" | "tool";
+export declare function blockedBy(messages: AiChatMessage[], running: boolean): Blocker | null;

package/dist/services/continue.js

@@ -0,0 +1,24 @@
+import {
+  isToolUIPart,
+  lastAssistantMessageIsCompleteWithApprovalResponses,
+  lastAssistantMessageIsCompleteWithToolCalls
+} from "ai";
+import { awaitingApproval } from "./approval.js";
+import { awaitingQuestion, isSkippedQuestion, questionInput } from "./questions.js";
+function shouldContinueChat(input) {
+  if (lastAssistantMessageIsCompleteWithApprovalResponses(input)) return true;
+  const parts = input.messages.at(-1)?.parts ?? [];
+  const start = parts.reduce((index, part, next) => part.type === "step-start" ? next : index, -1);
+  const questions = parts.slice(start + 1).filter((part) => isToolUIPart(part) && questionInput(part) !== null);
+  if (questions.some(isSkippedQuestion)) return false;
+  return questions.length > 0 && lastAssistantMessageIsCompleteWithToolCalls(input);
+}
+function blockedBy(messages, running) {
+  if (awaitingQuestion(messages)) return "question";
+  if (awaitingApproval(messages)) return "approval";
+  return awaitingApproval(messages, running) ? "tool" : null;
+}
+export {
+  blockedBy,
+  shouldContinueChat
+};

package/dist/services/errors.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Every way a turn can be refused, and nothing else.
+ *
+ * A closed union because the screen branches on it: a quota refusal wants an upgrade link,
+ * an outage wants a retry, and an unknown chat wants a developer to open `config.ts`. One
+ * "chat failed" banner for all three would be three lies.
+ */
+export type ChatErrorSlug = 
+/** No session where the rules want one. */
+"ai-chat/unauthorized"
+/** The rules refused this actor for this chat. */
+ | "ai-chat/forbidden"
+/** No entry under that key. Never a fall back to another chat. */
+ | "ai-chat/unknown-chat"
+/** The body is not a turn. */
+ | "ai-chat/invalid-request" | "ai-chat/rate-limited"
+/** Refused before the model ran: the plan, not the rules. */
+ | "ai-chat/quota-exceeded"
+/** The provider is unreachable or misconfigured. */
+ | "ai-chat/model-unavailable"
+/** The client went away mid-turn. */
+ | "ai-chat/aborted"
+/** A failure this contract does not model, so an unexpected one has somewhere honest to land. */
+ | "ai-chat/unavailable";
+export declare const CHAT_ERROR_SLUGS: readonly ["ai-chat/unauthorized", "ai-chat/forbidden", "ai-chat/unknown-chat", "ai-chat/invalid-request", "ai-chat/rate-limited", "ai-chat/quota-exceeded", "ai-chat/model-unavailable", "ai-chat/aborted", "ai-chat/unavailable"];
+export declare class ChatError extends Error {
+    readonly slug: ChatErrorSlug;
+    /** For an operator. Never rendered, never sent to a browser. */
+    readonly detail?: string;
+    /** Authoritative earliest retry, as Unix milliseconds. */
+    readonly retryAt?: number;
+    constructor(slug: ChatErrorSlug, message: string, detail?: string, retryAt?: number);
+}
+export declare function isChatError(value: unknown): value is ChatError;
+/**
+ * The one place a slug becomes a status, so a route and a client cannot disagree.
+ *
+ * 499 is nginx's rather than the RFC's, and it is still the right one: a turn the client
+ * abandoned is not a server error, and the alternatives are lying with 200 or alarming with
+ * 500.
+ */
+export declare const statusForChatError: Record<ChatErrorSlug, number>;
+export declare function isChatErrorSlug(value: unknown): value is ChatErrorSlug;
+/**
+ * A refusal as a route says it, which is the same text wherever it lands.
+ *
+ * Before a stream starts it is the body of a refused request, and the SDK's transport makes
+ * it the message of the `APICallError` a chat then holds; once a stream has started it is
+ * the `errorText` of an `error` chunk, which the SDK makes the message of an `Error`. One
+ * shape for both is what lets a screen read one slug out of either.
+ */
+export declare function refusalText(error: ChatError): string;

package/dist/services/errors.js

@@ -0,0 +1,54 @@
+const CHAT_ERROR_SLUGS = [
+  "ai-chat/unauthorized",
+  "ai-chat/forbidden",
+  "ai-chat/unknown-chat",
+  "ai-chat/invalid-request",
+  "ai-chat/rate-limited",
+  "ai-chat/quota-exceeded",
+  "ai-chat/model-unavailable",
+  "ai-chat/aborted",
+  "ai-chat/unavailable"
+];
+class ChatError extends Error {
+  slug;
+  /** For an operator. Never rendered, never sent to a browser. */
+  detail;
+  /** Authoritative earliest retry, as Unix milliseconds. */
+  retryAt;
+  constructor(slug, message, detail, retryAt) {
+    super(message);
+    this.name = "ChatError";
+    this.slug = slug;
+    this.detail = detail;
+    if (typeof retryAt === "number" && Number.isFinite(retryAt) && retryAt > 0 && retryAt <= 864e13)
+      this.retryAt = retryAt;
+  }
+}
+function isChatError(value) {
+  return value instanceof ChatError;
+}
+const statusForChatError = {
+  "ai-chat/unauthorized": 401,
+  "ai-chat/forbidden": 403,
+  "ai-chat/unknown-chat": 404,
+  "ai-chat/invalid-request": 400,
+  "ai-chat/rate-limited": 429,
+  "ai-chat/quota-exceeded": 402,
+  "ai-chat/model-unavailable": 502,
+  "ai-chat/aborted": 499,
+  "ai-chat/unavailable": 503
+};
+function isChatErrorSlug(value) {
+  return typeof value === "string" && CHAT_ERROR_SLUGS.includes(value);
+}
+function refusalText(error) {
+  return JSON.stringify({ error: error.slug, message: error.message, retryAt: error.retryAt });
+}
+export {
+  CHAT_ERROR_SLUGS,
+  ChatError,
+  isChatError,
+  isChatErrorSlug,
+  refusalText,
+  statusForChatError
+};

package/dist/services/media.d.ts

@@ -0,0 +1,9 @@
+import type { FileUIPart } from "ai";
+export type ChatMediaKind = "image" | "audio" | "video" | "file";
+export type ChatMedia = {
+    file: FileUIPart;
+    url: string | null;
+    kind: ChatMediaKind;
+};
+/** A message is untrusted content. Data URLs can only contain the declared passive format. */
+export declare function mediaOf(file: FileUIPart): ChatMedia;

package/dist/services/media.js

@@ -0,0 +1,19 @@
+const images = /* @__PURE__ */ new Set(["image/png", "image/jpeg", "image/webp", "image/gif", "image/avif", "image/bmp"]);
+function mediaOf(file) {
+  const mime = file.mediaType.toLowerCase().split(";")[0].trim();
+  const kind = images.has(mime) ? "image" : mime.startsWith("audio/") ? "audio" : mime.startsWith("video/") ? "video" : "file";
+  let url = null;
+  try {
+    const parsed = new URL(file.url);
+    if ((parsed.protocol === "https:" || parsed.protocol === "http:") && !parsed.username && !parsed.password)
+      url = parsed.href;
+    if (parsed.protocol === "blob:") url = file.url;
+    if (parsed.protocol === "data:" && kind !== "file" && file.url.startsWith(`data:${mime};base64,`) && /^[A-Za-z0-9+/]*={0,2}$/.test(file.url.slice(file.url.indexOf(",") + 1)))
+      url = file.url;
+  } catch {
+  }
+  return { file, url, kind };
+}
+export {
+  mediaOf
+};

package/dist/services/messages.d.ts

@@ -0,0 +1,44 @@
+import type { FinishReason, LanguageModelUsage, UIMessage } from "ai";
+/**
+ * What a route writes on a message beside its parts.
+ *
+ * The one thing about a message the AI SDK leaves to the app: its parts, their order and
+ * their states are the SDK's own `UIMessage`, and this types the `metadata` beside them the
+ * way the SDK's message-metadata guide does. Both fields are optional because both are
+ * genuinely unknown for some backends and some turns, and a meter that guessed would be a
+ * number somebody bills against. → docs/rules/capability-honesty.md
+ */
+export type AiChatMetadata = {
+    /** Suggested next prompts supplied by the application, never fabricated by the UI. */
+    followUps?: string[];
+    finishReason?: FinishReason;
+    /** Explicit user intent on a follow-up, kept alongside the native message. */
+    intent?: "continue";
+    continues?: string;
+    /** The model that answered, as the route was configured with it. */
+    model?: string;
+    modelChoice?: string;
+    /** Host-declared model capacity, not an estimate derived from text. */
+    contextWindow?: number;
+    /** Input tokens of the last model request, never the sum of a tool loop. */
+    contextTokens?: number | null;
+    /** What the turn cost, as the provider counted it at the SDK's `finish` part. */
+    usage?: LanguageModelUsage;
+    /** Server-observed milliseconds from starting the model call; never inferred from tokens. */
+    timing?: {
+        firstTokenMs?: number;
+        durationMs?: number;
+    };
+};
+export type AiChatMessage = UIMessage<AiChatMetadata>;
+/** One of a message's parts, whichever of the SDK's kinds it is. */
+export type AiChatPart = AiChatMessage["parts"][number];
+/** A host-owned feedback write. A resolved promise means accepted, not merely clicked. */
+export type ChatFeedback = {
+    chatId: string;
+    messageId: string;
+    rating: "up" | "down" | null;
+};
+export type ChatFeedbackOptions = {
+    onFeedback?: (feedback: ChatFeedback) => void | Promise<void>;
+};

package/dist/services/optional.d.ts

@@ -0,0 +1,7 @@
+import type { AiChatClient } from "./types";
+/**
+ * The client of the config the screen targets, or null when the service has no such config.
+ * Hooks import only this, so a screen builds, and runs on a fixture, before a service is set up.
+ * The registry (`services/index.ts` in the app) is where configs are found.
+ */
+export declare function getAiChat(config?: string): AiChatClient | null;

package/dist/services/optional.js

@@ -0,0 +1,7 @@
+import { clientOf } from "@slices.sh/core";
+function getAiChat(config) {
+  return clientOf("ai-chat", config);
+}
+export {
+  getAiChat
+};