agenthooksprotocol 0.0.0-bootstrap.0

package/dist/src/draft/generated.d.ts

@@ -0,0 +1,3085 @@
+export declare const SCHEMA_REVISION: "draft";
+export declare const PROTOCOL_VERSION: "draft";
+export type JsonPrimitive = null | boolean | number | string;
+export type JsonValue = JsonPrimitive | JsonValue[] | {
+    [key: string]: JsonValue;
+};
+export type AdditionalProperties = {
+    [key: string]: JsonValue;
+};
+export type OpenString<Known extends string> = Known | (string & {});
+export type UnknownVariant<Discriminator extends string> = AdditionalProperties & {
+    [Key in Discriminator]: string;
+};
+export interface ParseDiagnostic {
+    readonly path: string;
+    readonly code: "invalid_type" | "missing_required" | "literal_mismatch" | "unknown_enum" | "unknown_variant" | "invalid_known_variant" | "no_union_match" | "ambiguous_union" | "invalid_json";
+    readonly severity: "error" | "warning";
+    readonly message: string;
+}
+export type ParseResult<T> = {
+    readonly ok: true;
+    readonly value: T;
+    readonly raw: JsonValue;
+    readonly diagnostics: readonly ParseDiagnostic[];
+} | {
+    readonly ok: false;
+    readonly raw?: JsonValue;
+    readonly diagnostics: readonly ParseDiagnostic[];
+};
+/** Source: schema/draft/registration.schema.json#/$defs/authentication */
+export type Authentication = ({
+    tokenEnv?: string;
+    tokenRef?: string;
+    type: "bearer";
+} & AdditionalProperties & {
+    tokenEnv: JsonValue;
+} & AdditionalProperties) | ({
+    tokenRef: JsonValue;
+} & AdditionalProperties) | ({
+    clientId: string;
+    clientSecretRef?: string;
+    flow: OpenString<"authorization_code_pkce" | "client_credentials">;
+    issuer: string;
+    resource: string;
+    scopes?: Array<string>;
+    type: "oauth";
+} & AdditionalProperties);
+/** Source: schema/draft/registration.schema.json#/$defs/backend */
+export type Backend = {
+    authentication?: Authentication;
+    id: ReverseDnsName;
+    subscriptions: Array<InterceptSubscription | ObserveSubscription | UnknownVariant<"mode">>;
+    transport: StdioTransport | HttpTransport | UnknownVariant<"type">;
+} & AdditionalProperties;
+/** Source: schema/draft/capabilities.schema.json# */
+export type Capabilities = {
+    effects: Array<OpenString<"deny" | "allow" | "ask" | "modify" | "message" | "return" | "flow" | "inject"> | string>;
+    elicitation?: {
+        form?: {} & AdditionalProperties;
+        url?: {} & AdditionalProperties;
+    } & AdditionalProperties;
+    flow?: {
+        continuationCount?: number;
+        maxContinuations?: number;
+        operations: Array<OpenString<"stop" | "continue">>;
+        remainingContinuations?: number;
+    } & AdditionalProperties;
+    inject?: {
+        context: {
+            append: true;
+            deliverAt: Array<OpenString<"now" | "next_turn">>;
+        } & AdditionalProperties;
+    } & AdditionalProperties;
+    modify?: {
+        content?: ({
+            merge: boolean;
+            replace: boolean;
+        } & AdditionalProperties & {
+            replace: true;
+        } & AdditionalProperties) | ({
+            merge: true;
+        } & AdditionalProperties);
+        input?: ({
+            merge: boolean;
+            replace: boolean;
+        } & AdditionalProperties & {
+            replace: true;
+        } & AdditionalProperties) | ({
+            merge: true;
+        } & AdditionalProperties);
+        instructions?: ({
+            merge: boolean;
+            replace: boolean;
+        } & AdditionalProperties & {
+            replace: true;
+        } & AdditionalProperties) | ({
+            merge: true;
+        } & AdditionalProperties);
+        output?: ({
+            merge: boolean;
+            replace: boolean;
+        } & AdditionalProperties & {
+            replace: true;
+        } & AdditionalProperties) | ({
+            merge: true;
+        } & AdditionalProperties);
+        prompt?: ({
+            merge: boolean;
+            replace: boolean;
+        } & AdditionalProperties & {
+            replace: true;
+        } & AdditionalProperties) | ({
+            merge: true;
+        } & AdditionalProperties);
+        request?: ({
+            merge: boolean;
+            replace: boolean;
+        } & AdditionalProperties & {
+            replace: true;
+        } & AdditionalProperties) | ({
+            merge: true;
+        } & AdditionalProperties);
+        response?: ({
+            merge: boolean;
+            replace: boolean;
+        } & AdditionalProperties & {
+            replace: true;
+        } & AdditionalProperties) | ({
+            merge: true;
+        } & AdditionalProperties);
+        summary?: ({
+            merge: boolean;
+            replace: boolean;
+        } & AdditionalProperties & {
+            replace: true;
+        } & AdditionalProperties) | ({
+            merge: true;
+        } & AdditionalProperties);
+        workspace?: ({
+            merge: boolean;
+            replace: boolean;
+        } & AdditionalProperties & {
+            replace: true;
+        } & AdditionalProperties) | ({
+            merge: true;
+        } & AdditionalProperties);
+    } & AdditionalProperties;
+} & AdditionalProperties;
+/** Source: schema/draft/capabilities-request.schema.json# */
+export type CapabilitiesRequest = JsonRpcRequest & {
+    method: "hooks/capabilities";
+    params: {
+        protocolVersion: ProtocolVersion;
+    } & AdditionalProperties;
+} & AdditionalProperties;
+/** Source: schema/draft/capabilities-response.schema.json# */
+export type CapabilitiesResponse = JsonRpcSuccessResponse & {
+    result: {
+        manifest: {
+            authentication: Array<OpenString<"bearer" | "oauth">>;
+            contentCategories: Array<string>;
+            correlationIdentityFields: Array<string>;
+            events: Array<{
+                capabilities?: Capabilities;
+                event: OpenString<"tool.before" | "tool.after" | "session.start" | "session.end" | "config.change.before" | "config.change.after" | "turn.start" | "turn.finish.before" | "turn.end" | "turn.progress" | "model.request.before" | "model.response.after" | "model.error" | "model.switch.before" | "model.switch.after" | "tool.permission.request" | "tool.permission.resolved" | "tool.progress" | "tool.batch.after" | "context.compact.before" | "context.compact.after" | "task.change.before" | "task.change.after" | "user.attention" | "user.elicitation.request" | "user.elicitation.result" | "user.message.inbound" | "user.message.outbound" | "workspace.change.before" | "workspace.change.after" | "file.changed" | "hook.failure">;
+                modes: Array<OpenString<"observe" | "intercept">>;
+            } & AdditionalProperties>;
+            gaps: Array<{
+                path: string;
+                reason: string;
+            } & AdditionalProperties>;
+            limits: {
+                maxContinuations?: number;
+                maxTimeoutMs?: number;
+                maxUploadBytes?: number;
+                minTimeoutMs?: number;
+            } & AdditionalProperties;
+            managedPolicy: {
+                disableable: boolean;
+                scopes: Array<OpenString<"user" | "project" | "managed">>;
+            } & AdditionalProperties;
+            toolPaths: Array<string>;
+            transports: Array<OpenString<"http" | "stdio" | "in_process">>;
+        } & AdditionalProperties;
+        protocolVersion: ProtocolVersion;
+    } & AdditionalProperties;
+} & AdditionalProperties;
+/** Source: schema/draft/catalogue-event.schema.json# */
+export type CatalogueEvent = ConfigChangeBeforeEvent | ConfigChangeAfterEvent | TurnStartEvent | TurnFinishBeforeEvent | TurnEndEvent | TurnProgressEvent | ModelRequestBeforeEvent | ModelResponseAfterEvent | ModelErrorEvent | ModelSwitchBeforeEvent | ModelSwitchAfterEvent | ToolPermissionRequestEvent | ToolPermissionResolvedEvent | ToolProgressEvent | ToolBatchAfterEvent | ContextCompactBeforeEvent | ContextCompactAfterEvent | TaskChangeBeforeEvent | TaskChangeAfterEvent | UserAttentionEvent | UserElicitationRequestEvent | UserElicitationResultEvent | UserMessageInboundEvent | UserMessageOutboundEvent | WorkspaceChangeBeforeEvent | WorkspaceChangeAfterEvent | FileChangedEvent | HookFailureEvent;
+/** Source: schema/draft/catalogue-event.schema.json#/$defs/config.change.after */
+export type ConfigChangeAfterEvent = {
+    extensions?: Extensions;
+    gaps?: Array<{
+        path: string;
+        reason: string;
+    } & AdditionalProperties>;
+    id: string;
+    items?: Array<ContentItem>;
+    native?: NativeEvent;
+    parentEventId?: string;
+    session?: Session;
+    source: string;
+    synthesized?: boolean;
+    time: string;
+    turn?: {
+        id: string;
+        synthesized?: boolean;
+    } & AdditionalProperties;
+    type: "config.change.after";
+} & AdditionalProperties & InteractionEventConfigChangeAfter;
+/** Source: schema/draft/capabilities.schema.json#/$defs/config.change.before */
+export type ConfigChangeBeforeCapabilities = Capabilities & {
+    effects?: Array<OpenString<"deny" | "message">>;
+} & AdditionalProperties;
+/** Source: schema/draft/catalogue-event.schema.json#/$defs/config.change.before */
+export type ConfigChangeBeforeEvent = {
+    extensions?: Extensions;
+    gaps?: Array<{
+        path: string;
+        reason: string;
+    } & AdditionalProperties>;
+    id: string;
+    items?: Array<ContentItem>;
+    native?: NativeEvent;
+    parentEventId?: string;
+    session?: Session;
+    source: string;
+    synthesized?: boolean;
+    time: string;
+    turn?: {
+        id: string;
+        synthesized?: boolean;
+    } & AdditionalProperties;
+    type: "config.change.before";
+} & AdditionalProperties & InteractionEventConfigChangeBefore;
+/** Source: schema/draft/content-item.schema.json# */
+export type ContentItem = ({
+    body: ContentReference;
+    category?: string;
+    id: string;
+    kind: string;
+    mediaType: string;
+    parentItemId?: string;
+    role?: string;
+    selection: "body";
+    sha256?: string;
+    size?: number;
+    synthesized?: boolean;
+} & AdditionalProperties) | ({
+    category?: string;
+    gap: {
+        path?: string;
+        reason: string;
+    } & AdditionalProperties;
+    id: string;
+    kind: string;
+    mediaType: string;
+    parentItemId?: string;
+    role?: string;
+    selection: "body";
+    sha256?: string;
+    size?: number;
+    synthesized?: boolean;
+} & AdditionalProperties) | ({
+    category?: string;
+    id: string;
+    kind: string;
+    mediaType: string;
+    parentItemId?: string;
+    role?: string;
+    selection: "metadata";
+    sha256?: string;
+    size?: number;
+    synthesized?: boolean;
+} & AdditionalProperties) | ({
+    category?: string;
+    id: string;
+    kind: string;
+    mediaType: string;
+    parentItemId?: string;
+    role?: string;
+    selection: "omit";
+    sha256?: string;
+    size?: number;
+    synthesized?: boolean;
+} & AdditionalProperties);
+/** Source: schema/draft/content-reference.schema.json# */
+export type ContentReference = {
+    ref: string;
+    sha256: string;
+    size: number;
+} & AdditionalProperties;
+/** Source: schema/draft/content-selection.schema.json# */
+export type ContentSelection = {
+    audio?: OpenString<"body" | "metadata" | "omit">;
+    default: OpenString<"body" | "metadata" | "omit">;
+    files?: OpenString<"body" | "metadata" | "omit">;
+    images?: OpenString<"body" | "metadata" | "omit">;
+    reasoning?: OpenString<"body" | "metadata" | "omit">;
+    text?: OpenString<"body" | "metadata" | "omit">;
+    video?: OpenString<"body" | "metadata" | "omit">;
+} & AdditionalProperties;
+/** Source: schema/draft/content-upload.schema.json# */
+export type ContentUpload = {
+    auth?: Authentication;
+    endpoint: string;
+    maxBytes: number;
+    timeoutMs: number;
+} & AdditionalProperties;
+/** Source: schema/draft/capabilities.schema.json#/$defs/context.compact.after */
+export type ContextCompactAfterCapabilities = Capabilities & {
+    effects?: Array<OpenString<"inject" | "modify" | "message">>;
+    modify?: {} & AdditionalProperties;
+} & AdditionalProperties;
+/** Source: schema/draft/catalogue-event.schema.json#/$defs/context.compact.after */
+export type ContextCompactAfterEvent = ExecutionEventContextCompactAfter;
+/** Source: schema/draft/capabilities.schema.json#/$defs/context.compact.before */
+export type ContextCompactBeforeCapabilities = Capabilities & {
+    effects?: Array<OpenString<"deny" | "modify" | "return" | "inject" | "message">>;
+    modify?: {} & AdditionalProperties;
+} & AdditionalProperties;
+/** Source: schema/draft/catalogue-event.schema.json#/$defs/context.compact.before */
+export type ContextCompactBeforeEvent = ExecutionEventContextCompactBefore;
+/** Source: schema/draft/deny-effect.schema.json# */
+export type DenyEffect = {
+    code?: string;
+    extensions?: Extensions;
+    reason: string;
+    type: "deny";
+} & AdditionalProperties;
+/** Source: schema/draft/effect.schema.json# */
+export type Effect = DenyEffect | ({
+    type: "allow";
+} & AdditionalProperties) | ({
+    type: "ask";
+} & AdditionalProperties) | ({
+    operation: OpenString<"replace" | "merge">;
+    target: OpenString<"input" | "output" | "prompt" | "request" | "response" | "content" | "instructions" | "summary" | "workspace">;
+    type: "modify";
+    value: JsonValue;
+} & AdditionalProperties) | ({
+    text: string;
+    type: "message";
+} & AdditionalProperties) | ({
+    type: "return";
+    value: JsonValue;
+} & AdditionalProperties) | ({
+    operation: "stop";
+    reason: string;
+    type: "flow";
+} & AdditionalProperties) | ({
+    instruction?: string;
+    operation: "continue";
+    type: "flow";
+} & AdditionalProperties) | ({
+    deliverAt: OpenString<"now" | "next_turn">;
+    operation: "append";
+    target: "context";
+    type: "inject";
+    value: JsonValue;
+} & AdditionalProperties);
+/** Source: schema/draft/execution-event.schema.json# */
+export type ExecutionEvent = ExecutionEventTurnStart | ExecutionEventTurnFinishBefore | ExecutionEventTurnEnd | ExecutionEventTurnProgress | ExecutionEventModelRequestBefore | ExecutionEventModelResponseAfter | ExecutionEventModelError | ExecutionEventModelSwitchBefore | ExecutionEventModelSwitchAfter | ExecutionEventToolPermissionRequest | ExecutionEventToolPermissionResolved | ExecutionEventToolProgress | ExecutionEventToolBatchAfter | ExecutionEventContextCompactBefore | ExecutionEventContextCompactAfter | UnknownVariant<"type">;
+/** Source: schema/draft/execution-event.schema.json#/$defs/attempt */
+export type ExecutionEventAttempt = {
+    id: string;
+    number: number;
+    synthesized?: boolean;
+} & AdditionalProperties;
+/** Source: schema/draft/execution-event.schema.json#/$defs/attemptUsage */
+export type ExecutionEventAttemptusage = ExecutionEventUsage & {
+    kind?: "amount";
+    provenance?: OpenString<"provider" | "estimate">;
+    scope?: "attempt";
+} & AdditionalProperties;
+/** Source: schema/draft/execution-event.schema.json#/$defs/batch */
+export type ExecutionEventBatch = {
+    callIds: Array<string>;
+    id: string;
+    synthesized?: boolean;
+} & AdditionalProperties;
+/** Source: schema/draft/execution-event.schema.json#/$defs/context.compact.after */
+export type ExecutionEventContextCompactAfter = {
+    execution: ExecutionEventExecution;
+    extensions?: Extensions;
+    gaps?: Array<{
+        path: string;
+        reason: string;
+    } & AdditionalProperties>;
+    id: string;
+    items?: Array<ModelVisibleItem>;
+    native?: NativeEvent;
+    parentEventId?: string;
+    removed: Array<{
+        id: string;
+    } & AdditionalProperties>;
+    session?: Session;
+    source: string;
+    summary: ModelVisibleItem;
+    synthesized?: boolean;
+    time: string;
+    tokenCounts?: ExecutionEventTokencounts;
+    turn?: {
+        id: string;
+        synthesized?: boolean;
+    } & AdditionalProperties;
+    type: "context.compact.after";
+} & AdditionalProperties;
+/** Source: schema/draft/execution-event.schema.json#/$defs/context.compact.before */
+export type ExecutionEventContextCompactBefore = {
+    extensions?: Extensions;
+    gaps?: Array<{
+        path: string;
+        reason: string;
+    } & AdditionalProperties>;
+    id: string;
+    instructions?: ContentItem;
+    items: Array<ModelVisibleItem>;
+    native?: NativeEvent;
+    parentEventId?: string;
+    session?: Session;
+    source: string;
+    synthesized?: boolean;
+    time: string;
+    tokenCounts?: ExecutionEventTokencounts;
+    trigger: OpenString<"auto" | "manual" | "hook">;
+    turn?: {
+        id: string;
+        synthesized?: boolean;
+    } & AdditionalProperties;
+    type: "context.compact.before";
+} & AdditionalProperties & JsonValue & {
+    tokenCounts?: JsonValue;
+} & AdditionalProperties;
+/** Source: schema/draft/execution-event.schema.json#/$defs/error */
+export type ExecutionEventError = {
+    class: string;
+    code?: string;
+    message: string;
+    native?: NativeEvent;
+    status?: string | number;
+} & AdditionalProperties;
+/** Source: schema/draft/execution-event.schema.json#/$defs/execution */
+export type ExecutionEventExecution = ({
+    status: "executed";
+} & AdditionalProperties) | ({
+    reason: "supplied_result";
+    status: "skipped";
+} & AdditionalProperties) | ({
+    detail?: string;
+    reason: "policy";
+    status: "skipped";
+} & AdditionalProperties) | ({
+    detail?: string;
+    reason: "cancelled";
+    status: "skipped";
+} & AdditionalProperties) | ({
+    detail?: string;
+    reason: "timeout";
+    status: "skipped";
+} & AdditionalProperties) | ({
+    detail?: string;
+    reason: "other";
+    status: "skipped";
+} & AdditionalProperties);
+/** Source: schema/draft/execution-event.schema.json#/$defs/fileChange */
+export type ExecutionEventFilechange = {
+    after?: ContentItem;
+    before?: ContentItem;
+    change: OpenString<"created" | "modified" | "deleted" | "moved">;
+    path: string;
+    previousPath?: string;
+} & AdditionalProperties;
+/** Source: schema/draft/execution-event.schema.json#/$defs/mcp */
+export type ExecutionEventMcp = {
+    connection: ({
+        gaps?: Array<{
+            path: string;
+            reason: string;
+        } & AdditionalProperties>;
+        transport: "http";
+        url?: string;
+    } & AdditionalProperties & {
+        url: JsonValue;
+    } & AdditionalProperties) | ({
+        gaps: JsonValue;
+    } & AdditionalProperties) | ({
+        gaps?: Array<{
+            path: string;
+            reason: string;
+        } & AdditionalProperties>;
+        transport: "sse";
+        url?: string;
+    } & AdditionalProperties & {
+        url: JsonValue;
+    } & AdditionalProperties) | ({
+        gaps: JsonValue;
+    } & AdditionalProperties) | ({
+        args?: Array<string>;
+        command?: string;
+        cwd?: string;
+        gaps?: Array<{
+            path: string;
+            reason: string;
+        } & AdditionalProperties>;
+        transport: "stdio";
+    } & AdditionalProperties & {
+        command: JsonValue;
+    } & AdditionalProperties) | ({
+        gaps: JsonValue;
+    } & AdditionalProperties & {
+        args: JsonValue;
+    } & AdditionalProperties) | ({
+        gaps: JsonValue;
+    } & AdditionalProperties & {
+        cwd: JsonValue;
+    } & AdditionalProperties) | ({
+        gaps: JsonValue;
+    } & AdditionalProperties) | ({
+        address?: string;
+        addressForm?: string;
+        gaps?: Array<{
+            path: string;
+            reason: string;
+        } & AdditionalProperties>;
+        transport: string;
+    } & AdditionalProperties & {
+        addressForm: JsonValue;
+    } & AdditionalProperties) | ({
+        gaps: JsonValue;
+    } & AdditionalProperties & {
+        address: JsonValue;
+    } & AdditionalProperties) | ({
+        gaps: JsonValue;
+    } & AdditionalProperties) | UnknownVariant<"transport">;
+    provenance: OpenString<"runtime" | "inferred">;
+    server: {
+        id: string;
+        name?: string;
+    } & AdditionalProperties;
+    toolName: string;
+} & AdditionalProperties;
+/** Source: schema/draft/execution-event.schema.json#/$defs/model */
+export type ExecutionEventModel = {
+    id: string;
+    provider: string;
+} & AdditionalProperties;
+/** Source: schema/draft/execution-event.schema.json#/$defs/model.error */
+export type ExecutionEventModelError = {
+    attempt: ExecutionEventAttempt;
+    error: ExecutionEventError;
+    execution: ExecutionEventExecution & {
+        status?: "executed";
+    } & AdditionalProperties;
+    extensions?: Extensions;
+    gaps?: Array<{
+        path: string;
+        reason: string;
+    } & AdditionalProperties>;
+    id: string;
+    items?: Array<ContentItem>;
+    latencyMs?: number;
+    model: ExecutionEventModel;
+    native?: NativeEvent;
+    parentEventId?: string;
+    recovery?: string;
+    session?: Session;
+    source: string;
+    synthesized?: boolean;
+    time: string;
+    turn?: {
+        id: string;
+        synthesized?: boolean;
+    } & AdditionalProperties;
+    type: "model.error";
+    usage?: ExecutionEventAttemptusage;
+} & AdditionalProperties;
+/** Source: schema/draft/execution-event.schema.json#/$defs/model.request.before */
+export type ExecutionEventModelRequestBefore = {
+    attempt: ExecutionEventAttempt;
+    extensions?: Extensions;
+    gaps?: Array<{
+        path: string;
+        reason: string;
+    } & AdditionalProperties>;
+    id: string;
+    items: Array<ModelVisibleItem>;
+    model: ExecutionEventModel;
+    native?: NativeEvent;
+    params: {} & AdditionalProperties;
+    parentEventId?: string;
+    session?: Session;
+    source: string;
+    synthesized?: boolean;
+    time: string;
+    turn?: {
+        id: string;
+        synthesized?: boolean;
+    } & AdditionalProperties;
+    type: "model.request.before";
+} & AdditionalProperties;
+/** Source: schema/draft/execution-event.schema.json#/$defs/model.response.after */
+export type ExecutionEventModelResponseAfter = {
+    attempt: ExecutionEventAttempt;
+    execution: ExecutionEventExecution;
+    extensions?: Extensions;
+    finishReason: string;
+    gaps?: Array<{
+        path: string;
+        reason: string;
+    } & AdditionalProperties>;
+    id: string;
+    items: Array<ModelVisibleItem>;
+    latencyMs?: number;
+    model: ExecutionEventModel;
+    native?: NativeEvent;
+    parentEventId?: string;
+    session?: Session;
+    source: string;
+    synthesized?: boolean;
+    time: string;
+    turn?: {
+        id: string;
+        synthesized?: boolean;
+    } & AdditionalProperties;
+    type: "model.response.after";
+    usage?: ExecutionEventAttemptusage;
+} & AdditionalProperties;
+/** Source: schema/draft/execution-event.schema.json#/$defs/model.switch.after */
+export type ExecutionEventModelSwitchAfter = {
+    current: ExecutionEventModel;
+    extensions?: Extensions;
+    gaps?: Array<{
+        path: string;
+        reason: string;
+    } & AdditionalProperties>;
+    id: string;
+    items?: Array<ContentItem>;
+    native?: NativeEvent;
+    parentEventId?: string;
+    previous: ExecutionEventModel;
+    reason: string;
+    session?: Session;
+    source: string;
+    synthesized?: boolean;
+    time: string;
+    turn?: {
+        id: string;
+        synthesized?: boolean;
+    } & AdditionalProperties;
+    type: "model.switch.after";
+} & AdditionalProperties;
+/** Source: schema/draft/execution-event.schema.json#/$defs/model.switch.before */
+export type ExecutionEventModelSwitchBefore = {
+    current: ExecutionEventModel;
+    extensions?: Extensions;
+    gaps?: Array<{
+        path: string;
+        reason: string;
+    } & AdditionalProperties>;
+    id: string;
+    items?: Array<ContentItem>;
+    native?: NativeEvent;
+    parentEventId?: string;
+    pricing?: {
+        currency: string;
+        inputPerMillionTokens?: number;
+        outputPerMillionTokens?: number;
+    } & AdditionalProperties;
+    proposed: ExecutionEventModel;
+    reason: string;
+    session?: Session;
+    source: string;
+    synthesized?: boolean;
+    time: string;
+    turn?: {
+        id: string;
+        synthesized?: boolean;
+    } & AdditionalProperties;
+    type: "model.switch.before";
+} & AdditionalProperties;
+/** Source: schema/draft/execution-event.schema.json#/$defs/tokenCounts */
+export type ExecutionEventTokencounts = {
+    after?: number;
+    before?: number;
+} & AdditionalProperties;
+/** Source: schema/draft/execution-event.schema.json#/$defs/tool */
+export type ExecutionEventTool = {
+    input: {} & AdditionalProperties;
+    kind?: string;
+    mcp?: ExecutionEventMcp;
+    name: string;
+    origin: OpenString<"native" | "mcp">;
+} & AdditionalProperties;
+/** Source: schema/draft/execution-event.schema.json#/$defs/tool.batch.after */
+export type ExecutionEventToolBatchAfter = {
+    batch: {
+        id: string;
+        synthesized?: boolean;
+    } & AdditionalProperties;
+    calls: Array<{
+        batch?: ExecutionEventBatch;
+        call: {
+            id: string;
+            synthesized?: boolean;
+        } & AdditionalProperties;
+        execution: ExecutionEventExecution;
+        outcome: OpenString<"ok" | "error" | "denied" | "cancelled" | "timeout">;
+        path: string;
+        tool: ExecutionEventTool;
+    } & AdditionalProperties>;
+    extensions?: Extensions;
+    gaps?: Array<{
+        path: string;
+        reason: string;
+    } & AdditionalProperties>;
+    id: string;
+    items?: Array<ContentItem>;
+    native?: NativeEvent;
+    parentEventId?: string;
+    session?: Session;
+    source: string;
+    synthesized?: boolean;
+    time: string;
+    turn?: {
+        id: string;
+        synthesized?: boolean;
+    } & AdditionalProperties;
+    type: "tool.batch.after";
+} & AdditionalProperties;
+/** Source: schema/draft/execution-event.schema.json#/$defs/tool.permission.request */
+export type ExecutionEventToolPermissionRequest = {
+    batch?: ExecutionEventBatch;
+    call: {
+        id: string;
+        synthesized?: boolean;
+    } & AdditionalProperties;
+    extensions?: Extensions;
+    gaps?: Array<{
+        path: string;
+        reason: string;
+    } & AdditionalProperties>;
+    id: string;
+    items?: Array<ContentItem>;
+    native?: NativeEvent;
+    parentEventId?: string;
+    path: string;
+    sandboxBypass: boolean;
+    session?: Session;
+    source: string;
+    suggestions: Array<{} & AdditionalProperties>;
+    synthesized?: boolean;
+    time: string;
+    tool: ExecutionEventTool;
+    turn?: {
+        id: string;
+        synthesized?: boolean;
+    } & AdditionalProperties;
+    type: "tool.permission.request";
+} & AdditionalProperties;
+/** Source: schema/draft/execution-event.schema.json#/$defs/tool.permission.resolved */
+export type ExecutionEventToolPermissionResolved = {
+    batch?: ExecutionEventBatch;
+    call: {
+        id: string;
+        synthesized?: boolean;
+    } & AdditionalProperties;
+    decidedBy: OpenString<"user" | "policy" | "hook" | "auto" | "classifier">;
+    decision: OpenString<"allow" | "deny">;
+    extensions?: Extensions;
+    gaps?: Array<{
+        path: string;
+        reason: string;
+    } & AdditionalProperties>;
+    id: string;
+    items?: Array<ContentItem>;
+    native?: NativeEvent;
+    parentEventId?: string;
+    path: string;
+    session?: Session;
+    source: string;
+    synthesized?: boolean;
+    time: string;
+    tool: ExecutionEventTool;
+    turn?: {
+        id: string;
+        synthesized?: boolean;
+    } & AdditionalProperties;
+    type: "tool.permission.resolved";
+} & AdditionalProperties;
+/** Source: schema/draft/execution-event.schema.json#/$defs/tool.progress */
+export type ExecutionEventToolProgress = {
+    backgrounded: boolean;
+    batch?: ExecutionEventBatch;
+    call: {
+        id: string;
+        synthesized?: boolean;
+    } & AdditionalProperties;
+    extensions?: Extensions;
+    gaps?: Array<{
+        path: string;
+        reason: string;
+    } & AdditionalProperties>;
+    id: string;
+    items?: Array<ContentItem>;
+    native?: NativeEvent;
+    parentEventId?: string;
+    partialOutput: ModelVisibleItem;
+    path: string;
+    session?: Session;
+    source: string;
+    synthesized?: boolean;
+    time: string;
+    tool: ExecutionEventTool;
+    turn?: {
+        id: string;
+        synthesized?: boolean;
+    } & AdditionalProperties;
+    type: "tool.progress";
+} & AdditionalProperties;
+/** Source: schema/draft/execution-event.schema.json#/$defs/turn.end */
+export type ExecutionEventTurnEnd = {
+    continuationCount: number;
+    error?: ExecutionEventError;
+    extensions?: Extensions;
+    gaps?: Array<{
+        path: string;
+        reason: string;
+    } & AdditionalProperties>;
+    id: string;
+    items: Array<ModelVisibleItem>;
+    lastAssistantItem?: {
+        id: string;
+        synthesized?: boolean;
+    } & AdditionalProperties;
+    native?: NativeEvent;
+    outcome: OpenString<"completed" | "failed" | "cancelled" | "max_iterations">;
+    parentEventId?: string;
+    session?: Session;
+    source: string;
+    synthesized?: boolean;
+    time: string;
+    turn: {
+        id: string;
+        synthesized?: boolean;
+    } & AdditionalProperties;
+    type: "turn.end";
+    usage?: ExecutionEventTurnusage;
+} & AdditionalProperties;
+/** Source: schema/draft/execution-event.schema.json#/$defs/turn.finish.before */
+export type ExecutionEventTurnFinishBefore = {
+    continuationCount: number;
+    extensions?: Extensions;
+    gaps?: Array<{
+        path: string;
+        reason: string;
+    } & AdditionalProperties>;
+    id: string;
+    items: Array<ModelVisibleItem>;
+    lastAssistantItem?: {
+        id: string;
+        synthesized?: boolean;
+    } & AdditionalProperties;
+    native?: NativeEvent;
+    outcome: OpenString<"completed" | "failed" | "cancelled" | "max_iterations">;
+    parentEventId?: string;
+    session?: Session;
+    source: string;
+    synthesized?: boolean;
+    time: string;
+    turn: {
+        id: string;
+        synthesized?: boolean;
+    } & AdditionalProperties;
+    type: "turn.finish.before";
+    usage?: ExecutionEventTurnusage;
+} & AdditionalProperties;
+/** Source: schema/draft/execution-event.schema.json#/$defs/turn.progress */
+export type ExecutionEventTurnProgress = {
+    delta: ModelVisibleItem;
+    extensions?: Extensions;
+    final: boolean;
+    gaps?: Array<{
+        path: string;
+        reason: string;
+    } & AdditionalProperties>;
+    id: string;
+    item: {
+        id: string;
+        synthesized?: boolean;
+    } & AdditionalProperties;
+    items?: Array<ContentItem>;
+    native?: NativeEvent;
+    parentEventId?: string;
+    session?: Session;
+    source: string;
+    synthesized?: boolean;
+    time: string;
+    turn: {
+        id: string;
+        synthesized?: boolean;
+    } & AdditionalProperties;
+    type: "turn.progress";
+} & AdditionalProperties;
+/** Source: schema/draft/execution-event.schema.json#/$defs/turn.start */
+export type ExecutionEventTurnStart = {
+    expandedFrom?: string;
+    extensions?: Extensions;
+    gaps?: Array<{
+        path: string;
+        reason: string;
+    } & AdditionalProperties>;
+    id: string;
+    items: Array<ModelVisibleItem>;
+    native?: NativeEvent;
+    parentEventId?: string;
+    session?: Session;
+    source: string;
+    synthesized?: boolean;
+    time: string;
+    trigger: OpenString<"user" | "continuation" | "hook" | "external">;
+    turn: {
+        id: string;
+        synthesized?: boolean;
+    } & AdditionalProperties;
+    type: "turn.start";
+} & AdditionalProperties;
+/** Source: schema/draft/execution-event.schema.json#/$defs/turnUsage */
+export type ExecutionEventTurnusage = ExecutionEventUsage & {
+    kind?: "total";
+    scope?: "turn";
+} & AdditionalProperties;
+/** Source: schema/draft/execution-event.schema.json#/$defs/usage */
+export type ExecutionEventUsage = {
+    cacheReadTokens?: number;
+    cacheWriteTokens?: number;
+    completeness: OpenString<"complete" | "partial" | "unknown">;
+    cost?: {
+        amount: number;
+        basis: OpenString<"billed" | "reported" | "estimated">;
+        currency: string;
+    } & AdditionalProperties;
+    inputTokens?: number;
+    kind: OpenString<"amount" | "total">;
+    outputTokens?: number;
+    provenance: OpenString<"provider" | "estimate" | "mixed">;
+    scope: OpenString<"attempt" | "turn">;
+} & AdditionalProperties;
+/** Source: schema/draft/extensions.schema.json# */
+export type Extensions = {} & AdditionalProperties;
+/** Source: schema/draft/catalogue-event.schema.json#/$defs/file.changed */
+export type FileChangedEvent = TaskWorkspaceEventFileChanged;
+/** Source: schema/draft/catalogue-event.schema.json#/$defs/hook.failure */
+export type HookFailureEvent = {
+    extensions?: Extensions;
+    gaps?: Array<{
+        path: string;
+        reason: string;
+    } & AdditionalProperties>;
+    id: string;
+    items?: Array<ContentItem>;
+    native?: NativeEvent;
+    session?: Session;
+    source: string;
+    synthesized?: boolean;
+    time: string;
+    turn?: {
+        id: string;
+        synthesized?: boolean;
+    } & AdditionalProperties;
+    type: "hook.failure";
+} & AdditionalProperties & InteractionEventHookFailure;
+/** Source: schema/draft/registration.schema.json#/$defs/httpTransport */
+export type HttpTransport = {
+    type: "http";
+    url: string;
+} & AdditionalProperties;
+/** Source: schema/draft/interaction-event.schema.json# */
+export type InteractionEvent = InteractionEventConfigChangeBefore | InteractionEventConfigChangeAfter | InteractionEventUserAttention | InteractionEventUserElicitationRequest | InteractionEventUserElicitationResult | InteractionEventUserMessageInbound | InteractionEventUserMessageOutbound | InteractionEventHookFailure | UnknownVariant<"type">;
+/** Source: schema/draft/interaction-event.schema.json#/$defs/config.change.after */
+export type InteractionEventConfigChangeAfter = {
+    change: {
+        mcpServers?: Array<{} & AdditionalProperties>;
+        path?: string;
+        scope: string;
+        settings: Array<string>;
+        source: string;
+        summary: string;
+    } & AdditionalProperties;
+    type: "config.change.after";
+} & AdditionalProperties;
+/** Source: schema/draft/interaction-event.schema.json#/$defs/config.change.before */
+export type InteractionEventConfigChangeBefore = {
+    change: {
+        path?: string;
+        scope: string;
+        settings: Array<string>;
+        source: string;
+        summary: string;
+    } & AdditionalProperties;
+    type: "config.change.before";
+} & AdditionalProperties;
+/** Source: schema/draft/interaction-event.schema.json#/$defs/hook.failure */
+export type InteractionEventHookFailure = {
+    failure: {
+        backendId: string;
+        policy: OpenString<"fail-open" | "fail-closed">;
+        reason: string;
+    } & AdditionalProperties;
+    parentEventId: string;
+    type: "hook.failure";
+} & AdditionalProperties;
+/** Source: schema/draft/interaction-event.schema.json#/$defs/user.attention */
+export type InteractionEventUserAttention = {
+    attention: {
+        kind: string;
+        message: Array<ContentItem>;
+        title: Array<ContentItem>;
+    } & AdditionalProperties;
+    type: "user.attention";
+} & AdditionalProperties;
+/** Source: schema/draft/interaction-event.schema.json#/$defs/user.elicitation.request */
+export type InteractionEventUserElicitationRequest = {
+    elicitation: {
+        mode: OpenString<"form" | "url">;
+        request?: ContentItem & {
+            mediaType?: "application/json";
+        } & AdditionalProperties;
+        server: string;
+    } & AdditionalProperties;
+    type: "user.elicitation.request";
+} & AdditionalProperties;
+/** Source: schema/draft/interaction-event.schema.json#/$defs/user.elicitation.result */
+export type InteractionEventUserElicitationResult = {
+    elicitation: {
+        action: OpenString<"accept" | "decline" | "cancel">;
+        mode: OpenString<"form" | "url">;
+        result?: ContentItem & {
+            mediaType?: "application/json";
+        } & AdditionalProperties;
+        server: string;
+    } & AdditionalProperties;
+    type: "user.elicitation.result";
+} & AdditionalProperties;
+/** Source: schema/draft/interaction-event.schema.json#/$defs/user.message.inbound */
+export type InteractionEventUserMessageInbound = {
+    message: {
+        channel: string;
+        sender: string;
+        text: Array<ContentItem>;
+    } & AdditionalProperties;
+    type: "user.message.inbound";
+} & AdditionalProperties;
+/** Source: schema/draft/interaction-event.schema.json#/$defs/user.message.outbound */
+export type InteractionEventUserMessageOutbound = {
+    message: {
+        channel: string;
+        payload: Array<ContentItem>;
+    } & AdditionalProperties;
+    type: "user.message.outbound";
+} & AdditionalProperties;
+/** Source: schema/draft/intercept-deny-response.schema.json# */
+export type InterceptDenyResponse = JsonRpcSuccessResponse & {
+    result?: {
+        effects: Array<DenyEffect>;
+        extensions?: Extensions;
+        protocolVersion: ProtocolVersion;
+    } & AdditionalProperties;
+} & AdditionalProperties;
+/** Source: schema/draft/intercept-no-effect-response.schema.json# */
+export type InterceptNoEffectResponse = JsonRpcSuccessResponse & {
+    result?: {
+        effects: Array<JsonValue>;
+        extensions?: Extensions;
+        protocolVersion: ProtocolVersion;
+    } & AdditionalProperties;
+} & AdditionalProperties;
+/** Source: schema/draft/intercept-request.schema.json# */
+export type InterceptRequest = JsonRpcRequest & {
+    method: "hooks/intercept";
+    params: {
+        capabilities: Capabilities & {
+            flow?: JsonValue;
+        } & AdditionalProperties;
+        event: ToolBeforeEvent | ToolAfterEvent | SessionStartEvent | ConfigChangeBeforeEvent | TurnStartEvent | TurnFinishBeforeEvent | ModelRequestBeforeEvent | ModelSwitchBeforeEvent | ToolPermissionRequestEvent | ToolBatchAfterEvent | ContextCompactBeforeEvent | ContextCompactAfterEvent | TaskChangeBeforeEvent | UserElicitationRequestEvent | UserElicitationResultEvent | UserMessageInboundEvent | UserMessageOutboundEvent | WorkspaceChangeBeforeEvent | ModelResponseAfterEvent;
+        extensions?: Extensions;
+        protocolVersion: ProtocolVersion;
+        state?: {
+            candidate: null | ({
+                provenance?: {} & AdditionalProperties;
+                value: JsonValue;
+            } & AdditionalProperties);
+            flow?: OpenString<"none" | "stop" | "continue">;
+            injections?: Array<JsonValue>;
+            instructions?: Array<string>;
+            permission: OpenString<"none" | "allow" | "ask" | "deny">;
+        } & AdditionalProperties;
+    } & AdditionalProperties;
+} & AdditionalProperties;
+/** Source: schema/draft/intercept-response.schema.json# */
+export type InterceptResponse = JsonRpcSuccessResponse & {
+    result: {
+        effects: Array<Effect>;
+        extensions?: Extensions;
+        protocolVersion: ProtocolVersion;
+    } & AdditionalProperties;
+} & AdditionalProperties;
+/** Source: schema/draft/registration.schema.json#/$defs/interceptSubscription */
+export type InterceptSubscription = {
+    content: ContentSelection;
+    disableable?: boolean;
+    events: Array<OpenString<"tool.before" | "tool.after" | "session.start" | "config.change.before" | "turn.start" | "turn.finish.before" | "model.request.before" | "model.switch.before" | "tool.permission.request" | "tool.batch.after" | "context.compact.before" | "context.compact.after" | "task.change.before" | "user.elicitation.request" | "user.elicitation.result" | "user.message.inbound" | "user.message.outbound" | "workspace.change.before" | "model.response.after"> | string>;
+    failurePolicy: OpenString<"fail-open" | "fail-closed">;
+    filters?: {
+        paths?: Array<string>;
+        toolKinds?: Array<string>;
+    } & AdditionalProperties;
+    includeNative?: boolean;
+    mode: "intercept";
+    scope?: OpenString<"managed" | "project" | "user">;
+    timeoutMs: number;
+    upload?: ContentUpload;
+} & AdditionalProperties;
+/** Source: schema/draft/common.schema.json#/$defs/errorResponse */
+export type JsonRpcErrorResponse = {
+    error: {
+        code: number;
+        data?: JsonValue;
+        message: string;
+    } & AdditionalProperties;
+    id: JsonRpcResponseId;
+    jsonrpc: "2.0";
+} & AdditionalProperties;
+/** Source: schema/draft/common.schema.json#/$defs/jsonRpcId */
+export type JsonRpcId = string | number;
+/** Source: schema/draft/json-rpc-message.schema.json# */
+export type JsonRpcMessage = JsonRpcRequest | JsonRpcNotification | JsonRpcSuccessResponse | JsonRpcErrorResponse;
+/** Source: schema/draft/common.schema.json#/$defs/notification */
+export type JsonRpcNotification = {
+    jsonrpc: "2.0";
+    method: string;
+    params: {} & AdditionalProperties;
+} & AdditionalProperties;
+/** Source: schema/draft/common.schema.json#/$defs/request */
+export type JsonRpcRequest = {
+    id: JsonRpcId;
+    jsonrpc: "2.0";
+    method: string;
+    params: {} & AdditionalProperties;
+} & AdditionalProperties;
+/** Source: schema/draft/common.schema.json#/$defs/jsonRpcResponseId */
+export type JsonRpcResponseId = JsonRpcId | null;
+/** Source: schema/draft/common.schema.json#/$defs/successResponse */
+export type JsonRpcSuccessResponse = {
+    id: JsonRpcResponseId;
+    jsonrpc: "2.0";
+    result: {} & AdditionalProperties;
+} & AdditionalProperties;
+/** Source: schema/draft/mcp-elicitation.schema.json#/$defs/BooleanSchema */
+export type McpElicitationBooleanSchema = {
+    default?: boolean;
+    description?: string;
+    title?: string;
+    type: "boolean";
+} & AdditionalProperties;
+/** Source: schema/draft/mcp-elicitation.schema.json#/$defs/ElicitRequestFormParams */
+export type McpElicitationElicitRequestFormParams = {
+    _meta?: {
+        progressToken?: McpElicitationProgressToken;
+    } & AdditionalProperties;
+    message: string;
+    mode?: "form";
+    requestedSchema: {
+        $schema?: string;
+        properties: {} & AdditionalProperties;
+        required?: Array<string>;
+        type: "object";
+    } & AdditionalProperties;
+    task?: McpElicitationTaskMetadata;
+} & AdditionalProperties;
+/** Source: schema/draft/mcp-elicitation.schema.json#/$defs/ElicitRequestParams */
+export type McpElicitationElicitRequestParams = McpElicitationElicitRequestURLParams | McpElicitationElicitRequestFormParams;
+/** Source: schema/draft/mcp-elicitation.schema.json#/$defs/ElicitRequestURLParams */
+export type McpElicitationElicitRequestURLParams = {
+    _meta?: {
+        progressToken?: McpElicitationProgressToken;
+    } & AdditionalProperties;
+    elicitationId: string;
+    message: string;
+    mode: "url";
+    task?: McpElicitationTaskMetadata;
+    url: string;
+} & AdditionalProperties;
+/** Source: schema/draft/mcp-elicitation.schema.json#/$defs/ElicitResult */
+export type McpElicitationElicitResult = {
+    _meta?: {} & AdditionalProperties;
+    action: OpenString<"accept" | "cancel" | "decline">;
+    content?: {} & AdditionalProperties;
+} & AdditionalProperties;
+/** Source: schema/draft/mcp-elicitation.schema.json#/$defs/LegacyTitledEnumSchema */
+export type McpElicitationLegacyTitledEnumSchema = {
+    default?: string;
+    description?: string;
+    enum: Array<string>;
+    enumNames?: Array<string>;
+    title?: string;
+    type: "string";
+} & AdditionalProperties;
+/** Source: schema/draft/mcp-elicitation.schema.json#/$defs/NumberSchema */
+export type McpElicitationNumberSchema = {
+    default?: number;
+    description?: string;
+    maximum?: number;
+    minimum?: number;
+    title?: string;
+    type: OpenString<"integer" | "number">;
+} & AdditionalProperties;
+/** Source: schema/draft/mcp-elicitation.schema.json#/$defs/PrimitiveSchemaDefinition */
+export type McpElicitationPrimitiveSchemaDefinition = McpElicitationStringSchema | McpElicitationNumberSchema | McpElicitationBooleanSchema | McpElicitationUntitledSingleSelectEnumSchema | McpElicitationTitledSingleSelectEnumSchema | McpElicitationUntitledMultiSelectEnumSchema | McpElicitationTitledMultiSelectEnumSchema | McpElicitationLegacyTitledEnumSchema;
+/** Source: schema/draft/mcp-elicitation.schema.json#/$defs/ProgressToken */
+export type McpElicitationProgressToken = string | number;
+/** Source: schema/draft/mcp-elicitation.schema.json#/$defs/request */
+export type McpElicitationRequest = McpElicitationElicitRequestParams;
+/** Source: schema/draft/mcp-elicitation.schema.json#/$defs/result */
+export type McpElicitationResult = McpElicitationElicitResult;
+/** Source: schema/draft/mcp-elicitation.schema.json#/$defs/StringSchema */
+export type McpElicitationStringSchema = {
+    default?: string;
+    description?: string;
+    format?: OpenString<"date" | "date-time" | "email" | "uri">;
+    maxLength?: number;
+    minLength?: number;
+    title?: string;
+    type: "string";
+} & AdditionalProperties;
+/** Source: schema/draft/mcp-elicitation.schema.json#/$defs/TaskMetadata */
+export type McpElicitationTaskMetadata = {
+    ttl?: number;
+} & AdditionalProperties;
+/** Source: schema/draft/mcp-elicitation.schema.json#/$defs/TitledMultiSelectEnumSchema */
+export type McpElicitationTitledMultiSelectEnumSchema = {
+    default?: Array<string>;
+    description?: string;
+    items: {
+        anyOf: Array<{
+            const: string;
+            title: string;
+        } & AdditionalProperties>;
+    } & AdditionalProperties;
+    maxItems?: number;
+    minItems?: number;
+    title?: string;
+    type: "array";
+} & AdditionalProperties;
+/** Source: schema/draft/mcp-elicitation.schema.json#/$defs/TitledSingleSelectEnumSchema */
+export type McpElicitationTitledSingleSelectEnumSchema = {
+    default?: string;
+    description?: string;
+    oneOf: Array<{
+        const: string;
+        title: string;
+    } & AdditionalProperties>;
+    title?: string;
+    type: "string";
+} & AdditionalProperties;
+/** Source: schema/draft/mcp-elicitation.schema.json#/$defs/UntitledMultiSelectEnumSchema */
+export type McpElicitationUntitledMultiSelectEnumSchema = {
+    default?: Array<string>;
+    description?: string;
+    items: {
+        enum: Array<string>;
+        type: "string";
+    } & AdditionalProperties;
+    maxItems?: number;
+    minItems?: number;
+    title?: string;
+    type: "array";
+} & AdditionalProperties;
+/** Source: schema/draft/mcp-elicitation.schema.json#/$defs/UntitledSingleSelectEnumSchema */
+export type McpElicitationUntitledSingleSelectEnumSchema = {
+    default?: string;
+    description?: string;
+    enum: Array<string>;
+    title?: string;
+    type: "string";
+} & AdditionalProperties;
+/** Source: schema/draft/catalogue-event.schema.json#/$defs/model.error */
+export type ModelErrorEvent = ExecutionEventModelError;
+/** Source: schema/draft/capabilities.schema.json#/$defs/model.request.before */
+export type ModelRequestBeforeCapabilities = Capabilities & {
+    effects?: Array<OpenString<"deny" | "modify" | "inject" | "return" | "flow" | "message">>;
+    flow?: {
+        operations?: Array<OpenString<"stop">>;
+    } & AdditionalProperties;
+    modify?: {} & AdditionalProperties;
+} & AdditionalProperties;
+/** Source: schema/draft/catalogue-event.schema.json#/$defs/model.request.before */
+export type ModelRequestBeforeEvent = ExecutionEventModelRequestBefore;
+/** Source: schema/draft/capabilities.schema.json#/$defs/model.response.after */
+export type ModelResponseAfterCapabilities = Capabilities & {
+    effects?: Array<OpenString<"modify" | "flow" | "message">>;
+    flow?: {
+        operations?: Array<OpenString<"stop">>;
+    } & AdditionalProperties;
+    modify?: {} & AdditionalProperties;
+} & AdditionalProperties;
+/** Source: schema/draft/catalogue-event.schema.json#/$defs/model.response.after */
+export type ModelResponseAfterEvent = ExecutionEventModelResponseAfter;
+/** Source: schema/draft/catalogue-event.schema.json#/$defs/model.switch.after */
+export type ModelSwitchAfterEvent = ExecutionEventModelSwitchAfter;
+/** Source: schema/draft/capabilities.schema.json#/$defs/model.switch.before */
+export type ModelSwitchBeforeCapabilities = Capabilities & {
+    effects?: Array<OpenString<"deny" | "flow" | "message">>;
+    flow?: {
+        operations?: Array<OpenString<"stop">>;
+    } & AdditionalProperties;
+} & AdditionalProperties;
+/** Source: schema/draft/catalogue-event.schema.json#/$defs/model.switch.before */
+export type ModelSwitchBeforeEvent = ExecutionEventModelSwitchBefore;
+/** Source: schema/draft/content-item.schema.json#/$defs/modelVisibleItem */
+export type ModelVisibleItem = ContentItem & {
+    role: string;
+} & AdditionalProperties;
+/** Source: schema/draft/common.schema.json#/$defs/native */
+export type NativeEvent = JsonValue;
+/** Source: schema/draft/observe-notification.schema.json# */
+export type ObserveNotification = JsonRpcNotification & {
+    method?: "hooks/observe";
+    params?: {
+        event: ToolBeforeEvent | ToolAfterEvent | SessionStartEvent | SessionEndEvent | ConfigChangeBeforeEvent | ConfigChangeAfterEvent | TurnStartEvent | TurnFinishBeforeEvent | TurnEndEvent | TurnProgressEvent | ModelRequestBeforeEvent | ModelResponseAfterEvent | ModelErrorEvent | ModelSwitchBeforeEvent | ModelSwitchAfterEvent | ToolPermissionRequestEvent | ToolPermissionResolvedEvent | ToolProgressEvent | ToolBatchAfterEvent | ContextCompactBeforeEvent | ContextCompactAfterEvent | TaskChangeBeforeEvent | TaskChangeAfterEvent | UserAttentionEvent | UserElicitationRequestEvent | UserElicitationResultEvent | UserMessageInboundEvent | UserMessageOutboundEvent | WorkspaceChangeBeforeEvent | WorkspaceChangeAfterEvent | FileChangedEvent | HookFailureEvent;
+        protocolVersion: ProtocolVersion;
+    } & AdditionalProperties;
+} & AdditionalProperties;
+/** Source: schema/draft/registration.schema.json#/$defs/observeSubscription */
+export type ObserveSubscription = {
+    content: ContentSelection;
+    disableable?: boolean;
+    events: Array<OpenString<"tool.before" | "tool.after" | "session.start" | "session.end" | "config.change.before" | "config.change.after" | "turn.start" | "turn.finish.before" | "turn.end" | "turn.progress" | "model.request.before" | "model.response.after" | "model.error" | "model.switch.before" | "model.switch.after" | "tool.permission.request" | "tool.permission.resolved" | "tool.progress" | "tool.batch.after" | "context.compact.before" | "context.compact.after" | "task.change.before" | "task.change.after" | "user.attention" | "user.elicitation.request" | "user.elicitation.result" | "user.message.inbound" | "user.message.outbound" | "workspace.change.before" | "workspace.change.after" | "file.changed" | "hook.failure"> | string>;
+    filters?: {
+        paths?: Array<string>;
+        toolKinds?: Array<string>;
+    } & AdditionalProperties;
+    includeNative?: boolean;
+    mode: "observe";
+    scope?: OpenString<"managed" | "project" | "user">;
+    upload?: ContentUpload;
+} & AdditionalProperties;
+/** Source: schema/draft/common.schema.json#/$defs/protocolVersion */
+export type ProtocolVersion = "draft";
+/** Source: schema/draft/registration.schema.json# */
+export type Registration = {
+    hooks: Array<Backend>;
+    protocolVersion: ProtocolVersion;
+} & AdditionalProperties;
+/** Source: schema/draft/registration.schema.json#/$defs/contentReceiver */
+export type RegistrationContentreceiver = {
+    authentication?: Authentication;
+    maxBytes: number;
+    timeoutMs: number;
+    url: string;
+} & AdditionalProperties;
+/** Source: schema/draft/registration.schema.json#/$defs/reverseDns */
+export type ReverseDnsName = string;
+/** Source: schema/draft/common.schema.json#/$defs/session */
+export type Session = {
+    agent?: {
+        id: string;
+        type?: string;
+    } & AdditionalProperties;
+    cwd?: string;
+    id: string;
+    model?: string;
+    synthesized?: boolean;
+    workspaceRoots?: Array<string>;
+} & AdditionalProperties;
+/** Source: schema/draft/session-end.schema.json# */
+export type SessionEndEvent = {
+    counters?: {} & AdditionalProperties;
+    extensions?: Extensions;
+    gaps?: Array<{
+        path: string;
+        reason: string;
+    } & AdditionalProperties>;
+    id: string;
+    items?: Array<ContentItem>;
+    native?: NativeEvent;
+    outcome: OpenString<"completed" | "cancelled" | "error" | "unknown">;
+    parentEventId?: string;
+    reason: string;
+    session: Session;
+    source: string;
+    synthesized?: boolean;
+    time: string;
+    turn?: {
+        id: string;
+        synthesized?: boolean;
+    } & AdditionalProperties;
+    type: "session.end";
+} & AdditionalProperties;
+/** Source: schema/draft/capabilities.schema.json#/$defs/session.start */
+export type SessionStartCapabilities = Capabilities & {
+    effects?: Array<OpenString<"inject" | "message">>;
+} & AdditionalProperties;
+/** Source: schema/draft/session-start.schema.json# */
+export type SessionStartEvent = {
+    extensions?: Extensions;
+    gaps?: Array<{
+        path: string;
+        reason: string;
+    } & AdditionalProperties>;
+    harness: {
+        name: string;
+        version: string;
+    } & AdditionalProperties;
+    id: string;
+    items: Array<ModelVisibleItem>;
+    manifest: StaticCapabilityManifest;
+    native?: NativeEvent;
+    parentEventId?: string;
+    permissionMode: string;
+    resumedFrom?: {
+        id: string;
+        synthesized?: boolean;
+    } & AdditionalProperties;
+    session: Session;
+    source: string;
+    synthesized?: boolean;
+    time: string;
+    trigger: OpenString<"startup" | "resume" | "clear" | "compact" | "fork">;
+    turn?: {
+        id: string;
+        synthesized?: boolean;
+    } & AdditionalProperties;
+    type: "session.start";
+} & AdditionalProperties;
+/** Source: schema/draft/capabilities-response.schema.json#/allOf/1/properties/result/properties/manifest */
+export type StaticCapabilityManifest = {
+    authentication: Array<OpenString<"bearer" | "oauth">>;
+    contentCategories: Array<string>;
+    correlationIdentityFields: Array<string>;
+    events: Array<{
+        capabilities?: Capabilities;
+        event: OpenString<"tool.before" | "tool.after" | "session.start" | "session.end" | "config.change.before" | "config.change.after" | "turn.start" | "turn.finish.before" | "turn.end" | "turn.progress" | "model.request.before" | "model.response.after" | "model.error" | "model.switch.before" | "model.switch.after" | "tool.permission.request" | "tool.permission.resolved" | "tool.progress" | "tool.batch.after" | "context.compact.before" | "context.compact.after" | "task.change.before" | "task.change.after" | "user.attention" | "user.elicitation.request" | "user.elicitation.result" | "user.message.inbound" | "user.message.outbound" | "workspace.change.before" | "workspace.change.after" | "file.changed" | "hook.failure">;
+        modes: Array<OpenString<"observe" | "intercept">>;
+    } & AdditionalProperties>;
+    gaps: Array<{
+        path: string;
+        reason: string;
+    } & AdditionalProperties>;
+    limits: {
+        maxContinuations?: number;
+        maxTimeoutMs?: number;
+        maxUploadBytes?: number;
+        minTimeoutMs?: number;
+    } & AdditionalProperties;
+    managedPolicy: {
+        disableable: boolean;
+        scopes: Array<OpenString<"user" | "project" | "managed">>;
+    } & AdditionalProperties;
+    toolPaths: Array<string>;
+    transports: Array<OpenString<"http" | "stdio" | "in_process">>;
+} & AdditionalProperties;
+/** Source: schema/draft/registration.schema.json#/$defs/stdioTransport */
+export type StdioTransport = {
+    args?: Array<string>;
+    command: string;
+    cwd?: string;
+    lifecycle: OpenString<"persistent" | "per_event">;
+    type: "stdio";
+} & AdditionalProperties;
+/** Source: schema/draft/catalogue-event.schema.json#/$defs/task.change.after */
+export type TaskChangeAfterEvent = TaskWorkspaceEventTaskChangeAfter;
+/** Source: schema/draft/capabilities.schema.json#/$defs/task.change.before */
+export type TaskChangeBeforeCapabilities = Capabilities & {
+    effects?: Array<OpenString<"deny" | "message">>;
+} & AdditionalProperties;
+/** Source: schema/draft/catalogue-event.schema.json#/$defs/task.change.before */
+export type TaskChangeBeforeEvent = TaskWorkspaceEventTaskChangeBefore;
+/** Source: schema/draft/task-workspace-event.schema.json# */
+export type TaskWorkspaceEvent = TaskWorkspaceEventTaskChangeBefore | TaskWorkspaceEventTaskChangeAfter | TaskWorkspaceEventWorkspaceChangeBefore | TaskWorkspaceEventWorkspaceChangeAfter | TaskWorkspaceEventFileChanged | UnknownVariant<"type">;
+/** Source: schema/draft/task-workspace-event.schema.json#/$defs/file.changed */
+export type TaskWorkspaceEventFileChanged = {
+    changes: Array<{
+        after?: ContentReference;
+        agentCaused: boolean;
+        before?: ContentReference;
+        operation: OpenString<"create" | "update" | "remove">;
+        path: string;
+    } & AdditionalProperties>;
+    extensions?: Extensions;
+    gaps?: Array<{
+        path: string;
+        reason: string;
+    } & AdditionalProperties>;
+    id: string;
+    items?: Array<ContentItem>;
+    native?: NativeEvent;
+    parentEventId?: string;
+    session?: Session;
+    source: string;
+    synthesized?: boolean;
+    time: string;
+    turn?: {
+        id: string;
+        synthesized?: boolean;
+    } & AdditionalProperties;
+    type: "file.changed";
+} & AdditionalProperties;
+/** Source: schema/draft/task-workspace-event.schema.json#/$defs/task.change.after */
+export type TaskWorkspaceEventTaskChangeAfter = {
+    extensions?: Extensions;
+    gaps?: Array<{
+        path: string;
+        reason: string;
+    } & AdditionalProperties>;
+    id: string;
+    items?: Array<ContentItem>;
+    native?: NativeEvent;
+    parentEventId?: string;
+    session?: Session;
+    source: string;
+    synthesized?: boolean;
+    task: {
+        change: {} & AdditionalProperties;
+        description?: string;
+        id: string;
+        operation: OpenString<"create" | "update" | "remove">;
+        prior?: {} & AdditionalProperties;
+        synthesized?: boolean;
+    } & AdditionalProperties;
+    time: string;
+    turn?: {
+        id: string;
+        synthesized?: boolean;
+    } & AdditionalProperties;
+    type: "task.change.after";
+} & AdditionalProperties;
+/** Source: schema/draft/task-workspace-event.schema.json#/$defs/task.change.before */
+export type TaskWorkspaceEventTaskChangeBefore = {
+    extensions?: Extensions;
+    gaps?: Array<{
+        path: string;
+        reason: string;
+    } & AdditionalProperties>;
+    id: string;
+    items?: Array<ContentItem>;
+    native?: NativeEvent;
+    parentEventId?: string;
+    session?: Session;
+    source: string;
+    synthesized?: boolean;
+    task: {
+        change: {} & AdditionalProperties;
+        description?: string;
+        id: string;
+        operation: OpenString<"create" | "update" | "remove">;
+        prior?: {} & AdditionalProperties;
+        synthesized?: boolean;
+    } & AdditionalProperties;
+    time: string;
+    turn?: {
+        id: string;
+        synthesized?: boolean;
+    } & AdditionalProperties;
+    type: "task.change.before";
+} & AdditionalProperties;
+/** Source: schema/draft/task-workspace-event.schema.json#/$defs/workspace.change.after */
+export type TaskWorkspaceEventWorkspaceChangeAfter = {
+    extensions?: Extensions;
+    gaps?: Array<{
+        path: string;
+        reason: string;
+    } & AdditionalProperties>;
+    id: string;
+    items?: Array<ContentItem>;
+    native?: NativeEvent;
+    parentEventId?: string;
+    session?: Session;
+    source: string;
+    synthesized?: boolean;
+    time: string;
+    turn?: {
+        id: string;
+        synthesized?: boolean;
+    } & AdditionalProperties;
+    type: "workspace.change.after";
+    workspace: {
+        change: {
+            cwd?: string;
+            workspaceRoots?: Array<string>;
+        } & AdditionalProperties;
+        kind: OpenString<"cwd" | "roots" | "switch">;
+        prior?: {
+            cwd?: string;
+            workspaceRoots?: Array<string>;
+        } & AdditionalProperties;
+        reason?: string;
+    } & AdditionalProperties;
+} & AdditionalProperties;
+/** Source: schema/draft/task-workspace-event.schema.json#/$defs/workspace.change.before */
+export type TaskWorkspaceEventWorkspaceChangeBefore = {
+    extensions?: Extensions;
+    gaps?: Array<{
+        path: string;
+        reason: string;
+    } & AdditionalProperties>;
+    id: string;
+    items?: Array<ContentItem>;
+    native?: NativeEvent;
+    parentEventId?: string;
+    session?: Session;
+    source: string;
+    synthesized?: boolean;
+    time: string;
+    turn?: {
+        id: string;
+        synthesized?: boolean;
+    } & AdditionalProperties;
+    type: "workspace.change.before";
+    workspace: {
+        change: {
+            cwd?: string;
+            workspaceRoots?: Array<string>;
+        } & AdditionalProperties;
+        kind: OpenString<"cwd" | "roots" | "switch">;
+        prior?: {
+            cwd?: string;
+            workspaceRoots?: Array<string>;
+        } & AdditionalProperties;
+        reason?: string;
+    } & AdditionalProperties;
+} & AdditionalProperties;
+/** Source: schema/draft/capabilities.schema.json#/$defs/tool.after */
+export type ToolAfterCapabilities = Capabilities & {
+    effects?: Array<OpenString<"modify" | "inject" | "flow" | "message">>;
+    flow?: {
+        operations?: Array<OpenString<"stop" | "continue">>;
+    } & AdditionalProperties;
+    modify?: {} & AdditionalProperties;
+} & AdditionalProperties;
+/** Source: schema/draft/tool-after.schema.json# */
+export type ToolAfterEvent = {
+    batch?: ExecutionEventBatch;
+    call: {
+        id: string;
+        synthesized?: boolean;
+    } & AdditionalProperties;
+    durationMs?: number;
+    error?: ExecutionEventError;
+    execution: ExecutionEventExecution;
+    extensions?: Extensions;
+    fileChanges?: Array<ExecutionEventFilechange>;
+    gaps?: Array<{
+        path: string;
+        reason: string;
+    } & AdditionalProperties>;
+    id: string;
+    items: Array<ModelVisibleItem>;
+    native?: NativeEvent;
+    outcome: OpenString<"ok" | "error" | "denied" | "cancelled" | "timeout">;
+    parentEventId?: string;
+    path: string;
+    session?: Session;
+    source: string;
+    synthesized?: boolean;
+    time: string;
+    tool: ExecutionEventTool;
+    turn?: {
+        id: string;
+        synthesized?: boolean;
+    } & AdditionalProperties;
+    type: "tool.after";
+} & AdditionalProperties;
+/** Source: schema/draft/capabilities.schema.json#/$defs/tool.batch.after */
+export type ToolBatchAfterCapabilities = Capabilities & {
+    effects?: Array<OpenString<"flow" | "inject" | "message">>;
+    flow?: {
+        operations?: Array<OpenString<"stop">>;
+    } & AdditionalProperties;
+} & AdditionalProperties;
+/** Source: schema/draft/catalogue-event.schema.json#/$defs/tool.batch.after */
+export type ToolBatchAfterEvent = ExecutionEventToolBatchAfter;
+/** Source: schema/draft/capabilities.schema.json#/$defs/tool.before */
+export type ToolBeforeCapabilities = Capabilities & {
+    effects?: Array<OpenString<"deny" | "allow" | "ask" | "modify" | "inject" | "flow" | "return" | "message">>;
+    flow?: {
+        operations?: Array<OpenString<"stop">>;
+    } & AdditionalProperties;
+    modify?: {} & AdditionalProperties;
+} & AdditionalProperties;
+/** Source: schema/draft/tool-before.schema.json# */
+export type ToolBeforeEvent = {
+    batch?: ExecutionEventBatch;
+    call: {
+        id: string;
+        synthesized?: boolean;
+    } & AdditionalProperties;
+    extensions?: Extensions;
+    gaps?: Array<{
+        path: string;
+        reason: string;
+    } & AdditionalProperties>;
+    id: string;
+    items?: Array<ContentItem>;
+    native?: NativeEvent;
+    parentEventId?: string;
+    path: string;
+    session?: Session;
+    source: string;
+    synthesized?: boolean;
+    time: string;
+    tool: ExecutionEventTool;
+    turn?: {
+        id: string;
+        synthesized?: boolean;
+    } & AdditionalProperties;
+    type: "tool.before";
+} & AdditionalProperties;
+/** Source: schema/draft/capabilities.schema.json#/$defs/tool.permission.request */
+export type ToolPermissionRequestCapabilities = Capabilities & {
+    effects?: Array<OpenString<"allow" | "deny" | "modify" | "flow" | "message">>;
+    flow?: {
+        operations?: Array<OpenString<"stop">>;
+    } & AdditionalProperties;
+    modify?: {} & AdditionalProperties;
+} & AdditionalProperties;
+/** Source: schema/draft/catalogue-event.schema.json#/$defs/tool.permission.request */
+export type ToolPermissionRequestEvent = ExecutionEventToolPermissionRequest;
+/** Source: schema/draft/catalogue-event.schema.json#/$defs/tool.permission.resolved */
+export type ToolPermissionResolvedEvent = ExecutionEventToolPermissionResolved;
+/** Source: schema/draft/catalogue-event.schema.json#/$defs/tool.progress */
+export type ToolProgressEvent = ExecutionEventToolProgress;
+/** Source: schema/draft/catalogue-event.schema.json#/$defs/turn.end */
+export type TurnEndEvent = ExecutionEventTurnEnd;
+/** Source: schema/draft/capabilities.schema.json#/$defs/turn.finish.before */
+export type TurnFinishBeforeCapabilities = Capabilities & {
+    effects?: Array<OpenString<"modify" | "flow" | "message">>;
+    flow?: {
+        operations?: Array<OpenString<"stop" | "continue">>;
+    } & AdditionalProperties;
+    modify?: {} & AdditionalProperties;
+} & AdditionalProperties;
+/** Source: schema/draft/catalogue-event.schema.json#/$defs/turn.finish.before */
+export type TurnFinishBeforeEvent = ExecutionEventTurnFinishBefore;
+/** Source: schema/draft/catalogue-event.schema.json#/$defs/turn.progress */
+export type TurnProgressEvent = ExecutionEventTurnProgress;
+/** Source: schema/draft/capabilities.schema.json#/$defs/turn.start */
+export type TurnStartCapabilities = Capabilities & {
+    effects?: Array<OpenString<"deny" | "modify" | "inject" | "flow" | "message">>;
+    flow?: {
+        operations?: Array<OpenString<"stop">>;
+    } & AdditionalProperties;
+    modify?: {} & AdditionalProperties;
+} & AdditionalProperties;
+/** Source: schema/draft/catalogue-event.schema.json#/$defs/turn.start */
+export type TurnStartEvent = ExecutionEventTurnStart;
+/** Source: schema/draft/catalogue-event.schema.json#/$defs/user.attention */
+export type UserAttentionEvent = {
+    extensions?: Extensions;
+    gaps?: Array<{
+        path: string;
+        reason: string;
+    } & AdditionalProperties>;
+    id: string;
+    items?: Array<ContentItem>;
+    native?: NativeEvent;
+    parentEventId?: string;
+    session?: Session;
+    source: string;
+    synthesized?: boolean;
+    time: string;
+    turn?: {
+        id: string;
+        synthesized?: boolean;
+    } & AdditionalProperties;
+    type: "user.attention";
+} & AdditionalProperties & InteractionEventUserAttention;
+/** Source: schema/draft/capabilities.schema.json#/$defs/user.elicitation.request */
+export type UserElicitationRequestCapabilities = Capabilities & {
+    effects?: Array<OpenString<"deny" | "return" | "message">>;
+} & AdditionalProperties;
+/** Source: schema/draft/catalogue-event.schema.json#/$defs/user.elicitation.request */
+export type UserElicitationRequestEvent = {
+    extensions?: Extensions;
+    gaps?: Array<{
+        path: string;
+        reason: string;
+    } & AdditionalProperties>;
+    id: string;
+    items?: Array<ContentItem>;
+    native?: NativeEvent;
+    parentEventId?: string;
+    session?: Session;
+    source: string;
+    synthesized?: boolean;
+    time: string;
+    turn?: {
+        id: string;
+        synthesized?: boolean;
+    } & AdditionalProperties;
+    type: "user.elicitation.request";
+} & AdditionalProperties & InteractionEventUserElicitationRequest;
+/** Source: schema/draft/capabilities.schema.json#/$defs/user.elicitation.result */
+export type UserElicitationResultCapabilities = Capabilities & {
+    effects?: Array<OpenString<"modify" | "message">>;
+    modify?: {} & AdditionalProperties;
+} & AdditionalProperties;
+/** Source: schema/draft/catalogue-event.schema.json#/$defs/user.elicitation.result */
+export type UserElicitationResultEvent = {
+    extensions?: Extensions;
+    gaps?: Array<{
+        path: string;
+        reason: string;
+    } & AdditionalProperties>;
+    id: string;
+    items?: Array<ContentItem>;
+    native?: NativeEvent;
+    parentEventId?: string;
+    session?: Session;
+    source: string;
+    synthesized?: boolean;
+    time: string;
+    turn?: {
+        id: string;
+        synthesized?: boolean;
+    } & AdditionalProperties;
+    type: "user.elicitation.result";
+} & AdditionalProperties & InteractionEventUserElicitationResult;
+/** Source: schema/draft/capabilities.schema.json#/$defs/user.message.inbound */
+export type UserMessageInboundCapabilities = Capabilities & {
+    effects?: Array<OpenString<"deny" | "modify" | "message">>;
+    modify?: {} & AdditionalProperties;
+} & AdditionalProperties;
+/** Source: schema/draft/catalogue-event.schema.json#/$defs/user.message.inbound */
+export type UserMessageInboundEvent = {
+    extensions?: Extensions;
+    gaps?: Array<{
+        path: string;
+        reason: string;
+    } & AdditionalProperties>;
+    id: string;
+    items?: Array<ContentItem>;
+    native?: NativeEvent;
+    parentEventId?: string;
+    session?: Session;
+    source: string;
+    synthesized?: boolean;
+    time: string;
+    turn?: {
+        id: string;
+        synthesized?: boolean;
+    } & AdditionalProperties;
+    type: "user.message.inbound";
+} & AdditionalProperties & InteractionEventUserMessageInbound;
+/** Source: schema/draft/capabilities.schema.json#/$defs/user.message.outbound */
+export type UserMessageOutboundCapabilities = Capabilities & {
+    effects?: Array<OpenString<"deny" | "modify" | "message">>;
+    modify?: {} & AdditionalProperties;
+} & AdditionalProperties;
+/** Source: schema/draft/catalogue-event.schema.json#/$defs/user.message.outbound */
+export type UserMessageOutboundEvent = {
+    extensions?: Extensions;
+    gaps?: Array<{
+        path: string;
+        reason: string;
+    } & AdditionalProperties>;
+    id: string;
+    items?: Array<ContentItem>;
+    native?: NativeEvent;
+    parentEventId?: string;
+    session?: Session;
+    source: string;
+    synthesized?: boolean;
+    time: string;
+    turn?: {
+        id: string;
+        synthesized?: boolean;
+    } & AdditionalProperties;
+    type: "user.message.outbound";
+} & AdditionalProperties & InteractionEventUserMessageOutbound;
+/** Source: schema/draft/schema.json# */
+export type WireMessage = InterceptRequest | InterceptResponse | JsonRpcErrorResponse | ObserveNotification | CapabilitiesRequest | CapabilitiesResponse;
+/** Source: schema/draft/catalogue-event.schema.json#/$defs/workspace.change.after */
+export type WorkspaceChangeAfterEvent = TaskWorkspaceEventWorkspaceChangeAfter;
+/** Source: schema/draft/capabilities.schema.json#/$defs/workspace.change.before */
+export type WorkspaceChangeBeforeCapabilities = Capabilities & {
+    effects?: Array<OpenString<"deny" | "modify" | "message">>;
+    modify?: {} & AdditionalProperties;
+} & AdditionalProperties;
+/** Source: schema/draft/catalogue-event.schema.json#/$defs/workspace.change.before */
+export type WorkspaceChangeBeforeEvent = TaskWorkspaceEventWorkspaceChangeBefore;
+export declare function parseCapabilities(input: string | unknown): ParseResult<Capabilities>;
+export declare function encodeCapabilities(value: Capabilities): string;
+export declare const capabilitiesSchemaRevision: "draft";
+export declare function parseCapabilitiesRequest(input: string | unknown): ParseResult<CapabilitiesRequest>;
+export declare function encodeCapabilitiesRequest(value: CapabilitiesRequest): string;
+export declare const capabilitiesRequestSchemaRevision: "draft";
+export declare function parseCapabilitiesResponse(input: string | unknown): ParseResult<CapabilitiesResponse>;
+export declare function encodeCapabilitiesResponse(value: CapabilitiesResponse): string;
+export declare const capabilitiesResponseSchemaRevision: "draft";
+export declare function parseCatalogueEvent(input: string | unknown): ParseResult<CatalogueEvent>;
+export declare function encodeCatalogueEvent(value: CatalogueEvent): string;
+export declare const catalogueEventSchemaRevision: "draft";
+export declare function parseContentItem(input: string | unknown): ParseResult<ContentItem>;
+export declare function encodeContentItem(value: ContentItem): string;
+export declare const contentItemSchemaRevision: "draft";
+export declare function parseContentReference(input: string | unknown): ParseResult<ContentReference>;
+export declare function encodeContentReference(value: ContentReference): string;
+export declare const contentReferenceSchemaRevision: "draft";
+export declare function parseContentSelection(input: string | unknown): ParseResult<ContentSelection>;
+export declare function encodeContentSelection(value: ContentSelection): string;
+export declare const contentSelectionSchemaRevision: "draft";
+export declare function parseContentUpload(input: string | unknown): ParseResult<ContentUpload>;
+export declare function encodeContentUpload(value: ContentUpload): string;
+export declare const contentUploadSchemaRevision: "draft";
+export declare function parseDenyEffect(input: string | unknown): ParseResult<DenyEffect>;
+export declare function encodeDenyEffect(value: DenyEffect): string;
+export declare const denyEffectSchemaRevision: "draft";
+export declare function parseEffect(input: string | unknown): ParseResult<Effect>;
+export declare function encodeEffect(value: Effect): string;
+export declare const effectSchemaRevision: "draft";
+export declare function parseExecutionEvent(input: string | unknown): ParseResult<ExecutionEvent>;
+export declare function encodeExecutionEvent(value: ExecutionEvent): string;
+export declare const executionEventSchemaRevision: "draft";
+export declare function parseExtensions(input: string | unknown): ParseResult<Extensions>;
+export declare function encodeExtensions(value: Extensions): string;
+export declare const extensionsSchemaRevision: "draft";
+export declare function parseInteractionEvent(input: string | unknown): ParseResult<InteractionEvent>;
+export declare function encodeInteractionEvent(value: InteractionEvent): string;
+export declare const interactionEventSchemaRevision: "draft";
+export declare function parseInterceptDenyResponse(input: string | unknown): ParseResult<InterceptDenyResponse>;
+export declare function encodeInterceptDenyResponse(value: InterceptDenyResponse): string;
+export declare const interceptDenyResponseSchemaRevision: "draft";
+export declare function parseInterceptNoEffectResponse(input: string | unknown): ParseResult<InterceptNoEffectResponse>;
+export declare function encodeInterceptNoEffectResponse(value: InterceptNoEffectResponse): string;
+export declare const interceptNoEffectResponseSchemaRevision: "draft";
+export declare function parseInterceptRequest(input: string | unknown): ParseResult<InterceptRequest>;
+export declare function encodeInterceptRequest(value: InterceptRequest): string;
+export declare const interceptRequestSchemaRevision: "draft";
+export declare function parseInterceptResponse(input: string | unknown): ParseResult<InterceptResponse>;
+export declare function encodeInterceptResponse(value: InterceptResponse): string;
+export declare const interceptResponseSchemaRevision: "draft";
+export declare function parseJsonRpcMessage(input: string | unknown): ParseResult<JsonRpcMessage>;
+export declare function encodeJsonRpcMessage(value: JsonRpcMessage): string;
+export declare const jsonRpcMessageSchemaRevision: "draft";
+export declare function parseObserveNotification(input: string | unknown): ParseResult<ObserveNotification>;
+export declare function encodeObserveNotification(value: ObserveNotification): string;
+export declare const observeNotificationSchemaRevision: "draft";
+export declare function parseRegistration(input: string | unknown): ParseResult<Registration>;
+export declare function encodeRegistration(value: Registration): string;
+export declare const registrationSchemaRevision: "draft";
+export declare function parseSessionEndEvent(input: string | unknown): ParseResult<SessionEndEvent>;
+export declare function encodeSessionEndEvent(value: SessionEndEvent): string;
+export declare const sessionEndEventSchemaRevision: "draft";
+export declare function parseSessionStartEvent(input: string | unknown): ParseResult<SessionStartEvent>;
+export declare function encodeSessionStartEvent(value: SessionStartEvent): string;
+export declare const sessionStartEventSchemaRevision: "draft";
+export declare function parseTaskWorkspaceEvent(input: string | unknown): ParseResult<TaskWorkspaceEvent>;
+export declare function encodeTaskWorkspaceEvent(value: TaskWorkspaceEvent): string;
+export declare const taskWorkspaceEventSchemaRevision: "draft";
+export declare function parseToolAfterEvent(input: string | unknown): ParseResult<ToolAfterEvent>;
+export declare function encodeToolAfterEvent(value: ToolAfterEvent): string;
+export declare const toolAfterEventSchemaRevision: "draft";
+export declare function parseToolBeforeEvent(input: string | unknown): ParseResult<ToolBeforeEvent>;
+export declare function encodeToolBeforeEvent(value: ToolBeforeEvent): string;
+export declare const toolBeforeEventSchemaRevision: "draft";
+export declare function parseWireMessage(input: string | unknown): ParseResult<WireMessage>;
+export declare function encodeWireMessage(value: WireMessage): string;
+export declare const wireMessageSchemaRevision: "draft";
+export type DeliveryDiagnosticCode = "protocol_rejection" | "remote_rpc" | "transport" | "cancelled" | "deadline_exceeded" | "preparation" | "capacity";
+export type ConfigChangeAfterInput = {
+    change: {
+        mcpServers?: Array<{} & AdditionalProperties>;
+        path?: string;
+        scope: string;
+        settings: Array<string>;
+        source: string;
+        summary: string;
+    } & AdditionalProperties;
+    extensions?: Extensions;
+    gaps?: Array<{
+        path: string;
+        reason: string;
+    } & AdditionalProperties>;
+    id?: string;
+    items?: Array<ContentItem>;
+    native?: NativeEvent;
+    parentEventId?: string;
+    session?: Session;
+    synthesized?: boolean;
+    time?: string;
+    turn?: {
+        id: string;
+        synthesized?: boolean;
+    } & AdditionalProperties;
+};
+export type ConfigChangeBeforeInput = {
+    change: {
+        path?: string;
+        scope: string;
+        settings: Array<string>;
+        source: string;
+        summary: string;
+    } & AdditionalProperties;
+    extensions?: Extensions;
+    gaps?: Array<{
+        path: string;
+        reason: string;
+    } & AdditionalProperties>;
+    id?: string;
+    items?: Array<ContentItem>;
+    native?: NativeEvent;
+    parentEventId?: string;
+    session?: Session;
+    synthesized?: boolean;
+    time?: string;
+    turn?: {
+        id: string;
+        synthesized?: boolean;
+    } & AdditionalProperties;
+};
+export type ContextCompactAfterInput = {
+    execution: ExecutionEventExecution;
+    extensions?: Extensions;
+    gaps?: Array<{
+        path: string;
+        reason: string;
+    } & AdditionalProperties>;
+    id?: string;
+    items?: Array<ModelVisibleItem>;
+    native?: NativeEvent;
+    parentEventId?: string;
+    removed: Array<{
+        id: string;
+    } & AdditionalProperties>;
+    session?: Session;
+    summary: ModelVisibleItem;
+    synthesized?: boolean;
+    time?: string;
+    tokenCounts?: ExecutionEventTokencounts;
+    turn?: {
+        id: string;
+        synthesized?: boolean;
+    } & AdditionalProperties;
+};
+export type ContextCompactBeforeInput = {
+    extensions?: Extensions;
+    gaps?: Array<{
+        path: string;
+        reason: string;
+    } & AdditionalProperties>;
+    id?: string;
+    instructions?: ContentItem;
+    items: Array<ModelVisibleItem>;
+    native?: NativeEvent;
+    parentEventId?: string;
+    session?: Session;
+    synthesized?: boolean;
+    time?: string;
+    tokenCounts?: ExecutionEventTokencounts;
+    trigger: OpenString<"auto" | "manual" | "hook">;
+    turn?: {
+        id: string;
+        synthesized?: boolean;
+    } & AdditionalProperties;
+};
+export type FileChangedInput = {
+    changes: Array<{
+        after?: ContentReference;
+        agentCaused: boolean;
+        before?: ContentReference;
+        operation: OpenString<"create" | "update" | "remove">;
+        path: string;
+    } & AdditionalProperties>;
+    extensions?: Extensions;
+    gaps?: Array<{
+        path: string;
+        reason: string;
+    } & AdditionalProperties>;
+    id?: string;
+    items?: Array<ContentItem>;
+    native?: NativeEvent;
+    parentEventId?: string;
+    session?: Session;
+    synthesized?: boolean;
+    time?: string;
+    turn?: {
+        id: string;
+        synthesized?: boolean;
+    } & AdditionalProperties;
+};
+export type HookFailureInput = {
+    extensions?: Extensions;
+    failure: {
+        backendId: string;
+        policy: OpenString<"fail-open" | "fail-closed">;
+        reason: string;
+    } & AdditionalProperties;
+    gaps?: Array<{
+        path: string;
+        reason: string;
+    } & AdditionalProperties>;
+    id?: string;
+    items?: Array<ContentItem>;
+    native?: NativeEvent;
+    parentEventId: string;
+    session?: Session;
+    synthesized?: boolean;
+    time?: string;
+    turn?: {
+        id: string;
+        synthesized?: boolean;
+    } & AdditionalProperties;
+};
+export type ModelErrorInput = {
+    attempt: ExecutionEventAttempt;
+    error: ExecutionEventError;
+    execution: ExecutionEventExecution & {
+        status?: "executed";
+    } & AdditionalProperties;
+    extensions?: Extensions;
+    gaps?: Array<{
+        path: string;
+        reason: string;
+    } & AdditionalProperties>;
+    id?: string;
+    items?: Array<ContentItem>;
+    latencyMs?: number;
+    model: ExecutionEventModel;
+    native?: NativeEvent;
+    parentEventId?: string;
+    recovery?: string;
+    session?: Session;
+    synthesized?: boolean;
+    time?: string;
+    turn?: {
+        id: string;
+        synthesized?: boolean;
+    } & AdditionalProperties;
+    usage?: ExecutionEventAttemptusage;
+};
+export type ModelRequestBeforeInput = {
+    attempt: ExecutionEventAttempt;
+    extensions?: Extensions;
+    gaps?: Array<{
+        path: string;
+        reason: string;
+    } & AdditionalProperties>;
+    id?: string;
+    items: Array<ModelVisibleItem>;
+    model: ExecutionEventModel;
+    native?: NativeEvent;
+    params: {} & AdditionalProperties;
+    parentEventId?: string;
+    session?: Session;
+    synthesized?: boolean;
+    time?: string;
+    turn?: {
+        id: string;
+        synthesized?: boolean;
+    } & AdditionalProperties;
+};
+export type ModelResponseAfterInput = {
+    attempt: ExecutionEventAttempt;
+    execution: ExecutionEventExecution;
+    extensions?: Extensions;
+    finishReason: string;
+    gaps?: Array<{
+        path: string;
+        reason: string;
+    } & AdditionalProperties>;
+    id?: string;
+    items: Array<ModelVisibleItem>;
+    latencyMs?: number;
+    model: ExecutionEventModel;
+    native?: NativeEvent;
+    parentEventId?: string;
+    session?: Session;
+    synthesized?: boolean;
+    time?: string;
+    turn?: {
+        id: string;
+        synthesized?: boolean;
+    } & AdditionalProperties;
+    usage?: ExecutionEventAttemptusage;
+};
+export type ModelSwitchAfterInput = {
+    current: ExecutionEventModel;
+    extensions?: Extensions;
+    gaps?: Array<{
+        path: string;
+        reason: string;
+    } & AdditionalProperties>;
+    id?: string;
+    items?: Array<ContentItem>;
+    native?: NativeEvent;
+    parentEventId?: string;
+    previous: ExecutionEventModel;
+    reason: string;
+    session?: Session;
+    synthesized?: boolean;
+    time?: string;
+    turn?: {
+        id: string;
+        synthesized?: boolean;
+    } & AdditionalProperties;
+};
+export type ModelSwitchBeforeInput = {
+    current: ExecutionEventModel;
+    extensions?: Extensions;
+    gaps?: Array<{
+        path: string;
+        reason: string;
+    } & AdditionalProperties>;
+    id?: string;
+    items?: Array<ContentItem>;
+    native?: NativeEvent;
+    parentEventId?: string;
+    pricing?: {
+        currency: string;
+        inputPerMillionTokens?: number;
+        outputPerMillionTokens?: number;
+    } & AdditionalProperties;
+    proposed: ExecutionEventModel;
+    reason: string;
+    session?: Session;
+    synthesized?: boolean;
+    time?: string;
+    turn?: {
+        id: string;
+        synthesized?: boolean;
+    } & AdditionalProperties;
+};
+export type SessionEndInput = {
+    counters?: {} & AdditionalProperties;
+    extensions?: Extensions;
+    gaps?: Array<{
+        path: string;
+        reason: string;
+    } & AdditionalProperties>;
+    id?: string;
+    items?: Array<ContentItem>;
+    native?: NativeEvent;
+    outcome: OpenString<"completed" | "cancelled" | "error" | "unknown">;
+    parentEventId?: string;
+    reason: string;
+    session: Session;
+    synthesized?: boolean;
+    time?: string;
+    turn?: {
+        id: string;
+        synthesized?: boolean;
+    } & AdditionalProperties;
+};
+export type SessionStartInput = {
+    extensions?: Extensions;
+    gaps?: Array<{
+        path: string;
+        reason: string;
+    } & AdditionalProperties>;
+    harness: {
+        name: string;
+        version: string;
+    } & AdditionalProperties;
+    id?: string;
+    items: Array<ModelVisibleItem>;
+    native?: NativeEvent;
+    parentEventId?: string;
+    permissionMode: string;
+    resumedFrom?: {
+        id: string;
+        synthesized?: boolean;
+    } & AdditionalProperties;
+    session: Session;
+    synthesized?: boolean;
+    time?: string;
+    trigger: OpenString<"startup" | "resume" | "clear" | "compact" | "fork">;
+    turn?: {
+        id: string;
+        synthesized?: boolean;
+    } & AdditionalProperties;
+};
+export type TaskChangeAfterInput = {
+    extensions?: Extensions;
+    gaps?: Array<{
+        path: string;
+        reason: string;
+    } & AdditionalProperties>;
+    id?: string;
+    items?: Array<ContentItem>;
+    native?: NativeEvent;
+    parentEventId?: string;
+    session?: Session;
+    synthesized?: boolean;
+    task: {
+        change: {} & AdditionalProperties;
+        description?: string;
+        id: string;
+        operation: OpenString<"create" | "update" | "remove">;
+        prior?: {} & AdditionalProperties;
+        synthesized?: boolean;
+    } & AdditionalProperties;
+    time?: string;
+    turn?: {
+        id: string;
+        synthesized?: boolean;
+    } & AdditionalProperties;
+};
+export type TaskChangeBeforeInput = {
+    extensions?: Extensions;
+    gaps?: Array<{
+        path: string;
+        reason: string;
+    } & AdditionalProperties>;
+    id?: string;
+    items?: Array<ContentItem>;
+    native?: NativeEvent;
+    parentEventId?: string;
+    session?: Session;
+    synthesized?: boolean;
+    task: {
+        change: {} & AdditionalProperties;
+        description?: string;
+        id: string;
+        operation: OpenString<"create" | "update" | "remove">;
+        prior?: {} & AdditionalProperties;
+        synthesized?: boolean;
+    } & AdditionalProperties;
+    time?: string;
+    turn?: {
+        id: string;
+        synthesized?: boolean;
+    } & AdditionalProperties;
+};
+export type ToolAfterInput<T = unknown> = {
+    batch?: ExecutionEventBatch;
+    callId: string;
+    callSynthesized?: boolean;
+    durationMs?: number;
+    error?: ExecutionEventError;
+    execution: ExecutionEventExecution;
+    extensions?: Extensions;
+    fileChanges?: Array<ExecutionEventFilechange>;
+    gaps?: Array<{
+        path: string;
+        reason: string;
+    } & AdditionalProperties>;
+    id?: string;
+    items: Array<ModelVisibleItem>;
+    native?: NativeEvent;
+    outcome: OpenString<"ok" | "error" | "denied" | "cancelled" | "timeout">;
+    parentEventId?: string;
+    path: string;
+    session?: Session;
+    synthesized?: boolean;
+    time?: string;
+    input: T;
+    toolKind?: string;
+    toolMcp?: ExecutionEventMcp;
+    name: string;
+    origin: OpenString<"native" | "mcp">;
+    turn?: {
+        id: string;
+        synthesized?: boolean;
+    } & AdditionalProperties;
+};
+export type ToolBatchAfterInput = {
+    batch: {
+        id: string;
+        synthesized?: boolean;
+    } & AdditionalProperties;
+    calls: Array<{
+        batch?: ExecutionEventBatch;
+        call: {
+            id: string;
+            synthesized?: boolean;
+        } & AdditionalProperties;
+        execution: ExecutionEventExecution;
+        outcome: OpenString<"ok" | "error" | "denied" | "cancelled" | "timeout">;
+        path: string;
+        tool: ExecutionEventTool;
+    } & AdditionalProperties>;
+    extensions?: Extensions;
+    gaps?: Array<{
+        path: string;
+        reason: string;
+    } & AdditionalProperties>;
+    id?: string;
+    items?: Array<ContentItem>;
+    native?: NativeEvent;
+    parentEventId?: string;
+    session?: Session;
+    synthesized?: boolean;
+    time?: string;
+    turn?: {
+        id: string;
+        synthesized?: boolean;
+    } & AdditionalProperties;
+};
+export type ToolBeforeInput<T = unknown> = {
+    batch?: ExecutionEventBatch;
+    callId: string;
+    callSynthesized?: boolean;
+    extensions?: Extensions;
+    gaps?: Array<{
+        path: string;
+        reason: string;
+    } & AdditionalProperties>;
+    id?: string;
+    items?: Array<ContentItem>;
+    native?: NativeEvent;
+    parentEventId?: string;
+    path: string;
+    session?: Session;
+    synthesized?: boolean;
+    time?: string;
+    input: T;
+    toolKind?: string;
+    toolMcp?: ExecutionEventMcp;
+    name: string;
+    origin: OpenString<"native" | "mcp">;
+    turn?: {
+        id: string;
+        synthesized?: boolean;
+    } & AdditionalProperties;
+};
+export type ToolPermissionRequestInput<T = unknown> = {
+    batch?: ExecutionEventBatch;
+    callId: string;
+    callSynthesized?: boolean;
+    extensions?: Extensions;
+    gaps?: Array<{
+        path: string;
+        reason: string;
+    } & AdditionalProperties>;
+    id?: string;
+    items?: Array<ContentItem>;
+    native?: NativeEvent;
+    parentEventId?: string;
+    path: string;
+    sandboxBypass: boolean;
+    session?: Session;
+    suggestions: Array<{} & AdditionalProperties>;
+    synthesized?: boolean;
+    time?: string;
+    input: T;
+    toolKind?: string;
+    toolMcp?: ExecutionEventMcp;
+    name: string;
+    origin: OpenString<"native" | "mcp">;
+    turn?: {
+        id: string;
+        synthesized?: boolean;
+    } & AdditionalProperties;
+};
+export type ToolPermissionResolvedInput<T = unknown> = {
+    batch?: ExecutionEventBatch;
+    callId: string;
+    callSynthesized?: boolean;
+    decidedBy: OpenString<"user" | "policy" | "hook" | "auto" | "classifier">;
+    decision: OpenString<"allow" | "deny">;
+    extensions?: Extensions;
+    gaps?: Array<{
+        path: string;
+        reason: string;
+    } & AdditionalProperties>;
+    id?: string;
+    items?: Array<ContentItem>;
+    native?: NativeEvent;
+    parentEventId?: string;
+    path: string;
+    session?: Session;
+    synthesized?: boolean;
+    time?: string;
+    input: T;
+    toolKind?: string;
+    toolMcp?: ExecutionEventMcp;
+    name: string;
+    origin: OpenString<"native" | "mcp">;
+    turn?: {
+        id: string;
+        synthesized?: boolean;
+    } & AdditionalProperties;
+};
+export type ToolProgressInput<T = unknown> = {
+    backgrounded: boolean;
+    batch?: ExecutionEventBatch;
+    callId: string;
+    callSynthesized?: boolean;
+    extensions?: Extensions;
+    gaps?: Array<{
+        path: string;
+        reason: string;
+    } & AdditionalProperties>;
+    id?: string;
+    items?: Array<ContentItem>;
+    native?: NativeEvent;
+    parentEventId?: string;
+    partialOutput: ModelVisibleItem;
+    path: string;
+    session?: Session;
+    synthesized?: boolean;
+    time?: string;
+    input: T;
+    toolKind?: string;
+    toolMcp?: ExecutionEventMcp;
+    name: string;
+    origin: OpenString<"native" | "mcp">;
+    turn?: {
+        id: string;
+        synthesized?: boolean;
+    } & AdditionalProperties;
+};
+export type TurnEndInput = {
+    continuationCount: number;
+    error?: ExecutionEventError;
+    extensions?: Extensions;
+    gaps?: Array<{
+        path: string;
+        reason: string;
+    } & AdditionalProperties>;
+    id?: string;
+    items: Array<ModelVisibleItem>;
+    lastAssistantItem?: {
+        id: string;
+        synthesized?: boolean;
+    } & AdditionalProperties;
+    native?: NativeEvent;
+    outcome: OpenString<"completed" | "failed" | "cancelled" | "max_iterations">;
+    parentEventId?: string;
+    session?: Session;
+    synthesized?: boolean;
+    time?: string;
+    turn: {
+        id: string;
+        synthesized?: boolean;
+    } & AdditionalProperties;
+    usage?: ExecutionEventTurnusage;
+};
+export type TurnFinishBeforeInput = {
+    continuationCount: number;
+    extensions?: Extensions;
+    gaps?: Array<{
+        path: string;
+        reason: string;
+    } & AdditionalProperties>;
+    id?: string;
+    items: Array<ModelVisibleItem>;
+    lastAssistantItem?: {
+        id: string;
+        synthesized?: boolean;
+    } & AdditionalProperties;
+    native?: NativeEvent;
+    outcome: OpenString<"completed" | "failed" | "cancelled" | "max_iterations">;
+    parentEventId?: string;
+    session?: Session;
+    synthesized?: boolean;
+    time?: string;
+    turn: {
+        id: string;
+        synthesized?: boolean;
+    } & AdditionalProperties;
+    usage?: ExecutionEventTurnusage;
+};
+export type TurnProgressInput = {
+    delta: ModelVisibleItem;
+    extensions?: Extensions;
+    final: boolean;
+    gaps?: Array<{
+        path: string;
+        reason: string;
+    } & AdditionalProperties>;
+    id?: string;
+    item: {
+        id: string;
+        synthesized?: boolean;
+    } & AdditionalProperties;
+    items?: Array<ContentItem>;
+    native?: NativeEvent;
+    parentEventId?: string;
+    session?: Session;
+    synthesized?: boolean;
+    time?: string;
+    turn: {
+        id: string;
+        synthesized?: boolean;
+    } & AdditionalProperties;
+};
+export type TurnStartInput = {
+    expandedFrom?: string;
+    extensions?: Extensions;
+    gaps?: Array<{
+        path: string;
+        reason: string;
+    } & AdditionalProperties>;
+    id?: string;
+    items: Array<ModelVisibleItem>;
+    native?: NativeEvent;
+    parentEventId?: string;
+    session?: Session;
+    synthesized?: boolean;
+    time?: string;
+    trigger: OpenString<"user" | "continuation" | "hook" | "external">;
+    turn: {
+        id: string;
+        synthesized?: boolean;
+    } & AdditionalProperties;
+};
+export type UserAttentionInput = {
+    attention: {
+        kind: string;
+        message: Array<ContentItem>;
+        title: Array<ContentItem>;
+    } & AdditionalProperties;
+    extensions?: Extensions;
+    gaps?: Array<{
+        path: string;
+        reason: string;
+    } & AdditionalProperties>;
+    id?: string;
+    items?: Array<ContentItem>;
+    native?: NativeEvent;
+    parentEventId?: string;
+    session?: Session;
+    synthesized?: boolean;
+    time?: string;
+    turn?: {
+        id: string;
+        synthesized?: boolean;
+    } & AdditionalProperties;
+};
+export type UserElicitationRequestInput = {
+    elicitation: {
+        mode: OpenString<"form" | "url">;
+        request?: ContentItem & {
+            mediaType?: "application/json";
+        } & AdditionalProperties;
+        server: string;
+    } & AdditionalProperties;
+    extensions?: Extensions;
+    gaps?: Array<{
+        path: string;
+        reason: string;
+    } & AdditionalProperties>;
+    id?: string;
+    items?: Array<ContentItem>;
+    native?: NativeEvent;
+    parentEventId?: string;
+    session?: Session;
+    synthesized?: boolean;
+    time?: string;
+    turn?: {
+        id: string;
+        synthesized?: boolean;
+    } & AdditionalProperties;
+};
+export type UserElicitationResultInput = {
+    elicitation: {
+        action: OpenString<"accept" | "decline" | "cancel">;
+        mode: OpenString<"form" | "url">;
+        result?: ContentItem & {
+            mediaType?: "application/json";
+        } & AdditionalProperties;
+        server: string;
+    } & AdditionalProperties;
+    extensions?: Extensions;
+    gaps?: Array<{
+        path: string;
+        reason: string;
+    } & AdditionalProperties>;
+    id?: string;
+    items?: Array<ContentItem>;
+    native?: NativeEvent;
+    parentEventId?: string;
+    session?: Session;
+    synthesized?: boolean;
+    time?: string;
+    turn?: {
+        id: string;
+        synthesized?: boolean;
+    } & AdditionalProperties;
+};
+export type UserMessageInboundInput = {
+    extensions?: Extensions;
+    gaps?: Array<{
+        path: string;
+        reason: string;
+    } & AdditionalProperties>;
+    id?: string;
+    items?: Array<ContentItem>;
+    message: {
+        channel: string;
+        sender: string;
+        text: Array<ContentItem>;
+    } & AdditionalProperties;
+    native?: NativeEvent;
+    parentEventId?: string;
+    session?: Session;
+    synthesized?: boolean;
+    time?: string;
+    turn?: {
+        id: string;
+        synthesized?: boolean;
+    } & AdditionalProperties;
+};
+export type UserMessageOutboundInput = {
+    extensions?: Extensions;
+    gaps?: Array<{
+        path: string;
+        reason: string;
+    } & AdditionalProperties>;
+    id?: string;
+    items?: Array<ContentItem>;
+    message: {
+        channel: string;
+        payload: Array<ContentItem>;
+    } & AdditionalProperties;
+    native?: NativeEvent;
+    parentEventId?: string;
+    session?: Session;
+    synthesized?: boolean;
+    time?: string;
+    turn?: {
+        id: string;
+        synthesized?: boolean;
+    } & AdditionalProperties;
+};
+export type WorkspaceChangeAfterInput = {
+    extensions?: Extensions;
+    gaps?: Array<{
+        path: string;
+        reason: string;
+    } & AdditionalProperties>;
+    id?: string;
+    items?: Array<ContentItem>;
+    native?: NativeEvent;
+    parentEventId?: string;
+    session?: Session;
+    synthesized?: boolean;
+    time?: string;
+    turn?: {
+        id: string;
+        synthesized?: boolean;
+    } & AdditionalProperties;
+    workspace: {
+        change: {
+            cwd?: string;
+            workspaceRoots?: Array<string>;
+        } & AdditionalProperties;
+        kind: OpenString<"cwd" | "roots" | "switch">;
+        prior?: {
+            cwd?: string;
+            workspaceRoots?: Array<string>;
+        } & AdditionalProperties;
+        reason?: string;
+    } & AdditionalProperties;
+};
+export type WorkspaceChangeBeforeInput = {
+    extensions?: Extensions;
+    gaps?: Array<{
+        path: string;
+        reason: string;
+    } & AdditionalProperties>;
+    id?: string;
+    items?: Array<ContentItem>;
+    native?: NativeEvent;
+    parentEventId?: string;
+    session?: Session;
+    synthesized?: boolean;
+    time?: string;
+    turn?: {
+        id: string;
+        synthesized?: boolean;
+    } & AdditionalProperties;
+    workspace: {
+        change: {
+            cwd?: string;
+            workspaceRoots?: Array<string>;
+        } & AdditionalProperties;
+        kind: OpenString<"cwd" | "roots" | "switch">;
+        prior?: {
+            cwd?: string;
+            workspaceRoots?: Array<string>;
+        } & AdditionalProperties;
+        reason?: string;
+    } & AdditionalProperties;
+};
+export interface EventInputs {
+    "config.change.after": ConfigChangeAfterInput;
+    "config.change.before": ConfigChangeBeforeInput;
+    "context.compact.after": ContextCompactAfterInput;
+    "context.compact.before": ContextCompactBeforeInput;
+    "file.changed": FileChangedInput;
+    "hook.failure": HookFailureInput;
+    "model.error": ModelErrorInput;
+    "model.request.before": ModelRequestBeforeInput;
+    "model.response.after": ModelResponseAfterInput;
+    "model.switch.after": ModelSwitchAfterInput;
+    "model.switch.before": ModelSwitchBeforeInput;
+    "session.end": SessionEndInput;
+    "session.start": SessionStartInput;
+    "task.change.after": TaskChangeAfterInput;
+    "task.change.before": TaskChangeBeforeInput;
+    "tool.after": ToolAfterInput;
+    "tool.batch.after": ToolBatchAfterInput;
+    "tool.before": ToolBeforeInput;
+    "tool.permission.request": ToolPermissionRequestInput;
+    "tool.permission.resolved": ToolPermissionResolvedInput;
+    "tool.progress": ToolProgressInput;
+    "turn.end": TurnEndInput;
+    "turn.finish.before": TurnFinishBeforeInput;
+    "turn.progress": TurnProgressInput;
+    "turn.start": TurnStartInput;
+    "user.attention": UserAttentionInput;
+    "user.elicitation.request": UserElicitationRequestInput;
+    "user.elicitation.result": UserElicitationResultInput;
+    "user.message.inbound": UserMessageInboundInput;
+    "user.message.outbound": UserMessageOutboundInput;
+    "workspace.change.after": WorkspaceChangeAfterInput;
+    "workspace.change.before": WorkspaceChangeBeforeInput;
+}
+/** Project host facts only. The runtime supplies source, IDs, time, and manifest and validates the assembled request. */
+export declare function toEventInput<K extends keyof EventInputs>(type: K, input: EventInputs[K]): Record<string, JsonValue>;
+export type EventType = keyof EventInputs;
+export declare const events: {
+    readonly configChangeAfter: "config.change.after";
+    readonly configChangeBefore: "config.change.before";
+    readonly contextCompactAfter: "context.compact.after";
+    readonly contextCompactBefore: "context.compact.before";
+    readonly fileChanged: "file.changed";
+    readonly hookFailure: "hook.failure";
+    readonly modelError: "model.error";
+    readonly modelRequestBefore: "model.request.before";
+    readonly modelResponseAfter: "model.response.after";
+    readonly modelSwitchAfter: "model.switch.after";
+    readonly modelSwitchBefore: "model.switch.before";
+    readonly sessionEnd: "session.end";
+    readonly sessionStart: "session.start";
+    readonly taskChangeAfter: "task.change.after";
+    readonly taskChangeBefore: "task.change.before";
+    readonly toolAfter: "tool.after";
+    readonly toolBatchAfter: "tool.batch.after";
+    readonly toolBefore: "tool.before";
+    readonly toolPermissionRequest: "tool.permission.request";
+    readonly toolPermissionResolved: "tool.permission.resolved";
+    readonly toolProgress: "tool.progress";
+    readonly turnEnd: "turn.end";
+    readonly turnFinishBefore: "turn.finish.before";
+    readonly turnProgress: "turn.progress";
+    readonly turnStart: "turn.start";
+    readonly userAttention: "user.attention";
+    readonly userElicitationRequest: "user.elicitation.request";
+    readonly userElicitationResult: "user.elicitation.result";
+    readonly userMessageInbound: "user.message.inbound";
+    readonly userMessageOutbound: "user.message.outbound";
+    readonly workspaceChangeAfter: "workspace.change.after";
+    readonly workspaceChangeBefore: "workspace.change.before";
+};
+/** Named out-of-band content bindings. Streams are never inserted into wire models. */
+export interface ContentSourceBinding<S> {
+    readonly path: readonly (string | number)[];
+    readonly source: S;
+}
+export declare const contentSlots: {
+    readonly "config.change.after": {
+        readonly items: <S>(index: number, source: S) => ContentSourceBinding<S>;
+    };
+    readonly "config.change.before": {
+        readonly items: <S>(index: number, source: S) => ContentSourceBinding<S>;
+    };
+    readonly "context.compact.after": {
+        readonly items: <S>(index: number, source: S) => ContentSourceBinding<S>;
+        readonly summary: <S>(source: S) => ContentSourceBinding<S>;
+    };
+    readonly "context.compact.before": {
+        readonly instructions: <S>(source: S) => ContentSourceBinding<S>;
+        readonly items: <S>(index: number, source: S) => ContentSourceBinding<S>;
+    };
+    readonly "file.changed": {
+        readonly items: <S>(index: number, source: S) => ContentSourceBinding<S>;
+    };
+    readonly "hook.failure": {
+        readonly items: <S>(index: number, source: S) => ContentSourceBinding<S>;
+    };
+    readonly "model.error": {
+        readonly items: <S>(index: number, source: S) => ContentSourceBinding<S>;
+    };
+    readonly "model.request.before": {
+        readonly items: <S>(index: number, source: S) => ContentSourceBinding<S>;
+    };
+    readonly "model.response.after": {
+        readonly items: <S>(index: number, source: S) => ContentSourceBinding<S>;
+    };
+    readonly "model.switch.after": {
+        readonly items: <S>(index: number, source: S) => ContentSourceBinding<S>;
+    };
+    readonly "model.switch.before": {
+        readonly items: <S>(index: number, source: S) => ContentSourceBinding<S>;
+    };
+    readonly "session.end": {
+        readonly items: <S>(index: number, source: S) => ContentSourceBinding<S>;
+    };
+    readonly "session.start": {
+        readonly items: <S>(index: number, source: S) => ContentSourceBinding<S>;
+    };
+    readonly "task.change.after": {
+        readonly items: <S>(index: number, source: S) => ContentSourceBinding<S>;
+    };
+    readonly "task.change.before": {
+        readonly items: <S>(index: number, source: S) => ContentSourceBinding<S>;
+    };
+    readonly "tool.after": {
+        readonly fileChangesAfter: <S>(index: number, source: S) => ContentSourceBinding<S>;
+        readonly fileChangesBefore: <S>(index: number, source: S) => ContentSourceBinding<S>;
+        readonly items: <S>(index: number, source: S) => ContentSourceBinding<S>;
+    };
+    readonly "tool.batch.after": {
+        readonly items: <S>(index: number, source: S) => ContentSourceBinding<S>;
+    };
+    readonly "tool.before": {
+        readonly items: <S>(index: number, source: S) => ContentSourceBinding<S>;
+    };
+    readonly "tool.permission.request": {
+        readonly items: <S>(index: number, source: S) => ContentSourceBinding<S>;
+    };
+    readonly "tool.permission.resolved": {
+        readonly items: <S>(index: number, source: S) => ContentSourceBinding<S>;
+    };
+    readonly "tool.progress": {
+        readonly items: <S>(index: number, source: S) => ContentSourceBinding<S>;
+        readonly partialOutput: <S>(source: S) => ContentSourceBinding<S>;
+    };
+    readonly "turn.end": {
+        readonly items: <S>(index: number, source: S) => ContentSourceBinding<S>;
+    };
+    readonly "turn.finish.before": {
+        readonly items: <S>(index: number, source: S) => ContentSourceBinding<S>;
+    };
+    readonly "turn.progress": {
+        readonly delta: <S>(source: S) => ContentSourceBinding<S>;
+        readonly items: <S>(index: number, source: S) => ContentSourceBinding<S>;
+    };
+    readonly "turn.start": {
+        readonly items: <S>(index: number, source: S) => ContentSourceBinding<S>;
+    };
+    readonly "user.attention": {
+        readonly attentionMessage: <S>(index: number, source: S) => ContentSourceBinding<S>;
+        readonly attentionTitle: <S>(index: number, source: S) => ContentSourceBinding<S>;
+        readonly items: <S>(index: number, source: S) => ContentSourceBinding<S>;
+    };
+    readonly "user.elicitation.request": {
+        readonly elicitationRequest: <S>(source: S) => ContentSourceBinding<S>;
+        readonly items: <S>(index: number, source: S) => ContentSourceBinding<S>;
+    };
+    readonly "user.elicitation.result": {
+        readonly elicitationResult: <S>(source: S) => ContentSourceBinding<S>;
+        readonly items: <S>(index: number, source: S) => ContentSourceBinding<S>;
+    };
+    readonly "user.message.inbound": {
+        readonly items: <S>(index: number, source: S) => ContentSourceBinding<S>;
+        readonly messageText: <S>(index: number, source: S) => ContentSourceBinding<S>;
+    };
+    readonly "user.message.outbound": {
+        readonly items: <S>(index: number, source: S) => ContentSourceBinding<S>;
+        readonly messagePayload: <S>(index: number, source: S) => ContentSourceBinding<S>;
+    };
+    readonly "workspace.change.after": {
+        readonly items: <S>(index: number, source: S) => ContentSourceBinding<S>;
+    };
+    readonly "workspace.change.before": {
+        readonly items: <S>(index: number, source: S) => ContentSourceBinding<S>;
+    };
+};
+export declare enum Permission {
+    None = "none",
+    Allow = "allow",
+    Ask = "ask",
+    Deny = "deny"
+}
+export type InitialState = NonNullable<InterceptRequest["params"]["state"]>;
+export type StateCandidate = NonNullable<InitialState["candidate"]>;
+export declare const state: {
+    readonly candidate: (value: JsonValue, provenance?: Record<string, JsonValue>) => StateCandidate;
+    readonly initial: (permission: Permission, options?: Partial<InitialState>) => InitialState;
+};
+/** Canonical effect constructors; grants and admission remain runtime checks. */
+export declare const effects: {
+    readonly deny: (reason: string) => Effect;
+    readonly allow: () => Effect;
+    readonly ask: () => Effect;
+    readonly modify: (operation: OpenString<"replace" | "merge">, target: OpenString<"input" | "output" | "prompt" | "request" | "response" | "content" | "instructions" | "summary" | "workspace">, value: JsonValue) => Effect;
+    readonly message: (text: string) => Effect;
+    readonly return: (value: JsonValue) => Effect;
+    readonly flow_stop: (reason: string) => Effect;
+    readonly flow_continue: () => Effect;
+    readonly inject_append: (deliverAt: OpenString<"now" | "next_turn">, value: JsonValue) => Effect;
+    readonly modify_input: {
+        readonly replace: (value: JsonValue) => Effect;
+        readonly merge: (value: JsonValue) => Effect;
+    };
+    readonly modify_output: {
+        readonly replace: (value: JsonValue) => Effect;
+        readonly merge: (value: JsonValue) => Effect;
+    };
+    readonly modify_prompt: {
+        readonly replace: (value: JsonValue) => Effect;
+        readonly merge: (value: JsonValue) => Effect;
+    };
+    readonly modify_request: {
+        readonly replace: (value: JsonValue) => Effect;
+        readonly merge: (value: JsonValue) => Effect;
+    };
+    readonly modify_response: {
+        readonly replace: (value: JsonValue) => Effect;
+        readonly merge: (value: JsonValue) => Effect;
+    };
+    readonly modify_content: {
+        readonly replace: (value: JsonValue) => Effect;
+        readonly merge: (value: JsonValue) => Effect;
+    };
+    readonly modify_instructions: {
+        readonly replace: (value: JsonValue) => Effect;
+        readonly merge: (value: JsonValue) => Effect;
+    };
+    readonly modify_summary: {
+        readonly replace: (value: JsonValue) => Effect;
+        readonly merge: (value: JsonValue) => Effect;
+    };
+    readonly modify_workspace: {
+        readonly replace: (value: JsonValue) => Effect;
+        readonly merge: (value: JsonValue) => Effect;
+    };
+};
+/** Declaration convenience only. Event admission and per-call narrowing are runtime-owned. */
+export type CapabilityDeclaration = {
+    modes: ("intercept" | "observe")[];
+    capabilities: Capabilities;
+};
+export type CapabilityObservation = {
+    modes: ["observe"];
+};
+export type CapabilityModifyOperations = {
+    merge?: boolean;
+    replace?: boolean;
+};
+export type CapabilityFlowOperation = "continue" | "stop";
+export type CapabilityDelivery = "next_turn" | "now";
+export declare class CapabilityBuilder {
+    #private;
+    private constructor();
+    static intercept(): CapabilityBuilder;
+    private add;
+    build(): CapabilityDeclaration;
+    get modes(): ("intercept" | "observe")[];
+    get capabilities(): Capabilities;
+    toJSON(): CapabilityDeclaration;
+    allow(): CapabilityBuilder;
+    ask(): CapabilityBuilder;
+    deny(): CapabilityBuilder;
+    message(): CapabilityBuilder;
+    return(): CapabilityBuilder;
+    modifyContent(operations: CapabilityModifyOperations): CapabilityBuilder;
+    modifyInput(operations: CapabilityModifyOperations): CapabilityBuilder;
+    modifyInstructions(operations: CapabilityModifyOperations): CapabilityBuilder;
+    modifyOutput(operations: CapabilityModifyOperations): CapabilityBuilder;
+    modifyPrompt(operations: CapabilityModifyOperations): CapabilityBuilder;
+    modifyRequest(operations: CapabilityModifyOperations): CapabilityBuilder;
+    modifyResponse(operations: CapabilityModifyOperations): CapabilityBuilder;
+    modifySummary(operations: CapabilityModifyOperations): CapabilityBuilder;
+    modifyWorkspace(operations: CapabilityModifyOperations): CapabilityBuilder;
+    elicitationForm(): CapabilityBuilder;
+    elicitationUrl(): CapabilityBuilder;
+    flow(operations: readonly CapabilityFlowOperation[], counts?: {
+        remainingContinuations?: number;
+        continuationCount?: number;
+        maxContinuations?: number;
+    }): CapabilityBuilder;
+    injectContext(deliverAt: readonly CapabilityDelivery[]): CapabilityBuilder;
+}
+/** intercept includes observe; declarations do not prove host execution. */
+export declare const capabilities: Readonly<{
+    intercept: () => CapabilityBuilder;
+    observe: () => CapabilityObservation;
+}>;
+//# sourceMappingURL=generated.d.ts.map