@pouchy_ai/companion-sdk 0.40.1 → 0.42.0

package/src/client.ts

@@ -221,6 +221,12 @@ export type CallCredentials =
 			/** First-message override ('' = suppress the canned greeting so the call
 			 *  opens in-character / context-aware). Pass as overrides.agent.firstMessage. */
 			firstMessage?: string;
+			/** Generation handle of the call-active window this mint stamped (0.41.0).
+			 *  Self-plumbed integrations: pass it to endSession({ callGen }) at call
+			 *  end so the server clears exactly this call's window — a stale handle's
+			 *  late teardown then can't clear a newer call's window. connectCall()
+			 *  handles this automatically. */
+			callGen?: string;
 	  }
 	| {
 			provider: 'openai-realtime';
@@ -229,6 +235,8 @@ export type CallCredentials =
 			model: string;
 			voice: string;
 			expiresAt: number | null;
+			/** See the elevenlabs-convai branch — same window-generation handle. */
+			callGen?: string;
 	  };
 
 export interface RecalledMemory {
@@ -460,6 +468,12 @@ export class CompanionClient {
 	private readonly doFetch: typeof fetch;
 	private _session: string | null = null;
 	private cursor = 0;
+	/** Generation handle of the last call-active window THIS client minted
+	 *  (startCall → server callGen, 0.41.0). endSession sends it by default so
+	 *  the server's window clear is fenced to our own call — and sends an
+	 *  explicit null when this client never minted one, so a text client's
+	 *  close() can no longer kill a live call's window on the same session. */
+	private lastCallGen: string | null = null;
 	/** Pause-orphaned call replay fired (0.37.0) — once per client instance, so
 	 *  a manual second connect() can't double-deliver to a live handler. */
 	private replayedPendingToolCalls = false;
@@ -1442,7 +1456,13 @@ export class CompanionClient {
 	async sendWorldState(
 		event: WorldStateInput | WorldStateInput[],
 		opts?: { signal?: AbortSignal }
-	): Promise<{ accepted: number; dropped: number; injected: number; reacted: boolean }> {
+	): Promise<{
+		accepted: number;
+		dropped: number;
+		injected: number;
+		reacted: boolean;
+		duplicates: number;
+	}> {
 		const id = this.requireSession();
 		const fill = (e: WorldStateInput): WorldStateEvent => ({
 			...e,
@@ -1456,14 +1476,20 @@ export class CompanionClient {
 			dropped: number;
 			injected?: number;
 			reacted?: boolean;
+			duplicates?: number;
 		}>(`/api/companion/session/${id}/context`, body, opts?.signal);
 		// injected/reacted tell the host a live-call inject or a proactive text
 		// reaction was triggered by this batch (0.28.0 — previously discarded).
+		// duplicates (0.41.0) is how much of `accepted` was replay dedup: the
+		// server is envelope-id idempotent, so stamp stable `id`s on host-level
+		// retries and a re-sent batch folds nothing while reporting the same
+		// accepted count.
 		return {
 			accepted: json.accepted ?? 0,
 			dropped: json.dropped ?? 0,
 			injected: json.injected ?? 0,
-			reacted: json.reacted === true
+			reacted: json.reacted === true,
+			duplicates: json.duplicates ?? 0
 		};
 	}
 
@@ -1487,11 +1513,15 @@ export class CompanionClient {
 		opts?: { voice?: string; locale?: string; signal?: AbortSignal }
 	): Promise<CallCredentials> {
 		const id = this.requireSession();
-		return this.postJson<CallCredentials>(
+		const creds = await this.postJson<CallCredentials>(
 			`/api/companion/session/${id}/call`,
 			{ voice: opts?.voice, locale: opts?.locale },
 			opts?.signal
 		);
+		// Remember the minted window's generation so a later endSession()/close()
+		// (without an explicit callGen) fences its clear to OUR call (0.41.0).
+		this.lastCallGen = creds.callGen ?? null;
+		return creds;
 	}
 
 	/** Open a live voice call end-to-end: mints credentials (startCall) and opens a
@@ -1515,12 +1545,17 @@ export class CompanionClient {
 		// assigned after the call opens; a connect-phase onError finds the no-op.
 		let unsub: () => void = () => {};
 		let cleaned = false;
+		// Captured PER HANDLE at mint time (0.41.0): a second connectCall on this
+		// client overwrites lastCallGen, so the first handle's (possibly late)
+		// teardown must carry the gen of ITS OWN mint — the server then no-ops the
+		// clear instead of silencing the new call's window (CR-142 leg d).
+		let mintedGen: string | null = null;
 		const cleanup = () => {
 			if (cleaned) return;
 			cleaned = true;
 			unsub();
 			// Consolidate this call into durable memory (best-effort, keepalive).
-			void this.endSession({ transcript });
+			void this.endSession({ transcript, callGen: mintedGen });
 		};
 		const wrappedOpts: CompanionCallOptions = {
 			...opts,
@@ -1563,6 +1598,7 @@ export class CompanionClient {
 			: undefined;
 
 		const creds = await this.startCall({ voice: opts?.voice, locale: opts?.locale });
+		mintedGen = creds.callGen ?? null;
 		let call: CompanionCall;
 		try {
 			call = await openCompanionCall(creds, wrappedOpts, bridge);
@@ -1612,9 +1648,17 @@ export class CompanionClient {
 	 *  beacon — harmless). `facts` is how many memories were consolidated. */
 	async endSession(opts?: {
 		transcript?: { role: string; text: string }[];
+		/** Which call-active window this teardown owns (0.41.0). A string fences
+		 *  the server's window clear to that call's mint; `null` says "I hold no
+		 *  call — leave any live window alone". Defaults to the gen of the last
+		 *  call THIS client minted (null if none), so a text client's close() no
+		 *  longer kills a live call's window on the same session. Self-plumbed
+		 *  integrations pass startCall's `creds.callGen` here at call end. */
+		callGen?: string | null;
 	}): Promise<EndSessionResult | null> {
 		const id = this._session;
 		if (!id) return null;
+		const callGen = opts?.callGen !== undefined ? opts.callGen : this.lastCallGen;
 		// Cap the payload (fetch keepalive bodies are size-limited): last 60 lines.
 		const transcript = (opts?.transcript ?? [])
 			.filter((t) => t && typeof t.text === 'string' && t.text.trim())
@@ -1628,7 +1672,7 @@ export class CompanionClient {
 			const res = await this.fetchAuthed(this.url(`/api/companion/session/${id}/end`), {
 				method: 'POST',
 				headers: this.jsonHeaders(),
-				body: JSON.stringify({ transcript }),
+				body: JSON.stringify({ transcript, callGen }),
 				keepalive: true
 			});
 			return (await res.json().catch(() => null)) as EndSessionResult | null;

package/src/index.ts

@@ -91,6 +91,21 @@ export {
 } from './protocol';
 export type { CompanionErrorCode, ControlErrorCode } from './protocol';
 
+// Instant UI ⇄ Google A2UI v0.9 projection (0.42.0) — put `toA2UI` in front of
+// any renderer built against the A2UI catalog and it draws Pouchy panels;
+// `fromA2UI` ingests an A2UI surface back into the Instant UI panel shape.
+// The node-type catalog rides along as data for renderer capability checks.
+export { toA2UI, fromA2UI, INSTANT_UI_NODE_TYPES } from './a2ui';
+export type {
+	A2UISurface,
+	A2UIComponent,
+	A2UIValue,
+	InstantUIInput,
+	DynamicInterface,
+	GenuiNode,
+	EmbeddedAction
+} from './a2ui';
+
 // The framework-agnostic view controller behind the /svelte and /vue subpath
 // adapters (and the separate `@pouchy_ai/react` package) — exported from the
 // root too, so a host on any OTHER framework (or none) can reuse the same