inline-chat-kit 0.55.1 → 0.56.0

package/dist/labels/labels.d.ts

@@ -0,0 +1,254 @@
+import { ReactNode } from 'react';
+/**
+ * Every word the kit says, in one place.
+ *
+ * The components each took a `labels` prop, and that was enough right up until
+ * somebody assembled them: `ChatExperience` and `ChatTurnRow` draw a dozen of
+ * them and passed none of it through, so a chat translated piece by piece still
+ * said "Copy", "Allow once" and "Thinking" in English. This is the one object
+ * that reaches all of them.
+ *
+ * Grouped by the component that says it, so a translator can find a string by
+ * looking at the screen. Every group is partial: what is left out stays the
+ * English default below. `{name}` in a value is filled in by the component —
+ * keep the placeholder, move it wherever the language wants it.
+ *
+ * What counts: text on screen, an `aria-label`, a `title`, a placeholder, text
+ * only a screen reader gets, and anything said through the live region.
+ * Everything a person sees or hears.
+ */
+export declare const defaultLabels: {
+    approval: {
+        once: string;
+        always: string;
+        deny: string;
+        allowedOnce: string;
+        allowedAlways: string;
+        wasDenied: string;
+        pending: string;
+    };
+    tool: {
+        input: string;
+        output: string;
+        error: string;
+        pending: string;
+        running: string;
+        done: string;
+    };
+    reasoning: {
+        thinking: string;
+        thought: string;
+        /** Followed by the duration: "Thought for 12s". */
+        thoughtFor: string;
+    };
+    chain: {
+        /** Followed by the count: "Thought through 4 steps". */
+        through: string;
+        step: string;
+        steps: string;
+        thinking: string;
+    };
+    tasks: {
+        pending: string;
+        running: string;
+        done: string;
+        error: string;
+        /** `{done}` and `{total}` are filled in. */
+        progress: string;
+    };
+    sources: {
+        title: string;
+        one: string;
+        many: string;
+    };
+    /** The marker in the prose, spoken as "Source 2: <title>". */
+    citation: {
+        cite: string;
+    };
+    answerActions: {
+        copy: string;
+        copied: string;
+        regenerate: string;
+        up: string;
+        down: string;
+    };
+    branch: {
+        previous: string;
+        next: string;
+        /** `{index}` and `{total}` are filled in. */
+        position: string;
+    };
+    context: {
+        name: string;
+        /** Between the two numbers: "128k of 1M". */
+        of: string;
+        tokens: string;
+        /** Said once it is past `warnAt`, and it should say what happens next. */
+        nearlyFull: string;
+    };
+    attachments: {
+        /** Followed by the file's name. */
+        remove: string;
+    };
+    question: {
+        next: string;
+        none: string;
+        edit: string;
+        /** The free-text row, when the question does not name its own. */
+        other: string;
+        /** The alphabet the options are lettered from, in order. */
+        letters: string;
+    };
+    questionGroup: {
+        /** After the count, in the folded row: "3 answers". */
+        answers: string;
+    };
+    /** The composer — the box you type in, and the bubble it becomes. */
+    input: {
+        placeholder: string;
+        send: string;
+        save: string;
+        stop: string;
+        cancelEdit: string;
+        /** The "+" that opens the menu. */
+        add: string;
+        closeMenu: string;
+        /** The three built-in menu entries. */
+        attach: string;
+        design: string;
+        connectors: string;
+        /** Under a sent message. */
+        copy: string;
+        edit: string;
+        readMore: string;
+        readLess: string;
+        /** The microphone, by what pressing it would do. */
+        dictate: string;
+        stopListening: string;
+        waitingForMicrophone: string;
+        cancelTranscription: string;
+        microphoneBlocked: string;
+        microphoneBlockedHelp: string;
+    };
+    /** Said through the live region while dictating, and shown when it fails. */
+    voice: {
+        listening: string;
+        stoppedListening: string;
+        transcribing: string;
+        nothingHeard: string;
+        transcriptAdded: string;
+        transcriptFailed: string;
+        refused: string;
+        notFound: string;
+        couldNotOpen: string;
+    };
+    header: {
+        back: string;
+        more: string;
+    };
+    highlighter: {
+        menu: string;
+        reply: string;
+        remove: string;
+        /** The invisible button per highlight, followed by its text. */
+        highlight: string;
+        /** `{count}` is filled in. */
+        countOne: string;
+        countMany: string;
+        /** Read when the answer takes focus: how to highlight without a pointer. */
+        keyboardHint: string;
+    };
+    thread: {
+        title: string;
+        save: string;
+        close: string;
+        /** Screen-reader only, before the quoted passage. */
+        on: string;
+        placeholder: string;
+    };
+    codeBlock: {
+        copy: string;
+        copyCode: string;
+        copied: string;
+        copiedAnnouncement: string;
+    };
+    pane: {
+        close: string;
+        expand: string;
+        collapse: string;
+    };
+    conversation: {
+        jump: string;
+    };
+    emptyState: {
+        suggestions: string;
+    };
+    /** What `ChatExperience` adds around the pieces. */
+    experience: {
+        title: string;
+        savedHighlights: string;
+        themeToLight: string;
+        themeToDark: string;
+        share: string;
+        selectionMode: string;
+        marker: string;
+        precise: string;
+        windowFull: string;
+        highlights: string;
+        close: string;
+        /** `{index}` is filled in. */
+        paragraph: string;
+        /** Said when a request starts. */
+        responding: string;
+    };
+};
+type Defaults = typeof defaultLabels;
+/** Every string one component says, all required. */
+export type LabelsOf<K extends keyof Defaults> = {
+    [S in keyof Defaults[K]]: string;
+};
+/**
+ * What a host passes: any component's group, any of its strings. The rest
+ * stay English.
+ */
+export type ChatLabels = {
+    [K in keyof Defaults]?: Partial<LabelsOf<K>>;
+};
+export type ApprovalLabels = LabelsOf<"approval">;
+export type ToolLabels = LabelsOf<"tool">;
+export type ReasoningLabels = LabelsOf<"reasoning">;
+export type ChainLabels = LabelsOf<"chain">;
+export type TaskListLabels = LabelsOf<"tasks">;
+export type SourcesLabels = LabelsOf<"sources">;
+export type AnswerActionsLabels = LabelsOf<"answerActions">;
+export type BranchLabels = LabelsOf<"branch">;
+export type ContextLabels = LabelsOf<"context">;
+export type ChatInputLabels = LabelsOf<"input">;
+export type VoiceLabels = LabelsOf<"voice">;
+/**
+ * Hands a `ChatLabels` to every kit component beneath it.
+ *
+ * Through context rather than a prop on each row: `ChatTurnRow` is memoised,
+ * and a translation threaded through its props would be one more thing that
+ * had to stay referentially stable. It still has to be stable here — a new
+ * object in context re-renders every reader — so the value is keyed on the
+ * *contents*, and an object literal written inline in a host's render costs
+ * nothing after the first time.
+ *
+ * Nests: an inner provider overrides the outer one string by string.
+ */
+export declare function LabelsProvider({ labels, children, }: {
+    labels?: ChatLabels;
+    children?: ReactNode;
+}): import("react").JSX.Element;
+/**
+ * One component's strings: the English default, under whatever a
+ * `LabelsProvider` above says, under the component's own `labels` prop.
+ *
+ * The prop wins because it is the more specific of the two — somebody who
+ * wrote a string on one instance meant that instance.
+ */
+export declare function useLabels<K extends keyof Defaults>(group: K, local?: Partial<LabelsOf<K>>): LabelsOf<K>;
+/** `"{done} of {total}"` → `"2 of 5"`. */
+export declare function fill(template: string, values: Record<string, string | number>): string;
+export {};

package/dist/turnParts/turnParts.d.ts

@@ -3,7 +3,7 @@ import { Thought } from '../ChainOfThought/ChainOfThought';
 import { Source } from '../Sources/Sources';
 import { Task } from '../TaskList/TaskList';
 import { ToolState } from '../Tool/Tool';
-import { Decision } from '../Approval/Approval';
+import { ApprovalChoice, Decision } from '../Approval/Approval';
 import { Answer, Question } from '../QuestionCard/types';
 import { SystemTone } from '../SystemMessage/SystemMessage';
 import { ArtifactKind, ArtifactState } from '../Artifact/ArtifactCard';
@@ -87,6 +87,12 @@ export type TurnPart = {
     };
     /** `null` or absent while it is still being asked. */
     decision?: Decision | null;
+    /**
+     * Which answers are offered. All three when left out. Drop `"always"`
+     * where a standing permission means nothing — approving one edit to a
+     * plan, say — and "Allow once" stays the primary.
+     */
+    choices?: ApprovalChoice[];
 } | {
     kind: "question";
     id: string;
@@ -129,7 +135,28 @@ export type TurnPart = {
     lang?: string;
     content?: string;
     state?: ArtifactState;
-};
+} | CustomPart;
+/**
+ * A part the kit does not know how to draw, and the host does.
+ *
+ * Every other kind is a component in this package. This one is the host's:
+ * `type` says which of its own cards it is — `"plan-diff"`, `"send-request"` —
+ * and `data` is whatever that card needs. `<ChatTurnRow>` hands it to
+ * `renderPart` and draws what comes back, in its place among the other parts.
+ *
+ * Still data rather than JSX, for the reason the rest are: a stream can send
+ * `{ kind: "custom", id, type, data }` and cannot send a component. Merged by
+ * id like everything else, so `{ kind: "custom", id, data }` replaces `data`
+ * and leaves `type` alone.
+ */
+export interface CustomPart {
+    kind: "custom";
+    id: string;
+    /** Which of the host's cards this is. The kit never reads it. */
+    type: string;
+    /** Whatever that card needs. Replaced whole on an update, not merged. */
+    data?: unknown;
+}
 /**
  * An update to a part, which is a part with everything optional but the two
  * fields that say which one it is.

package/dist/voice/useVoiceInput.d.ts

@@ -1,4 +1,5 @@
 import { RefObject } from 'react';
+import { VoiceLabels } from '../labels/labels';
 /**
  * The microphone, and everything around turning it into text except the part
  * that is a service.
@@ -63,6 +64,12 @@ export interface UseVoiceInputOptions {
      * straight to the browser.
      */
     meterRef?: RefObject<HTMLElement | null>;
+    /**
+     * What is said through the live region, and the errors it reports. English
+     * when left out. A hook cannot read a `LabelsProvider` the host renders
+     * below it, so `ChatInput` passes its own through here.
+     */
+    labels?: Partial<VoiceLabels>;
 }
 export interface VoiceInput {
     state: VoiceState;
@@ -76,4 +83,4 @@ export interface VoiceInput {
     /** Forget a refusal, so the button can be offered again. */
     reset: () => void;
 }
-export declare function useVoiceInput({ onTranscribe, onTranscript, onDone, meterRef, }: UseVoiceInputOptions): VoiceInput;
+export declare function useVoiceInput({ onTranscribe, onTranscript, onDone, meterRef, labels, }: UseVoiceInputOptions): VoiceInput;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "inline-chat-kit",
-  "version": "0.55.1",
-  "description": "An inline AI chat experience for React. The input is the message: it morphs into the bubble, the answer streams beneath it, and the parts around it \u2014 tool calls, reasoning, questions, artifacts, dictation \u2014 come with it.",
+  "version": "0.56.0",
+  "description": "An inline AI chat experience for React. The input is the message: it morphs into the bubble, the answer streams beneath it, and the parts around it — tool calls, reasoning, questions, artifacts, dictation — come with it.",
   "keywords": [
     "react",
     "chat",