@neta-art/cohub 1.2.0 → 1.2.1

package/README.md

@@ -96,8 +96,23 @@ stop();
 You can also listen with business-oriented event names:
 
 ```ts
+session.on("turn.patch", (event) => {
+  // Streaming state-machine patch: { turnId, seq, baseSeq, ops }.
+  // Consecutive append ops may be compacted to { v }.
+  console.log(event.payload.ops);
+});
+
+session.subscribe({
+  patchState: (result) => {
+    if (result.applied) {
+      console.log(result.state.contentBlocks);
+    }
+  },
+});
+
 session.on("turn.final", (event) => {
-  console.log(event.payload);
+  // Fired when an assistant_final message.persisted event arrives.
+  console.log(event.payload.message);
 });
 
 space.on("message.persisted", (event) => {
@@ -107,7 +122,8 @@ space.on("message.persisted", (event) => {
 
 Supported business event names:
 
-- `turn.progress`
+- `turn.patch`
+- `turn.progress` (legacy compatibility)
 - `turn.final`
 - `turn.error`
 - `message.persisted`

package/dist/apis/spaces.d.ts

@@ -1,15 +1,18 @@
 import type { WebsocketClient, WebsocketEventPayload } from "../websocket.js";
 import type { HttpTransport, Fetch } from "../transport.js";
+import { type SessionPatchApplyResult } from "../session-patch-reducer.js";
 import type { CheckpointRecord, ContentBlock, SessionMessageResponse, SessionMessagesPaginatedResponse, SessionMessagesResponse, SessionRecord, SpaceAccessPolicy, SpaceBootstrapSource, SpaceChannelBindingInput, SpaceCheckpointDetailResponse, SpaceCreateResponse, SpaceEnvInput, SpaceFsFileResponse, SpaceFsMoveInput, SpaceFsTreeResponse, SpaceFsUploadResponse, SpaceUsageResponse, SpaceFsWriteFileInput, SpaceMember, SpaceRecord, SpaceRole, SpaceSessionsResponse } from "../types.js";
 import { SpaceInvitationsApi } from "./invitations.js";
 export type SessionSubscriptionHandlers = {
+    patch?: (event: WebsocketEventPayload) => void;
+    patchState?: (result: SessionPatchApplyResult) => void;
     progress?: (event: WebsocketEventPayload) => void;
     final?: (event: WebsocketEventPayload) => void;
     error?: (event: WebsocketEventPayload) => void;
     persisted?: (event: WebsocketEventPayload) => void;
     event?: (event: WebsocketEventPayload) => void;
 };
-export type SessionEventName = "turn.progress" | "turn.final" | "turn.error" | "message.persisted";
+export type SessionEventName = "turn.patch" | "turn.progress" | "turn.final" | "turn.error" | "message.persisted";
 export type SpaceEventName = SessionEventName | "event";
 type SessionSendMessageInput = {
     content: ContentBlock[];
@@ -86,6 +89,7 @@ declare class SessionRealtimeClient {
     private readonly websocketClient;
     private readonly spaceId;
     private readonly sessionId;
+    private readonly patchReducer;
     constructor(websocketClient: WebsocketClient | null, spaceId: string, sessionId: string);
     subscribe(handlers: SessionSubscriptionHandlers): () => void;
     on(type: SessionEventName, handler: (event: WebsocketEventPayload) => void): () => void;

package/dist/apis/spaces.js

@@ -1,12 +1,13 @@
 import { ensureRealtimeConnected } from "../realtime.js";
+import { SessionPatchReducer, } from "../session-patch-reducer.js";
 import { SpaceInvitationsApi } from "./invitations.js";
 const DEFAULT_DEDUP_WINDOW_MS = 2000;
 const toSessionEventName = (type) => {
     switch (type) {
+        case "session.turn.patch":
+            return "turn.patch";
         case "session.turn.progress":
             return "turn.progress";
-        case "session.turn.final":
-            return "turn.final";
         case "session.turn.error":
             return "turn.error";
         case "session.message.persisted":
@@ -15,6 +16,24 @@ const toSessionEventName = (type) => {
             return null;
     }
 };
+const isAssistantFinalPersistedEvent = (event) => {
+    if (event.type !== "session.message.persisted")
+        return false;
+    const message = event.payload.message;
+    if (!message || typeof message !== "object")
+        return false;
+    const record = message;
+    return record.role === "assistant" && record.meta?.messageKind === "assistant_final";
+};
+const getPersistedMessageTurnId = (event) => {
+    if (event.type !== "session.message.persisted")
+        return null;
+    const message = event.payload.message;
+    if (!message || typeof message !== "object")
+        return null;
+    const meta = message.meta;
+    return typeof meta?.turnId === "string" ? meta.turnId : null;
+};
 export class SpacesApi {
     transport;
     constructor(transport) {
@@ -173,6 +192,7 @@ class SessionRealtimeClient {
     websocketClient;
     spaceId;
     sessionId;
+    patchReducer = new SessionPatchReducer();
     constructor(websocketClient, spaceId, sessionId) {
         this.websocketClient = websocketClient;
         this.spaceId = spaceId;
@@ -188,20 +208,56 @@ class SessionRealtimeClient {
                 return;
             handlers.event?.(event);
             const eventName = toSessionEventName(event.type);
+            if (eventName === "turn.patch") {
+                handlers.patch?.(event);
+                if (event.type === "session.turn.patch") {
+                    const payload = event.payload;
+                    if (typeof payload.seq === "number" &&
+                        typeof payload.baseSeq === "number" &&
+                        Array.isArray(payload.ops)) {
+                        handlers.patchState?.(this.patchReducer.applyPatch({
+                            spaceId: this.spaceId,
+                            sessionId: this.sessionId,
+                            turnId: typeof payload.turnId === "string" ? payload.turnId : null,
+                            seq: payload.seq,
+                            baseSeq: payload.baseSeq,
+                            ops: payload.ops,
+                            anchorUserMessageId: typeof payload.anchorUserMessageId === "string"
+                                ? payload.anchorUserMessageId
+                                : null,
+                        }));
+                    }
+                }
+            }
             if (eventName === "turn.progress")
                 handlers.progress?.(event);
-            if (eventName === "turn.final")
-                handlers.final?.(event);
-            if (eventName === "turn.error")
+            if (eventName === "turn.error") {
+                this.patchReducer.fail({
+                    spaceId: this.spaceId,
+                    sessionId: this.sessionId,
+                });
                 handlers.error?.(event);
+            }
             if (eventName === "message.persisted")
                 handlers.persisted?.(event);
+            if (isAssistantFinalPersistedEvent(event)) {
+                this.patchReducer.complete({
+                    spaceId: this.spaceId,
+                    sessionId: this.sessionId,
+                    turnId: getPersistedMessageTurnId(event),
+                });
+                handlers.final?.(event);
+            }
         });
         return () => unsubscribe();
     }
     on(type, handler) {
         return this.subscribe({
             event: (event) => {
+                if (type === "turn.final" && isAssistantFinalPersistedEvent(event)) {
+                    handler(event);
+                    return;
+                }
                 if (toSessionEventName(event.type) === type)
                     handler(event);
             },
@@ -299,6 +355,10 @@ export class SpaceEventsApi {
                 handler(event);
                 return;
             }
+            if (type === "turn.final" && isAssistantFinalPersistedEvent(event)) {
+                handler(event);
+                return;
+            }
             if (toSessionEventName(event.type) === type)
                 handler(event);
         });

package/dist/index.d.ts

@@ -1,9 +1,11 @@
 export { CohubHttpClient, createHttpClient } from "./http.js";
 export { CohubClient, createCohubClient } from "./client.js";
 export { WebsocketClient, createWebsocketClient } from "./websocket.js";
+export { SessionPatchReducer, createSessionPatchReducer } from "./session-patch-reducer.js";
 export { HttpError } from "./transport.js";
 export { COHUB_ENVIRONMENTS, normalizeBaseUrl, normalizeWebsocketUrl, resolveApiBaseUrl, resolveCohubEnvironment, resolveWebsocketUrl, } from "./environment.js";
 export type { CohubClientOptions, Fetch } from "./transport.js";
 export type { CohubEnvironment } from "./environment.js";
+export type { SessionPatchApplyInput, SessionPatchApplyResult, SessionPatchState, SessionPatchStatus, } from "./session-patch-reducer.js";
 export * from "./types.js";
 export type { SessionEventName, SessionSubscriptionHandlers, SpaceChannelBindingRecord, SpaceEventName, WebSocketConnectionState } from "./apis/spaces.js";

package/dist/index.js

@@ -1,6 +1,7 @@
 export { CohubHttpClient, createHttpClient } from "./http.js";
 export { CohubClient, createCohubClient } from "./client.js";
 export { WebsocketClient, createWebsocketClient } from "./websocket.js";
+export { SessionPatchReducer, createSessionPatchReducer } from "./session-patch-reducer.js";
 export { HttpError } from "./transport.js";
 export { COHUB_ENVIRONMENTS, normalizeBaseUrl, normalizeWebsocketUrl, resolveApiBaseUrl, resolveCohubEnvironment, resolveWebsocketUrl, } from "./environment.js";
 export * from "./types.js";

package/dist/session-patch-reducer.d.ts

@@ -0,0 +1,49 @@
+import type { ContentBlock } from "@neta-art/cohub-protocol/core";
+import type { RealtimePatchOperation, SessionTurnPatchEvent } from "@neta-art/cohub-protocol/realtime";
+export type SessionPatchStatus = "idle" | "pending" | "streaming" | "completed" | "failed";
+export type SessionPatchState = {
+    spaceId: string | null;
+    sessionId: string;
+    status: SessionPatchStatus;
+    contentBlocks: ContentBlock[];
+    anchorUserMessageId: string | null;
+    patchSeq: number;
+    turnId: string | null;
+    appendPath: string | null;
+};
+export type SessionPatchApplyInput = {
+    spaceId?: string | null;
+    sessionId: string;
+    turnId?: string | null;
+    seq: number;
+    baseSeq: number;
+    ops: RealtimePatchOperation[];
+    anchorUserMessageId?: string | null;
+};
+export type SessionPatchApplyResult = {
+    applied: true;
+    state: SessionPatchState;
+} | {
+    applied: false;
+    reason: "duplicate" | "version_mismatch" | "invalid";
+    state: SessionPatchState;
+};
+type SessionPatchKeyInput = {
+    spaceId?: string | null;
+    sessionId: string;
+    turnId?: string | null;
+};
+export declare class SessionPatchReducer {
+    private readonly states;
+    private key;
+    get(input: SessionPatchKeyInput): SessionPatchState;
+    start(input: SessionPatchKeyInput): SessionPatchState;
+    complete(input: SessionPatchKeyInput): SessionPatchState;
+    fail(input: SessionPatchKeyInput): SessionPatchState;
+    reset(input: SessionPatchKeyInput): void;
+    resetAll(): void;
+    applyEvent(event: SessionTurnPatchEvent): SessionPatchApplyResult;
+    applyPatch(input: SessionPatchApplyInput): SessionPatchApplyResult;
+}
+export declare const createSessionPatchReducer: () => SessionPatchReducer;
+export {};

package/dist/session-patch-reducer.js

@@ -0,0 +1,273 @@
+const blockTextPathPattern = /^\/message\/content\/blocks\/(\d+)\/(text|thinking)$/;
+const blockPathPattern = /^\/message\/content\/blocks\/(\d+)$/;
+const blockMetaPathPattern = /^\/message\/content\/blocks\/(\d+)\/_meta$/;
+const blockSignaturePathPattern = /^\/message\/content\/blocks\/(\d+)\/signature$/;
+const createIdleState = (input) => ({
+    spaceId: input.spaceId ?? null,
+    sessionId: input.sessionId,
+    status: "idle",
+    contentBlocks: [],
+    anchorUserMessageId: null,
+    patchSeq: 0,
+    turnId: null,
+    appendPath: null,
+});
+function cloneBlock(block) {
+    return structuredClone(block);
+}
+function getStreamIndex(block) {
+    const value = block._meta?.streamIndex;
+    return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+function findBlockByStreamIndex(blocks, streamIndex) {
+    return blocks.findIndex((block) => getStreamIndex(block) === streamIndex);
+}
+function sortBlocksByStreamIndex(blocks) {
+    return [...blocks].sort((a, b) => {
+        const aIndex = getStreamIndex(a);
+        const bIndex = getStreamIndex(b);
+        if (aIndex == null && bIndex == null)
+            return 0;
+        if (aIndex == null)
+            return 1;
+        if (bIndex == null)
+            return -1;
+        return aIndex - bIndex;
+    });
+}
+function isContentBlock(value) {
+    return Boolean(value && typeof value === "object" && "type" in value);
+}
+function ensureTextLikeBlock(blocks, streamIndex, field) {
+    const existingIndex = findBlockByStreamIndex(blocks, streamIndex);
+    const existing = existingIndex >= 0 ? blocks[existingIndex] : undefined;
+    if (field === "text") {
+        if (existing?.type === "text")
+            return existing;
+        const block = {
+            type: "text",
+            text: "",
+            _meta: { streamIndex },
+        };
+        blocks.push(block);
+        return block;
+    }
+    if (existing?.type === "thinking")
+        return existing;
+    const block = {
+        type: "thinking",
+        thinking: "",
+        _meta: { streamIndex },
+    };
+    blocks.push(block);
+    return block;
+}
+function appendTextLikeValue(blocks, path, value) {
+    const match = path.match(blockTextPathPattern);
+    if (!match || typeof value !== "string")
+        return false;
+    const streamIndex = Number(match[1]);
+    const field = match[2];
+    const block = ensureTextLikeBlock(blocks, streamIndex, field);
+    if (field === "text" && block.type === "text") {
+        block.text += value;
+    }
+    if (field === "thinking" && block.type === "thinking") {
+        block.thinking += value;
+    }
+    return true;
+}
+function applyPatchOpsToBlocks(current, ops, initialAppendPath) {
+    const next = current.map(cloneBlock);
+    let anchorUserMessageId;
+    let appendPath = initialAppendPath;
+    let failed = false;
+    for (const op of ops) {
+        if (!op.o && !op.p) {
+            if (!appendPath || !appendTextLikeValue(next, appendPath, op.v)) {
+                failed = true;
+                break;
+            }
+            continue;
+        }
+        if (op.o === "merge" && op.p === "/message/metadata") {
+            const anchor = op.v.anchorUserMessageId;
+            if (typeof anchor === "string" && anchor.trim()) {
+                anchorUserMessageId = anchor;
+            }
+            continue;
+        }
+        if (op.o === "append") {
+            if (!appendTextLikeValue(next, op.p, op.v)) {
+                failed = true;
+                break;
+            }
+            appendPath = op.p;
+            continue;
+        }
+        if (op.o === "merge") {
+            const match = op.p.match(blockMetaPathPattern);
+            if (!match)
+                continue;
+            const streamIndex = Number(match[1]);
+            const blockIndex = findBlockByStreamIndex(next, streamIndex);
+            const block = blockIndex >= 0 ? next[blockIndex] : undefined;
+            if (!block)
+                continue;
+            block._meta = { ...(block._meta ?? {}), ...op.v };
+            continue;
+        }
+        if (op.o === "replace") {
+            const match = op.p.match(blockSignaturePathPattern);
+            if (match) {
+                if (typeof op.v !== "string")
+                    continue;
+                const blockIndex = findBlockByStreamIndex(next, Number(match[1]));
+                const block = blockIndex >= 0 ? next[blockIndex] : undefined;
+                if (block?.type === "thinking")
+                    block.signature = op.v;
+                continue;
+            }
+        }
+        if (op.o === "replace" || op.o === "add") {
+            const match = op.p.match(blockPathPattern);
+            if (!match || !isContentBlock(op.v))
+                continue;
+            const streamIndex = Number(match[1]);
+            const block = cloneBlock(op.v);
+            block._meta = { ...(block._meta ?? {}), streamIndex };
+            const blockIndex = findBlockByStreamIndex(next, streamIndex);
+            if (blockIndex >= 0) {
+                next[blockIndex] = block;
+            }
+            else {
+                next.push(block);
+            }
+            continue;
+        }
+        if (op.o === "remove") {
+            const match = op.p.match(blockPathPattern);
+            if (!match)
+                continue;
+            const blockIndex = findBlockByStreamIndex(next, Number(match[1]));
+            if (blockIndex >= 0)
+                next.splice(blockIndex, 1);
+        }
+    }
+    return {
+        failed,
+        contentBlocks: sortBlocksByStreamIndex(next),
+        anchorUserMessageId,
+        appendPath,
+    };
+}
+export class SessionPatchReducer {
+    states = new Map();
+    key(input) {
+        return `${input.spaceId ?? ""}:${input.sessionId}`;
+    }
+    get(input) {
+        const key = this.key(input);
+        return this.states.get(key) ?? createIdleState(input);
+    }
+    start(input) {
+        const state = {
+            ...this.get(input),
+            status: "pending",
+            contentBlocks: [],
+            anchorUserMessageId: null,
+            patchSeq: 0,
+            turnId: null,
+            appendPath: null,
+        };
+        this.states.set(this.key(input), state);
+        return state;
+    }
+    complete(input) {
+        const current = this.get(input);
+        const state = {
+            ...current,
+            turnId: input.turnId ?? current.turnId,
+            status: "completed",
+            contentBlocks: [],
+            anchorUserMessageId: null,
+        };
+        this.states.set(this.key(input), state);
+        return state;
+    }
+    fail(input) {
+        const current = this.get(input);
+        const state = {
+            ...current,
+            turnId: input.turnId ?? current.turnId,
+            status: "failed",
+            contentBlocks: [],
+            anchorUserMessageId: null,
+        };
+        this.states.set(this.key(input), state);
+        return state;
+    }
+    reset(input) {
+        this.states.delete(this.key(input));
+    }
+    resetAll() {
+        this.states.clear();
+    }
+    applyEvent(event) {
+        return this.applyPatch({
+            spaceId: event.spaceId,
+            sessionId: event.sessionId,
+            turnId: event.payload.turnId,
+            seq: event.payload.seq,
+            baseSeq: event.payload.baseSeq,
+            ops: event.payload.ops,
+            anchorUserMessageId: event.payload.anchorUserMessageId,
+        });
+    }
+    applyPatch(input) {
+        const current = this.get(input);
+        const currentTurnId = current.turnId;
+        const inputTurnId = input.turnId ?? null;
+        const isDifferentKnownTurn = Boolean(currentTurnId && inputTurnId && currentTurnId !== inputTurnId);
+        const isFreshKnownTurn = isDifferentKnownTurn && input.baseSeq === 0;
+        const currentSeq = isFreshKnownTurn ? 0 : current.patchSeq;
+        const isTerminalSameTurn = (current.status === "completed" || current.status === "failed") &&
+            Boolean(currentTurnId) &&
+            currentTurnId === inputTurnId;
+        if (isTerminalSameTurn) {
+            return { applied: false, reason: "duplicate", state: current };
+        }
+        if (isDifferentKnownTurn && !isFreshKnownTurn) {
+            return { applied: false, reason: "version_mismatch", state: current };
+        }
+        if (input.seq <= currentSeq) {
+            return { applied: false, reason: "duplicate", state: current };
+        }
+        if (input.baseSeq !== currentSeq) {
+            return { applied: false, reason: "version_mismatch", state: current };
+        }
+        const startingFresh = input.baseSeq === 0 || isFreshKnownTurn;
+        const baseBlocks = startingFresh ? [] : current.contentBlocks;
+        const patched = applyPatchOpsToBlocks(baseBlocks, input.ops, startingFresh ? null : current.appendPath);
+        if (patched.failed) {
+            return { applied: false, reason: "version_mismatch", state: current };
+        }
+        const next = {
+            ...current,
+            spaceId: input.spaceId ?? current.spaceId ?? null,
+            sessionId: input.sessionId,
+            status: "streaming",
+            contentBlocks: patched.contentBlocks,
+            anchorUserMessageId: patched.anchorUserMessageId ??
+                input.anchorUserMessageId ??
+                current.anchorUserMessageId ??
+                null,
+            patchSeq: input.seq,
+            turnId: input.turnId ?? current.turnId ?? null,
+            appendPath: patched.appendPath,
+        };
+        this.states.set(this.key(next), next);
+        return { applied: true, state: next };
+    }
+}
+export const createSessionPatchReducer = () => new SessionPatchReducer();

package/dist/types.d.ts

@@ -252,6 +252,10 @@ export type SpaceUsageHourlyStat = {
     outputTokens: number;
     cacheReadTokens: number;
     cacheWriteTokens: number;
+    costInput: number;
+    costOutput: number;
+    costCacheRead: number;
+    costCacheWrite: number;
     costTotal: number;
     requestCount: number;
     successCount: number;
@@ -264,6 +268,10 @@ export type SpaceUsageSummary = {
     outputTokens: number;
     cacheReadTokens: number;
     cacheWriteTokens: number;
+    costInput: number;
+    costOutput: number;
+    costCacheRead: number;
+    costCacheWrite: number;
     costTotal: number;
     requestCount: number;
     successCount: number;

package/dist/websocket.d.ts

@@ -96,6 +96,7 @@ export declare class WebsocketClient {
     private awaitingPong;
     private lastPingRequestId;
     private pongDeadlineAt;
+    private readonly compactStreamContexts;
     state: WebsocketClientState;
     connectionId: string | null;
     private readonly listeners;
@@ -124,6 +125,8 @@ export declare class WebsocketClient {
     private resolveAuthWaiter;
     private rejectAuthWaiter;
     private handleMessage;
+    private rememberCompactStreamContext;
+    private handleCompactFrame;
     private startPingLoop;
     private stopPingLoop;
     private clearReconnectTimer;

package/dist/websocket.js

@@ -1,4 +1,4 @@
-import { realtimeEnvelopeSchema, } from "@neta-art/cohub-protocol/realtime";
+import { realtimeCompactFrameSchema, realtimeEnvelopeSchema, WS_COMPACT_STREAM_CAPABILITY, } from "@neta-art/cohub-protocol/realtime";
 import { resolveWebsocketUrl } from "./environment.js";
 const createEventMap = () => ({
     connecting: new Set(),
@@ -32,6 +32,28 @@ const isRetryableCloseCode = (code) => {
     return true;
 };
 const AUTH_CLOSE_REASON = "authentication failed";
+const isRecord = (value) => Boolean(value && typeof value === "object" && !Array.isArray(value));
+const compactFrameToPatchOperation = (frame) => {
+    if (frame.t === "d")
+        return { v: frame.v };
+    if (frame.o === "remove")
+        return { o: "remove", p: frame.p };
+    if (frame.o === "merge") {
+        return isRecord(frame.v) ? { o: "merge", p: frame.p, v: frame.v } : null;
+    }
+    if (!("v" in frame))
+        return null;
+    switch (frame.o) {
+        case "append":
+            return { o: "append", p: frame.p, v: frame.v };
+        case "replace":
+            return { o: "replace", p: frame.p, v: frame.v };
+        case "add":
+            return { o: "add", p: frame.p, v: frame.v };
+        default:
+            return null;
+    }
+};
 class WebsocketAuthError extends Error {
     constructor(message) {
         super(message);
@@ -59,6 +81,7 @@ export class WebsocketClient {
     awaitingPong = false;
     lastPingRequestId = null;
     pongDeadlineAt = 0;
+    compactStreamContexts = new Map();
     state = "idle";
     connectionId = null;
     listeners = createEventMap();
@@ -221,7 +244,10 @@ export class WebsocketClient {
         if (!token)
             throw new WebsocketAuthError("missing access token");
         const waiter = this.createAuthWaiter();
-        this.send({ type: "auth", payload: { token } });
+        this.send({
+            type: "auth",
+            payload: { token, capabilities: [WS_COMPACT_STREAM_CAPABILITY] },
+        });
         await waiter.promise;
     }
     createAuthWaiter() {
@@ -256,12 +282,18 @@ export class WebsocketClient {
             this.emit("error", { error: new Error("invalid websocket payload"), recoverable: true });
             return;
         }
+        const compactResult = realtimeCompactFrameSchema.safeParse(parsed);
+        if (compactResult.success) {
+            this.handleCompactFrame(compactResult.data);
+            return;
+        }
         const result = realtimeEnvelopeSchema.safeParse(parsed);
         if (!result.success) {
             this.emit("error", { error: new Error("invalid realtime envelope"), recoverable: true });
             return;
         }
         const envelope = result.data;
+        this.rememberCompactStreamContext(envelope);
         switch (envelope.type) {
             case "system.ready": {
                 const connectionId = typeof envelope.payload.connectionId === "string"
@@ -351,6 +383,79 @@ export class WebsocketClient {
             }
         }
     }
+    rememberCompactStreamContext(envelope) {
+        if (envelope.type === "session.turn.patch") {
+            const payload = envelope.payload;
+            const turnId = typeof payload.turnId === "string" ? payload.turnId : null;
+            const messageId = typeof payload.messageId === "string" ? payload.messageId : null;
+            const realtimeMeta = payload._rt && typeof payload._rt === "object"
+                ? payload._rt
+                : null;
+            const sid = typeof realtimeMeta?.sid === "string" && realtimeMeta.sid.trim()
+                ? realtimeMeta.sid
+                : turnId ?? messageId;
+            if (!sid)
+                return;
+            this.compactStreamContexts.set(sid, {
+                spaceId: envelope.spaceId ?? null,
+                sessionId: envelope.sessionId ?? null,
+                turnId,
+                messageId,
+                anchorUserMessageId: typeof payload.anchorUserMessageId === "string"
+                    ? payload.anchorUserMessageId
+                    : null,
+            });
+            return;
+        }
+        if (envelope.type !== "session.message.persisted")
+            return;
+        const message = envelope.payload.message;
+        if (!message || typeof message !== "object")
+            return;
+        const meta = message.meta;
+        const turnId = typeof meta?.turnId === "string" ? meta.turnId : null;
+        if (!turnId)
+            return;
+        for (const [sid, context] of this.compactStreamContexts.entries()) {
+            if (context.turnId === turnId)
+                this.compactStreamContexts.delete(sid);
+        }
+    }
+    handleCompactFrame(frame) {
+        const context = this.compactStreamContexts.get(frame.sid);
+        if (!context?.sessionId) {
+            this.emit("error", {
+                error: new Error(`unknown compact stream: ${frame.sid}`),
+                recoverable: true,
+            });
+            return;
+        }
+        const op = compactFrameToPatchOperation(frame);
+        if (!op) {
+            this.emit("error", {
+                error: new Error(`invalid compact stream frame: ${frame.sid}`),
+                recoverable: true,
+            });
+            return;
+        }
+        const envelope = {
+            id: `compact:${frame.sid}:${frame.s}`,
+            timestamp: Date.now(),
+            domain: "session",
+            type: "session.turn.patch",
+            spaceId: context.spaceId,
+            sessionId: context.sessionId,
+            payload: {
+                turnId: context.turnId,
+                messageId: context.messageId,
+                anchorUserMessageId: context.anchorUserMessageId,
+                seq: frame.s,
+                baseSeq: frame.b,
+                ops: [op],
+            },
+        };
+        this.emit("event", envelope);
+    }
     startPingLoop() {
         this.stopPingLoop();
         this.pingTimer = setInterval(() => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@neta-art/cohub",
-  "version": "1.2.0",
+  "version": "1.2.1",
   "description": "Cohub SDK for spaces, sessions, checkpoints, and realtime agent collaboration.",
   "license": "UNLICENSED",
   "private": false,
@@ -44,7 +44,7 @@
     "README.md"
   ],
   "dependencies": {
-    "@neta-art/cohub-protocol": "1.2.0"
+    "@neta-art/cohub-protocol": "1.2.1"
   },
   "devDependencies": {
     "typescript": "^6.0.3"