@rimelabs/sdk 0.1.0-alpha.20 → 0.1.0-alpha.22

package/CHANGELOG.md

@@ -1,5 +1,36 @@
 # Changelog
 
+## [0.1.0-alpha.22](https://github.com/rimelabs/rime-sdk/compare/typescript-v0.1.0-alpha.21...typescript-v0.1.0-alpha.22) (2026-10-24)
+
+
+### ⚠ BREAKING CHANGES
+
+* Rust SessionInfo struct literals must add truncation: None. The optional field reports the policy published by the server.
+* Go Prism service faults now match ErrRealtime instead of ErrStream. Rust service faults now use ErrorKind::Realtime instead of Stream. Keep fault inspection for code, scope, and retry classification.
+
+### Features
+
+* add Prism conversation history operations ([#108](https://github.com/rimelabs/rime-sdk/issues/108)) ([1f33051](https://github.com/rimelabs/rime-sdk/commit/1f330517163cd521bd03321a0728295f84da0316))
+* add Prism history truncation controls ([#109](https://github.com/rimelabs/rime-sdk/issues/109)) ([b8b1aa1](https://github.com/rimelabs/rime-sdk/commit/b8b1aa172e69df650bfeda274bb91329f7e5bc52))
+
+
+### Bug Fixes
+
+* distinguish Prism faults and correct SDK release guidance ([#102](https://github.com/rimelabs/rime-sdk/issues/102)) ([b152abb](https://github.com/rimelabs/rime-sdk/commit/b152abb1ac4e5dabb92e747c04a6bc70aa72b60e))
+
+## [0.1.0-alpha.21](https://github.com/rimelabs/rime-sdk/compare/typescript-v0.1.0-alpha.20...typescript-v0.1.0-alpha.21) (2026-10-23)
+
+
+### ⚠ BREAKING CHANGES
+
+* Rust RealtimeSession::info returns an owned SessionInfo snapshot instead of a reference so cloned handles can read current settings.
+
+### Features
+
+* expose Prism error retry classification ([#99](https://github.com/rimelabs/rime-sdk/issues/99)) ([c04309c](https://github.com/rimelabs/rime-sdk/commit/c04309c174c2eed82df3b676581c45cab2a95db6))
+* **realtime:** request ids, reply labels, and the items a reply answers ([#95](https://github.com/rimelabs/rime-sdk/issues/95)) ([f33950b](https://github.com/rimelabs/rime-sdk/commit/f33950b2d0fdb960f4701c1a1ec208c0d539d5ec))
+* support mid-session Prism settings updates in all SDKs ([#101](https://github.com/rimelabs/rime-sdk/issues/101)) ([83f5347](https://github.com/rimelabs/rime-sdk/commit/83f534761418217292fbbce8dbdc47454ad5ddb8))
+
 ## [0.1.0-alpha.20](https://github.com/rimelabs/rime-sdk/compare/typescript-v0.1.0-alpha.19...typescript-v0.1.0-alpha.20) (2026-10-22)
 
 

package/README.md

@@ -324,6 +324,7 @@ See the [TTS guide](https://github.com/rimelabs/rime-sdk/blob/main/typescript/do
 for more examples. Visit [Rime documentation](https://docs.rime.ai/) for service
 information, or report SDK issues on [GitHub](https://github.com/rimelabs/rime-sdk/issues).
 Include the SDK version and the error's `requestId` when available; omit API keys.
+For Prism, include `session.info.requestId`.
 
 SDK code uses the [MIT license](LICENSE). The Prism protocol module uses
 [Apache 2.0](LICENSE-PRISM); see its [notices](NOTICE-PRISM).

package/dist/realtime/client.js

@@ -3,6 +3,8 @@ import { RimeCancelledError, RimeInputError, RimeUnavailableError, } from "../er
 import { cancellation, scope } from "./async.js";
 import { RealtimeSession } from "./session.js";
 import { RealtimeConnection } from "./transport.js";
+import { toolSettings } from "./settings.js";
+import { responseMetadata, truncationSettings } from "./protocol.js";
 const DEFAULT_ENDPOINT = "wss://prism.api.rime.ai/v1/realtime";
 function endpoint(value) {
     let url;
@@ -34,48 +36,6 @@ function timeouts(options = {}) {
         throw new RimeInputError("Timeouts must be finite and positive");
     return result;
 }
-/** Reject values that JSON.stringify would silently drop or change. */
-function copyJson(value) {
-    if (value === null || typeof value === "string" || typeof value === "boolean")
-        return value;
-    if (typeof value === "number" && Number.isFinite(value))
-        return value;
-    if (Array.isArray(value))
-        return Array.from(value, copyJson);
-    if (value &&
-        typeof value === "object" &&
-        [Object.prototype, null].includes(Object.getPrototypeOf(value)))
-        return Object.fromEntries(Object.entries(value).map(([key, item]) => [key, copyJson(item)]));
-    throw new RimeInputError("Tool schemas must contain finite JSON values");
-}
-function fillerSettings(value) {
-    if (!value || typeof value !== "object" || Array.isArray(value))
-        throw new RimeInputError("prismFiller must be a filler object");
-    const kind = value.type;
-    if (!["none", "text", "auto"].includes(kind))
-        throw new RimeInputError("Prism filler type must be none, text, or auto");
-    const field = kind === "text" ? "text" : kind === "auto" ? "instructions" : null;
-    if (Object.entries(value).some(([key, item]) => item !== undefined && key !== "type" && key !== field))
-        throw new RimeInputError("Prism filler has fields not allowed for its type");
-    const text = field === null ? undefined : value[field];
-    if (kind === "text" || text !== undefined) {
-        // Rust str::trim uses Unicode White_Space, which differs from JS trim.
-        if (typeof text !== "string" ||
-            !/\P{White_Space}/u.test(text) ||
-            [...text].length > 500)
-            throw new RimeInputError("Prism filler text must be nonblank and at most 500 characters");
-        // Unicode mode matches lone surrogates but preserves valid UTF-16 pairs.
-        if (/[\uD800-\uDFFF]/u.test(text))
-            throw new RimeInputError("Prism filler text must be valid UTF-8");
-    }
-    if (kind === "text")
-        return { type: "text", text: text };
-    if (kind === "auto")
-        return text === undefined
-            ? { type: "auto" }
-            : { type: "auto", instructions: text };
-    return { type: "none" };
-}
 export class Realtime {
     credentials;
     checkOpen;
@@ -94,47 +54,14 @@ export class Realtime {
         if (options.interruptOnSpeech !== undefined &&
             typeof options.interruptOnSpeech !== "boolean")
             throw new RimeInputError("interruptOnSpeech must be a boolean");
-        const names = new Set();
         const settings = {
             modalities: ["text", "audio"],
             input_audio_format: "pcm16",
             turn_detection: { interrupt_response: options.interruptOnSpeech ?? true },
-            tools: (options.tools ?? []).map((tool) => {
-                if (typeof tool.name !== "string" ||
-                    !tool.name.trim() ||
-                    names.has(tool.name))
-                    throw new RimeInputError("Tool names must be nonblank and unique");
-                names.add(tool.name);
-                if (!tool.parameters ||
-                    Array.isArray(tool.parameters) ||
-                    typeof tool.parameters !== "object" ||
-                    (tool.description !== undefined &&
-                        typeof tool.description !== "string"))
-                    throw new RimeInputError("Tool parameters must be a JSON object and description must be a string");
-                let parameters;
-                try {
-                    parameters = copyJson(tool.parameters);
-                }
-                catch {
-                    throw new RimeInputError("Tool schemas must contain finite JSON values");
-                }
-                if (parameters === null ||
-                    typeof parameters !== "object" ||
-                    Array.isArray(parameters))
-                    throw new RimeInputError("Tool parameters must be an object");
-                return {
-                    type: "function",
-                    ...(tool.prismFiller === undefined
-                        ? {}
-                        : { prism_filler: fillerSettings(tool.prismFiller) }),
-                    function: {
-                        name: tool.name,
-                        description: tool.description ?? "",
-                        parameters,
-                    },
-                };
-            }),
+            tools: toolSettings(options.tools ?? []),
         };
+        if (options.truncation !== undefined)
+            settings.truncation = truncationSettings(options.truncation);
         if (options.turnDetection !== undefined) {
             const detection = options.turnDetection;
             if (!detection ||
@@ -153,6 +80,14 @@ export class Realtime {
                 settings.turn_detection.prism_end_of_turn_timeout_ms = value;
             }
         }
+        if (options.responseMetadata != null)
+            settings.prism_response_metadata = responseMetadata(options.responseMetadata);
+        const requestId = options.requestId ?? undefined;
+        if (requestId !== undefined &&
+            (typeof requestId !== "string" ||
+                !requestId.trim() ||
+                !/^[\x20-\x7e]+$/.test(requestId)))
+            throw new RimeInputError("requestId must be nonblank printable ASCII");
         for (const name of ["voice", "instructions"]) {
             const value = options[name];
             if (value !== undefined && value !== null) {
@@ -170,7 +105,7 @@ export class Realtime {
                 openingScope.signal.throwIfAborted();
                 let socket;
                 try {
-                    socket = new RealtimeConnection(address, this.credentials.realtimeAuthorization());
+                    socket = new RealtimeConnection(address, this.credentials.realtimeAuthorization(), requestId);
                 }
                 catch {
                     throw new RimeUnavailableError("Realtime handshake failed");

package/dist/realtime/conversation.d.ts

@@ -1,5 +1,5 @@
 import type { RealtimeSession } from "./session.js";
-import type { AudioChunk, OutputRef, SessionEvent } from "./types.js";
+import type { AudioChunk, NormalizedRealtimeFault, OutputRef, SessionEvent } from "./types.js";
 export interface ConversationSource {
     /** Return one chunk, or null at EOF. Abort must release a pending read. */
     read(signal: AbortSignal): Promise<AudioChunk | null>;
@@ -34,7 +34,7 @@ export interface ConversationOptions {
     readonly playback: ConversationPlayback;
     /** Called inline for every event. Must be synchronous and nonblocking.
      * Scheduled application work remains the caller's responsibility. */
-    readonly onEvent?: (event: SessionEvent) => void;
+    readonly onEvent?: (event: SessionEvent<NormalizedRealtimeFault>) => void;
     readonly signal?: AbortSignal;
 }
 /** Run until input EOF, session closure, failure, or abort.

package/dist/realtime/conversation.js

@@ -1,7 +1,7 @@
 import { abortable, scope } from "../cancellation.js";
 import { RimeCancelledError, RimeInputError, RimeResourceLimitError, RimeTimeoutError, } from "../errors.js";
 import { Deferred } from "./async.js";
-import { isSessionCloseError } from "./session.js";
+import { isSessionCloseError, responseInterruptsSpeech } from "./session.js";
 import { RimeRealtimeError } from "./types.js";
 /** Run until input EOF, session closure, failure, or abort.
  * Owns the session's active lifetime and closes it on exit. The caller owns
@@ -171,7 +171,12 @@ export async function runConversation(session, { source, playback, onEvent, sign
                 stream,
                 receipt: start(() => measure(stream)),
                 sealed: false,
+                measured: false,
             };
+            const measuredOutput = output;
+            void output.receipt.then(() => {
+                measuredOutput.measured = true;
+            }, () => { });
             reply.outputs.set(key, output);
             if (reply.interrupted) {
                 playback.interrupt([ref]);
@@ -209,6 +214,7 @@ export async function runConversation(session, { source, playback, onEvent, sign
                         interrupted.add(id);
                     replies.set(id, {
                         ref: payload.response,
+                        interruptOnSpeech: responseInterruptsSpeech(session, payload.response),
                         outputs: new Map(),
                         interrupted: blocked,
                         ended: false,
@@ -229,10 +235,16 @@ export async function runConversation(session, { source, playback, onEvent, sign
                     }
                     break;
                 }
-                case "speech.started":
-                    if (session.info.interruptOnSpeech)
-                        interrupt([...replies.values()]);
+                case "speech.started": {
+                    // The newest eligible reply controls the playback batch.
+                    // A pending finished report is no longer physical playback.
+                    const eligible = [...replies.values()].filter((reply) => !reply.interrupted &&
+                        (!reply.ended ||
+                            [...reply.outputs.values()].some((output) => !output.measured)));
+                    if (eligible.at(-1)?.interruptOnSpeech)
+                        interrupt(eligible);
                     break;
+                }
                 case "response.abandoned": {
                     if (parents.has(payload.response.responseId))
                         interrupted.add(payload.response.responseId);

package/dist/realtime/faults.d.ts

@@ -0,0 +1,2 @@
+import type { NormalizedRealtimeFault, RealtimeFault } from "./types.js";
+export declare function normalizeFault(fault: RealtimeFault): NormalizedRealtimeFault;

package/dist/realtime/faults.js

@@ -0,0 +1,25 @@
+// Reuse SDK-normalized faults so events and rejected requests share one object.
+const normalizedFaults = new WeakSet();
+export function normalizeFault(fault) {
+    if (normalizedFaults.has(fault))
+        return fault;
+    const snapshot = {
+        code: fault.code,
+        message: fault.message,
+        scope: fault.scope,
+        requestId: fault.requestId,
+        responseId: fault.responseId,
+        itemId: fault.itemId,
+        callIds: Object.freeze([...(fault.callIds ?? [])]),
+        correlationId: fault.correlationId,
+        parameter: fault.parameter,
+    };
+    const normalized = Object.freeze({
+        ...snapshot,
+        retryable: snapshot.code === "capacity_exceeded" ||
+            snapshot.code === "unavailable" ||
+            snapshot.code === "response_timeout",
+    });
+    normalizedFaults.add(normalized);
+    return normalized;
+}

package/dist/realtime/history.d.ts

@@ -0,0 +1,4 @@
+import type { HistoryItem } from "./types.js";
+export declare function itemSettings(item: HistoryItem): Record<string, string>;
+export declare function historyId(value: string): string;
+export declare function listedItem(value: unknown): HistoryItem;

package/dist/realtime/history.js

@@ -0,0 +1,87 @@
+import { RimeInputError, RimeStreamError } from "../errors.js";
+function utf8(value) {
+    return typeof value === "string" && !/[\uD800-\uDFFF]/u.test(value);
+}
+export function itemSettings(item) {
+    if (!item || typeof item !== "object")
+        throw new RimeInputError("history item must be an object");
+    const value = { type: item.type };
+    if (item.id !== undefined) {
+        if (!utf8(item.id) || [...item.id].length < 1 || [...item.id].length > 32)
+            throw new RimeInputError("item.id must contain 1 to 32 characters");
+        value.id = item.id;
+    }
+    switch (item.type) {
+        case "message":
+            if (!["user", "assistant", "system"].includes(item.role) ||
+                !utf8(item.text) ||
+                [...item.text].length > 4000)
+                throw new RimeInputError("invalid history message");
+            value.role = item.role;
+            value.text = item.text;
+            break;
+        case "function_call":
+            value.call_id = item.callId;
+            value.name = item.name;
+            value.arguments = item.arguments;
+            if (!item.callId || !item.name)
+                throw new RimeInputError("past calls require callId and name");
+            break;
+        case "function_call_output":
+            value.call_id = item.callId;
+            value.output = item.output;
+            if (!item.callId)
+                throw new RimeInputError("tool results require callId");
+            break;
+        default:
+            throw new RimeInputError("invalid history item type");
+    }
+    if (!Object.values(value).every(utf8))
+        throw new RimeInputError("history fields must be valid UTF-8 strings");
+    return value;
+}
+export function historyId(value) {
+    if (!utf8(value) || !value)
+        throw new RimeInputError("history ID must be nonempty valid UTF-8");
+    return value;
+}
+export function listedItem(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        throw new RimeStreamError("invalid history item");
+    const o = value;
+    const field = (name) => {
+        if (typeof o[name] !== "string")
+            throw new RimeStreamError("invalid history field " + name);
+        if ((name === "call_id" || name === "name") && !o[name])
+            throw new RimeStreamError("invalid history identity");
+        return o[name];
+    };
+    const id = field("id");
+    if (!id)
+        throw new RimeStreamError("invalid history item id");
+    switch (o.type) {
+        case "message": {
+            const role = field("role");
+            if (role !== "user" && role !== "assistant" && role !== "system")
+                throw new RimeStreamError("invalid history role");
+            return Object.freeze({ type: o.type, id, role, text: field("text") });
+        }
+        case "function_call":
+            return Object.freeze({
+                type: o.type,
+                id,
+                callId: field("call_id"),
+                name: field("name"),
+                arguments: field("arguments"),
+            });
+        case "function_call_output":
+            return Object.freeze({
+                type: o.type,
+                id,
+                callId: field("call_id"),
+                output: field("output"),
+            });
+        default:
+            throw new RimeStreamError("invalid history item type");
+    }
+}

package/dist/realtime/protocol.d.ts

@@ -1,5 +1,9 @@
 import * as t from "./types.js";
 export interface SessionSettings {
+    truncation?: "auto" | "disabled" | {
+        type: "retention_ratio";
+        retention_ratio: number;
+    };
     modalities: ("text" | "audio")[];
     input_audio_format: "pcm16";
     turn_detection: {
@@ -18,9 +22,25 @@ export interface SessionSettings {
     }[];
     voice?: string;
     instructions?: string;
+    prism_response_metadata?: t.Labels;
+}
+/** A copy of the client's labels for every reply: keys to strings. */
+export declare function responseMetadata(value: unknown): t.Labels;
+export interface SessionPatch {
+    truncation?: SessionSettings["truncation"];
+    voice?: string;
+    instructions?: string;
+    tools?: SessionSettings["tools"];
+    turn_detection?: {
+        interrupt_response: boolean;
+    };
 }
 export interface SessionView {
+    truncation: t.Truncation | null;
+    settingsRevision: number | null;
     id: string;
+    requestId: string | null;
+    responseMetadata: t.Labels | null;
     voice: string;
     interruptOnSpeech: boolean | null;
     toolResultTimeoutS: number | null;
@@ -32,6 +52,7 @@ export interface SessionCreated {
     session: SessionView;
 }
 export interface SessionUpdated {
+    info?: t.SessionInfo;
     kind: "session.updated";
     session: SessionView;
 }
@@ -40,9 +61,18 @@ export interface ItemCreated {
     itemId: string;
 }
 export interface ToolResultCreated {
+    itemId: string | null;
     kind: "tool.result.created";
     callId: string;
 }
+export interface HistoryListed {
+    kind: "history.listed";
+    items: readonly t.HistoryItem[];
+}
+export interface ItemDeleted {
+    kind: "item.deleted";
+    itemId: string;
+}
 export interface AudioCleared {
     kind: "audio.cleared";
 }
@@ -54,14 +84,14 @@ export interface ItemTruncated {
 export interface ResponseEnded extends t.ResponseEnded {
     drainToken: string | null;
 }
-export type Acknowledgment = SessionUpdated | ItemCreated | ToolResultCreated | AudioCleared | ItemTruncated | t.ResponseStarted | ResponseEnded;
-export type ServerPayload = SessionCreated | Acknowledgment | t.InputEvent | t.MessageStarted | t.TextDelta | t.TextDone | t.AudioDelta | t.AudioDone | t.ToolCall | t.FaultEvent;
+export type Acknowledgment = SessionUpdated | HistoryListed | ItemDeleted | ItemCreated | ToolResultCreated | AudioCleared | ItemTruncated | t.ResponseStarted | ResponseEnded;
+export type ServerPayload = SessionCreated | Acknowledgment | t.InputEvent<t.NormalizedRealtimeFault> | t.MessageStarted | t.TextDelta | t.TextDone | t.AudioDelta | t.AudioDone | t.ToolCall | t.FaultEvent<t.NormalizedRealtimeFault>;
 export interface ServerEvent {
     eventId: string;
     requestId: string | null;
     payload: ServerPayload;
 }
-export type RequestKind = "session.update" | "conversation.item.create" | "response.create" | "response.cancel" | "input_audio_buffer.clear" | "conversation.item.truncate";
+export type RequestKind = "session.update" | "conversation.item.create" | "prism.conversation.get" | "conversation.item.delete" | "response.create" | "response.cancel" | "input_audio_buffer.clear" | "conversation.item.truncate";
 /** A request carries its result type and checks it before exposing the result. */
 export declare class Request<T extends Acknowledgment> {
     readonly kind: RequestKind;
@@ -72,6 +102,10 @@ export declare class Request<T extends Acknowledgment> {
     check(event: Acknowledgment): void;
 }
 export declare const requests: {
+    historyItem: Request<ItemCreated>;
+    historyResult: Request<ToolResultCreated>;
+    history: Request<HistoryListed>;
+    delete: Request<ItemDeleted>;
     update: Request<SessionUpdated>;
     item: Request<ItemCreated>;
     toolResult: Request<ToolResultCreated>;
@@ -81,4 +115,5 @@ export declare const requests: {
     clear: Request<AudioCleared>;
     truncate: Request<ItemTruncated>;
 };
+export declare function truncationSettings(value: t.Truncation): NonNullable<SessionSettings["truncation"]>;
 export declare function decode(raw: string, sessionId: string | null): ServerEvent | null;

package/dist/realtime/protocol.js

@@ -1,6 +1,17 @@
 // SPDX-License-Identifier: Apache-2.0
 /** Decode only the protocol fields the SDK uses. Unknown events and fields stay open. */
-import { RimeStreamError } from "../errors.js";
+import { RimeInputError, RimeStreamError } from "../errors.js";
+import { normalizeFault } from "./faults.js";
+import { listedItem } from "./history.js";
+/** A copy of the client's labels for every reply: keys to strings. */
+export function responseMetadata(value) {
+    if (!value ||
+        typeof value !== "object" ||
+        ![Object.prototype, null].includes(Object.getPrototypeOf(value)) ||
+        Object.values(value).some((label) => typeof label !== "string"))
+        throw new RimeInputError("responseMetadata must map keys to strings");
+    return Object.freeze({ ...value });
+}
 /** A request carries its result type and checks it before exposing the result. */
 export class Request {
     kind;
@@ -21,6 +32,10 @@ export class Request {
     }
 }
 export const requests = {
+    historyItem: new Request("conversation.item.create", (e) => e.kind === "item.created"),
+    historyResult: new Request("conversation.item.create", (e) => e.kind === "tool.result.created"),
+    history: new Request("prism.conversation.get", (e) => e.kind === "history.listed"),
+    delete: new Request("conversation.item.delete", (e) => e.kind === "item.deleted"),
     update: new Request("session.update", (e) => e.kind === "session.updated"),
     item: new Request("conversation.item.create", (e) => e.kind === "item.created"),
     toolResult: new Request("conversation.item.create", (e) => e.kind === "tool.result.created"),
@@ -57,6 +72,11 @@ function integer(value, field) {
         return invalid(field);
     return value;
 }
+function revision(value) {
+    return value.prism_settings_revision === undefined
+        ? null
+        : integer(value.prism_settings_revision, "prism_settings_revision");
+}
 function duration(value, field) {
     if (value == null)
         return null;
@@ -64,6 +84,29 @@ function duration(value, field) {
         return invalid(field);
     return value;
 }
+export function truncationSettings(value) {
+    if (value === "auto" || value === "disabled")
+        return value;
+    if (value &&
+        typeof value === "object" &&
+        !Array.isArray(value) &&
+        Object.keys(value).every((key) => key === "retentionRatio") &&
+        typeof value.retentionRatio === "number" &&
+        value.retentionRatio > 0 &&
+        value.retentionRatio <= 1)
+        return { type: "retention_ratio", retention_ratio: value.retentionRatio };
+    throw new RimeInputError("truncation must be auto, disabled, or a retentionRatio above zero and at most one");
+}
+function truncation(value) {
+    if (value === "auto" || value === "disabled")
+        return value;
+    const o = object(value, "session.truncation");
+    if (o.type !== "retention_ratio" ||
+        typeof o.retention_ratio !== "number" ||
+        !(o.retention_ratio > 0 && o.retention_ratio <= 1))
+        return invalid("session.truncation");
+    return Object.freeze({ retentionRatio: o.retention_ratio });
+}
 function session(value) {
     const view = object(value, "session");
     const detection = view.turn_detection === undefined
@@ -100,7 +143,13 @@ function session(value) {
     if (interrupt !== undefined && typeof interrupt !== "boolean")
         invalid("session.prism_effective_interrupt_response");
     return {
+        settingsRevision: revision(view),
+        truncation: view.truncation === undefined ? null : truncation(view.truncation),
         id: id(view.id, "session.id"),
+        requestId: optionalString(view.request_id, "session.request_id"),
+        responseMetadata: view.prism_response_metadata === undefined
+            ? null
+            : clientMetadata(object(view.prism_response_metadata, "session.prism_response_metadata")),
         voice: view.voice === undefined ? "" : string(view.voice, "session.voice"),
         interruptOnSpeech: interrupt ?? null,
         turnDetection: Object.freeze({ eagerness, endOfTurnTimeoutMs }),
@@ -108,6 +157,11 @@ function session(value) {
         toolContinuationTimeoutS: duration(waits.continuation_timeout_s, "continuation_timeout_s"),
     };
 }
+/** The client's labels in `metadata`: its string values under keys that are
+ * not Prism's `prism_` ones. */
+function clientMetadata(metadata) {
+    return Object.freeze(Object.fromEntries(Object.entries(metadata).filter((entry) => !entry[0].startsWith("prism_") && typeof entry[1] === "string")));
+}
 function fault(value) {
     const error = object(value, "error");
     const owner = error.owner == null ? {} : object(error.owner, "error.owner");
@@ -115,8 +169,9 @@ function fault(value) {
     const calls = owner.call_ids ?? [];
     if (!Array.isArray(calls))
         return invalid("error.owner.call_ids");
-    return Object.freeze({
-        code: error.code === undefined ? "unknown" : string(error.code, "error.code"),
+    const code = error.code === undefined ? "unknown" : string(error.code, "error.code");
+    return normalizeFault({
+        code,
         message: error.message === undefined ? "" : string(error.message, "error.message"),
         scope: scope === "event" ||
             scope === "utterance" ||
@@ -128,7 +183,7 @@ function fault(value) {
         requestId: optionalString(owner.event_id, "error.owner.event_id"),
         responseId: optionalString(owner.response_id, "error.owner.response_id"),
         itemId: optionalString(owner.item_id, "error.owner.item_id"),
-        callIds: Object.freeze(calls.map((value) => id(value, "error.owner.call_ids"))),
+        callIds: calls.map((value) => id(value, "error.owner.call_ids")),
         correlationId: optionalString(error.correlation_id, "error.correlation_id"),
         parameter: optionalString(error.param, "error.param"),
     });
@@ -195,15 +250,29 @@ function decodeValue(value, sessionId) {
             if (item.type === "function_call_output")
                 payload = {
                     kind: "tool.result.created",
+                    itemId: optionalString(item.id, "item.id"),
                     callId: id(item.call_id, "item.call_id"),
                 };
             else {
-                if (item.type !== undefined && item.type !== "message")
+                if (item.type !== undefined &&
+                    item.type !== "message" &&
+                    item.type !== "function_call")
                     invalid("item.type");
                 payload = { kind: "item.created", itemId: id(item.id, "item.id") };
             }
             break;
         }
+        case "prism.conversation":
+            if (!Array.isArray(event.items))
+                return invalid("items");
+            payload = {
+                kind: "history.listed",
+                items: Object.freeze(event.items.map(listedItem)),
+            };
+            break;
+        case "conversation.item.deleted":
+            payload = { kind: "item.deleted", itemId: id(event.item_id, "item_id") };
+            break;
         case "input_audio_buffer.cleared":
             payload = { kind: "audio.cleared" };
             break;
@@ -291,8 +360,14 @@ function decodeValue(value, sessionId) {
                 ? undefined
                 : string(metadata.prism_cause, "prism_cause");
             const parent = optionalString(metadata.prism_parent_response_id, "prism_parent_response_id");
+            const inputItemId = optionalString(metadata.prism_input_item_id, "prism_input_item_id");
+            const inputItemIds = response.prism_input_item_ids ??
+                (inputItemId === null ? [] : [inputItemId]);
+            if (!Array.isArray(inputItemIds))
+                return invalid("prism_input_item_ids");
             payload = {
                 kind: "response.started",
+                settingsRevision: revision(response),
                 response: ref(response.id),
                 cause: cause === undefined
                     ? "speech"
@@ -304,7 +379,9 @@ function decodeValue(value, sessionId) {
                                 ? "proactive"
                                 : "unknown",
                 parent: parent === null ? null : ref(parent),
-                inputItemId: optionalString(metadata.prism_input_item_id, "prism_input_item_id"),
+                inputItemId,
+                metadata: clientMetadata(metadata),
+                inputItemIds: Object.freeze(inputItemIds.map((value) => id(value, "prism_input_item_ids"))),
             };
             break;
         }
@@ -318,6 +395,7 @@ function decodeValue(value, sessionId) {
             const status = string(response.status, "response.status");
             payload = {
                 kind: "response.ended",
+                settingsRevision: revision(response),
                 response: ref(response.id),
                 status: status === "completed" ||
                     status === "cancelled" ||