@runtypelabs/persona 1.47.0 → 2.0.0

package/src/session.ts

@@ -10,7 +10,9 @@ import {
   InjectMessageOptions,
   InjectAssistantMessageOptions,
   InjectUserMessageOptions,
-  InjectSystemMessageOptions
+  InjectSystemMessageOptions,
+  PersonaArtifactRecord,
+  PersonaArtifactManualUpsert
 } from "./types";
 import {
   generateUserMessageId,
@@ -19,14 +21,12 @@ import {
 import { IMAGE_ONLY_MESSAGE_FALLBACK_TEXT } from "./utils/content";
 import type {
   VoiceProvider,
-  VoiceResult,
   VoiceStatus,
   VoiceConfig,
   TextToSpeechConfig
 } from "./types";
 import {
   createVoiceProvider,
-  createBestAvailableVoiceProvider,
   isVoiceSupported
 } from "./voice";
 
@@ -42,6 +42,10 @@ type SessionCallbacks = {
   onStreamingChanged: (streaming: boolean) => void;
   onError?: (error: Error) => void;
   onVoiceStatusChanged?: (status: VoiceStatus) => void;
+  onArtifactsState?: (state: {
+    artifacts: PersonaArtifactRecord[];
+    selectedId: string | null;
+  }) => void;
 };
 
 export class AgentWidgetSession {
@@ -58,6 +62,9 @@ export class AgentWidgetSession {
   // Agent execution state
   private agentExecution: AgentExecutionState | null = null;
 
+  private artifacts = new Map<string, PersonaArtifactRecord>();
+  private selectedArtifactId: string | null = null;
+
   // Voice support
   private voiceProvider: VoiceProvider | null = null;
   private voiceActive = false;
@@ -136,6 +143,38 @@ export class AgentWidgetSession {
     return this.voiceStatus;
   }
 
+  /**
+   * Get the voice interruption mode from the provider (none/cancel/barge-in)
+   */
+  public getVoiceInterruptionMode(): "none" | "cancel" | "barge-in" {
+    if (this.voiceProvider?.getInterruptionMode) {
+      return this.voiceProvider.getInterruptionMode();
+    }
+    return "none";
+  }
+
+  /**
+   * Stop voice playback / cancel in-flight request without starting recording.
+   * Returns to idle state.
+   */
+  public stopVoicePlayback(): void {
+    if (this.voiceProvider?.stopPlayback) {
+      this.voiceProvider.stopPlayback();
+    }
+  }
+
+  /** Returns true if the barge-in mic stream is alive (hot mic between turns) */
+  public isBargeInActive(): boolean {
+    return this.voiceProvider?.isBargeInActive?.() ?? false;
+  }
+
+  /** Tear down the barge-in mic pipeline — "hang up" the always-on mic */
+  public async deactivateBargeIn(): Promise<void> {
+    if (this.voiceProvider?.deactivateBargeIn) {
+      await this.voiceProvider.deactivateBargeIn();
+    }
+  }
+
   // Pending placeholder IDs for Runtype two-phase voice flow
   private pendingVoiceUserMessageId: string | null = null;
   private pendingVoiceAssistantMessageId: string | null = null;
@@ -227,9 +266,12 @@ export class AgentWidgetSession {
             this.injectAssistantMessage({ content: result.text.trim() });
           }
 
-          // If Runtype provider returned audio (server-side TTS), mark the
-          // assistant message as already spoken so browser TTS doesn't double-speak
-          if (result.audio?.base64) {
+          // Mark assistant message as already spoken so browser TTS doesn't
+          // double-speak. This covers both paths:
+          //   - Batch: audio.base64 is present in the voice_response
+          //   - Streaming: audio arrives as binary PCM chunks (no base64 here)
+          // In either case, the Runtype provider handles TTS — browser TTS must skip.
+          {
             const spokenId = this.pendingVoiceAssistantMessageId
               ?? [...this.messages].reverse().find(m => m.role === 'assistant')?.id;
             if (spokenId) this.ttsSpokenMessageIds.add(spokenId);
@@ -939,11 +981,128 @@ export class AgentWidgetSession {
     this.abortController = null;
     this.messages = [];
     this.agentExecution = null;
+    this.clearArtifactState();
     this.setStreaming(false);
     this.setStatus("idle");
     this.callbacks.onMessagesChanged([...this.messages]);
   }
 
+  public getArtifacts(): PersonaArtifactRecord[] {
+    return [...this.artifacts.values()];
+  }
+
+  public getArtifactById(id: string): PersonaArtifactRecord | undefined {
+    return this.artifacts.get(id);
+  }
+
+  public getSelectedArtifactId(): string | null {
+    return this.selectedArtifactId;
+  }
+
+  public selectArtifact(id: string | null): void {
+    this.selectedArtifactId = id;
+    this.emitArtifactsState();
+  }
+
+  public clearArtifacts(): void {
+    this.clearArtifactState();
+  }
+
+  public upsertArtifact(manual: PersonaArtifactManualUpsert): PersonaArtifactRecord {
+    const id =
+      manual.id ||
+      `art_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 9)}`;
+    if (manual.artifactType === "markdown") {
+      const rec: PersonaArtifactRecord = {
+        id,
+        artifactType: "markdown",
+        title: manual.title,
+        status: "complete",
+        markdown: manual.content
+      };
+      this.artifacts.set(id, rec);
+      this.selectedArtifactId = id;
+      this.emitArtifactsState();
+      return rec;
+    }
+    const rec: PersonaArtifactRecord = {
+      id,
+      artifactType: "component",
+      title: manual.title,
+      status: "complete",
+      component: manual.component,
+      props: manual.props ?? {}
+    };
+    this.artifacts.set(id, rec);
+    this.selectedArtifactId = id;
+    this.emitArtifactsState();
+    return rec;
+  }
+
+  private clearArtifactState(): void {
+    if (this.artifacts.size === 0 && this.selectedArtifactId === null) return;
+    this.artifacts.clear();
+    this.selectedArtifactId = null;
+    this.emitArtifactsState();
+  }
+
+  private emitArtifactsState(): void {
+    this.callbacks.onArtifactsState?.({
+      artifacts: [...this.artifacts.values()],
+      selectedId: this.selectedArtifactId
+    });
+  }
+
+  private applyArtifactStreamEvent(ev: AgentWidgetEvent): void {
+    switch (ev.type) {
+      case "artifact_start": {
+        if (ev.artifactType === "markdown") {
+          this.artifacts.set(ev.id, {
+            id: ev.id,
+            artifactType: "markdown",
+            title: ev.title,
+            status: "streaming",
+            markdown: ""
+          });
+        } else {
+          this.artifacts.set(ev.id, {
+            id: ev.id,
+            artifactType: "component",
+            title: ev.title,
+            status: "streaming",
+            component: ev.component ?? "",
+            props: {}
+          });
+        }
+        this.selectedArtifactId = ev.id;
+        break;
+      }
+      case "artifact_delta": {
+        const row = this.artifacts.get(ev.id);
+        if (row?.artifactType === "markdown") {
+          row.markdown = (row.markdown ?? "") + ev.artDelta;
+        }
+        break;
+      }
+      case "artifact_update": {
+        const row = this.artifacts.get(ev.id);
+        if (row?.artifactType === "component") {
+          row.props = { ...row.props, ...ev.props };
+          if (ev.component) row.component = ev.component;
+        }
+        break;
+      }
+      case "artifact_complete": {
+        const row = this.artifacts.get(ev.id);
+        if (row) row.status = "complete";
+        break;
+      }
+      default:
+        return;
+    }
+    this.emitArtifactsState();
+  }
+
   public hydrateMessages(messages: AgentWidgetMessage[]) {
     this.abortController?.abort();
     this.abortController = null;
@@ -972,7 +1131,7 @@ export class AgentWidgetSession {
             agentName: event.message.agentMetadata.agentName ?? '',
             status: 'running',
             currentIteration: event.message.agentMetadata.iteration ?? 0,
-            maxIterations: 0
+            maxTurns: 0
           };
         } else if (event.message.agentMetadata.iteration !== undefined) {
           this.agentExecution.currentIteration = event.message.agentMetadata.iteration;
@@ -998,6 +1157,13 @@ export class AgentWidgetSession {
         this.agentExecution.status = 'error';
       }
       this.callbacks.onError?.(event.error);
+    } else if (
+      event.type === "artifact_start" ||
+      event.type === "artifact_delta" ||
+      event.type === "artifact_update" ||
+      event.type === "artifact_complete"
+    ) {
+      this.applyArtifactStreamEvent(event);
     }
   };
 

package/src/styles/tailwind.css

@@ -14,7 +14,7 @@
 }
 
 @layer components {
-  .tvw-widget-shadow {
+  .persona-widget-shadow {
     box-shadow: 0 25px 50px -12px rgba(15, 23, 42, 0.35);
   }
 }