@slices.sh/ai-chat 0.1.0

package/dist/hooks/use-question-draft.js

@@ -0,0 +1,57 @@
+"use client";
+import { useCallback, useMemo, useState } from "react";
+import { isSkippedQuestion, questionInput } from "../services/types.js";
+const BLANK = { picked: [], other: false, text: "" };
+function answerOf(question, entry) {
+  const text = entry.other ? entry.text.trim() : "";
+  const values = [...entry.picked, ...text ? [text] : []];
+  if (!values.length) return void 0;
+  return question.multiple ? values : values[0];
+}
+function applied(entry, question, change) {
+  switch (change.type) {
+    case "choose":
+      if (!question.multiple) return { ...entry, picked: [change.value], other: false };
+      return {
+        ...entry,
+        picked: entry.picked.includes(change.value) ? entry.picked.filter((item) => item !== change.value) : [...entry.picked, change.value]
+      };
+    case "toggle-other":
+      return question.multiple ? { ...entry, other: !entry.other } : { ...entry, picked: [], other: true };
+    case "select-other":
+      return { ...entry, picked: question.multiple ? entry.picked : [], other: true };
+    case "write-other":
+      return { ...entry, text: change.text, picked: question.multiple ? entry.picked : [], other: true };
+    case "clear":
+      return BLANK;
+  }
+}
+function useQuestionDraft(input) {
+  const [entries, setEntries] = useState({});
+  const change = useCallback(
+    (name, edit) => {
+      const question = input.questions.find((q) => q.name === name);
+      if (!question) return;
+      setEntries((current) => ({ ...current, [name]: applied(current[name] ?? BLANK, question, edit) }));
+    },
+    [input]
+  );
+  return useMemo(() => {
+    const answers = {};
+    for (const question of input.questions) {
+      const answer = answerOf(question, entries[question.name] ?? BLANK);
+      if (answer !== void 0) answers[question.name] = answer;
+    }
+    return {
+      answers,
+      picked: (name, value) => entries[name]?.picked.includes(value) ?? false,
+      other: (name) => ({ on: entries[name]?.other ?? false, text: entries[name]?.text ?? "" }),
+      change
+    };
+  }, [input, entries, change]);
+}
+export {
+  isSkippedQuestion,
+  questionInput,
+  useQuestionDraft
+};

package/dist/hooks/use-question-steps.d.ts

@@ -0,0 +1,18 @@
+import type { Questionnaire } from "../services/types";
+import type { QuestionCheck } from "./use-question-check";
+export type StepMove = "back"
+/** Stays, and says why, while the question being left has no good answer. */
+ | "next"
+/** Goes where the first answer to fix is, saying why in each, unless every answer can be sent. */
+ | "finish";
+export type QuestionSteps = {
+    /** Zero-based; a form of one question is its own last step. */
+    index: number;
+    count: number;
+    /** The person went somewhere, so the arriving question takes focus; the first one never does. */
+    moved: boolean;
+    active(name: string): boolean;
+    /** True when the move went through: for finish, when everything can be sent. */
+    move(move: StepMove): boolean;
+};
+export declare function useQuestionSteps(input: Questionnaire, check: QuestionCheck): QuestionSteps;

package/dist/hooks/use-question-steps.js

@@ -0,0 +1,31 @@
+"use client";
+import { useCallback, useMemo, useState } from "react";
+function useQuestionSteps(input, check) {
+  const [index, setIndex] = useState(0);
+  const [moved, setMoved] = useState(false);
+  const count = input.questions.length;
+  const move = useCallback(
+    (step) => {
+      const go = (to) => {
+        setIndex(to);
+        setMoved(true);
+        return true;
+      };
+      if (step === "back") return index > 0 && go(index - 1);
+      if (step === "next")
+        return index < count - 1 && !check.reveal([input.questions[index].name]) && go(index + 1);
+      const names = input.questions.map((q) => q.name);
+      if (!check.reveal(names)) return true;
+      go(names.findIndex((name) => check.problem(name) !== null));
+      return false;
+    },
+    [index, count, input, check]
+  );
+  return useMemo(
+    () => ({ index, count, moved, active: (name) => input.questions[index]?.name === name, move }),
+    [index, count, moved, input, move]
+  );
+}
+export {
+  useQuestionSteps
+};

package/dist/hooks/use-question-write.d.ts

@@ -0,0 +1,8 @@
+import { type QuestionAnswers } from "../services/types";
+import type { AiChat } from "./use-chat-instance";
+export type QuestionWrite = {
+    run(answers: QuestionAnswers): Promise<void>;
+    pending: boolean;
+    error: Error | null;
+};
+export declare function useQuestionWrite(chat: AiChat, id: string): QuestionWrite;

package/dist/hooks/use-question-write.js

@@ -0,0 +1,25 @@
+"use client";
+import { useCallback, useMemo, useState } from "react";
+import { answerQuestions } from "../services/types.js";
+function useQuestionWrite(chat, id) {
+  const [pending, setPending] = useState(false);
+  const [error, setError] = useState(null);
+  const run = useCallback(
+    async (answers) => {
+      setPending(true);
+      setError(null);
+      try {
+        await answerQuestions(chat, id, answers);
+      } catch (error2) {
+        setError(error2 instanceof Error ? error2 : new Error(String(error2)));
+      } finally {
+        setPending(false);
+      }
+    },
+    [chat, id]
+  );
+  return useMemo(() => ({ run, pending, error }), [run, pending, error]);
+}
+export {
+  useQuestionWrite
+};

package/dist/hooks/use-read-aloud.d.ts

@@ -0,0 +1,8 @@
+/** Explicit user playback, one owner at a time; unmount never cancels another message's voice. */
+export declare function useReadAloud(text: string): {
+    available: boolean;
+    playing: boolean;
+    failed: boolean;
+    toggle: () => void;
+};
+export type ReadAloud = ReturnType<typeof useReadAloud>;

package/dist/hooks/use-read-aloud.js

@@ -0,0 +1,60 @@
+"use client";
+import { useEffect, useState, useSyncExternalStore } from "react";
+let reading = { owner: null, phase: "idle" };
+const listeners = /* @__PURE__ */ new Set();
+const subscribe = (listener) => {
+  listeners.add(listener);
+  return () => {
+    listeners.delete(listener);
+  };
+};
+const snapshot = () => reading;
+const server = () => IDLE;
+const IDLE = { owner: null, phase: "idle" };
+const supported = () => typeof window !== "undefined" && "speechSynthesis" in window && "SpeechSynthesisUtterance" in window;
+function publish(next) {
+  reading = next;
+  listeners.forEach((listener) => listener());
+}
+function stop(owner) {
+  if (reading.owner !== owner) return;
+  publish(IDLE);
+  window.speechSynthesis.cancel();
+}
+function useReadAloud(text) {
+  const [owner] = useState(() => ({}));
+  const current = useSyncExternalStore(subscribe, snapshot, server);
+  const available = useSyncExternalStore(subscribe, supported, () => false);
+  useEffect(
+    () => () => {
+      if (supported()) stop(owner);
+    },
+    [owner, text]
+  );
+  const playing = current.owner === owner && current.phase === "playing";
+  const failed = current.owner === owner && current.phase === "error";
+  const toggle = () => {
+    if (!available || !text.trim()) return;
+    if (reading.owner === owner && reading.phase === "playing") return stop(owner);
+    publish(IDLE);
+    window.speechSynthesis.cancel();
+    const run = { owner, phase: "playing" };
+    publish(run);
+    try {
+      const utterance = new SpeechSynthesisUtterance(text);
+      utterance.onend = () => {
+        if (reading === run) publish(IDLE);
+      };
+      utterance.onerror = () => {
+        if (reading === run) publish({ owner, phase: "error" });
+      };
+      window.speechSynthesis.speak(utterance);
+    } catch {
+      if (reading === run) publish({ owner, phase: "error" });
+    }
+  };
+  return { available, playing, failed, toggle };
+}
+export {
+  useReadAloud
+};

package/dist/hooks/use-reasoning.d.ts

@@ -0,0 +1,8 @@
+export type Reasoning = {
+    seconds: number | null;
+    streaming: boolean;
+    open: boolean;
+    setOpen(open: boolean): void;
+};
+/** Historical traces have no measured duration; only a trace observed live gets a timer. */
+export declare function useReasoning(streaming: boolean): Reasoning;

package/dist/hooks/use-reasoning.js

@@ -0,0 +1,32 @@
+"use client";
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+function useReasoning(streaming) {
+  const [started] = useState(() => streaming ? Date.now() : null);
+  const [seconds, setSeconds] = useState(() => streaming ? 0 : null);
+  const [open, set] = useState(streaming);
+  const touched = useRef(false);
+  const setOpen = useCallback((value) => {
+    touched.current = true;
+    set(value);
+  }, []);
+  useEffect(() => {
+    if (started === null) return;
+    const update = () => setSeconds(Math.max(0, Math.floor((Date.now() - started) / 1e3)));
+    if (streaming) {
+      const timer = setInterval(update, 1e3);
+      return () => clearInterval(timer);
+    }
+    const finish = setTimeout(update, 0);
+    const fold = setTimeout(() => {
+      if (!touched.current) set(false);
+    }, 1e3);
+    return () => {
+      clearTimeout(finish);
+      clearTimeout(fold);
+    };
+  }, [streaming, started]);
+  return useMemo(() => ({ seconds, streaming, open, setOpen }), [seconds, streaming, open, setOpen]);
+}
+export {
+  useReasoning
+};

package/dist/hooks/use-remembered-approvals.d.ts

@@ -0,0 +1,9 @@
+import type { AiChat } from "./use-chat-instance";
+import type { ToolApprovalMemory } from "./use-tool-approval-memory";
+export type ApprovalAutomation = {
+    failure: {
+        id: string;
+        error: Error;
+    } | null;
+};
+export declare function useRememberedApprovals(chat: AiChat, policy: ToolApprovalMemory): ApprovalAutomation;

package/dist/hooks/use-remembered-approvals.js

@@ -0,0 +1,40 @@
+"use client";
+import { useChat } from "@ai-sdk/react";
+import { getToolName, isToolUIPart } from "ai";
+import { useEffect, useMemo, useRef, useState } from "react";
+import { respondToApproval } from "../services/types.js";
+function useRememberedApprovals(chat, policy) {
+  const { messages } = useChat({ chat });
+  const attempts = useRef(/* @__PURE__ */ new WeakMap());
+  const mounted = useRef(true);
+  useEffect(() => {
+    mounted.current = true;
+    return () => {
+      mounted.current = false;
+    };
+  }, []);
+  const [failure, setFailure] = useState(null);
+  useEffect(() => {
+    if (!policy.enabled) return;
+    let attempted = attempts.current.get(chat);
+    if (!attempted) {
+      attempted = /* @__PURE__ */ new Set();
+      attempts.current.set(chat, attempted);
+    }
+    for (const message of messages)
+      for (const part of message.parts) {
+        if (!isToolUIPart(part) || part.state !== "approval-requested" || !policy.tools.includes(getToolName(part)) || attempted.has(part.approval.id))
+          continue;
+        const id = part.approval.id;
+        attempted.add(id);
+        void respondToApproval(chat, id, true).catch((error) => {
+          if (mounted.current)
+            setFailure({ id, error: error instanceof Error ? error : new Error(String(error)) });
+        });
+      }
+  }, [chat, messages, policy]);
+  return useMemo(() => ({ failure }), [failure]);
+}
+export {
+  useRememberedApprovals
+};

package/dist/hooks/use-reply.d.ts

@@ -0,0 +1,3 @@
+import type { AiChat } from "./use-chat-instance";
+/** Sends at once, for a chat with no queue; an open question is skipped, and this is the reply. */
+export declare function useReply(chat: AiChat): (text: string) => void;

package/dist/hooks/use-reply.js

@@ -0,0 +1,9 @@
+"use client";
+import { useCallback } from "react";
+import { sendPastQuestions } from "../services/types.js";
+function useReply(chat) {
+  return useCallback((text) => void sendPastQuestions(chat, text), [chat]);
+}
+export {
+  useReply
+};

package/dist/hooks/use-report-missing-configuration.d.ts

@@ -0,0 +1,9 @@
+import { type Chat } from "@ai-sdk/react";
+import type { AiChatMessage } from "../services/types";
+/**
+ * Tells the tab when a turn was refused because the server lacks configuration.
+ *
+ * On the chat whatever made it, because an app that hands the screen its own `Chat` still
+ * points it at the installed route, and the route's answer is the same either way.
+ */
+export declare function useReportMissingConfiguration(chat: Chat<AiChatMessage>): void;

package/dist/hooks/use-report-missing-configuration.js

@@ -0,0 +1,14 @@
+"use client";
+import { useChat } from "@ai-sdk/react";
+import { useEffect } from "react";
+import { reportIfMissingConfiguration } from "@slices.sh/core/configuration";
+import { refusalBody } from "./chat-refusal.js";
+function useReportMissingConfiguration(chat) {
+  const { error } = useChat({ chat });
+  useEffect(() => {
+    if (error) reportIfMissingConfiguration(refusalBody(error));
+  }, [error]);
+}
+export {
+  useReportMissingConfiguration
+};

package/dist/hooks/use-retry-delay.d.ts

@@ -0,0 +1,5 @@
+export declare function useRetryDelay(error: unknown): {
+    seconds: number;
+    deadline: number | null;
+};
+export type RetryDelay = ReturnType<typeof useRetryDelay>;

package/dist/hooks/use-retry-delay.js

@@ -0,0 +1,17 @@
+"use client";
+import { useEffect, useState } from "react";
+import { retryAtOf } from "./chat-refusal.js";
+function useRetryDelay(error) {
+  const deadline = retryAtOf(error);
+  const [now, setNow] = useState(() => Date.now());
+  useEffect(() => {
+    if (deadline === null) return;
+    const tick = () => setNow(Date.now());
+    const timer = setInterval(tick, 250);
+    return () => clearInterval(timer);
+  }, [deadline]);
+  return { seconds: deadline === null ? 0 : Math.max(0, Math.ceil((deadline - now) / 1e3)), deadline };
+}
+export {
+  useRetryDelay
+};

package/dist/hooks/use-sent-draft.d.ts

@@ -0,0 +1,8 @@
+import type { AiChatMessage } from "../services/types";
+export type SentDraft = {
+    value: string | null;
+    start: () => void;
+    set: (value: string) => void;
+    cancel: () => void;
+};
+export declare function useSentDraft(message: AiChatMessage): SentDraft;

package/dist/hooks/use-sent-draft.js

@@ -0,0 +1,25 @@
+"use client";
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+function useSentDraft(message) {
+  const text = message.role === "user" ? message.parts.flatMap((part) => part.type === "text" ? [part.text] : []).join("\n") : "";
+  const key = message.id + "\0" + text;
+  const [state, setState] = useState({ key, value: null });
+  if (state.key !== key) setState({ key, value: null });
+  const returnFocus = useRef(null);
+  const wasEditing = useRef(false);
+  const start = useCallback(() => {
+    returnFocus.current = document.activeElement instanceof HTMLElement ? document.activeElement : null;
+    setState({ key, value: text });
+  }, [key, text]);
+  const set = useCallback((value2) => setState({ key, value: value2 }), [key]);
+  const cancel = useCallback(() => setState({ key, value: null }), [key]);
+  const value = state.key === key ? state.value : null;
+  useEffect(() => {
+    if (value === null && wasEditing.current && returnFocus.current?.isConnected) returnFocus.current.focus();
+    wasEditing.current = value !== null;
+  }, [value]);
+  return useMemo(() => ({ value, start, set, cancel }), [value, start, set, cancel]);
+}
+export {
+  useSentDraft
+};

package/dist/hooks/use-source-disclosure.d.ts

@@ -0,0 +1,5 @@
+export type SourceDisclosure = {
+    open: boolean;
+    setOpen(open: boolean): void;
+};
+export declare function useSourceDisclosure(): SourceDisclosure;

package/dist/hooks/use-source-disclosure.js

@@ -0,0 +1,9 @@
+"use client";
+import { useMemo, useState } from "react";
+function useSourceDisclosure() {
+  const [open, setOpen] = useState(false);
+  return useMemo(() => ({ open, setOpen }), [open]);
+}
+export {
+  useSourceDisclosure
+};

package/dist/hooks/use-sources.d.ts

@@ -0,0 +1,3 @@
+import { type AiChatMessage, type ChatSource } from "../services/types";
+export type Sources = readonly ChatSource[];
+export declare function useSources(message: AiChatMessage): Sources;

package/dist/hooks/use-sources.js

@@ -0,0 +1,9 @@
+"use client";
+import { useMemo } from "react";
+import { sourcesOf } from "../services/types.js";
+function useSources(message) {
+  return useMemo(() => sourcesOf(message), [message]);
+}
+export {
+  useSources
+};

package/dist/hooks/use-tool-approval-memory.d.ts

@@ -0,0 +1,8 @@
+import type { AiChat } from "./use-chat-instance";
+export type ToolApprovalMemory = {
+    enabled: boolean;
+    tools: readonly string[];
+    remember(tool: string): void;
+    forget(tool: string): void;
+};
+export declare function useToolApprovalMemory(chat: AiChat, enabled?: boolean): ToolApprovalMemory;

package/dist/hooks/use-tool-approval-memory.js

@@ -0,0 +1,16 @@
+"use client";
+import { useMemo, useSyncExternalStore } from "react";
+import { toolApprovalMemory } from "../services/types.js";
+const EMPTY = [];
+const server = () => EMPTY;
+function useToolApprovalMemory(chat, enabled = true) {
+  const memory = useMemo(() => toolApprovalMemory(chat), [chat]);
+  const tools = useSyncExternalStore(memory.watch, memory.snapshot, server);
+  return useMemo(
+    () => ({ enabled, tools, remember: memory.remember, forget: memory.forget }),
+    [enabled, tools, memory]
+  );
+}
+export {
+  useToolApprovalMemory
+};

package/dist/hooks/use-tool-approval.d.ts

@@ -0,0 +1,10 @@
+import type { AiChat } from "./use-chat-instance";
+export type ToolApproval = {
+    run(input: {
+        approved: boolean;
+    }): Promise<void>;
+    pending: boolean;
+    error: Error | null;
+    reset(): void;
+};
+export declare function useToolApproval(chat: AiChat, id: string): ToolApproval;

package/dist/hooks/use-tool-approval.js

@@ -0,0 +1,26 @@
+"use client";
+import { useCallback, useMemo, useState } from "react";
+import { respondToApproval } from "../services/types.js";
+function useToolApproval(chat, id) {
+  const [pending, setPending] = useState(false);
+  const [error, setError] = useState(null);
+  const reset = useCallback(() => setError(null), []);
+  const run = useCallback(
+    async ({ approved }) => {
+      setPending(true);
+      setError(null);
+      try {
+        await respondToApproval(chat, id, approved);
+      } catch (caught) {
+        setError(caught instanceof Error ? caught : new Error(String(caught)));
+      } finally {
+        setPending(false);
+      }
+    },
+    [chat, id]
+  );
+  return useMemo(() => ({ run, pending, error, reset }), [run, pending, error, reset]);
+}
+export {
+  useToolApproval
+};

package/dist/hooks/use-turn-queue.d.ts

@@ -0,0 +1,32 @@
+import type { FileUIPart } from "ai";
+import { type Blocker } from "../services/types";
+import type { AiChat } from "./use-chat-instance";
+export type QueuedTurn = {
+    id: string;
+    text: string;
+    draft: string | null;
+    files?: FileUIPart[];
+};
+export type QueueChange = {
+    type: "edit";
+    id: string;
+    text: string;
+} | {
+    type: "begin-edit" | "save-edit" | "cancel-edit" | "remove" | "send-now";
+    id: string;
+}
+/** Skips the open question of this tool call, and moves the turn on. */
+ | {
+    type: "skip-question";
+    toolCallId: string;
+};
+export type TurnQueue = {
+    enqueue(text: string, files?: readonly FileUIPart[]): void;
+    waiting: number;
+    items: readonly QueuedTurn[];
+    change(action: QueueChange): void;
+    /** What holds the queue besides a running turn: null when nothing does. */
+    blockedBy: Blocker | null;
+};
+/** FIFO by default. Editing holds its place; Send now explicitly stops and reprioritizes. */
+export declare function useTurnQueue(chat: AiChat): TurnQueue;

package/dist/hooks/use-turn-queue.js

@@ -0,0 +1,33 @@
+"use client";
+import { useChat } from "@ai-sdk/react";
+import { useCallback, useEffect, useMemo, useState, useSyncExternalStore } from "react";
+import { blockedBy } from "../services/types.js";
+import { createMailbox } from "./turn-mailbox.js";
+const EMPTY = [];
+const server = () => EMPTY;
+function useTurnQueue(chat) {
+  const { status, messages } = useChat({ chat });
+  const [box] = useState(createMailbox);
+  const items = useSyncExternalStore(box.watch, box.snapshot, server);
+  useEffect(() => box.open(), [box]);
+  useEffect(() => {
+    box.drain(chat);
+  }, [status, messages, box, chat]);
+  const enqueue = useCallback(
+    (text, files) => {
+      const value = text.trim();
+      if (!value && !files?.length) return;
+      box.apply({ type: "enqueue", text: value, files }, chat);
+    },
+    [box, chat]
+  );
+  const change = useCallback((action) => box.apply(action, chat), [box, chat]);
+  const waitingFor = blockedBy(messages, status === "submitted" || status === "streaming");
+  return useMemo(
+    () => ({ enqueue, items, waiting: items.length, change, blockedBy: waitingFor }),
+    [enqueue, items, change, waitingFor]
+  );
+}
+export {
+  useTurnQueue
+};

package/dist/index.d.ts

@@ -0,0 +1,10 @@
+import type { AiChatClient } from "./services/types";
+export type { AiChatClient };
+/**
+ * Configures the ai-chat service: services/ai-chat/<config>.config.ts has
+ * `export default aiChat({ provider: … })`. This module is client-safe: it holds a
+ * description, and the server half of the provider is loaded lazily.
+ */
+export declare const aiChat: <Options extends Record<string, unknown>>(options: {
+    provider: import("@slices.sh/core").Provider<AiChatClient>;
+} & Options) => import("@slices.sh/core").ServiceConfig<AiChatClient>;

package/dist/index.js

@@ -0,0 +1,5 @@
+import { defineService } from "@slices.sh/core";
+const aiChat = defineService("ai-chat");
+export {
+  aiChat
+};

package/dist/next.d.ts

@@ -0,0 +1,43 @@
+import "server-only";
+/** app/api/ai-chat/[config]/[[...path]]/route.ts re-exports these. */
+export declare const GET: (request: Request, context: {
+    params: Promise<{
+        config?: string;
+        path?: string[];
+    }> | {
+        config?: string;
+        path?: string[];
+    };
+}) => Promise<Response>, POST: (request: Request, context: {
+    params: Promise<{
+        config?: string;
+        path?: string[];
+    }> | {
+        config?: string;
+        path?: string[];
+    };
+}) => Promise<Response>, PUT: (request: Request, context: {
+    params: Promise<{
+        config?: string;
+        path?: string[];
+    }> | {
+        config?: string;
+        path?: string[];
+    };
+}) => Promise<Response>, PATCH: (request: Request, context: {
+    params: Promise<{
+        config?: string;
+        path?: string[];
+    }> | {
+        config?: string;
+        path?: string[];
+    };
+}) => Promise<Response>, DELETE: (request: Request, context: {
+    params: Promise<{
+        config?: string;
+        path?: string[];
+    }> | {
+        config?: string;
+        path?: string[];
+    };
+}) => Promise<Response>;

package/dist/next.js

@@ -0,0 +1,10 @@
+import "server-only";
+import { serviceRoute } from "@slices.sh/core/server";
+const { GET, POST, PUT, PATCH, DELETE } = serviceRoute("ai-chat");
+export {
+  DELETE,
+  GET,
+  PATCH,
+  POST,
+  PUT
+};