@xandreed/process-host 0.0.0-stage → 0.15.0

package/dist/process-protocol.entity.d.ts

@@ -0,0 +1,970 @@
+import { Schema } from "effect";
+import { UserMessage } from "@xandreed/core";
+/** The supported wire protocol; stored journal formats have their own version. @public */
+export declare const PROCESS_PROTOCOL_VERSION = 1;
+/** Correlates an outstanding command; durable idempotence belongs to framework input/key identities. @public */
+export declare const ProcessRequestId: Schema.brand<Schema.Trimmed, "ProcessRequestId">;
+export type ProcessRequestId = typeof ProcessRequestId.Type;
+/** Full progress exports all JSON-compatible event content and must be selected explicitly. @public */
+export declare const ProcessEventMode: Schema.Literals<readonly ["projection", "full"]>;
+export type ProcessEventMode = typeof ProcessEventMode.Type;
+/** Version 1 requests. The parent host creates sessions and supplies the Agent and its services. @public */
+export declare const ProcessCommand: Schema.toTaggedUnion<"_tag", readonly [Schema.TaggedStruct<"hello", {
+    readonly requestId: Schema.brand<Schema.Trimmed, "ProcessRequestId">;
+    readonly protocolVersion: Schema.Int;
+}>, Schema.TaggedStruct<"begin", {
+    readonly requestId: Schema.brand<Schema.Trimmed, "ProcessRequestId">;
+    readonly session: Schema.Struct<{
+        readonly id: Schema.brand<Schema.String, "ConversationId">;
+        readonly owner: Schema.Trimmed;
+    }>;
+    readonly runId: Schema.brand<Schema.String, "RunId">;
+    readonly userMessage: typeof UserMessage;
+    readonly key: Schema.optionalKey<Schema.String>;
+    readonly command: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+    readonly meta: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+    readonly resumes: Schema.optionalKey<Schema.Int>;
+    readonly takeOver: Schema.optionalKey<Schema.Boolean>;
+    readonly timeLimitMs: Schema.optionalKey<Schema.Int>;
+}>, Schema.TaggedStruct<"send", {
+    readonly requestId: Schema.brand<Schema.Trimmed, "ProcessRequestId">;
+    readonly session: Schema.Struct<{
+        readonly id: Schema.brand<Schema.String, "ConversationId">;
+        readonly owner: Schema.Trimmed;
+    }>;
+    readonly input: Schema.Struct<{
+        readonly id: Schema.brand<Schema.Trimmed, "InboxItemId">;
+        readonly source: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+        readonly userMessage: typeof UserMessage;
+    }>;
+}>, Schema.TaggedStruct<"steer", {
+    readonly requestId: Schema.brand<Schema.Trimmed, "ProcessRequestId">;
+    readonly session: Schema.Struct<{
+        readonly id: Schema.brand<Schema.String, "ConversationId">;
+        readonly owner: Schema.Trimmed;
+    }>;
+    readonly input: Schema.Struct<{
+        readonly id: Schema.brand<Schema.Trimmed, "InboxItemId">;
+        readonly source: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+        readonly userMessage: typeof UserMessage;
+    }>;
+}>, Schema.TaggedStruct<"answer", {
+    readonly requestId: Schema.brand<Schema.Trimmed, "ProcessRequestId">;
+    readonly parent: Schema.Struct<{
+        readonly id: Schema.brand<Schema.String, "ConversationId">;
+        readonly owner: Schema.Trimmed;
+    }>;
+    readonly taskId: Schema.brand<Schema.String, "ConversationId">;
+    readonly questionId: Schema.brand<Schema.Trimmed, "TaskQuestionId">;
+    readonly text: Schema.NonEmptyString;
+}>, Schema.TaggedStruct<"cancel", {
+    readonly requestId: Schema.brand<Schema.Trimmed, "ProcessRequestId">;
+    readonly session: Schema.Struct<{
+        readonly id: Schema.brand<Schema.String, "ConversationId">;
+        readonly owner: Schema.Trimmed;
+    }>;
+    readonly turn: Schema.Int;
+}>, Schema.TaggedStruct<"ping", {
+    readonly requestId: Schema.brand<Schema.Trimmed, "ProcessRequestId">;
+}>, Schema.TaggedStruct<"shutdown", {
+    readonly requestId: Schema.brand<Schema.Trimmed, "ProcessRequestId">;
+    readonly deadlineMs: Schema.optionalKey<Schema.Int>;
+}>]>;
+export type ProcessCommand = typeof ProcessCommand.Type;
+/** UI progress with explicit field selection; decoded tool values and provider failures are excluded. */
+export declare const ProcessProjection: Schema.toTaggedUnion<"_tag", readonly [Schema.TaggedStruct<"step.started", {
+    readonly step: Schema.Int;
+    readonly run: Schema.withDecodingDefaultKey<Schema.brand<Schema.Int, "RunOrdinal">, never>;
+    readonly planned: Schema.Boolean;
+}>, Schema.TaggedStruct<"step.ended", {
+    readonly step: Schema.Int;
+    readonly run: Schema.withDecodingDefaultKey<Schema.brand<Schema.Int, "RunOrdinal">, never>;
+    readonly status: Schema.Literals<readonly ["completed", "failed", "cancelled", "malformed", "truncated"]>;
+}>, Schema.TaggedStruct<"assistant.delta", {
+    readonly step: Schema.Int;
+    readonly id: Schema.brand<Schema.String, "StreamPartId">;
+    readonly delta: Schema.String;
+}>, Schema.TaggedStruct<"assistant.message", {
+    readonly step: Schema.Int;
+    readonly run: Schema.withDecodingDefaultKey<Schema.brand<Schema.Int, "RunOrdinal">, never>;
+    readonly text: Schema.String;
+}>, Schema.TaggedStruct<"tool.started", {
+    step: Schema.Int;
+    invocationId: Schema.brand<Schema.String, "InvocationId">;
+    toolCallId: Schema.optionalKey<Schema.brand<Schema.String, "ToolCallId">>;
+    tool: Schema.String;
+}>, Schema.TaggedStruct<"tool.completed", {
+    readonly ok: Schema.Boolean;
+    readonly step: Schema.Int;
+    readonly invocationId: Schema.brand<Schema.String, "InvocationId">;
+    readonly toolCallId: Schema.optionalKey<Schema.brand<Schema.String, "ToolCallId">>;
+    readonly tool: Schema.String;
+}>, Schema.TaggedStruct<"tool.refused", {
+    readonly reason: Schema.Literals<readonly ["inactive", "forbidden", "denied", "call-limit", "tool-call-limit", "run-call-limit", "tripped", "concurrency", "intercepted"]>;
+    readonly step: Schema.Int;
+    readonly invocationId: Schema.brand<Schema.String, "InvocationId">;
+    readonly toolCallId: Schema.optionalKey<Schema.brand<Schema.String, "ToolCallId">>;
+    readonly tool: Schema.String;
+}>, Schema.TaggedStruct<"tool.progress", {
+    readonly text: Schema.String;
+    readonly step: Schema.Int;
+    readonly invocationId: Schema.brand<Schema.String, "InvocationId">;
+    readonly toolCallId: Schema.optionalKey<Schema.brand<Schema.String, "ToolCallId">>;
+    readonly tool: Schema.String;
+}>, Schema.TaggedStruct<"stream.fallback", {
+    readonly step: Schema.Int;
+    readonly run: Schema.withDecodingDefaultKey<Schema.brand<Schema.Int, "RunOrdinal">, never>;
+}>]>;
+export type ProcessProjection = typeof ProcessProjection.Type;
+/** Bus lifecycle events are provisional; only acknowledged SessionLog rows produce lifecycle frames. */
+export declare const ProcessFullEvent: Schema.Union<readonly [Schema.Struct<{
+    readonly _tag: Schema.tag<"step.started">;
+    readonly step: Schema.Int;
+    readonly run: Schema.withDecodingDefaultKey<Schema.brand<Schema.Int, "RunOrdinal">, never>;
+    readonly planned: Schema.Boolean;
+    readonly activeTools: Schema.$Array<Schema.String>;
+}>, Schema.Struct<{
+    readonly _tag: Schema.tag<"tool.started">;
+    readonly step: Schema.Int;
+    readonly invocationId: Schema.brand<Schema.String, "InvocationId">;
+    readonly toolCallId: Schema.optionalKey<Schema.brand<Schema.String, "ToolCallId">>;
+    readonly tool: Schema.String;
+    readonly input: Schema.Unknown;
+    readonly labels: Schema.$Record<Schema.String, Schema.String>;
+    readonly stage: Schema.OptionFromNullOr<Schema.String>;
+}>, Schema.Struct<{
+    readonly _tag: Schema.tag<"tool.refused">;
+    readonly step: Schema.Int;
+    readonly invocationId: Schema.brand<Schema.String, "InvocationId">;
+    readonly toolCallId: Schema.optionalKey<Schema.brand<Schema.String, "ToolCallId">>;
+    readonly tool: Schema.String;
+    readonly input: Schema.Unknown;
+    readonly reason: Schema.Literals<readonly ["inactive", "forbidden", "denied", "call-limit", "tool-call-limit", "run-call-limit", "tripped", "concurrency", "intercepted"]>;
+    readonly message: Schema.String;
+}>, Schema.Struct<{
+    readonly _tag: Schema.tag<"tool.progress">;
+    readonly step: Schema.Int;
+    readonly invocationId: Schema.brand<Schema.String, "InvocationId">;
+    readonly toolCallId: Schema.optionalKey<Schema.brand<Schema.String, "ToolCallId">>;
+    readonly tool: Schema.String;
+    readonly channel: Schema.Literals<readonly ["stdout", "stderr", "status"]>;
+    readonly text: Schema.String;
+}>, Schema.Struct<{
+    readonly _tag: Schema.tag<"tool.completed">;
+    readonly step: Schema.Int;
+    readonly invocationId: Schema.brand<Schema.String, "InvocationId">;
+    readonly toolCallId: Schema.optionalKey<Schema.brand<Schema.String, "ToolCallId">>;
+    readonly tool: Schema.String;
+    readonly input: Schema.Unknown;
+    readonly ok: Schema.Boolean;
+    readonly result: Schema.Unknown;
+    readonly encoded: Schema.Unknown;
+    readonly durationMs: Schema.Number;
+    readonly labels: Schema.$Record<Schema.String, Schema.String>;
+    readonly stage: Schema.OptionFromNullOr<Schema.String>;
+}>, Schema.Struct<{
+    readonly _tag: Schema.tag<"step.ended">;
+    readonly step: Schema.Int;
+    readonly run: Schema.withDecodingDefaultKey<Schema.brand<Schema.Int, "RunOrdinal">, never>;
+    readonly status: Schema.Literals<readonly ["completed", "failed", "cancelled", "malformed", "truncated"]>;
+    readonly results: Schema.$Array<Schema.Struct<{
+        readonly entry: Schema.brand<Schema.Trimmed, "EntryId">;
+        readonly toolCallId: Schema.brand<Schema.String, "ToolCallId">;
+        readonly tool: Schema.String;
+        readonly ok: Schema.Boolean;
+    }>>;
+}>, Schema.Struct<{
+    readonly _tag: Schema.tag<"completion.evaluated">;
+    readonly step: Schema.Int;
+    readonly run: Schema.withDecodingDefaultKey<Schema.brand<Schema.Int, "RunOrdinal">, never>;
+    readonly verdict: Schema.Struct<{
+        readonly complete: Schema.Boolean;
+        readonly awaiting: Schema.$Array<Schema.Trimmed>;
+        readonly facts: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+    }>;
+}>, Schema.Struct<{
+    readonly _tag: Schema.tag<"skills.activated">;
+    readonly skills: Schema.$Array<Schema.String>;
+    readonly tools: Schema.$Array<Schema.String>;
+    readonly source: Schema.Literals<readonly ["always", "matcher", "load_skill", "host"]>;
+}>, Schema.Struct<{
+    readonly _tag: Schema.tag<"context.built">;
+    readonly step: Schema.Int;
+    readonly turn: Schema.Int;
+    readonly run: Schema.withDecodingDefaultKey<Schema.brand<Schema.Int, "RunOrdinal">, never>;
+    readonly strategy: Schema.String;
+    readonly strategyVersion: Schema.String;
+    readonly fingerprint: Schema.String;
+    readonly systemFingerprint: Schema.String;
+    readonly estimatedTokens: Schema.Int;
+    readonly reservedTokens: Schema.Int;
+    readonly budgetTokens: Schema.Int;
+    readonly compactions: Schema.Int;
+    readonly activeTools: Schema.$Array<Schema.String>;
+}>, Schema.Struct<{
+    readonly _tag: Schema.tag<"decision.recorded">;
+    readonly record: Schema.Struct<{
+        readonly version: Schema.Literal<1>;
+        readonly id: Schema.brand<Schema.Trimmed, "DecisionId">;
+        readonly family: Schema.NonEmptyString;
+        readonly contextHash: Schema.String;
+        readonly candidateHash: Schema.String;
+        readonly policyVersion: Schema.String;
+        readonly candidates: Schema.$Array<Schema.Struct<{
+            readonly id: Schema.brand<Schema.String, "CandidateId">;
+            readonly description: Schema.String;
+        }>>;
+        readonly attempts: Schema.$Array<Schema.String>;
+        readonly selection: Schema.OptionFromNullOr<Schema.String>;
+        readonly validation: Schema.Literals<readonly ["accepted", "rejected", "abstained", "failed", "cancelled", "bypassed"]>;
+        readonly fallback: Schema.OptionFromNullOr<Schema.String>;
+        readonly applied: Schema.OptionFromNullOr<Schema.String>;
+        readonly probabilities: Schema.OptionFromNullOr<Schema.$Record<Schema.String, Schema.Number>>;
+    }>;
+}>, Schema.Struct<{
+    readonly _tag: Schema.tag<"assistant.message">;
+    readonly step: Schema.Int;
+    readonly run: Schema.withDecodingDefaultKey<Schema.brand<Schema.Int, "RunOrdinal">, never>;
+    readonly text: Schema.String;
+    readonly reasoning: Schema.String;
+    readonly model: Schema.OptionFromNullOr<Schema.String>;
+    readonly toolCalls: Schema.$Array<Schema.Struct<{
+        readonly id: Schema.brand<Schema.String, "ToolCallId">;
+        readonly tool: Schema.String;
+        readonly input: Schema.Unknown;
+    }>>;
+    readonly usage: Schema.Struct<{
+        readonly inputTokens: Schema.Number;
+        readonly outputTokens: Schema.Number;
+        readonly totalTokens: Schema.Number;
+        readonly cacheReadTokens: Schema.Number;
+        readonly cacheWriteTokens: Schema.withDecodingDefaultKey<Schema.Number, never>;
+        readonly reasoningTokens: Schema.withDecodingDefaultKey<Schema.Number, never>;
+    }>;
+    readonly finishReason: Schema.Literals<readonly ["stop", "length", "content-filter", "tool-calls", "error", "pause", "other", "unknown"]>;
+}>, Schema.Struct<{
+    readonly _tag: Schema.tag<"assistant.delta">;
+    readonly step: Schema.Int;
+    readonly channel: Schema.Literals<readonly ["text", "reasoning", "tool-params"]>;
+    readonly id: Schema.brand<Schema.String, "StreamPartId">;
+    readonly delta: Schema.String;
+}>, Schema.Struct<{
+    readonly _tag: Schema.tag<"stream.fallback">;
+    readonly step: Schema.Int;
+    readonly run: Schema.withDecodingDefaultKey<Schema.brand<Schema.Int, "RunOrdinal">, never>;
+    readonly message: Schema.String;
+}>, Schema.Struct<{
+    readonly _tag: Schema.tag<"host">;
+    readonly name: Schema.Trimmed;
+    readonly data: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+}>, Schema.Struct<{
+    readonly callId: Schema.brand<Schema.Trimmed, "ModelCallId">;
+    readonly attempt: Schema.Int;
+    readonly purpose: Schema.Literals<readonly ["Loop", "Helper"]>;
+    readonly method: Schema.Literals<readonly ["Text", "Object", "Stream"]>;
+    readonly model: Schema.OptionFromNullOr<typeof import("@xandreed/core").ModelSelection>;
+    readonly runId: Schema.OptionFromNullOr<Schema.brand<Schema.String, "RunId">>;
+    readonly run: Schema.OptionFromNullOr<Schema.brand<Schema.Int, "RunOrdinal">>;
+    readonly step: Schema.OptionFromNullOr<Schema.Int>;
+    readonly durationMs: Schema.Finite;
+    readonly usage: Schema.toTaggedUnion<"_tag", readonly [Schema.TaggedStruct<"Unknown", {}>, Schema.TaggedStruct<"Known", {
+        readonly usage: Schema.Struct<{
+            readonly inputTokens: Schema.Int;
+            readonly outputTokens: Schema.Int;
+            readonly totalTokens: Schema.Int;
+            readonly cacheReadTokens: Schema.Int;
+            readonly cacheWriteTokens: Schema.Int;
+            readonly reasoningTokens: Schema.Int;
+        }>;
+    }>, Schema.TaggedStruct<"Partial", {
+        readonly usage: Schema.Struct<{
+            readonly inputTokens: Schema.Int;
+            readonly outputTokens: Schema.Int;
+            readonly totalTokens: Schema.Int;
+            readonly cacheReadTokens: Schema.Int;
+            readonly cacheWriteTokens: Schema.Int;
+            readonly reasoningTokens: Schema.Int;
+        }>;
+        readonly reported: Schema.$Array<Schema.Literals<readonly ["inputTokens", "outputTokens", "cacheReadTokens", "cacheWriteTokens", "reasoningTokens"]>>;
+    }>]>;
+    readonly outcome: Schema.toTaggedUnion<"_tag", readonly [Schema.TaggedStruct<"Completed", {}>, Schema.TaggedStruct<"Failed", {
+        readonly failure: Schema.OptionFromNullOr<Schema.Literals<readonly ["ContextOverflow", "Authentication", "InvalidRequest", "RateLimit", "Quota", "Transient", "InvalidResponse", "Timeout", "Unknown"]>>;
+    }>, Schema.TaggedStruct<"Interrupted", {}>]>;
+    readonly _tag: Schema.tag<"model.called">;
+}>, Schema.Struct<{
+    readonly _tag: Schema.tag<"tool.intercepted">;
+    readonly source: Schema.optionalKey<Schema.Literals<readonly ["loop", "direct"]>>;
+    readonly phase: Schema.toTaggedUnion<"_tag", readonly [Schema.TaggedStruct<"Before", {
+        readonly decision: Schema.toTaggedUnion<"_tag", readonly [Schema.TaggedStruct<"Allow", {}>, Schema.TaggedStruct<"Deny", {
+            readonly failure: Schema.Struct<{
+                readonly error: Schema.String;
+                readonly message: Schema.String;
+            }>;
+        }>, Schema.TaggedStruct<"Rewrite", {
+            readonly input: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+        }>, Schema.TaggedStruct<"Respond", {
+            readonly kind: Schema.Literals<readonly ["Success", "Failure"]>;
+        }>]>;
+    }>, Schema.TaggedStruct<"After", {
+        readonly decision: Schema.toTaggedUnion<"_tag", readonly [Schema.TaggedStruct<"Keep", {}>, Schema.TaggedStruct<"Replace", {
+            readonly kind: Schema.Literals<readonly ["Success", "Failure"]>;
+        }>]>;
+    }>]>;
+    readonly invocationId: Schema.brand<Schema.String, "InvocationId">;
+    readonly tool: Schema.String;
+    readonly toolCallId: Schema.optionalKey<Schema.brand<Schema.String, "ToolCallId">>;
+    readonly run: Schema.OptionFromNullOr<Schema.Struct<{
+        readonly id: Schema.brand<Schema.String, "RunId">;
+        readonly turn: Schema.Int;
+        readonly ordinal: Schema.brand<Schema.Int, "RunOrdinal">;
+    }>>;
+    readonly step: Schema.Int;
+}>]>;
+/** The mode stays explicit in every progress frame. */
+export declare const ProcessProgress: Schema.toTaggedUnion<"mode", readonly [Schema.Struct<{
+    readonly mode: Schema.Literal<"projection">;
+    readonly event: Schema.toTaggedUnion<"_tag", readonly [Schema.TaggedStruct<"step.started", {
+        readonly step: Schema.Int;
+        readonly run: Schema.withDecodingDefaultKey<Schema.brand<Schema.Int, "RunOrdinal">, never>;
+        readonly planned: Schema.Boolean;
+    }>, Schema.TaggedStruct<"step.ended", {
+        readonly step: Schema.Int;
+        readonly run: Schema.withDecodingDefaultKey<Schema.brand<Schema.Int, "RunOrdinal">, never>;
+        readonly status: Schema.Literals<readonly ["completed", "failed", "cancelled", "malformed", "truncated"]>;
+    }>, Schema.TaggedStruct<"assistant.delta", {
+        readonly step: Schema.Int;
+        readonly id: Schema.brand<Schema.String, "StreamPartId">;
+        readonly delta: Schema.String;
+    }>, Schema.TaggedStruct<"assistant.message", {
+        readonly step: Schema.Int;
+        readonly run: Schema.withDecodingDefaultKey<Schema.brand<Schema.Int, "RunOrdinal">, never>;
+        readonly text: Schema.String;
+    }>, Schema.TaggedStruct<"tool.started", {
+        step: Schema.Int;
+        invocationId: Schema.brand<Schema.String, "InvocationId">;
+        toolCallId: Schema.optionalKey<Schema.brand<Schema.String, "ToolCallId">>;
+        tool: Schema.String;
+    }>, Schema.TaggedStruct<"tool.completed", {
+        readonly ok: Schema.Boolean;
+        readonly step: Schema.Int;
+        readonly invocationId: Schema.brand<Schema.String, "InvocationId">;
+        readonly toolCallId: Schema.optionalKey<Schema.brand<Schema.String, "ToolCallId">>;
+        readonly tool: Schema.String;
+    }>, Schema.TaggedStruct<"tool.refused", {
+        readonly reason: Schema.Literals<readonly ["inactive", "forbidden", "denied", "call-limit", "tool-call-limit", "run-call-limit", "tripped", "concurrency", "intercepted"]>;
+        readonly step: Schema.Int;
+        readonly invocationId: Schema.brand<Schema.String, "InvocationId">;
+        readonly toolCallId: Schema.optionalKey<Schema.brand<Schema.String, "ToolCallId">>;
+        readonly tool: Schema.String;
+    }>, Schema.TaggedStruct<"tool.progress", {
+        readonly text: Schema.String;
+        readonly step: Schema.Int;
+        readonly invocationId: Schema.brand<Schema.String, "InvocationId">;
+        readonly toolCallId: Schema.optionalKey<Schema.brand<Schema.String, "ToolCallId">>;
+        readonly tool: Schema.String;
+    }>, Schema.TaggedStruct<"stream.fallback", {
+        readonly step: Schema.Int;
+        readonly run: Schema.withDecodingDefaultKey<Schema.brand<Schema.Int, "RunOrdinal">, never>;
+    }>]>;
+}>, Schema.Struct<{
+    readonly mode: Schema.Literal<"full">;
+    readonly event: Schema.toEncoded<Schema.Union<readonly [Schema.Struct<{
+        readonly _tag: Schema.tag<"step.started">;
+        readonly step: Schema.Int;
+        readonly run: Schema.withDecodingDefaultKey<Schema.brand<Schema.Int, "RunOrdinal">, never>;
+        readonly planned: Schema.Boolean;
+        readonly activeTools: Schema.$Array<Schema.String>;
+    }>, Schema.Struct<{
+        readonly _tag: Schema.tag<"tool.started">;
+        readonly step: Schema.Int;
+        readonly invocationId: Schema.brand<Schema.String, "InvocationId">;
+        readonly toolCallId: Schema.optionalKey<Schema.brand<Schema.String, "ToolCallId">>;
+        readonly tool: Schema.String;
+        readonly input: Schema.Unknown;
+        readonly labels: Schema.$Record<Schema.String, Schema.String>;
+        readonly stage: Schema.OptionFromNullOr<Schema.String>;
+    }>, Schema.Struct<{
+        readonly _tag: Schema.tag<"tool.refused">;
+        readonly step: Schema.Int;
+        readonly invocationId: Schema.brand<Schema.String, "InvocationId">;
+        readonly toolCallId: Schema.optionalKey<Schema.brand<Schema.String, "ToolCallId">>;
+        readonly tool: Schema.String;
+        readonly input: Schema.Unknown;
+        readonly reason: Schema.Literals<readonly ["inactive", "forbidden", "denied", "call-limit", "tool-call-limit", "run-call-limit", "tripped", "concurrency", "intercepted"]>;
+        readonly message: Schema.String;
+    }>, Schema.Struct<{
+        readonly _tag: Schema.tag<"tool.progress">;
+        readonly step: Schema.Int;
+        readonly invocationId: Schema.brand<Schema.String, "InvocationId">;
+        readonly toolCallId: Schema.optionalKey<Schema.brand<Schema.String, "ToolCallId">>;
+        readonly tool: Schema.String;
+        readonly channel: Schema.Literals<readonly ["stdout", "stderr", "status"]>;
+        readonly text: Schema.String;
+    }>, Schema.Struct<{
+        readonly _tag: Schema.tag<"tool.completed">;
+        readonly step: Schema.Int;
+        readonly invocationId: Schema.brand<Schema.String, "InvocationId">;
+        readonly toolCallId: Schema.optionalKey<Schema.brand<Schema.String, "ToolCallId">>;
+        readonly tool: Schema.String;
+        readonly input: Schema.Unknown;
+        readonly ok: Schema.Boolean;
+        readonly result: Schema.Unknown;
+        readonly encoded: Schema.Unknown;
+        readonly durationMs: Schema.Number;
+        readonly labels: Schema.$Record<Schema.String, Schema.String>;
+        readonly stage: Schema.OptionFromNullOr<Schema.String>;
+    }>, Schema.Struct<{
+        readonly _tag: Schema.tag<"step.ended">;
+        readonly step: Schema.Int;
+        readonly run: Schema.withDecodingDefaultKey<Schema.brand<Schema.Int, "RunOrdinal">, never>;
+        readonly status: Schema.Literals<readonly ["completed", "failed", "cancelled", "malformed", "truncated"]>;
+        readonly results: Schema.$Array<Schema.Struct<{
+            readonly entry: Schema.brand<Schema.Trimmed, "EntryId">;
+            readonly toolCallId: Schema.brand<Schema.String, "ToolCallId">;
+            readonly tool: Schema.String;
+            readonly ok: Schema.Boolean;
+        }>>;
+    }>, Schema.Struct<{
+        readonly _tag: Schema.tag<"completion.evaluated">;
+        readonly step: Schema.Int;
+        readonly run: Schema.withDecodingDefaultKey<Schema.brand<Schema.Int, "RunOrdinal">, never>;
+        readonly verdict: Schema.Struct<{
+            readonly complete: Schema.Boolean;
+            readonly awaiting: Schema.$Array<Schema.Trimmed>;
+            readonly facts: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+        }>;
+    }>, Schema.Struct<{
+        readonly _tag: Schema.tag<"skills.activated">;
+        readonly skills: Schema.$Array<Schema.String>;
+        readonly tools: Schema.$Array<Schema.String>;
+        readonly source: Schema.Literals<readonly ["always", "matcher", "load_skill", "host"]>;
+    }>, Schema.Struct<{
+        readonly _tag: Schema.tag<"context.built">;
+        readonly step: Schema.Int;
+        readonly turn: Schema.Int;
+        readonly run: Schema.withDecodingDefaultKey<Schema.brand<Schema.Int, "RunOrdinal">, never>;
+        readonly strategy: Schema.String;
+        readonly strategyVersion: Schema.String;
+        readonly fingerprint: Schema.String;
+        readonly systemFingerprint: Schema.String;
+        readonly estimatedTokens: Schema.Int;
+        readonly reservedTokens: Schema.Int;
+        readonly budgetTokens: Schema.Int;
+        readonly compactions: Schema.Int;
+        readonly activeTools: Schema.$Array<Schema.String>;
+    }>, Schema.Struct<{
+        readonly _tag: Schema.tag<"decision.recorded">;
+        readonly record: Schema.Struct<{
+            readonly version: Schema.Literal<1>;
+            readonly id: Schema.brand<Schema.Trimmed, "DecisionId">;
+            readonly family: Schema.NonEmptyString;
+            readonly contextHash: Schema.String;
+            readonly candidateHash: Schema.String;
+            readonly policyVersion: Schema.String;
+            readonly candidates: Schema.$Array<Schema.Struct<{
+                readonly id: Schema.brand<Schema.String, "CandidateId">;
+                readonly description: Schema.String;
+            }>>;
+            readonly attempts: Schema.$Array<Schema.String>;
+            readonly selection: Schema.OptionFromNullOr<Schema.String>;
+            readonly validation: Schema.Literals<readonly ["accepted", "rejected", "abstained", "failed", "cancelled", "bypassed"]>;
+            readonly fallback: Schema.OptionFromNullOr<Schema.String>;
+            readonly applied: Schema.OptionFromNullOr<Schema.String>;
+            readonly probabilities: Schema.OptionFromNullOr<Schema.$Record<Schema.String, Schema.Number>>;
+        }>;
+    }>, Schema.Struct<{
+        readonly _tag: Schema.tag<"assistant.message">;
+        readonly step: Schema.Int;
+        readonly run: Schema.withDecodingDefaultKey<Schema.brand<Schema.Int, "RunOrdinal">, never>;
+        readonly text: Schema.String;
+        readonly reasoning: Schema.String;
+        readonly model: Schema.OptionFromNullOr<Schema.String>;
+        readonly toolCalls: Schema.$Array<Schema.Struct<{
+            readonly id: Schema.brand<Schema.String, "ToolCallId">;
+            readonly tool: Schema.String;
+            readonly input: Schema.Unknown;
+        }>>;
+        readonly usage: Schema.Struct<{
+            readonly inputTokens: Schema.Number;
+            readonly outputTokens: Schema.Number;
+            readonly totalTokens: Schema.Number;
+            readonly cacheReadTokens: Schema.Number;
+            readonly cacheWriteTokens: Schema.withDecodingDefaultKey<Schema.Number, never>;
+            readonly reasoningTokens: Schema.withDecodingDefaultKey<Schema.Number, never>;
+        }>;
+        readonly finishReason: Schema.Literals<readonly ["stop", "length", "content-filter", "tool-calls", "error", "pause", "other", "unknown"]>;
+    }>, Schema.Struct<{
+        readonly _tag: Schema.tag<"assistant.delta">;
+        readonly step: Schema.Int;
+        readonly channel: Schema.Literals<readonly ["text", "reasoning", "tool-params"]>;
+        readonly id: Schema.brand<Schema.String, "StreamPartId">;
+        readonly delta: Schema.String;
+    }>, Schema.Struct<{
+        readonly _tag: Schema.tag<"stream.fallback">;
+        readonly step: Schema.Int;
+        readonly run: Schema.withDecodingDefaultKey<Schema.brand<Schema.Int, "RunOrdinal">, never>;
+        readonly message: Schema.String;
+    }>, Schema.Struct<{
+        readonly _tag: Schema.tag<"host">;
+        readonly name: Schema.Trimmed;
+        readonly data: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+    }>, Schema.Struct<{
+        readonly callId: Schema.brand<Schema.Trimmed, "ModelCallId">;
+        readonly attempt: Schema.Int;
+        readonly purpose: Schema.Literals<readonly ["Loop", "Helper"]>;
+        readonly method: Schema.Literals<readonly ["Text", "Object", "Stream"]>;
+        readonly model: Schema.OptionFromNullOr<typeof import("@xandreed/core").ModelSelection>;
+        readonly runId: Schema.OptionFromNullOr<Schema.brand<Schema.String, "RunId">>;
+        readonly run: Schema.OptionFromNullOr<Schema.brand<Schema.Int, "RunOrdinal">>;
+        readonly step: Schema.OptionFromNullOr<Schema.Int>;
+        readonly durationMs: Schema.Finite;
+        readonly usage: Schema.toTaggedUnion<"_tag", readonly [Schema.TaggedStruct<"Unknown", {}>, Schema.TaggedStruct<"Known", {
+            readonly usage: Schema.Struct<{
+                readonly inputTokens: Schema.Int;
+                readonly outputTokens: Schema.Int;
+                readonly totalTokens: Schema.Int;
+                readonly cacheReadTokens: Schema.Int;
+                readonly cacheWriteTokens: Schema.Int;
+                readonly reasoningTokens: Schema.Int;
+            }>;
+        }>, Schema.TaggedStruct<"Partial", {
+            readonly usage: Schema.Struct<{
+                readonly inputTokens: Schema.Int;
+                readonly outputTokens: Schema.Int;
+                readonly totalTokens: Schema.Int;
+                readonly cacheReadTokens: Schema.Int;
+                readonly cacheWriteTokens: Schema.Int;
+                readonly reasoningTokens: Schema.Int;
+            }>;
+            readonly reported: Schema.$Array<Schema.Literals<readonly ["inputTokens", "outputTokens", "cacheReadTokens", "cacheWriteTokens", "reasoningTokens"]>>;
+        }>]>;
+        readonly outcome: Schema.toTaggedUnion<"_tag", readonly [Schema.TaggedStruct<"Completed", {}>, Schema.TaggedStruct<"Failed", {
+            readonly failure: Schema.OptionFromNullOr<Schema.Literals<readonly ["ContextOverflow", "Authentication", "InvalidRequest", "RateLimit", "Quota", "Transient", "InvalidResponse", "Timeout", "Unknown"]>>;
+        }>, Schema.TaggedStruct<"Interrupted", {}>]>;
+        readonly _tag: Schema.tag<"model.called">;
+    }>, Schema.Struct<{
+        readonly _tag: Schema.tag<"tool.intercepted">;
+        readonly source: Schema.optionalKey<Schema.Literals<readonly ["loop", "direct"]>>;
+        readonly phase: Schema.toTaggedUnion<"_tag", readonly [Schema.TaggedStruct<"Before", {
+            readonly decision: Schema.toTaggedUnion<"_tag", readonly [Schema.TaggedStruct<"Allow", {}>, Schema.TaggedStruct<"Deny", {
+                readonly failure: Schema.Struct<{
+                    readonly error: Schema.String;
+                    readonly message: Schema.String;
+                }>;
+            }>, Schema.TaggedStruct<"Rewrite", {
+                readonly input: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+            }>, Schema.TaggedStruct<"Respond", {
+                readonly kind: Schema.Literals<readonly ["Success", "Failure"]>;
+            }>]>;
+        }>, Schema.TaggedStruct<"After", {
+            readonly decision: Schema.toTaggedUnion<"_tag", readonly [Schema.TaggedStruct<"Keep", {}>, Schema.TaggedStruct<"Replace", {
+                readonly kind: Schema.Literals<readonly ["Success", "Failure"]>;
+            }>]>;
+        }>]>;
+        readonly invocationId: Schema.brand<Schema.String, "InvocationId">;
+        readonly tool: Schema.String;
+        readonly toolCallId: Schema.optionalKey<Schema.brand<Schema.String, "ToolCallId">>;
+        readonly run: Schema.OptionFromNullOr<Schema.Struct<{
+            readonly id: Schema.brand<Schema.String, "RunId">;
+            readonly turn: Schema.Int;
+            readonly ordinal: Schema.brand<Schema.Int, "RunOrdinal">;
+        }>>;
+        readonly step: Schema.Int;
+    }>]>>;
+}>]>;
+export type ProcessProgress = typeof ProcessProgress.Type;
+/** The real TurnRunner result; this command reply is separate from durable turn.ended evidence. */
+export declare const ProcessTurnResult: Schema.Struct<{
+    readonly outcome: Schema.Literals<readonly ["completed", "partial", "failed", "waiting"]>;
+    readonly reply: Schema.OptionFromNullOr<Schema.String>;
+    readonly usage: Schema.Struct<{
+        readonly inputTokens: Schema.Number;
+        readonly outputTokens: Schema.Number;
+        readonly totalTokens: Schema.Number;
+        readonly cacheReadTokens: Schema.Number;
+        readonly cacheWriteTokens: Schema.withDecodingDefaultKey<Schema.Number, never>;
+        readonly reasoningTokens: Schema.withDecodingDefaultKey<Schema.Number, never>;
+    }>;
+    readonly pending: Schema.optionalKey<Schema.Int>;
+}>;
+export type ProcessTurnResult = typeof ProcessTurnResult.Type;
+/** Owned transport/host failures. Framework codes are optional metadata, never raw error messages. */
+export declare const ProcessErrorCode: Schema.Literals<readonly ["protocol.handshake", "protocol.version", "protocol.sequence", "protocol.invalid", "host.busy", "host.owner", "host.stopping", "host.unsupported", "host.command", "host.setup", "host.runtime", "host.peer"]>;
+export type ProcessErrorCode = typeof ProcessErrorCode.Type;
+/** Version 1 output. Lifecycle identity and journal cursors carry no admitted message or failure text. @public */
+export declare const ProcessEvent: Schema.toTaggedUnion<"_tag", readonly [Schema.TaggedStruct<"hello", {
+    readonly requestId: Schema.brand<Schema.Trimmed, "ProcessRequestId">;
+    readonly protocolVersion: Schema.Literals<readonly [1]>;
+}>, Schema.TaggedStruct<"turn.started", {
+    readonly runId: Schema.brand<Schema.String, "RunId">;
+    readonly origin: Schema.Literals<readonly ["user", "inbox", "task"]>;
+    readonly input: Schema.optionalKey<Schema.brand<Schema.Trimmed, "InboxItemId">>;
+    readonly task: Schema.optionalKey<Schema.Struct<{
+        readonly taskId: Schema.brand<Schema.String, "ConversationId">;
+        readonly parent: Schema.brand<Schema.String, "ConversationId">;
+    }>>;
+    readonly resumes: Schema.optionalKey<Schema.Int>;
+    readonly journal: Schema.Struct<{
+        readonly seq: Schema.Int;
+        readonly at: Schema.Finite;
+    }>;
+    readonly session: Schema.Struct<{
+        readonly id: Schema.brand<Schema.String, "ConversationId">;
+        readonly owner: Schema.Trimmed;
+    }>;
+    readonly turn: Schema.Int;
+    readonly requestId: Schema.optionalKey<Schema.brand<Schema.Trimmed, "ProcessRequestId">>;
+}>, Schema.TaggedStruct<"turn.event", {
+    readonly runId: Schema.brand<Schema.String, "RunId">;
+    readonly progress: Schema.toTaggedUnion<"mode", readonly [Schema.Struct<{
+        readonly mode: Schema.Literal<"projection">;
+        readonly event: Schema.toTaggedUnion<"_tag", readonly [Schema.TaggedStruct<"step.started", {
+            readonly step: Schema.Int;
+            readonly run: Schema.withDecodingDefaultKey<Schema.brand<Schema.Int, "RunOrdinal">, never>;
+            readonly planned: Schema.Boolean;
+        }>, Schema.TaggedStruct<"step.ended", {
+            readonly step: Schema.Int;
+            readonly run: Schema.withDecodingDefaultKey<Schema.brand<Schema.Int, "RunOrdinal">, never>;
+            readonly status: Schema.Literals<readonly ["completed", "failed", "cancelled", "malformed", "truncated"]>;
+        }>, Schema.TaggedStruct<"assistant.delta", {
+            readonly step: Schema.Int;
+            readonly id: Schema.brand<Schema.String, "StreamPartId">;
+            readonly delta: Schema.String;
+        }>, Schema.TaggedStruct<"assistant.message", {
+            readonly step: Schema.Int;
+            readonly run: Schema.withDecodingDefaultKey<Schema.brand<Schema.Int, "RunOrdinal">, never>;
+            readonly text: Schema.String;
+        }>, Schema.TaggedStruct<"tool.started", {
+            step: Schema.Int;
+            invocationId: Schema.brand<Schema.String, "InvocationId">;
+            toolCallId: Schema.optionalKey<Schema.brand<Schema.String, "ToolCallId">>;
+            tool: Schema.String;
+        }>, Schema.TaggedStruct<"tool.completed", {
+            readonly ok: Schema.Boolean;
+            readonly step: Schema.Int;
+            readonly invocationId: Schema.brand<Schema.String, "InvocationId">;
+            readonly toolCallId: Schema.optionalKey<Schema.brand<Schema.String, "ToolCallId">>;
+            readonly tool: Schema.String;
+        }>, Schema.TaggedStruct<"tool.refused", {
+            readonly reason: Schema.Literals<readonly ["inactive", "forbidden", "denied", "call-limit", "tool-call-limit", "run-call-limit", "tripped", "concurrency", "intercepted"]>;
+            readonly step: Schema.Int;
+            readonly invocationId: Schema.brand<Schema.String, "InvocationId">;
+            readonly toolCallId: Schema.optionalKey<Schema.brand<Schema.String, "ToolCallId">>;
+            readonly tool: Schema.String;
+        }>, Schema.TaggedStruct<"tool.progress", {
+            readonly text: Schema.String;
+            readonly step: Schema.Int;
+            readonly invocationId: Schema.brand<Schema.String, "InvocationId">;
+            readonly toolCallId: Schema.optionalKey<Schema.brand<Schema.String, "ToolCallId">>;
+            readonly tool: Schema.String;
+        }>, Schema.TaggedStruct<"stream.fallback", {
+            readonly step: Schema.Int;
+            readonly run: Schema.withDecodingDefaultKey<Schema.brand<Schema.Int, "RunOrdinal">, never>;
+        }>]>;
+    }>, Schema.Struct<{
+        readonly mode: Schema.Literal<"full">;
+        readonly event: Schema.toEncoded<Schema.Union<readonly [Schema.Struct<{
+            readonly _tag: Schema.tag<"step.started">;
+            readonly step: Schema.Int;
+            readonly run: Schema.withDecodingDefaultKey<Schema.brand<Schema.Int, "RunOrdinal">, never>;
+            readonly planned: Schema.Boolean;
+            readonly activeTools: Schema.$Array<Schema.String>;
+        }>, Schema.Struct<{
+            readonly _tag: Schema.tag<"tool.started">;
+            readonly step: Schema.Int;
+            readonly invocationId: Schema.brand<Schema.String, "InvocationId">;
+            readonly toolCallId: Schema.optionalKey<Schema.brand<Schema.String, "ToolCallId">>;
+            readonly tool: Schema.String;
+            readonly input: Schema.Unknown;
+            readonly labels: Schema.$Record<Schema.String, Schema.String>;
+            readonly stage: Schema.OptionFromNullOr<Schema.String>;
+        }>, Schema.Struct<{
+            readonly _tag: Schema.tag<"tool.refused">;
+            readonly step: Schema.Int;
+            readonly invocationId: Schema.brand<Schema.String, "InvocationId">;
+            readonly toolCallId: Schema.optionalKey<Schema.brand<Schema.String, "ToolCallId">>;
+            readonly tool: Schema.String;
+            readonly input: Schema.Unknown;
+            readonly reason: Schema.Literals<readonly ["inactive", "forbidden", "denied", "call-limit", "tool-call-limit", "run-call-limit", "tripped", "concurrency", "intercepted"]>;
+            readonly message: Schema.String;
+        }>, Schema.Struct<{
+            readonly _tag: Schema.tag<"tool.progress">;
+            readonly step: Schema.Int;
+            readonly invocationId: Schema.brand<Schema.String, "InvocationId">;
+            readonly toolCallId: Schema.optionalKey<Schema.brand<Schema.String, "ToolCallId">>;
+            readonly tool: Schema.String;
+            readonly channel: Schema.Literals<readonly ["stdout", "stderr", "status"]>;
+            readonly text: Schema.String;
+        }>, Schema.Struct<{
+            readonly _tag: Schema.tag<"tool.completed">;
+            readonly step: Schema.Int;
+            readonly invocationId: Schema.brand<Schema.String, "InvocationId">;
+            readonly toolCallId: Schema.optionalKey<Schema.brand<Schema.String, "ToolCallId">>;
+            readonly tool: Schema.String;
+            readonly input: Schema.Unknown;
+            readonly ok: Schema.Boolean;
+            readonly result: Schema.Unknown;
+            readonly encoded: Schema.Unknown;
+            readonly durationMs: Schema.Number;
+            readonly labels: Schema.$Record<Schema.String, Schema.String>;
+            readonly stage: Schema.OptionFromNullOr<Schema.String>;
+        }>, Schema.Struct<{
+            readonly _tag: Schema.tag<"step.ended">;
+            readonly step: Schema.Int;
+            readonly run: Schema.withDecodingDefaultKey<Schema.brand<Schema.Int, "RunOrdinal">, never>;
+            readonly status: Schema.Literals<readonly ["completed", "failed", "cancelled", "malformed", "truncated"]>;
+            readonly results: Schema.$Array<Schema.Struct<{
+                readonly entry: Schema.brand<Schema.Trimmed, "EntryId">;
+                readonly toolCallId: Schema.brand<Schema.String, "ToolCallId">;
+                readonly tool: Schema.String;
+                readonly ok: Schema.Boolean;
+            }>>;
+        }>, Schema.Struct<{
+            readonly _tag: Schema.tag<"completion.evaluated">;
+            readonly step: Schema.Int;
+            readonly run: Schema.withDecodingDefaultKey<Schema.brand<Schema.Int, "RunOrdinal">, never>;
+            readonly verdict: Schema.Struct<{
+                readonly complete: Schema.Boolean;
+                readonly awaiting: Schema.$Array<Schema.Trimmed>;
+                readonly facts: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+            }>;
+        }>, Schema.Struct<{
+            readonly _tag: Schema.tag<"skills.activated">;
+            readonly skills: Schema.$Array<Schema.String>;
+            readonly tools: Schema.$Array<Schema.String>;
+            readonly source: Schema.Literals<readonly ["always", "matcher", "load_skill", "host"]>;
+        }>, Schema.Struct<{
+            readonly _tag: Schema.tag<"context.built">;
+            readonly step: Schema.Int;
+            readonly turn: Schema.Int;
+            readonly run: Schema.withDecodingDefaultKey<Schema.brand<Schema.Int, "RunOrdinal">, never>;
+            readonly strategy: Schema.String;
+            readonly strategyVersion: Schema.String;
+            readonly fingerprint: Schema.String;
+            readonly systemFingerprint: Schema.String;
+            readonly estimatedTokens: Schema.Int;
+            readonly reservedTokens: Schema.Int;
+            readonly budgetTokens: Schema.Int;
+            readonly compactions: Schema.Int;
+            readonly activeTools: Schema.$Array<Schema.String>;
+        }>, Schema.Struct<{
+            readonly _tag: Schema.tag<"decision.recorded">;
+            readonly record: Schema.Struct<{
+                readonly version: Schema.Literal<1>;
+                readonly id: Schema.brand<Schema.Trimmed, "DecisionId">;
+                readonly family: Schema.NonEmptyString;
+                readonly contextHash: Schema.String;
+                readonly candidateHash: Schema.String;
+                readonly policyVersion: Schema.String;
+                readonly candidates: Schema.$Array<Schema.Struct<{
+                    readonly id: Schema.brand<Schema.String, "CandidateId">;
+                    readonly description: Schema.String;
+                }>>;
+                readonly attempts: Schema.$Array<Schema.String>;
+                readonly selection: Schema.OptionFromNullOr<Schema.String>;
+                readonly validation: Schema.Literals<readonly ["accepted", "rejected", "abstained", "failed", "cancelled", "bypassed"]>;
+                readonly fallback: Schema.OptionFromNullOr<Schema.String>;
+                readonly applied: Schema.OptionFromNullOr<Schema.String>;
+                readonly probabilities: Schema.OptionFromNullOr<Schema.$Record<Schema.String, Schema.Number>>;
+            }>;
+        }>, Schema.Struct<{
+            readonly _tag: Schema.tag<"assistant.message">;
+            readonly step: Schema.Int;
+            readonly run: Schema.withDecodingDefaultKey<Schema.brand<Schema.Int, "RunOrdinal">, never>;
+            readonly text: Schema.String;
+            readonly reasoning: Schema.String;
+            readonly model: Schema.OptionFromNullOr<Schema.String>;
+            readonly toolCalls: Schema.$Array<Schema.Struct<{
+                readonly id: Schema.brand<Schema.String, "ToolCallId">;
+                readonly tool: Schema.String;
+                readonly input: Schema.Unknown;
+            }>>;
+            readonly usage: Schema.Struct<{
+                readonly inputTokens: Schema.Number;
+                readonly outputTokens: Schema.Number;
+                readonly totalTokens: Schema.Number;
+                readonly cacheReadTokens: Schema.Number;
+                readonly cacheWriteTokens: Schema.withDecodingDefaultKey<Schema.Number, never>;
+                readonly reasoningTokens: Schema.withDecodingDefaultKey<Schema.Number, never>;
+            }>;
+            readonly finishReason: Schema.Literals<readonly ["stop", "length", "content-filter", "tool-calls", "error", "pause", "other", "unknown"]>;
+        }>, Schema.Struct<{
+            readonly _tag: Schema.tag<"assistant.delta">;
+            readonly step: Schema.Int;
+            readonly channel: Schema.Literals<readonly ["text", "reasoning", "tool-params"]>;
+            readonly id: Schema.brand<Schema.String, "StreamPartId">;
+            readonly delta: Schema.String;
+        }>, Schema.Struct<{
+            readonly _tag: Schema.tag<"stream.fallback">;
+            readonly step: Schema.Int;
+            readonly run: Schema.withDecodingDefaultKey<Schema.brand<Schema.Int, "RunOrdinal">, never>;
+            readonly message: Schema.String;
+        }>, Schema.Struct<{
+            readonly _tag: Schema.tag<"host">;
+            readonly name: Schema.Trimmed;
+            readonly data: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+        }>, Schema.Struct<{
+            readonly callId: Schema.brand<Schema.Trimmed, "ModelCallId">;
+            readonly attempt: Schema.Int;
+            readonly purpose: Schema.Literals<readonly ["Loop", "Helper"]>;
+            readonly method: Schema.Literals<readonly ["Text", "Object", "Stream"]>;
+            readonly model: Schema.OptionFromNullOr<typeof import("@xandreed/core").ModelSelection>;
+            readonly runId: Schema.OptionFromNullOr<Schema.brand<Schema.String, "RunId">>;
+            readonly run: Schema.OptionFromNullOr<Schema.brand<Schema.Int, "RunOrdinal">>;
+            readonly step: Schema.OptionFromNullOr<Schema.Int>;
+            readonly durationMs: Schema.Finite;
+            readonly usage: Schema.toTaggedUnion<"_tag", readonly [Schema.TaggedStruct<"Unknown", {}>, Schema.TaggedStruct<"Known", {
+                readonly usage: Schema.Struct<{
+                    readonly inputTokens: Schema.Int;
+                    readonly outputTokens: Schema.Int;
+                    readonly totalTokens: Schema.Int;
+                    readonly cacheReadTokens: Schema.Int;
+                    readonly cacheWriteTokens: Schema.Int;
+                    readonly reasoningTokens: Schema.Int;
+                }>;
+            }>, Schema.TaggedStruct<"Partial", {
+                readonly usage: Schema.Struct<{
+                    readonly inputTokens: Schema.Int;
+                    readonly outputTokens: Schema.Int;
+                    readonly totalTokens: Schema.Int;
+                    readonly cacheReadTokens: Schema.Int;
+                    readonly cacheWriteTokens: Schema.Int;
+                    readonly reasoningTokens: Schema.Int;
+                }>;
+                readonly reported: Schema.$Array<Schema.Literals<readonly ["inputTokens", "outputTokens", "cacheReadTokens", "cacheWriteTokens", "reasoningTokens"]>>;
+            }>]>;
+            readonly outcome: Schema.toTaggedUnion<"_tag", readonly [Schema.TaggedStruct<"Completed", {}>, Schema.TaggedStruct<"Failed", {
+                readonly failure: Schema.OptionFromNullOr<Schema.Literals<readonly ["ContextOverflow", "Authentication", "InvalidRequest", "RateLimit", "Quota", "Transient", "InvalidResponse", "Timeout", "Unknown"]>>;
+            }>, Schema.TaggedStruct<"Interrupted", {}>]>;
+            readonly _tag: Schema.tag<"model.called">;
+        }>, Schema.Struct<{
+            readonly _tag: Schema.tag<"tool.intercepted">;
+            readonly source: Schema.optionalKey<Schema.Literals<readonly ["loop", "direct"]>>;
+            readonly phase: Schema.toTaggedUnion<"_tag", readonly [Schema.TaggedStruct<"Before", {
+                readonly decision: Schema.toTaggedUnion<"_tag", readonly [Schema.TaggedStruct<"Allow", {}>, Schema.TaggedStruct<"Deny", {
+                    readonly failure: Schema.Struct<{
+                        readonly error: Schema.String;
+                        readonly message: Schema.String;
+                    }>;
+                }>, Schema.TaggedStruct<"Rewrite", {
+                    readonly input: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+                }>, Schema.TaggedStruct<"Respond", {
+                    readonly kind: Schema.Literals<readonly ["Success", "Failure"]>;
+                }>]>;
+            }>, Schema.TaggedStruct<"After", {
+                readonly decision: Schema.toTaggedUnion<"_tag", readonly [Schema.TaggedStruct<"Keep", {}>, Schema.TaggedStruct<"Replace", {
+                    readonly kind: Schema.Literals<readonly ["Success", "Failure"]>;
+                }>]>;
+            }>]>;
+            readonly invocationId: Schema.brand<Schema.String, "InvocationId">;
+            readonly tool: Schema.String;
+            readonly toolCallId: Schema.optionalKey<Schema.brand<Schema.String, "ToolCallId">>;
+            readonly run: Schema.OptionFromNullOr<Schema.Struct<{
+                readonly id: Schema.brand<Schema.String, "RunId">;
+                readonly turn: Schema.Int;
+                readonly ordinal: Schema.brand<Schema.Int, "RunOrdinal">;
+            }>>;
+            readonly step: Schema.Int;
+        }>]>>;
+    }>]>;
+    readonly session: Schema.Struct<{
+        readonly id: Schema.brand<Schema.String, "ConversationId">;
+        readonly owner: Schema.Trimmed;
+    }>;
+    readonly turn: Schema.Int;
+    readonly requestId: Schema.optionalKey<Schema.brand<Schema.Trimmed, "ProcessRequestId">>;
+}>, Schema.TaggedStruct<"turn.ended", {
+    readonly reason: Schema.Literals<readonly ["completed", "partial", "failed", "waiting", "cancelled", "interrupted"]>;
+    readonly failureCode: Schema.optionalKey<Schema.String>;
+    readonly journal: Schema.Struct<{
+        readonly seq: Schema.Int;
+        readonly at: Schema.Finite;
+    }>;
+    readonly session: Schema.Struct<{
+        readonly id: Schema.brand<Schema.String, "ConversationId">;
+        readonly owner: Schema.Trimmed;
+    }>;
+    readonly turn: Schema.Int;
+    readonly requestId: Schema.optionalKey<Schema.brand<Schema.Trimmed, "ProcessRequestId">>;
+}>, Schema.TaggedStruct<"begin.result", {
+    readonly requestId: Schema.brand<Schema.Trimmed, "ProcessRequestId">;
+    readonly result: Schema.Struct<{
+        readonly outcome: Schema.Literals<readonly ["completed", "partial", "failed", "waiting"]>;
+        readonly reply: Schema.OptionFromNullOr<Schema.String>;
+        readonly usage: Schema.Struct<{
+            readonly inputTokens: Schema.Number;
+            readonly outputTokens: Schema.Number;
+            readonly totalTokens: Schema.Number;
+            readonly cacheReadTokens: Schema.Number;
+            readonly cacheWriteTokens: Schema.withDecodingDefaultKey<Schema.Number, never>;
+            readonly reasoningTokens: Schema.withDecodingDefaultKey<Schema.Number, never>;
+        }>;
+        readonly pending: Schema.optionalKey<Schema.Int>;
+    }>;
+}>, Schema.TaggedStruct<"queued", {
+    readonly requestId: Schema.brand<Schema.Trimmed, "ProcessRequestId">;
+    readonly command: Schema.Literals<readonly ["send", "steer"]>;
+    readonly enqueued: Schema.Boolean;
+    readonly pending: Schema.Int;
+}>, Schema.TaggedStruct<"answered", {
+    readonly requestId: Schema.brand<Schema.Trimmed, "ProcessRequestId">;
+    readonly accepted: Schema.Literals<readonly [true]>;
+    readonly enqueued: Schema.Boolean;
+}>, Schema.TaggedStruct<"cancelled", {
+    readonly requestId: Schema.brand<Schema.Trimmed, "ProcessRequestId">;
+    readonly cancelled: Schema.Boolean;
+    readonly pending: Schema.Int;
+}>, Schema.TaggedStruct<"pong", {
+    readonly requestId: Schema.brand<Schema.Trimmed, "ProcessRequestId">;
+    readonly activity: Schema.Struct<{
+        readonly openTurns: Schema.$Array<Schema.Struct<{
+            readonly session: Schema.brand<Schema.String, "ConversationId">;
+            readonly turn: Schema.Int;
+            readonly since: Schema.Number;
+        }>>;
+        readonly beginningTurns: Schema.Int;
+        readonly runningTasks: Schema.Int;
+        readonly waiting: Schema.$Array<Schema.Struct<{
+            readonly session: Schema.brand<Schema.String, "ConversationId">;
+            readonly pending: Schema.Int;
+        }>>;
+        readonly queuedInput: Schema.Int;
+        readonly inFlight: Schema.Boolean;
+        readonly busy: Schema.Boolean;
+        readonly stopping: Schema.Boolean;
+    }>;
+}>, Schema.TaggedStruct<"shutdown", {
+    readonly report: Schema.Struct<{
+        readonly idle: Schema.Boolean;
+        readonly interrupted: Schema.$Array<Schema.Struct<{
+            readonly session: Schema.brand<Schema.String, "ConversationId">;
+            readonly turn: Schema.Int;
+            readonly since: Schema.Number;
+        }>>;
+        readonly left: Schema.Struct<{
+            readonly openTurns: Schema.$Array<Schema.Struct<{
+                readonly session: Schema.brand<Schema.String, "ConversationId">;
+                readonly turn: Schema.Int;
+                readonly since: Schema.Number;
+            }>>;
+            readonly beginningTurns: Schema.Int;
+            readonly runningTasks: Schema.Int;
+            readonly waiting: Schema.$Array<Schema.Struct<{
+                readonly session: Schema.brand<Schema.String, "ConversationId">;
+                readonly pending: Schema.Int;
+            }>>;
+            readonly queuedInput: Schema.Int;
+            readonly inFlight: Schema.Boolean;
+            readonly busy: Schema.Boolean;
+            readonly stopping: Schema.Boolean;
+        }>;
+    }>;
+    readonly requestId: Schema.optionalKey<Schema.brand<Schema.Trimmed, "ProcessRequestId">>;
+}>, Schema.TaggedStruct<"error", {
+    readonly code: Schema.Literals<readonly ["protocol.handshake", "protocol.version", "protocol.sequence", "protocol.invalid", "host.busy", "host.owner", "host.stopping", "host.unsupported", "host.command", "host.setup", "host.runtime", "host.peer"]>;
+    readonly message: Schema.String;
+    readonly fatal: Schema.Boolean;
+    readonly frameworkCode: Schema.optionalKey<Schema.String>;
+    readonly requestId: Schema.optionalKey<Schema.brand<Schema.Trimmed, "ProcessRequestId">>;
+}>]>;
+export type ProcessEvent = typeof ProcessEvent.Type;