@runtypelabs/voice 0.2.3 → 0.3.0

package/dist/react.js

@@ -1,7 +1,7 @@
 "use client";
 
 // src/react.ts
-import { useEffect, useMemo, useRef, useSyncExternalStore } from "react";
+import { useEffect, useRef, useState, useSyncExternalStore } from "react";
 
 // src/pcm-player.ts
 var PCM_SAMPLE_RATE = 24e3;
@@ -148,9 +148,58 @@ function initialSnapshot() {
     error: null,
     errorDetails: void 0,
     interruptionMode: "none",
-    canCancel: false
+    canCancel: false,
+    artifacts: [],
+    session: null
   };
 }
+function readString(value) {
+  return typeof value === "string" && value ? value : void 0;
+}
+function readArtifactFile(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return void 0;
+  const file = value;
+  const path = readString(file.path);
+  const mimeType = readString(file.mimeType);
+  if (!path || !mimeType) return void 0;
+  const language = readString(file.language);
+  return { path, mimeType, ...language ? { language } : {} };
+}
+function applyArtifactFrame(existing, frame, identity) {
+  if (frame.type === "artifact_start") {
+    const title = readString(frame.title);
+    const component = readString(frame.component);
+    const file = readArtifactFile(frame.file);
+    return {
+      ...identity,
+      artifactType: frame.artifactType === "component" ? "component" : "markdown",
+      ...title ? { title } : {},
+      ...file ? { file } : {},
+      ...component ? { component } : {},
+      content: "",
+      status: "streaming"
+    };
+  }
+  if (!existing) return void 0;
+  if (frame.type === "artifact_delta") {
+    const delta = typeof frame.delta === "string" ? frame.delta : "";
+    return delta ? { ...existing, content: existing.content + delta } : void 0;
+  }
+  if (frame.type === "artifact_update") {
+    const component = readString(frame.component) ?? existing.component;
+    const props = frame.props && typeof frame.props === "object" && !Array.isArray(frame.props) ? frame.props : existing.props;
+    return {
+      ...existing,
+      ...component ? { component } : {},
+      ...props ? { props } : {}
+    };
+  }
+  if (frame.type === "artifact_complete") return { ...existing, status: "complete" };
+  return void 0;
+}
+function readTurnId(msg) {
+  return typeof msg.turnId === "string" && msg.turnId ? msg.turnId : null;
+}
 var VoiceClient = class {
   constructor(options) {
     this.options = options;
@@ -171,6 +220,16 @@ var VoiceClient = class {
   stoppedResponse = false;
   responseEnded = true;
   hasPendingAudio = false;
+  /**
+   * The assistant entry built from clause captions for the turn being spoken. The
+   * authoritative transcript replaces it; a stop commits it, because it captions
+   * audio the caller already heard.
+   */
+  pendingAssistant = null;
+  /** Turn whose clause captions were already committed by a stop, so its authoritative text is redundant. */
+  committedAssistantTurnId = null;
+  activeTurnId = null;
+  suppressedArtifactTurnId = null;
   getSnapshot = () => this.snapshot;
   subscribe = (listener) => {
     this.listeners.add(listener);
@@ -192,7 +251,7 @@ var VoiceClient = class {
     if (this.snapshot.status !== "idle" && this.snapshot.status !== "error") return;
     this.cleanup();
     const generation = this.generation;
-    this.update({ ...initialSnapshot(), status: "connecting" });
+    this.update({ ...initialSnapshot(), session: this.snapshot.session, status: "connecting" });
     try {
       const token = tokenOverride ?? (typeof this.options.clientToken === "function" ? await this.options.clientToken() : this.options.clientToken);
       if (generation !== this.generation) return;
@@ -207,6 +266,20 @@ var VoiceClient = class {
       url.pathname = `${basePath}/ws/agents/${encodeURIComponent(this.options.agentId)}/voice`;
       url.search = "";
       url.searchParams.set("voiceProtocol", "runtype-browser-v1");
+      const capabilities = this.options.artifacts ? "partial_transcript,artifacts" : "partial_transcript";
+      url.searchParams.set("clientCapabilities", capabilities);
+      const sessionId = this.options.sessionId ?? this.snapshot.session?.sessionId;
+      if (sessionId) url.searchParams.set("sessionId", sessionId);
+      const visitorToken = typeof this.options.visitorToken === "function" ? await this.options.visitorToken() : this.options.visitorToken;
+      if (generation !== this.generation) return;
+      if (this.options.visitorToken !== void 0 && !visitorToken) {
+        throw new Error(
+          "Voice visitor credential unavailable. Initialize the client session first."
+        );
+      }
+      if (visitorToken && !/^cvt_[A-Za-z0-9_-]+$/.test(visitorToken)) {
+        throw new Error("Invalid voice visitor credential.");
+      }
       url.hash = "";
       const stream = await navigator.mediaDevices.getUserMedia({
         audio: { sampleRate: CAPTURE_SAMPLE_RATE, channelCount: 1, echoCancellation: true }
@@ -230,7 +303,11 @@ var VoiceClient = class {
         return;
       }
       this.player = player;
-      const socket = new WebSocket(url.toString(), ["runtype.bearer", token]);
+      const socket = new WebSocket(url.toString(), [
+        "runtype.bearer",
+        token,
+        ...visitorToken ? [visitorToken] : []
+      ]);
       socket.binaryType = "arraybuffer";
       this.socket = socket;
       socket.onopen = () => {
@@ -261,6 +338,11 @@ var VoiceClient = class {
     this.cleanup();
     this.update({ status: "idle", interimTranscript: null, audioLevel: 0, isMuted: false });
   };
+  /** Forget the remembered conversation so the next startCall opens a new one. No-op during a call. */
+  resetSession = () => {
+    if (this.snapshot.status !== "idle" && this.snapshot.status !== "error") return;
+    this.update({ session: null });
+  };
   toggleMute = () => {
     this.update({ isMuted: !this.snapshot.isMuted, audioLevel: 0 });
   };
@@ -275,9 +357,11 @@ var VoiceClient = class {
     this.clearPlayback();
     if (this.snapshot.interruptionMode === "none") {
       this.stoppedResponse = !this.responseEnded;
+      this.commitClauseCaptions();
       this.setStatus("listening");
       return;
     }
+    this.suppressedArtifactTurnId = this.activeTurnId;
     this.awaitingClear = true;
     this.setStatus("listening");
     this.socket.send(JSON.stringify({ type: "cancel" }));
@@ -319,6 +403,82 @@ var VoiceClient = class {
     this.awaitingClear = false;
     this.stoppedResponse = false;
     this.responseEnded = true;
+    this.commitClauseCaptions();
+    this.committedAssistantTurnId = null;
+    this.activeTurnId = null;
+    this.suppressedArtifactTurnId = null;
+    const settledArtifacts = this.snapshot.artifacts.filter(
+      (artifact) => artifact.status === "complete"
+    );
+    if (settledArtifacts.length !== this.snapshot.artifacts.length)
+      this.update({ artifacts: settledArtifacts });
+  }
+  /**
+   * Folds an `artifact` message into the snapshot. Frames of a turn the caller
+   * cancelled are dropped; a playback-only stop leaves the turn running, so its
+   * artifacts keep arriving and are kept.
+   */
+  applyArtifactMessage(msg) {
+    if (this.awaitingClear) return;
+    const frame = msg.event;
+    if (!frame || typeof frame !== "object" || Array.isArray(frame)) return;
+    const event = frame;
+    const id = readString(event.id);
+    if (!id) return;
+    const turnId = readTurnId(msg);
+    if (turnId !== null && turnId === this.suppressedArtifactTurnId) return;
+    if (turnId !== null) this.activeTurnId = turnId;
+    const artifacts = this.snapshot.artifacts;
+    const index = artifacts.findIndex((artifact) => artifact.id === id);
+    const executionId = readString(msg.executionId);
+    const next = applyArtifactFrame(index === -1 ? void 0 : artifacts[index], event, {
+      id,
+      turnId,
+      ...executionId ? { executionId } : {}
+    });
+    if (!next) return;
+    this.update({
+      artifacts: index === -1 ? [...artifacts, next] : [...artifacts.slice(0, index), next, ...artifacts.slice(index + 1)]
+    });
+  }
+  /** Settles the spoken clauses in place and ends the turn's claim on them. */
+  commitClauseCaptions() {
+    this.committedAssistantTurnId = this.pendingAssistant?.turnId ?? null;
+    const settled = this.pendingAssistant !== null;
+    this.pendingAssistant = null;
+    if (!settled) return;
+    const transcript = this.snapshot.transcript;
+    const last = transcript[transcript.length - 1];
+    if (last?.role !== "assistant" || last.partial !== true) return;
+    const { partial: _partial, ...committed } = last;
+    this.update({ transcript: [...transcript.slice(0, -1), committed] });
+  }
+  /** Extends the turn's spoken-so-far assistant entry, or opens one for a new turn. */
+  appendClauseCaption(text, turnId) {
+    const transcript = this.snapshot.transcript;
+    const last = transcript[transcript.length - 1];
+    if (this.pendingAssistant?.turnId === turnId && last?.role === "assistant") {
+      return {
+        interimTranscript: null,
+        transcript: [...transcript.slice(0, -1), { ...last, content: last.content + text }],
+        status: "speaking"
+      };
+    }
+    this.pendingAssistant = { turnId };
+    return {
+      interimTranscript: null,
+      transcript: [
+        ...transcript,
+        {
+          role: "assistant",
+          content: text,
+          timestamp: Date.now(),
+          partial: true,
+          ...turnId ? { turnId } : {}
+        }
+      ],
+      status: "speaking"
+    };
   }
   clearPlayback() {
     this.playbackRevision += 1;
@@ -353,32 +513,61 @@ var VoiceClient = class {
       return;
     }
     switch (msg.type) {
-      case "session_config":
+      case "session_config": {
         if (msg.interruptionMode === "none" || msg.interruptionMode === "cancel" || msg.interruptionMode === "barge-in") {
           this.update({ interruptionMode: msg.interruptionMode });
         }
+        const sessionId = readString(msg.sessionId);
+        const conversationId = readString(msg.conversationId);
+        if (sessionId && conversationId) {
+          const session = { sessionId, conversationId };
+          this.update({ session });
+          this.options.onSession?.(session);
+        }
+        break;
+      }
+      case "artifact":
+        this.applyArtifactMessage(msg);
         break;
       case "transcript_interim":
         this.update({ interimTranscript: typeof msg.text === "string" ? msg.text || null : null });
         break;
-      case "transcript_final":
+      case "transcript_partial": {
+        if (msg.role !== "assistant" || typeof msg.text !== "string" || !msg.text) break;
+        this.activeTurnId = readTurnId(msg) ?? this.activeTurnId;
+        if (this.awaitingClear || this.stoppedResponse) break;
+        this.responseEnded = false;
+        this.update(this.appendClauseCaption(msg.text, readTurnId(msg)));
+        break;
+      }
+      case "transcript_final": {
         if (typeof msg.text !== "string" || msg.role !== "user" && msg.role !== "assistant") break;
-        if (msg.role === "assistant" && (this.awaitingClear || this.stoppedResponse)) break;
+        const role = msg.role;
+        const text = msg.text;
+        if (role === "assistant" && (this.awaitingClear || this.stoppedResponse)) break;
+        const turnId = readTurnId(msg);
+        if (turnId !== null) this.activeTurnId = turnId;
+        if (role === "assistant" && turnId !== null && turnId === this.committedAssistantTurnId)
+          break;
         this.responseEnded = false;
+        const transcript = this.snapshot.transcript;
+        const last = transcript[transcript.length - 1];
+        const supersedes = role === "assistant" && this.pendingAssistant !== null && last?.role === "assistant" && (turnId === null || this.pendingAssistant.turnId === null || this.pendingAssistant.turnId === turnId);
+        this.pendingAssistant = null;
+        const entry = {
+          role,
+          content: text,
+          // INVARIANT: reuse the caption's timestamp so a keyed list does not remount the bubble.
+          timestamp: supersedes && last ? last.timestamp : Date.now(),
+          ...turnId ? { turnId } : {}
+        };
         this.update({
           interimTranscript: null,
-          transcript: [
-            ...this.snapshot.transcript,
-            {
-              role: msg.role,
-              content: msg.text,
-              timestamp: Date.now(),
-              ...typeof msg.turnId === "string" && msg.turnId ? { turnId: msg.turnId } : {}
-            }
-          ],
-          status: this.awaitingClear ? this.snapshot.status : msg.role === "user" ? "thinking" : "speaking"
+          transcript: supersedes ? [...transcript.slice(0, -1), entry] : [...transcript, entry],
+          status: this.awaitingClear ? this.snapshot.status : role === "user" ? "thinking" : "speaking"
         });
         break;
+      }
       case "audio_end": {
         this.responseEnded = true;
         if (this.stoppedResponse) {
@@ -395,10 +584,12 @@ var VoiceClient = class {
         break;
       }
       case "audio_clear":
+        this.suppressedArtifactTurnId = this.activeTurnId ?? this.suppressedArtifactTurnId;
         this.clearPlayback();
         this.awaitingClear = false;
         this.stoppedResponse = false;
         this.responseEnded = true;
+        this.commitClauseCaptions();
         this.setStatus("listening");
         break;
       case "metrics": {
@@ -411,8 +602,11 @@ var VoiceClient = class {
             // @snake-case-ok: Existing voice wire contract.
             firstAudioMs: number(msg.first_audio_ms),
             // @snake-case-ok: Existing voice wire contract.
-            totalMs: number(msg.total_ms)
+            totalMs: number(msg.total_ms),
+            // @snake-case-ok: Existing voice wire contract.
+            firstSynthesisMs: number(msg.first_synthesis_ms),
             // @snake-case-ok: Existing voice wire contract.
+            incremental: msg.incremental === true
           }
         });
         break;
@@ -467,25 +661,68 @@ var VoiceClient = class {
 };
 
 // src/react.ts
-function useVoiceClient({ agentId, apiUrl, clientToken }) {
+function useVoiceClient({
+  agentId,
+  apiUrl,
+  clientToken,
+  artifacts,
+  sessionId,
+  visitorToken,
+  onSession
+}) {
+  const sessionRef = useRef(sessionId);
+  useEffect(() => {
+    sessionRef.current = sessionId;
+  }, [sessionId]);
   const tokenRef = useRef(clientToken);
+  const visitorRef = useRef(visitorToken);
+  const sessionCallbackRef = useRef(onSession);
+  useEffect(() => {
+    visitorRef.current = visitorToken;
+    sessionCallbackRef.current = onSession;
+  }, [visitorToken, onSession]);
   useEffect(() => {
     tokenRef.current = clientToken;
   }, [clientToken]);
-  const client = useMemo(
-    () => new VoiceClient({
+  const createClient = () => new VoiceClient({
+    agentId,
+    apiUrl,
+    artifacts,
+    get sessionId() {
+      return sessionRef.current;
+    },
+    get visitorToken() {
+      return visitorRef.current;
+    },
+    onSession: (session) => sessionCallbackRef.current?.(session),
+    clientToken: () => typeof tokenRef.current === "function" ? tokenRef.current() : tokenRef.current
+  });
+  const [binding, setBinding] = useState(() => ({
+    agentId,
+    apiUrl,
+    artifacts,
+    sessionId,
+    client: createClient()
+  }));
+  const configurationChanged = binding.agentId !== agentId || binding.apiUrl !== apiUrl || binding.artifacts !== artifacts;
+  if (configurationChanged || binding.sessionId !== sessionId) {
+    const acknowledgesSession = sessionId !== void 0 && sessionId === binding.client.getSnapshot().session?.sessionId;
+    setBinding({
       agentId,
       apiUrl,
-      clientToken: () => typeof tokenRef.current === "function" ? tokenRef.current() : tokenRef.current
-    }),
-    [agentId, apiUrl]
-  );
+      artifacts,
+      sessionId,
+      client: !configurationChanged && acknowledgesSession ? binding.client : createClient()
+    });
+  }
+  const client = binding.client;
   const snapshot = useSyncExternalStore(client.subscribe, client.getSnapshot, client.getSnapshot);
   useEffect(() => () => client.endCall(), [client]);
   return {
     ...snapshot,
     startCall: client.startCall,
     endCall: client.endCall,
+    resetSession: client.resetSession,
     toggleMute: client.toggleMute,
     cancelResponse: client.cancelResponse
   };

package/dist/types-DaXyPeiV.d.cts

@@ -0,0 +1,95 @@
+type VoiceStatus = 'idle' | 'connecting' | 'listening' | 'thinking' | 'speaking' | 'error';
+type InterruptionMode = 'none' | 'cancel' | 'barge-in';
+interface TranscriptEntry {
+    readonly role: 'user' | 'assistant';
+    readonly content: string;
+    readonly timestamp: number;
+    readonly turnId?: string;
+    /**
+     * The reply is still being spoken, so `content` holds the clauses committed so
+     * far. A later snapshot replaces this entry with the authoritative transcript,
+     * or clears the flag in place when the caller stops the reply.
+     */
+    readonly partial?: boolean;
+}
+interface VoiceMetrics {
+    readonly llmMs?: number;
+    readonly ttsMs?: number;
+    readonly firstAudioMs?: number;
+    readonly totalMs?: number;
+    /**
+     * Turn start to the first synthesis request. Below `llmMs` when the engine spoke
+     * clauses while the reply was still generating, and equal to it otherwise.
+     */
+    readonly firstSynthesisMs?: number;
+    /** True when the reply was synthesized clause by clause, so `ttsMs` covers overlapped work. */
+    readonly incremental?: boolean;
+}
+/** File metadata for a previewable artifact, mirroring the unified `artifact_start.file` field. */
+interface VoiceArtifactFile {
+    readonly path: string;
+    readonly mimeType: string;
+    readonly language?: string;
+}
+/**
+ * An artifact the agent produced during a call, assembled from the additive
+ * `artifact` wire message. Artifacts arrive beside speech and are never spoken.
+ */
+interface VoiceArtifact {
+    readonly id: string;
+    readonly turnId: string | null;
+    readonly executionId?: string;
+    readonly artifactType: 'markdown' | 'component';
+    readonly title?: string;
+    readonly file?: VoiceArtifactFile;
+    readonly content: string;
+    readonly component?: string;
+    readonly props?: Record<string, unknown>;
+    readonly status: 'streaming' | 'complete';
+}
+/** The conversation this call is attached to, reported by the server once the call opens. */
+interface VoiceSession {
+    readonly sessionId: string;
+    readonly conversationId: string;
+}
+interface VoiceSnapshot {
+    readonly status: VoiceStatus;
+    readonly transcript: readonly TranscriptEntry[];
+    readonly interimTranscript: string | null;
+    readonly metrics: VoiceMetrics | null;
+    readonly audioLevel: number;
+    readonly isMuted: boolean;
+    readonly error: string | null;
+    readonly errorDetails?: {
+        code: string;
+        serverId?: string;
+        serverName: string;
+        diagnosticId: string;
+    };
+    readonly interruptionMode: InterruptionMode;
+    readonly canCancel: boolean;
+    readonly artifacts: readonly VoiceArtifact[];
+    /** Survives `endCall` so a host can reopen the same conversation; null until the server reports it. */
+    readonly session: VoiceSession | null;
+}
+interface VoiceClientOptions {
+    agentId: string;
+    /** Browser client token, or a getter called once per call to obtain a fresh token. */
+    clientToken: string | (() => string | Promise<string>);
+    /** Absolute API base URL, including any proxy path prefix. Defaults to https://api.runtype.com. */
+    apiUrl?: string;
+    /**
+     * Declares the `artifacts` capability, so the server sends `artifact` messages
+     * and the client assembles `snapshot.artifacts`. Off by default, which keeps an
+     * existing embed's wire byte-identical.
+     */
+    artifacts?: boolean;
+    /** Reuses an existing client session's conversation. Overrides the id remembered from a previous call. */
+    sessionId?: string;
+    /** Proof minted by client/init; resolve from the host's token-scoped visitor store on every call. */
+    visitorToken?: string | (() => string | undefined | Promise<string | undefined>);
+    /** Observe the server's conversation so a host can reuse it for text. Never contains visitor credentials. */
+    onSession?: (session: VoiceSession) => void;
+}
+
+export type { InterruptionMode as I, TranscriptEntry as T, VoiceClientOptions as V, VoiceSnapshot as a, VoiceArtifact as b, VoiceArtifactFile as c, VoiceMetrics as d, VoiceSession as e, VoiceStatus as f };

package/dist/types-DaXyPeiV.d.ts

@@ -0,0 +1,95 @@
+type VoiceStatus = 'idle' | 'connecting' | 'listening' | 'thinking' | 'speaking' | 'error';
+type InterruptionMode = 'none' | 'cancel' | 'barge-in';
+interface TranscriptEntry {
+    readonly role: 'user' | 'assistant';
+    readonly content: string;
+    readonly timestamp: number;
+    readonly turnId?: string;
+    /**
+     * The reply is still being spoken, so `content` holds the clauses committed so
+     * far. A later snapshot replaces this entry with the authoritative transcript,
+     * or clears the flag in place when the caller stops the reply.
+     */
+    readonly partial?: boolean;
+}
+interface VoiceMetrics {
+    readonly llmMs?: number;
+    readonly ttsMs?: number;
+    readonly firstAudioMs?: number;
+    readonly totalMs?: number;
+    /**
+     * Turn start to the first synthesis request. Below `llmMs` when the engine spoke
+     * clauses while the reply was still generating, and equal to it otherwise.
+     */
+    readonly firstSynthesisMs?: number;
+    /** True when the reply was synthesized clause by clause, so `ttsMs` covers overlapped work. */
+    readonly incremental?: boolean;
+}
+/** File metadata for a previewable artifact, mirroring the unified `artifact_start.file` field. */
+interface VoiceArtifactFile {
+    readonly path: string;
+    readonly mimeType: string;
+    readonly language?: string;
+}
+/**
+ * An artifact the agent produced during a call, assembled from the additive
+ * `artifact` wire message. Artifacts arrive beside speech and are never spoken.
+ */
+interface VoiceArtifact {
+    readonly id: string;
+    readonly turnId: string | null;
+    readonly executionId?: string;
+    readonly artifactType: 'markdown' | 'component';
+    readonly title?: string;
+    readonly file?: VoiceArtifactFile;
+    readonly content: string;
+    readonly component?: string;
+    readonly props?: Record<string, unknown>;
+    readonly status: 'streaming' | 'complete';
+}
+/** The conversation this call is attached to, reported by the server once the call opens. */
+interface VoiceSession {
+    readonly sessionId: string;
+    readonly conversationId: string;
+}
+interface VoiceSnapshot {
+    readonly status: VoiceStatus;
+    readonly transcript: readonly TranscriptEntry[];
+    readonly interimTranscript: string | null;
+    readonly metrics: VoiceMetrics | null;
+    readonly audioLevel: number;
+    readonly isMuted: boolean;
+    readonly error: string | null;
+    readonly errorDetails?: {
+        code: string;
+        serverId?: string;
+        serverName: string;
+        diagnosticId: string;
+    };
+    readonly interruptionMode: InterruptionMode;
+    readonly canCancel: boolean;
+    readonly artifacts: readonly VoiceArtifact[];
+    /** Survives `endCall` so a host can reopen the same conversation; null until the server reports it. */
+    readonly session: VoiceSession | null;
+}
+interface VoiceClientOptions {
+    agentId: string;
+    /** Browser client token, or a getter called once per call to obtain a fresh token. */
+    clientToken: string | (() => string | Promise<string>);
+    /** Absolute API base URL, including any proxy path prefix. Defaults to https://api.runtype.com. */
+    apiUrl?: string;
+    /**
+     * Declares the `artifacts` capability, so the server sends `artifact` messages
+     * and the client assembles `snapshot.artifacts`. Off by default, which keeps an
+     * existing embed's wire byte-identical.
+     */
+    artifacts?: boolean;
+    /** Reuses an existing client session's conversation. Overrides the id remembered from a previous call. */
+    sessionId?: string;
+    /** Proof minted by client/init; resolve from the host's token-scoped visitor store on every call. */
+    visitorToken?: string | (() => string | undefined | Promise<string | undefined>);
+    /** Observe the server's conversation so a host can reuse it for text. Never contains visitor credentials. */
+    onSession?: (session: VoiceSession) => void;
+}
+
+export type { InterruptionMode as I, TranscriptEntry as T, VoiceClientOptions as V, VoiceSnapshot as a, VoiceArtifact as b, VoiceArtifactFile as c, VoiceMetrics as d, VoiceSession as e, VoiceStatus as f };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@runtypelabs/voice",
-  "version": "0.2.3",
+  "version": "0.3.0",
   "description": "Runtype browser voice client with React and Persona adapters",
   "type": "module",
   "license": "MIT",
@@ -30,14 +30,6 @@
     "README.md",
     "LICENSE"
   ],
-  "scripts": {
-    "build": "tsup",
-    "dev": "tsup --watch",
-    "test": "vitest run",
-    "typecheck": "tsgo --noEmit",
-    "lint": "eslint .",
-    "prepublishOnly": "pnpm build"
-  },
   "peerDependencies": {
     "react": ">=18 <20",
     "@runtypelabs/persona": ">=4.22.0 <5"
@@ -69,5 +61,12 @@
   },
   "publishConfig": {
     "access": "public"
+  },
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "test": "vitest run",
+    "typecheck": "tsgo --noEmit",
+    "lint": "eslint ."
   }
-}
+}

package/dist/types-9SfA7oHc.d.cts

@@ -1,40 +0,0 @@
-type VoiceStatus = 'idle' | 'connecting' | 'listening' | 'thinking' | 'speaking' | 'error';
-type InterruptionMode = 'none' | 'cancel' | 'barge-in';
-interface TranscriptEntry {
-    readonly role: 'user' | 'assistant';
-    readonly content: string;
-    readonly timestamp: number;
-    readonly turnId?: string;
-}
-interface VoiceMetrics {
-    readonly llmMs?: number;
-    readonly ttsMs?: number;
-    readonly firstAudioMs?: number;
-    readonly totalMs?: number;
-}
-interface VoiceSnapshot {
-    readonly status: VoiceStatus;
-    readonly transcript: readonly TranscriptEntry[];
-    readonly interimTranscript: string | null;
-    readonly metrics: VoiceMetrics | null;
-    readonly audioLevel: number;
-    readonly isMuted: boolean;
-    readonly error: string | null;
-    readonly errorDetails?: {
-        code: string;
-        serverId?: string;
-        serverName: string;
-        diagnosticId: string;
-    };
-    readonly interruptionMode: InterruptionMode;
-    readonly canCancel: boolean;
-}
-interface VoiceClientOptions {
-    agentId: string;
-    /** Browser client token, or a getter called once per call to obtain a fresh token. */
-    clientToken: string | (() => string | Promise<string>);
-    /** Absolute API base URL, including any proxy path prefix. Defaults to https://api.runtype.com. */
-    apiUrl?: string;
-}
-
-export type { InterruptionMode as I, TranscriptEntry as T, VoiceClientOptions as V, VoiceSnapshot as a, VoiceMetrics as b, VoiceStatus as c };