@pmate/chat-sdk 0.1.1

package/lib/components/WaveformFeedback.d.ts

@@ -0,0 +1,6 @@
+import type { ChatInputTokens } from "../types/chatInput";
+export declare function WaveformFeedback({ levels, tokens, compact, }: {
+    levels: number[];
+    tokens: ChatInputTokens;
+    compact?: boolean;
+}): import("react/jsx-runtime").JSX.Element;

package/lib/components/WaveformFeedback.js

@@ -0,0 +1,44 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import React from "react";
+export function WaveformFeedback({ levels, tokens, compact = false, }) {
+    const normalizedLevels = normalizeLevels(levels, compact ? 13 : 17);
+    return (_jsx("div", { style: {
+            display: "flex",
+            alignItems: "flex-end",
+            justifyContent: "center",
+            gap: compact ? 2 : 3,
+            minHeight: compact ? 24 : 30,
+            filter: compact ? "blur(0.15px)" : "blur(0.1px)",
+        }, children: normalizedLevels.map((level, index) => {
+            const distanceFromCenter = Math.abs(index - (normalizedLevels.length - 1) / 2);
+            const centerWeight = 1 - distanceFromCenter / ((normalizedLevels.length + 1) / 2);
+            const shapedLevel = Math.max(compact ? 0.18 : 0.1, level * (compact ? 0.82 + centerWeight * 0.9 : 0.58 + centerWeight * 0.82));
+            const baseHeight = compact ? 6 : 6;
+            const dynamicHeight = compact ? 12 : 14;
+            const opacity = compact ? 0.5 + centerWeight * 0.4 : 0.36 + centerWeight * 0.52;
+            return (_jsx("span", { style: {
+                    width: compact ? 3 : 4,
+                    height: `${baseHeight + Math.round(shapedLevel * dynamicHeight)}px`,
+                    borderRadius: tokens.radius.waveformBar,
+                    background: tokens.color.voiceWaveformActive,
+                    opacity,
+                    boxShadow: `0 0 ${compact ? 7 : 8}px rgba(124, 92, 255, ${compact ? 0.12 + centerWeight * 0.16 : 0.08 + centerWeight * 0.14})`,
+                    transition: `height ${tokens.motion.waveformPulse}, opacity ${tokens.motion.pressFeedback}`,
+                } }, index));
+        }) }));
+}
+function normalizeLevels(levels, targetBars) {
+    if (levels.length === targetBars) {
+        return levels;
+    }
+    if (levels.length === 0) {
+        return Array.from({ length: targetBars }, () => 0.18);
+    }
+    return Array.from({ length: targetBars }, (_, index) => {
+        const mappedIndex = (index / Math.max(1, targetBars - 1)) * Math.max(0, levels.length - 1);
+        const left = Math.floor(mappedIndex);
+        const right = Math.min(levels.length - 1, Math.ceil(mappedIndex));
+        const mix = mappedIndex - left;
+        return levels[left] * (1 - mix) + levels[right] * mix;
+    });
+}

package/lib/components/icons.d.ts

@@ -0,0 +1,11 @@
+type IconProps = {
+    size?: number;
+    stroke?: string;
+    strokeWidth?: number;
+};
+export declare function MicOutlineIcon({ size, stroke, strokeWidth, }: IconProps): import("react/jsx-runtime").JSX.Element;
+export declare function KeyboardOutlineIcon({ size, stroke, strokeWidth, }: IconProps): import("react/jsx-runtime").JSX.Element;
+export declare function SmileOutlineIcon({ size, stroke, strokeWidth, }: IconProps): import("react/jsx-runtime").JSX.Element;
+export declare function PlusOutlineIcon({ size, stroke, strokeWidth, }: IconProps): import("react/jsx-runtime").JSX.Element;
+export declare function ImageOutlineIcon({ size, stroke, strokeWidth, }: IconProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/lib/components/icons.js

@@ -0,0 +1,29 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import React from "react";
+function BaseIcon({ size = 22, children, }) {
+    return (_jsx("svg", { width: size, height: size, viewBox: "0 0 24 24", fill: "none", xmlns: "http://www.w3.org/2000/svg", "aria-hidden": "true", children: children }));
+}
+export function MicOutlineIcon({ size, stroke = "currentColor", strokeWidth = 1.9, }) {
+    return (_jsxs(BaseIcon, { size: size, children: [_jsx("rect", { x: "9", y: "3", width: "6", height: "11", rx: "3", stroke: stroke, strokeWidth: strokeWidth }), _jsx("path", { d: "M6.5 11.5C6.5 14.5376 8.96243 17 12 17C15.0376 17 17.5 14.5376 17.5 11.5", stroke: stroke, strokeWidth: strokeWidth, strokeLinecap: "round" }), _jsx("path", { d: "M12 17V21", stroke: stroke, strokeWidth: strokeWidth, strokeLinecap: "round" }), _jsx("path", { d: "M8.5 21H15.5", stroke: stroke, strokeWidth: strokeWidth, strokeLinecap: "round" })] }));
+}
+export function KeyboardOutlineIcon({ size, stroke = "currentColor", strokeWidth = 1.8, }) {
+    return (_jsxs(BaseIcon, { size: size, children: [_jsx("rect", { x: "3", y: "5", width: "18", height: "14", rx: "3", stroke: stroke, strokeWidth: strokeWidth }), [
+                [6.5, 9],
+                [10, 9],
+                [13.5, 9],
+                [17, 9],
+                [6.5, 12.5],
+                [10, 12.5],
+                [13.5, 12.5],
+                [17, 12.5],
+            ].map(([cx, cy], index) => (_jsx("circle", { cx: cx, cy: cy, r: "0.8", fill: stroke }, index))), _jsx("path", { d: "M7 16.2H17", stroke: stroke, strokeWidth: strokeWidth, strokeLinecap: "round" })] }));
+}
+export function SmileOutlineIcon({ size, stroke = "currentColor", strokeWidth = 1.8, }) {
+    return (_jsxs(BaseIcon, { size: size, children: [_jsx("circle", { cx: "12", cy: "12", r: "9", stroke: stroke, strokeWidth: strokeWidth }), _jsx("circle", { cx: "9", cy: "10", r: "1", fill: stroke }), _jsx("circle", { cx: "15", cy: "10", r: "1", fill: stroke }), _jsx("path", { d: "M8.2 14.2C9.15 15.55 10.42 16.2 12 16.2C13.58 16.2 14.85 15.55 15.8 14.2", stroke: stroke, strokeWidth: strokeWidth, strokeLinecap: "round" })] }));
+}
+export function PlusOutlineIcon({ size, stroke = "currentColor", strokeWidth = 1.8, }) {
+    return (_jsxs(BaseIcon, { size: size, children: [_jsx("circle", { cx: "12", cy: "12", r: "9", stroke: stroke, strokeWidth: strokeWidth }), _jsx("path", { d: "M12 8V16", stroke: stroke, strokeWidth: strokeWidth, strokeLinecap: "round" }), _jsx("path", { d: "M8 12H16", stroke: stroke, strokeWidth: strokeWidth, strokeLinecap: "round" })] }));
+}
+export function ImageOutlineIcon({ size, stroke = "currentColor", strokeWidth = 1.8, }) {
+    return (_jsxs(BaseIcon, { size: size, children: [_jsx("rect", { x: "4", y: "5", width: "16", height: "14", rx: "3", stroke: stroke, strokeWidth: strokeWidth }), _jsx("circle", { cx: "9", cy: "10", r: "1.6", stroke: stroke, strokeWidth: strokeWidth }), _jsx("path", { d: "M7 16L11.2 12.1C11.75 11.58 12.63 11.58 13.18 12.1L17 15.6", stroke: stroke, strokeWidth: strokeWidth, strokeLinecap: "round", strokeLinejoin: "round" })] }));
+}

package/lib/hooks/useAttachmentState.d.ts

@@ -0,0 +1,6 @@
+import type { ChatAttachment } from "../types/attachment";
+export declare function useAttachmentState(): {
+    attachments: ChatAttachment[];
+    addAttachment(attachment: Omit<ChatAttachment, "id" | "kind">): void;
+    removeAttachment(id: string): void;
+};

package/lib/hooks/useAttachmentState.js

@@ -0,0 +1,21 @@
+import { useChatInputState } from "./useChatInputState";
+export function useAttachmentState() {
+    const { attachments, setAttachments, setStatus } = useChatInputState();
+    return {
+        attachments,
+        addAttachment(attachment) {
+            setAttachments([
+                ...attachments,
+                {
+                    id: crypto.randomUUID(),
+                    kind: "image",
+                    ...attachment,
+                },
+            ]);
+            setStatus("attachment-selected");
+        },
+        removeAttachment(id) {
+            setAttachments(attachments.filter((item) => item.id !== id));
+        },
+    };
+}

package/lib/hooks/useChatInputState.d.ts

@@ -0,0 +1,14 @@
+export declare function useChatInputState(): {
+    mode: import("..").ChatInputMode;
+    setMode: (args_0: import("..").ChatInputMode | ((prev: import("..").ChatInputMode) => import("..").ChatInputMode)) => void;
+    status: import("..").ChatInputStatus;
+    setStatus: (args_0: import("..").ChatInputStatus | ((prev: import("..").ChatInputStatus) => import("..").ChatInputStatus)) => void;
+    text: string;
+    setText: (args_0: string | ((prev: string) => string)) => void;
+    transcript: string;
+    setTranscript: (args_0: string | ((prev: string) => string)) => void;
+    error: string | null;
+    setError: (args_0: string | ((prev: string | null) => string | null) | null) => void;
+    attachments: import("..").ChatAttachment[];
+    setAttachments: (args_0: import("..").ChatAttachment[] | ((prev: import("..").ChatAttachment[]) => import("..").ChatAttachment[])) => void;
+};

package/lib/hooks/useChatInputState.js

@@ -0,0 +1,25 @@
+import { useAtom } from "jotai";
+import { chatInputErrorAtom, chatInputModeAtom, chatInputStatusAtom, chatInputTextAtom, chatInputTranscriptAtom, } from "../atoms/chatInputAtoms";
+import { attachmentListAtom } from "../atoms/attachmentAtoms";
+export function useChatInputState() {
+    const [mode, setMode] = useAtom(chatInputModeAtom);
+    const [status, setStatus] = useAtom(chatInputStatusAtom);
+    const [text, setText] = useAtom(chatInputTextAtom);
+    const [transcript, setTranscript] = useAtom(chatInputTranscriptAtom);
+    const [error, setError] = useAtom(chatInputErrorAtom);
+    const [attachments, setAttachments] = useAtom(attachmentListAtom);
+    return {
+        mode,
+        setMode,
+        status,
+        setStatus,
+        text,
+        setText,
+        transcript,
+        setTranscript,
+        error,
+        setError,
+        attachments,
+        setAttachments,
+    };
+}

package/lib/hooks/useTranscriptComposer.d.ts

@@ -0,0 +1 @@
+export declare function insertTranscriptText(currentText: string, transcript: string): string;

package/lib/hooks/useTranscriptComposer.js

@@ -0,0 +1,11 @@
+export function insertTranscriptText(currentText, transcript) {
+    const base = currentText.trim();
+    const next = transcript.trim();
+    if (!base) {
+        return next;
+    }
+    if (!next) {
+        return base;
+    }
+    return `${base} ${next}`;
+}

package/lib/hooks/useVoiceInputController.d.ts

@@ -0,0 +1,14 @@
+import type { ChatVoiceConfig } from "../types/voice";
+type StopAction = "send" | "transcribe";
+export declare function useVoiceInputController(config?: ChatVoiceConfig): {
+    mode: import("..").ChatInputMode;
+    status: import("..").ChatInputStatus;
+    waveformLevels: number[];
+    durationMs: number;
+    beginVoiceMode: () => void;
+    setMode: (args_0: import("..").ChatInputMode | ((prev: import("..").ChatInputMode) => import("..").ChatInputMode)) => void;
+    startRecording: () => void;
+    cancelRecording: (message?: string | null) => void;
+    stopRecording: (action?: StopAction) => void;
+};
+export {};

package/lib/hooks/useVoiceInputController.js

@@ -0,0 +1,133 @@
+import { useAtom } from "jotai";
+import { useEffect, useRef } from "react";
+import { waveformLevelsAtom, recordingDurationMsAtom } from "../atoms/voiceAtoms";
+import { insertTranscriptText } from "./useTranscriptComposer";
+import { useChatInputState } from "./useChatInputState";
+import { MicEvents, MicStateManager } from "../voice/MicStateManager";
+const DEFAULT_WAVEFORM = [
+    0.18, 0.28, 0.42, 0.58, 0.74, 0.9, 0.74, 0.58, 0.42, 0.28, 0.18,
+];
+export function useVoiceInputController(config) {
+    const managerRef = useRef(null);
+    const stopActionRef = useRef("send");
+    const abortMessageRef = useRef(null);
+    const [levels, setLevels] = useAtom(waveformLevelsAtom);
+    const [durationMs, setDurationMs] = useAtom(recordingDurationMsAtom);
+    const { mode, setMode, status, setStatus, text, setText, setTranscript, setError, } = useChatInputState();
+    const modeRef = useRef(mode);
+    const textRef = useRef(text);
+    const configRef = useRef(config);
+    modeRef.current = mode;
+    textRef.current = text;
+    configRef.current = config;
+    useEffect(() => {
+        const manager = new MicStateManager();
+        manager.init();
+        managerRef.current = manager;
+        const unsubData = manager.on(MicEvents.Data, () => {
+            setDurationMs((value) => value + 120);
+        });
+        const unsubLevel = manager.on(MicEvents.Level, (nextLevels) => {
+            setLevels(nextLevels);
+        });
+        const unsubFinished = manager.on(MicEvents.Finished, (blob) => {
+            setLevels(DEFAULT_WAVEFORM);
+            setDurationMs(0);
+            if (stopActionRef.current === "transcribe") {
+                setStatus("transcribing");
+                void transcribeBlob(blob);
+                return;
+            }
+            setTranscript("");
+            setStatus(modeRef.current === "voice" ? "voice-mode-ready" : "idle");
+            setError(null);
+            void configRef.current?.onVoiceSend?.(blob);
+        });
+        const unsubAbort = manager.on(MicEvents.Abort, () => {
+            setLevels(DEFAULT_WAVEFORM);
+            setDurationMs(0);
+            setStatus(modeRef.current === "voice" ? "voice-mode-ready" : "idle");
+            setError(abortMessageRef.current);
+            abortMessageRef.current = null;
+        });
+        const unsubError = manager.on(MicEvents.Error, (error) => {
+            setLevels(DEFAULT_WAVEFORM);
+            setDurationMs(0);
+            setStatus("error");
+            setError(error.message);
+        });
+        return () => {
+            unsubData();
+            unsubLevel();
+            unsubFinished();
+            unsubAbort();
+            unsubError();
+            manager.dispose();
+            managerRef.current = null;
+        };
+    }, []);
+    async function transcribeBlob(blob) {
+        try {
+            const nextTranscript = configRef.current?.asrClient
+                ? (await configRef.current.asrClient.transcribe(blob, {
+                    lang: configRef.current.lang,
+                })).text.trim()
+                : (configRef.current?.simulatedTranscript ?? "hello from transcript").trim();
+            if (!nextTranscript) {
+                setStatus("error");
+                setError("No speech was recognized.");
+                return;
+            }
+            setTranscript(nextTranscript);
+            setText(insertTranscriptText(textRef.current, nextTranscript));
+            setDurationMs(0);
+            setStatus("transcript-ready");
+            setError(null);
+        }
+        catch (error) {
+            setStatus("error");
+            setError(error instanceof Error ? error.message : String(error));
+        }
+    }
+    function beginVoiceMode() {
+        setMode("voice");
+        setStatus("voice-mode-ready");
+        setError(null);
+    }
+    function startRecording() {
+        if (status === "recording") {
+            return;
+        }
+        setStatus("recording");
+        setError(null);
+        setTranscript("");
+        setDurationMs(0);
+        setLevels(DEFAULT_WAVEFORM);
+        abortMessageRef.current = null;
+        stopActionRef.current = "send";
+        void managerRef.current?.start();
+    }
+    function cancelRecording(message = null) {
+        abortMessageRef.current = message;
+        managerRef.current?.abort();
+    }
+    function stopRecording(action = "send") {
+        if (durationMs < (configRef.current?.minDurationMs ?? 450)) {
+            cancelRecording(configRef.current?.shortRecordingMessage ?? "Hold a little longer to record.");
+            return;
+        }
+        stopActionRef.current = action;
+        managerRef.current?.stop();
+    }
+    return {
+        mode,
+        status,
+        waveformLevels: levels,
+        durationMs,
+        beginVoiceMode,
+        setMode,
+        startRecording,
+        cancelRecording,
+        stopRecording,
+    };
+}

package/lib/index.d.ts

@@ -0,0 +1,23 @@
+export * from "./components/AttachmentPreview";
+export * from "./components/ChatInputDesktop";
+export * from "./components/ChatInputMobile";
+export * from "./components/EmojiTrigger";
+export * from "./components/HoldToTalkButton";
+export * from "./components/ImageTrigger";
+export * from "./components/InputSurface";
+export * from "./components/SendAction";
+export * from "./components/StatusHint";
+export * from "./components/TextComposer";
+export * from "./components/VoiceModeSwitch";
+export * from "./components/WaveformFeedback";
+export * from "./hooks/useAttachmentState";
+export * from "./hooks/useChatInputState";
+export * from "./hooks/useTranscriptComposer";
+export * from "./hooks/useVoiceInputController";
+export * from "./services/agentSdkASRClient";
+export * from "./services/authTokenResolver";
+export * from "./tokens/defaultTokens";
+export * from "./types/attachment";
+export * from "./types/chatInput";
+export * from "./types/voice";
+export * from "./voice/Recorder";

package/lib/index.js

@@ -0,0 +1,23 @@
+export * from "./components/AttachmentPreview";
+export * from "./components/ChatInputDesktop";
+export * from "./components/ChatInputMobile";
+export * from "./components/EmojiTrigger";
+export * from "./components/HoldToTalkButton";
+export * from "./components/ImageTrigger";
+export * from "./components/InputSurface";
+export * from "./components/SendAction";
+export * from "./components/StatusHint";
+export * from "./components/TextComposer";
+export * from "./components/VoiceModeSwitch";
+export * from "./components/WaveformFeedback";
+export * from "./hooks/useAttachmentState";
+export * from "./hooks/useChatInputState";
+export * from "./hooks/useTranscriptComposer";
+export * from "./hooks/useVoiceInputController";
+export * from "./services/agentSdkASRClient";
+export * from "./services/authTokenResolver";
+export * from "./tokens/defaultTokens";
+export * from "./types/attachment";
+export * from "./types/chatInput";
+export * from "./types/voice";
+export * from "./voice/Recorder";

package/lib/recorder-processor.js

@@ -0,0 +1,20 @@
+class RecorderProcessor extends AudioWorkletProcessor {
+  process(inputs) {
+    const input = inputs[0]
+    if (!input || !input[0]) {
+      return true
+    }
+
+    const samples = input[0]
+    const pcm = new Int16Array(samples.length)
+    for (let i = 0; i < samples.length; i += 1) {
+      const sample = Math.max(-1, Math.min(1, samples[i]))
+      pcm[i] = sample < 0 ? sample * 0x8000 : sample * 0x7fff
+    }
+
+    this.port.postMessage({ type: "pcm", data: pcm.buffer }, [pcm.buffer])
+    return true
+  }
+}
+
+registerProcessor("pmate-mic-recorder-processor", RecorderProcessor)

package/lib/services/agentSdkASRClient.d.ts

@@ -0,0 +1,28 @@
+import { AsyncStream } from "@pmate/utils";
+export type AgentSdkStreamLike = {
+    stream<TFinal = unknown, TChunk = Blob>(request: {
+        agentId: string;
+        stream: AsyncStream<TChunk>;
+        params?: Record<string, unknown>;
+        minChunkSizeBytes?: number;
+    }): {
+        finish(): Promise<TFinal | null>;
+    };
+};
+export type AgentSdkASRClientOptions = {
+    client: AgentSdkStreamLike;
+    agentId: string;
+    tokenResolver?: {
+        getToken(): string;
+    };
+    minChunkSizeBytes?: number;
+};
+export declare class AgentSdkASRClient {
+    private readonly options;
+    constructor(options: AgentSdkASRClientOptions);
+    transcribe(blob: Blob, input?: {
+        lang?: string;
+    }): Promise<{
+        text: string;
+    }>;
+}

package/lib/services/agentSdkASRClient.js

@@ -0,0 +1,25 @@
+import { AsyncStream } from "@pmate/utils";
+export class AgentSdkASRClient {
+    options;
+    constructor(options) {
+        this.options = options;
+    }
+    async transcribe(blob, input) {
+        const token = this.options.tokenResolver?.getToken() ?? "";
+        const stream = new AsyncStream();
+        const task = this.options.client.stream({
+            agentId: this.options.agentId,
+            stream,
+            params: {
+                lang: input?.lang ?? "auto",
+                token,
+            },
+            minChunkSizeBytes: this.options.minChunkSizeBytes ?? 0,
+        });
+        stream.push(blob);
+        stream.end();
+        return {
+            text: String((await task.finish()) ?? "").trim(),
+        };
+    }
+}

package/lib/services/authTokenResolver.d.ts

@@ -0,0 +1,7 @@
+export type AuthTokenResolver = {
+    getToken(): string;
+};
+export declare function createAuthTokenResolver(input: {
+    token?: string;
+    getToken?: () => string | null | undefined;
+}): AuthTokenResolver;

package/lib/services/authTokenResolver.js

@@ -0,0 +1,7 @@
+export function createAuthTokenResolver(input) {
+    return {
+        getToken() {
+            return input.token ?? input.getToken?.() ?? "";
+        },
+    };
+}

package/lib/stories/ChatInput.stories.d.ts

@@ -0,0 +1,15 @@
+import type { StoryObj } from "@storybook/react-vite";
+declare const meta: {
+    title: string;
+    parameters: {
+        layout: string;
+    };
+};
+export default meta;
+type Story = StoryObj<typeof meta>;
+export declare const MobileIdle: Story;
+export declare const MobileVoiceReady: Story;
+export declare const MobileRecording: Story;
+export declare const DesktopTyping: Story;
+export declare const DesktopAttachment: Story;
+export declare const WaveformActive: Story;

package/lib/stories/ChatInput.stories.js

@@ -0,0 +1,38 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { ChatInputDesktop } from "../components/ChatInputDesktop";
+import { ChatInputMobile } from "../components/ChatInputMobile";
+import { WaveformFeedback } from "../components/WaveformFeedback";
+import { mergeChatInputTokens } from "../tokens/defaultTokens";
+const meta = {
+    title: "@pmate/chat-sdk/ChatInput",
+    parameters: {
+        layout: "centered",
+    },
+};
+export default meta;
+export const MobileIdle = {
+    render: () => _jsx("div", { style: { width: 360 }, children: _jsx(ChatInputMobile, {}) }),
+};
+export const MobileVoiceReady = {
+    render: () => (_jsx("div", { style: { width: 360 }, children: _jsx(ChatInputMobile, { initialState: { mode: "voice", status: "voice-mode-ready" } }) })),
+};
+export const MobileRecording = {
+    render: () => (_jsx("div", { style: { width: 360 }, children: _jsx(ChatInputMobile, { initialState: {
+                mode: "voice",
+                status: "recording",
+                waveformLevels: [0.25, 0.5, 0.88, 0.52, 0.28],
+            } }) })),
+};
+export const DesktopTyping = {
+    render: () => (_jsx("div", { style: { width: 720 }, children: _jsx(ChatInputDesktop, { initialState: { text: "Ship chat-sdk storybook first", status: "typing" } }) })),
+};
+export const DesktopAttachment = {
+    render: () => (_jsx("div", { style: { width: 720 }, children: _jsx(ChatInputDesktop, { initialState: {
+                text: "Desktop attachment state",
+                status: "attachment-selected",
+                attachments: [{ id: "1", kind: "image", name: "spec.png" }],
+            } }) })),
+};
+export const WaveformActive = {
+    render: () => (_jsx(WaveformFeedback, { levels: [0.2, 0.5, 0.9, 0.55, 0.3], tokens: mergeChatInputTokens() })),
+};

package/lib/tests/agentSdkASRClient.test.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/tests/agentSdkASRClient.test.js

@@ -0,0 +1,39 @@
+import { describe, expect, it } from "vitest";
+import { AgentSdkASRClient, } from "../services/agentSdkASRClient";
+describe("AgentSdkASRClient", () => {
+    it("streams audio blobs through agent-sdk and returns final text", async () => {
+        const seen = {
+            blobSizes: [],
+        };
+        const client = new AgentSdkASRClient({
+            client: {
+                stream(request) {
+                    seen.agentId = request.agentId;
+                    seen.lang = String(request.params?.lang ?? "");
+                    seen.token = String(request.params?.token ?? "");
+                    return {
+                        async finish() {
+                            for await (const chunk of request.stream) {
+                                seen.blobSizes.push(chunk.size);
+                            }
+                            return "transcribed text";
+                        },
+                    };
+                },
+            },
+            agentId: "agent:transcribe",
+            tokenResolver: {
+                getToken: () => "user-token",
+            },
+            minChunkSizeBytes: 0,
+        });
+        const result = await client.transcribe(new Blob(["voice-bytes"]), {
+            lang: "en",
+        });
+        expect(result.text).toBe("transcribed text");
+        expect(seen.agentId).toBe("agent:transcribe");
+        expect(seen.lang).toBe("en");
+        expect(seen.token).toBe("user-token");
+        expect(seen.blobSizes).toEqual([11]);
+    });
+});

package/lib/tests/defaultTokens.test.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/tests/defaultTokens.test.js

@@ -0,0 +1,16 @@
+import { describe, expect, it } from "vitest";
+import { defaultChatInputTokens, mergeChatInputTokens } from "../tokens/defaultTokens";
+describe("chat-sdk tokens", () => {
+    it("keeps purple brand as default", () => {
+        expect(defaultChatInputTokens.color.brandPrimary).toBe("#6D4AFF");
+    });
+    it("merges nested token overrides", () => {
+        const merged = mergeChatInputTokens({
+            color: {
+                brandPrimary: "#000000",
+            },
+        });
+        expect(merged.color.brandPrimary).toBe("#000000");
+        expect(merged.color.voiceWaveformActive).toBe(defaultChatInputTokens.color.voiceWaveformActive);
+    });
+});

package/lib/tests/transcriptComposer.test.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/tests/transcriptComposer.test.js

@@ -0,0 +1,10 @@
+import { describe, expect, it } from "vitest";
+import { insertTranscriptText } from "../hooks/useTranscriptComposer";
+describe("insertTranscriptText", () => {
+    it("returns transcript when current text is empty", () => {
+        expect(insertTranscriptText("", "hello")).toBe("hello");
+    });
+    it("appends transcript to existing text", () => {
+        expect(insertTranscriptText("draft", "hello")).toBe("draft hello");
+    });
+});

package/lib/tokens/defaultTokens.d.ts

@@ -0,0 +1,3 @@
+import type { ChatInputTokens, DeepPartial } from "../types/chatInput";
+export declare const defaultChatInputTokens: ChatInputTokens;
+export declare function mergeChatInputTokens(overrides?: DeepPartial<ChatInputTokens>): ChatInputTokens;