xo-harness 0.2.0 → 0.3.0

package/dist/internal/protocol/provider.d.ts

@@ -8,8 +8,25 @@ export declare const ProviderCapabilitiesSchema: z.ZodObject<{
     modelManagedFloor: z.ZodBoolean;
     supportsToolCalls: z.ZodBoolean;
     supportsAsyncContext: z.ZodBoolean;
+    supportsToolStatusContext: z.ZodOptional<z.ZodBoolean>;
     supportsPlayoutAcknowledgements: z.ZodBoolean;
     reportsResponseState: z.ZodOptional<z.ZodBoolean>;
+    inputCadence: z.ZodOptional<z.ZodEnum<{
+        continuous: "continuous";
+        "on-demand": "on-demand";
+    }>>;
+    outputLifecycle: z.ZodOptional<z.ZodEnum<{
+        continuous: "continuous";
+        response: "response";
+    }>>;
+    supportsAssistantTurn: z.ZodOptional<z.ZodBoolean>;
+    supportsTextOutput: z.ZodOptional<z.ZodBoolean>;
+    textInput: z.ZodOptional<z.ZodEnum<{
+        backend: "backend";
+        conversation: "conversation";
+        unsupported: "unsupported";
+    }>>;
+    maxContextUpdateBytes: z.ZodOptional<z.ZodInt>;
 }, z.core.$strip>;
 export type ProviderCapabilities = z.infer<typeof ProviderCapabilitiesSchema>;
 export declare const PlayoutProgressSchema: z.ZodObject<{
@@ -17,6 +34,31 @@ export declare const PlayoutProgressSchema: z.ZodObject<{
     playedThroughSample: z.ZodInt;
 }, z.core.$strip>;
 export type PlayoutProgress = z.infer<typeof PlayoutProgressSchema>;
+/** Local device evidence. Discarded ranges must never become played-through acknowledgements. */
+export declare const PlayoutRangeSchema: z.ZodObject<{
+    streamId: z.ZodString;
+    startSample: z.ZodInt;
+    endSample: z.ZodInt;
+    status: z.ZodEnum<{
+        discarded: "discarded";
+        played: "played";
+    }>;
+}, z.core.$strip>;
+export type PlayoutRange = z.infer<typeof PlayoutRangeSchema>;
+/** Application-authored context; typed user messages still use sendText. */
+export declare const ConversationContextUpdateSchema: z.ZodObject<{
+    contextId: z.ZodString;
+    kind: z.ZodEnum<{
+        commentary: "commentary";
+        instructions: "instructions";
+        thinking: "thinking";
+    }>;
+    content: z.ZodString;
+    delegationId: z.ZodOptional<z.ZodString>;
+    callId: z.ZodOptional<z.ZodString>;
+    taskId: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type ConversationContextUpdate = z.infer<typeof ConversationContextUpdateSchema>;
 /** What the model may produce; ["text"] runs a session without audio output. */
 export declare const OutputModalitySchema: z.ZodEnum<{
     audio: "audio";
@@ -37,6 +79,11 @@ export type AssistantTurnRequest = z.infer<typeof AssistantTurnRequestSchema>;
  * the number that proves (and prices) cache effectiveness.
  */
 export declare const UsagePayloadSchema: z.ZodObject<{
+    responseId: z.ZodOptional<z.ZodString>;
+    scope: z.ZodOptional<z.ZodEnum<{
+        backend: "backend";
+        voice: "voice";
+    }>>;
     inputTokens: z.ZodNumber;
     outputTokens: z.ZodNumber;
     totalTokens: z.ZodNumber;
@@ -54,6 +101,18 @@ export declare const TranscriptPayloadSchema: z.ZodObject<{
     }>;
     text: z.ZodString;
     streamId: z.ZodOptional<z.ZodString>;
+    source: z.ZodOptional<z.ZodObject<{
+        scope: z.ZodEnum<{
+            backend: "backend";
+            voice: "voice";
+        }>;
+        responseId: z.ZodOptional<z.ZodString>;
+        itemId: z.ZodOptional<z.ZodString>;
+        outputIndex: z.ZodOptional<z.ZodInt>;
+        contentIndex: z.ZodOptional<z.ZodInt>;
+        summaryIndex: z.ZodOptional<z.ZodInt>;
+        delegationId: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
 }, z.core.$strip>;
 export type TranscriptPayload = z.infer<typeof TranscriptPayloadSchema>;
 /** Incremental text from either speaker; finalized by a matching `transcript`. */
@@ -64,8 +123,88 @@ export declare const TranscriptDeltaPayloadSchema: z.ZodObject<{
     }>;
     delta: z.ZodString;
     streamId: z.ZodOptional<z.ZodString>;
+    source: z.ZodOptional<z.ZodObject<{
+        scope: z.ZodEnum<{
+            backend: "backend";
+            voice: "voice";
+        }>;
+        responseId: z.ZodOptional<z.ZodString>;
+        itemId: z.ZodOptional<z.ZodString>;
+        outputIndex: z.ZodOptional<z.ZodInt>;
+        contentIndex: z.ZodOptional<z.ZodInt>;
+        summaryIndex: z.ZodOptional<z.ZodInt>;
+        delegationId: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
 }, z.core.$strip>;
 export type TranscriptDeltaPayload = z.infer<typeof TranscriptDeltaPayloadSchema>;
+/** Native timed text, without an authoritative turn/item completion. */
+export declare const TranscriptFragmentSchema: z.ZodObject<{
+    role: z.ZodEnum<{
+        assistant: "assistant";
+        user: "user";
+    }>;
+    text: z.ZodString;
+    fragmentId: z.ZodString;
+    startMs: z.ZodNumber;
+    endMs: z.ZodNumber;
+    timebase: z.ZodLiteral<"provider-session">;
+}, z.core.$strip>;
+export type TranscriptFragment = z.infer<typeof TranscriptFragmentSchema>;
+export declare const BackendResponseSchema: z.ZodObject<{
+    delegationId: z.ZodOptional<z.ZodString>;
+    responseId: z.ZodString;
+    phase: z.ZodEnum<{
+        completed: "completed";
+        started: "started";
+        "waiting-for-tools": "waiting-for-tools";
+    }>;
+    status: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const BackendToolSchema: z.ZodObject<{
+    delegationId: z.ZodOptional<z.ZodString>;
+    responseId: z.ZodString;
+    toolId: z.ZodString;
+    outputIndex: z.ZodOptional<z.ZodInt>;
+    name: z.ZodString;
+    phase: z.ZodEnum<{
+        completed: "completed";
+        failed: "failed";
+        started: "started";
+    }>;
+}, z.core.$strip>;
+export declare const DelegationCreatedSchema: z.ZodObject<{
+    delegationId: z.ZodString;
+    target: z.ZodEnum<{
+        client: "client";
+        responses: "responses";
+    }>;
+    offsetMs: z.ZodNumber;
+    responseId: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const ContextDeliverySchema: z.ZodObject<{
+    contextId: z.ZodString;
+    callId: z.ZodOptional<z.ZodString>;
+    taskId: z.ZodOptional<z.ZodString>;
+    phase: z.ZodEnum<{
+        acknowledged: "acknowledged";
+        failed: "failed";
+        submitted: "submitted";
+    }>;
+    kind: z.ZodEnum<{
+        commentary: "commentary";
+        instructions: "instructions";
+        thinking: "thinking";
+    }>;
+    startMs: z.ZodOptional<z.ZodNumber>;
+    endMs: z.ZodOptional<z.ZodNumber>;
+    message: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+/** Cumulative session duration, never summed across snapshots. */
+export declare const DurationUsageSchema: z.ZodObject<{
+    seconds: z.ZodNumber;
+    final: z.ZodBoolean;
+    contextWindowUsageRatio: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
 /** Generation state only: idle says nothing about buffered audio playback or background tasks. */
 export declare const ResponseStateSchema: z.ZodEnum<{
     idle: "idle";
@@ -161,7 +300,19 @@ export declare const ProviderEventSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
         channels: z.ZodInt;
         startSample: z.ZodInt;
         data: z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>;
-    }, z.core.$strip>;
+    }, z.core.$strict>;
+    source: z.ZodOptional<z.ZodObject<{
+        scope: z.ZodEnum<{
+            backend: "backend";
+            voice: "voice";
+        }>;
+        responseId: z.ZodOptional<z.ZodString>;
+        itemId: z.ZodOptional<z.ZodString>;
+        outputIndex: z.ZodOptional<z.ZodInt>;
+        contentIndex: z.ZodOptional<z.ZodInt>;
+        summaryIndex: z.ZodOptional<z.ZodInt>;
+        delegationId: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
 }, z.core.$strip>, z.ZodObject<{
     type: z.ZodLiteral<"audio.interrupted">;
     streamId: z.ZodString;
@@ -172,6 +323,18 @@ export declare const ProviderEventSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     }>;
     text: z.ZodString;
     streamId: z.ZodOptional<z.ZodString>;
+    source: z.ZodOptional<z.ZodObject<{
+        scope: z.ZodEnum<{
+            backend: "backend";
+            voice: "voice";
+        }>;
+        responseId: z.ZodOptional<z.ZodString>;
+        itemId: z.ZodOptional<z.ZodString>;
+        outputIndex: z.ZodOptional<z.ZodInt>;
+        contentIndex: z.ZodOptional<z.ZodInt>;
+        summaryIndex: z.ZodOptional<z.ZodInt>;
+        delegationId: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
     type: z.ZodLiteral<"transcript">;
 }, z.core.$strip>, z.ZodObject<{
     role: z.ZodEnum<{
@@ -180,15 +343,158 @@ export declare const ProviderEventSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     }>;
     delta: z.ZodString;
     streamId: z.ZodOptional<z.ZodString>;
+    source: z.ZodOptional<z.ZodObject<{
+        scope: z.ZodEnum<{
+            backend: "backend";
+            voice: "voice";
+        }>;
+        responseId: z.ZodOptional<z.ZodString>;
+        itemId: z.ZodOptional<z.ZodString>;
+        outputIndex: z.ZodOptional<z.ZodInt>;
+        contentIndex: z.ZodOptional<z.ZodInt>;
+        summaryIndex: z.ZodOptional<z.ZodInt>;
+        delegationId: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
     type: z.ZodLiteral<"transcript.delta">;
+}, z.core.$strip>, z.ZodObject<{
+    role: z.ZodEnum<{
+        assistant: "assistant";
+        user: "user";
+    }>;
+    text: z.ZodString;
+    fragmentId: z.ZodString;
+    startMs: z.ZodNumber;
+    endMs: z.ZodNumber;
+    timebase: z.ZodLiteral<"provider-session">;
+    type: z.ZodLiteral<"transcript.fragment">;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodEnum<{
+        reasoning_summary: "reasoning_summary";
+        refusal: "refusal";
+        text: "text";
+    }>;
+    source: z.ZodObject<{
+        delegationId: z.ZodOptional<z.ZodString>;
+        scope: z.ZodLiteral<"backend">;
+        responseId: z.ZodString;
+        itemId: z.ZodString;
+        outputIndex: z.ZodInt;
+        contentIndex: z.ZodOptional<z.ZodInt>;
+        summaryIndex: z.ZodOptional<z.ZodInt>;
+    }, z.core.$strip>;
+    delta: z.ZodString;
+    type: z.ZodLiteral<"backend.output.delta">;
+}, z.core.$strip>, z.ZodObject<{
+    source: z.ZodObject<{
+        delegationId: z.ZodOptional<z.ZodString>;
+        scope: z.ZodLiteral<"backend">;
+        responseId: z.ZodString;
+        itemId: z.ZodString;
+        outputIndex: z.ZodInt;
+    }, z.core.$strip>;
+    content: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodEnum<{
+            refusal: "refusal";
+            text: "text";
+        }>;
+        text: z.ZodString;
+        contentIndex: z.ZodInt;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"reasoning_summary">;
+        text: z.ZodString;
+        summaryIndex: z.ZodInt;
+    }, z.core.$strip>], "kind">>;
+    status: z.ZodOptional<z.ZodEnum<{
+        cancelled: "cancelled";
+        completed: "completed";
+        failed: "failed";
+        in_progress: "in_progress";
+        incomplete: "incomplete";
+    }>>;
+    type: z.ZodLiteral<"backend.output">;
+}, z.core.$strip>, z.ZodObject<{
+    delegationId: z.ZodOptional<z.ZodString>;
+    responseId: z.ZodString;
+    phase: z.ZodEnum<{
+        completed: "completed";
+        started: "started";
+        "waiting-for-tools": "waiting-for-tools";
+    }>;
+    status: z.ZodOptional<z.ZodString>;
+    type: z.ZodLiteral<"backend.response">;
+}, z.core.$strip>, z.ZodObject<{
+    delegationId: z.ZodOptional<z.ZodString>;
+    responseId: z.ZodString;
+    toolId: z.ZodString;
+    outputIndex: z.ZodOptional<z.ZodInt>;
+    name: z.ZodString;
+    phase: z.ZodEnum<{
+        completed: "completed";
+        failed: "failed";
+        started: "started";
+    }>;
+    type: z.ZodLiteral<"backend.tool">;
+}, z.core.$strip>, z.ZodObject<{
+    delegationId: z.ZodString;
+    target: z.ZodEnum<{
+        client: "client";
+        responses: "responses";
+    }>;
+    offsetMs: z.ZodNumber;
+    responseId: z.ZodOptional<z.ZodString>;
+    type: z.ZodLiteral<"delegation.created">;
+}, z.core.$strip>, z.ZodObject<{
+    contextId: z.ZodString;
+    callId: z.ZodOptional<z.ZodString>;
+    taskId: z.ZodOptional<z.ZodString>;
+    phase: z.ZodEnum<{
+        acknowledged: "acknowledged";
+        failed: "failed";
+        submitted: "submitted";
+    }>;
+    kind: z.ZodEnum<{
+        commentary: "commentary";
+        instructions: "instructions";
+        thinking: "thinking";
+    }>;
+    startMs: z.ZodOptional<z.ZodNumber>;
+    endMs: z.ZodOptional<z.ZodNumber>;
+    message: z.ZodOptional<z.ZodString>;
+    type: z.ZodLiteral<"context.delivery">;
+}, z.core.$strip>, z.ZodObject<{
+    seconds: z.ZodNumber;
+    final: z.ZodBoolean;
+    contextWindowUsageRatio: z.ZodOptional<z.ZodNumber>;
+    type: z.ZodLiteral<"usage.duration">;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"tool.delivery_failed">;
+    callId: z.ZodString;
+    error: z.ZodString;
 }, z.core.$strip>, z.ZodObject<{
     type: z.ZodLiteral<"tool.call">;
     call: z.ZodObject<{
         callId: z.ZodString;
         name: z.ZodString;
         arguments: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        source: z.ZodOptional<z.ZodObject<{
+            scope: z.ZodEnum<{
+                backend: "backend";
+                voice: "voice";
+            }>;
+            responseId: z.ZodOptional<z.ZodString>;
+            itemId: z.ZodOptional<z.ZodString>;
+            outputIndex: z.ZodOptional<z.ZodInt>;
+            contentIndex: z.ZodOptional<z.ZodInt>;
+            summaryIndex: z.ZodOptional<z.ZodInt>;
+            delegationId: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
     }, z.core.$strip>;
 }, z.core.$strip>, z.ZodObject<{
+    responseId: z.ZodOptional<z.ZodString>;
+    scope: z.ZodOptional<z.ZodEnum<{
+        backend: "backend";
+        voice: "voice";
+    }>>;
     inputTokens: z.ZodNumber;
     outputTokens: z.ZodNumber;
     totalTokens: z.ZodNumber;
@@ -204,5 +510,6 @@ export declare const ProviderEventSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
 }, z.core.$strip>, z.ZodObject<{
     type: z.ZodLiteral<"closed">;
     reason: z.ZodString;
+    finalized: z.ZodOptional<z.ZodBoolean>;
 }, z.core.$strip>], "type">;
 export type ProviderEvent = z.infer<typeof ProviderEventSchema>;

package/dist/internal/protocol/provider.js

@@ -1,5 +1,7 @@
 import { z } from "zod";
 import { AudioChunkSchema } from "./audio.js";
+import { BackendOutputDeltaSchema, BackendOutputSchema } from "./backend-output.js";
+import { ProviderOutputSourceSchema } from "./output-source.js";
 import { ToolCallSchema } from "./tools.js";
 /**
  * What a provider can actually do, declared at session start and recorded in
@@ -8,20 +10,53 @@ import { ToolCallSchema } from "./tools.js";
 export const ProviderCapabilitiesSchema = z.object({
     /** Microphone audio may keep flowing while the model is speaking (full duplex). */
     continuousInputDuringOutput: z.boolean(),
-    /** The model decides when to speak (server VAD); the harness never gates turns. */
+    /** The provider decides when to speak, through VAD or a continuous model policy; the harness does not gate turns. */
     modelManagedFloor: z.boolean(),
     supportsToolCalls: z.boolean(),
     /** Accepts out-of-band context injections such as task settlement announcements. */
     supportsAsyncContext: z.boolean(),
+    /** Accepts derived tool.status context silently, without starting an assistant turn. */
+    supportsToolStatusContext: z.boolean().optional(),
     /** Honors playout acknowledgements for truncation-accurate barge-in. */
     supportsPlayoutAcknowledgements: z.boolean(),
     /** Emits response.state for pending generation and queued continuations. Optional for continuous models. */
     reportsResponseState: z.boolean().optional(),
+    /**
+     * Continuous input requires a paced audio clock, including silence between utterances.
+     * This is separate from listening during output. Missing means on-demand input.
+     */
+    inputCadence: z.enum(["continuous", "on-demand"]).optional(),
+    /** Continuous audio spans display messages; response audio has separate streams. Missing means response. */
+    outputLifecycle: z.enum(["continuous", "response"]).optional(),
+    supportsAssistantTurn: z.boolean().optional(),
+    supportsTextOutput: z.boolean().optional(),
+    /** Typed text destination. Missing preserves legacy conversation input; attachments are not implied. */
+    textInput: z.enum(["conversation", "backend", "unsupported"]).optional(),
+    /** Maximum UTF-8 bytes for one direct appendContext update, when bounded by the adapter. */
+    maxContextUpdateBytes: z.int().positive().optional(),
 });
 export const PlayoutProgressSchema = z.object({
     streamId: z.string().min(1),
     playedThroughSample: z.int().nonnegative(),
 });
+/** Local device evidence. Discarded ranges must never become played-through acknowledgements. */
+export const PlayoutRangeSchema = z
+    .object({
+    streamId: z.string().min(1),
+    startSample: z.int().nonnegative(),
+    endSample: z.int().nonnegative(),
+    status: z.enum(["played", "discarded"]),
+})
+    .refine((range) => range.endSample > range.startSample, "Playout range must contain samples");
+/** Application-authored context; typed user messages still use sendText. */
+export const ConversationContextUpdateSchema = z.object({
+    contextId: z.string().min(1),
+    kind: z.enum(["thinking", "commentary", "instructions"]),
+    content: z.string().min(1).max(16_000),
+    delegationId: z.string().min(1).optional(),
+    callId: z.string().min(1).optional(),
+    taskId: z.string().min(1).optional(),
+});
 /** What the model may produce; ["text"] runs a session without audio output. */
 export const OutputModalitySchema = z.enum(["audio", "text"]);
 /**
@@ -38,6 +73,8 @@ export const AssistantTurnRequestSchema = z.object({
  * the number that proves (and prices) cache effectiveness.
  */
 export const UsagePayloadSchema = z.object({
+    responseId: z.string().min(1).optional(),
+    scope: z.enum(["voice", "backend"]).optional(),
     inputTokens: z.number().int().nonnegative(),
     outputTokens: z.number().int().nonnegative(),
     totalTokens: z.number().int().nonnegative(),
@@ -51,12 +88,61 @@ export const TranscriptPayloadSchema = z.object({
     role: z.enum(["user", "assistant"]),
     text: z.string().min(1),
     streamId: z.string().min(1).optional(),
+    source: ProviderOutputSourceSchema.optional(),
 });
 /** Incremental text from either speaker; finalized by a matching `transcript`. */
 export const TranscriptDeltaPayloadSchema = z.object({
     role: z.enum(["user", "assistant"]),
     delta: z.string().min(1),
     streamId: z.string().min(1).optional(),
+    source: ProviderOutputSourceSchema.optional(),
+});
+/** Native timed text, without an authoritative turn/item completion. */
+export const TranscriptFragmentSchema = z
+    .object({
+    role: z.enum(["user", "assistant"]),
+    text: z.string().min(1),
+    fragmentId: z.string().min(1),
+    startMs: z.number().nonnegative(),
+    endMs: z.number().nonnegative(),
+    timebase: z.literal("provider-session"),
+})
+    .refine((fragment) => fragment.endMs >= fragment.startMs, "Transcript interval ends before it starts");
+export const BackendResponseSchema = z.object({
+    delegationId: z.string().min(1).optional(),
+    responseId: z.string().min(1),
+    phase: z.enum(["started", "waiting-for-tools", "completed"]),
+    status: z.string().max(256).optional(),
+});
+export const BackendToolSchema = z.object({
+    delegationId: z.string().min(1).optional(),
+    responseId: z.string().min(1),
+    toolId: z.string().min(1),
+    outputIndex: z.int().nonnegative().optional(),
+    name: z.string().min(1),
+    phase: z.enum(["started", "completed", "failed"]),
+});
+export const DelegationCreatedSchema = z.object({
+    delegationId: z.string().min(1),
+    target: z.enum(["responses", "client"]),
+    offsetMs: z.number().nonnegative(),
+    responseId: z.string().min(1).optional(),
+});
+export const ContextDeliverySchema = z.object({
+    contextId: z.string().min(1),
+    callId: z.string().min(1).optional(),
+    taskId: z.string().min(1).optional(),
+    phase: z.enum(["submitted", "acknowledged", "failed"]),
+    kind: z.enum(["thinking", "commentary", "instructions"]),
+    startMs: z.number().nonnegative().optional(),
+    endMs: z.number().nonnegative().optional(),
+    message: z.string().max(2000).optional(),
+});
+/** Cumulative session duration, never summed across snapshots. */
+export const DurationUsageSchema = z.object({
+    seconds: z.number().nonnegative(),
+    final: z.boolean(),
+    contextWindowUsageRatio: z.number().min(0).max(1).optional(),
 });
 /** Generation state only: idle says nothing about buffered audio playback or background tasks. */
 export const ResponseStateSchema = z.enum(["pending", "idle"]);
@@ -111,13 +197,26 @@ export const ProviderEventSchema = z.discriminatedUnion("type", [
     /** Optional allow-listed diagnostics for explaining provider behavior after the fact. */
     z.object({ type: z.literal("diagnostic"), diagnostic: ProviderDiagnosticSchema }),
     /** Model speech as sample-addressed PCM. */
-    z.object({ type: z.literal("audio.output"), chunk: AudioChunkSchema }),
+    z.object({
+        type: z.literal("audio.output"),
+        chunk: AudioChunkSchema,
+        source: ProviderOutputSourceSchema.optional(),
+    }),
     /** Clear queued playback for this stream and ignore its subsequent audio chunks. */
     z.object({ type: z.literal("audio.interrupted"), streamId: z.string().min(1) }),
     /** Final transcript text for either role. */
     TranscriptPayloadSchema.extend({ type: z.literal("transcript") }),
     /** Incremental text from either speaker; assembled into a streaming text part. */
     TranscriptDeltaPayloadSchema.extend({ type: z.literal("transcript.delta") }),
+    TranscriptFragmentSchema.safeExtend({ type: z.literal("transcript.fragment") }),
+    BackendOutputDeltaSchema.safeExtend({ type: z.literal("backend.output.delta") }),
+    BackendOutputSchema.extend({ type: z.literal("backend.output") }),
+    BackendResponseSchema.extend({ type: z.literal("backend.response") }),
+    BackendToolSchema.extend({ type: z.literal("backend.tool") }),
+    DelegationCreatedSchema.extend({ type: z.literal("delegation.created") }),
+    ContextDeliverySchema.extend({ type: z.literal("context.delivery") }),
+    DurationUsageSchema.extend({ type: z.literal("usage.duration") }),
+    z.object({ type: z.literal("tool.delivery_failed"), callId: z.string().min(1), error: z.string().min(1) }),
     /** The model requested a tool invocation. */
     z.object({ type: z.literal("tool.call"), call: ToolCallSchema }),
     /** Token accounting for one completed response. */
@@ -129,5 +228,5 @@ export const ProviderEventSchema = z.discriminatedUnion("type", [
         recoverable: z.boolean(),
     }),
     /** Terminal: the provider connection is gone. Always the last event. */
-    z.object({ type: z.literal("closed"), reason: z.string().min(1) }),
+    z.object({ type: z.literal("closed"), reason: z.string().min(1), finalized: z.boolean().optional() }),
 ]);