@h-rig/contracts 0.0.6-alpha.77 → 0.0.6-alpha.79

package/dist/src/pi-session.d.ts

@@ -0,0 +1,113 @@
+export type RigPiSessionTransport = "http-control-ws-events";
+export interface RigPiSessionMetadata {
+    runId: string;
+    sessionId: string;
+    daemonId: string;
+    cwd: string;
+    agentDir: string;
+    sessionDir: string;
+    transport: RigPiSessionTransport;
+    /**
+     * Absolute path of the Pi session jsonl backing this session, when the
+     * session persists to disk. Recorded on the run record so a tier-1
+     * re-dispatch (deploy-safe runs) can reopen the same session.
+     */
+    sessionFile?: string;
+    /**
+     * Set when the daemon reopened a previous attempt's session file instead
+     * of creating a fresh session (tier-1 session resume).
+     */
+    resumedFromSessionFile?: string;
+    serverBasePath: string;
+    eventsPath: string;
+    createdAt: string;
+    updatedAt: string;
+    backend: {
+        kind: "worker-pi-sessiond";
+        version: string;
+        pid?: number;
+        commit?: string;
+    };
+}
+export type RigPiDaemonConnection = {
+    mode: "unix";
+    socketPath: string;
+    tokenRef: string;
+    endpointId?: string;
+    hostId?: string;
+} | {
+    mode: "http";
+    baseUrl: string;
+    tokenRef: string;
+    endpointId?: string;
+    hostId?: string;
+};
+export interface RigPiSessionPrivateMetadata {
+    public: RigPiSessionMetadata;
+    daemonConnection: RigPiDaemonConnection;
+}
+export type RigPiControlStreamingBehavior = "steer" | "followUp";
+export interface RigPiPromptRequest {
+    text: string;
+    streamingBehavior?: RigPiControlStreamingBehavior;
+}
+export interface RigPiShellRequest {
+    text: string;
+}
+export interface RigPiCommandRequest {
+    text: string;
+}
+export interface RigPiCommandResponseRequest {
+    requestId: string;
+    value?: unknown;
+    cancelled?: boolean;
+}
+export interface RigPiExtensionUiResponseRequest {
+    requestId: string;
+    value?: unknown;
+    cancelled?: boolean;
+}
+export interface RigPiReadyPendingResponse {
+    ready: false;
+    runId: string;
+    status?: string;
+    retryAfterMs: number;
+}
+export interface RigPiReadyResponse {
+    ready: true;
+    metadata: RigPiSessionMetadata;
+}
+export type RigPiSessionResponse = RigPiReadyPendingResponse | RigPiReadyResponse;
+export type RigPiEventEnvelope = {
+    type: "ready";
+    metadata: RigPiSessionMetadata;
+} | {
+    type: "pi.event";
+    sessionId: string;
+    runId?: string;
+    event: unknown;
+} | {
+    type: "pi.ui_event";
+    sessionId: string;
+    runId?: string;
+    event: unknown;
+} | {
+    type: "extension_ui_request";
+    sessionId: string;
+    runId?: string;
+    request: unknown;
+} | {
+    type: "status.update";
+    sessionId: string;
+    runId?: string;
+    status: unknown;
+} | {
+    type: "activity.update";
+    sessionId: string;
+    runId?: string;
+    activity: unknown;
+} | {
+    type: "error";
+    message: string;
+    detail?: unknown;
+};

package/dist/src/plugin-hooks.d.ts

@@ -0,0 +1,51 @@
+import { Schema } from "effect";
+/** Tool input payload as delivered on the hook's stdin (`tool_input`). */
+export declare const HookToolInput: Schema.$Record<Schema.String, Schema.Unknown>;
+export type HookToolInput = typeof HookToolInput.Type;
+/**
+ * Parsed hook invocation handed to a typed hook implementation.
+ *
+ * Derived from the Claude Code hook stdin payload (see @rig/hook-kit's
+ * `readHookInput`) plus the runner's resolved environment:
+ * - `event`        — the lifecycle event the hook fired on
+ * - `toolName`     — `tool_name` from the payload (absent for non-tool events)
+ * - `toolInput`    — `tool_input` from the payload (`{}` when absent)
+ * - `filePaths`    — file path candidates extracted from the tool input
+ *                    (@rig/hook-kit's `extractToolFilePaths`)
+ * - `projectRoot`  — resolved project root (@rig/hook-kit's `resolveProjectRoot`)
+ * - `taskId`       — current Rig task id, `""` when not running inside a task
+ */
+export declare const HookContext: Schema.Struct<{
+    readonly event: Schema.Literals<readonly ["PreToolUse", "PostToolUse", "UserPromptSubmit", "Stop", "SessionStart", "SessionEnd"]>;
+    readonly toolName: Schema.optional<Schema.String>;
+    readonly toolInput: Schema.$Record<Schema.String, Schema.Unknown>;
+    readonly filePaths: Schema.$Array<Schema.String>;
+    readonly projectRoot: Schema.String;
+    readonly taskId: Schema.String;
+}>;
+export type HookContext = typeof HookContext.Type;
+export declare const HookDecision: Schema.Literals<readonly ["allow", "block"]>;
+export type HookDecision = typeof HookDecision.Type;
+/**
+ * Result returned by a typed hook implementation.
+ *
+ * Serialized to the same stdout/exit-code protocol that @rig/hook-kit's
+ * `block()` uses (the contract Claude Code's hook runner expects):
+ * - `decision: "block"` → `BLOCKED: <reason>` on stdout, non-zero exit
+ * - `decision: "allow"` → exit 0; `systemMessage` (when set) on stdout
+ */
+export declare const HookResult: Schema.Struct<{
+    readonly decision: Schema.Literals<readonly ["allow", "block"]>;
+    /** Why the action was blocked. Surfaced to the agent on stdout. */
+    readonly reason: Schema.optional<Schema.String>;
+    /** Extra context printed on stdout for either decision. */
+    readonly systemMessage: Schema.optional<Schema.String>;
+}>;
+export type HookResult = typeof HookResult.Type;
+/**
+ * A typed hook implementation. Registered per hook id via definePlugin's
+ * runtime channel: `definePlugin(meta, { hooks: { [hookId]: impl } })`.
+ * Functions can't be represented by Schema, so this is a plain type — the
+ * referential-integrity rules are enforced by @rig/core's definePlugin.
+ */
+export type HookImplementation = (input: HookContext) => Promise<HookResult> | HookResult;

package/dist/src/plugin.d.ts

@@ -0,0 +1,230 @@
+import { Schema } from "effect";
+export declare const ValidatorCategory: Schema.Literals<readonly ["boundary", "contract", "integration", "regression", "external", "custom"]>;
+export type ValidatorCategory = typeof ValidatorCategory.Type;
+export declare const ValidatorRegistration: Schema.Struct<{
+    readonly id: Schema.String;
+    readonly category: Schema.Literals<readonly ["boundary", "contract", "integration", "regression", "external", "custom"]>;
+    readonly description: Schema.optional<Schema.String>;
+}>;
+export type ValidatorRegistration = typeof ValidatorRegistration.Type;
+export declare const HookEvent: Schema.Literals<readonly ["PreToolUse", "PostToolUse", "UserPromptSubmit", "Stop", "SessionStart", "SessionEnd"]>;
+export type HookEvent = typeof HookEvent.Type;
+export declare const HookMatcher: Schema.Union<readonly [Schema.Struct<{
+    readonly kind: Schema.Literal<"all">;
+}>, Schema.Struct<{
+    readonly kind: Schema.Literal<"tool">;
+    readonly name: Schema.String;
+}>, Schema.Struct<{
+    readonly kind: Schema.Literal<"glob">;
+    readonly pattern: Schema.String;
+}>]>;
+export type HookMatcher = typeof HookMatcher.Type;
+export declare const HookRegistration: Schema.Struct<{
+    readonly id: Schema.String;
+    readonly event: Schema.Literals<readonly ["PreToolUse", "PostToolUse", "UserPromptSubmit", "Stop", "SessionStart", "SessionEnd"]>;
+    readonly matcher: Schema.Union<readonly [Schema.Struct<{
+        readonly kind: Schema.Literal<"all">;
+    }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"tool">;
+        readonly name: Schema.String;
+    }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"glob">;
+        readonly pattern: Schema.String;
+    }>]>;
+    /**
+     * Shell command Claude Code invokes when this hook fires. Resolved as-is by
+     * Claude Code's hook runner. Use absolute paths or expand
+     * `$CLAUDE_PROJECT_DIR` for project-relative paths.
+     *
+     * Alternative: leave `command` unset and ship a typed implementation via
+     * definePlugin's runtime channel (`{ hooks: { [hookId]: fn } }`) — see
+     * `HookContext`/`HookResult`/`HookImplementation` in plugin-hooks.ts. The
+     * runtime materializes a shim command for typed hooks automatically. A hook
+     * may not have both a `command` and a typed implementation.
+     */
+    readonly command: Schema.optional<Schema.String>;
+    readonly description: Schema.optional<Schema.String>;
+}>;
+export type HookRegistration = typeof HookRegistration.Type;
+export declare const SkillRegistration: Schema.Struct<{
+    readonly id: Schema.String;
+    readonly path: Schema.String;
+    readonly description: Schema.optional<Schema.String>;
+}>;
+export type SkillRegistration = typeof SkillRegistration.Type;
+export declare const RepoSourceRegistration: Schema.Struct<{
+    readonly id: Schema.String;
+    readonly url: Schema.String;
+    readonly defaultPath: Schema.optional<Schema.String>;
+    readonly description: Schema.optional<Schema.String>;
+    readonly defaultBranch: Schema.optional<Schema.String>;
+    readonly remoteEnvVar: Schema.optional<Schema.String>;
+    readonly checkoutEnvVar: Schema.optional<Schema.String>;
+}>;
+export type RepoSourceRegistration = typeof RepoSourceRegistration.Type;
+export declare const AgentRoleRegistration: Schema.Struct<{
+    readonly id: Schema.String;
+    readonly defaultModel: Schema.optional<Schema.String>;
+    readonly description: Schema.optional<Schema.String>;
+}>;
+export type AgentRoleRegistration = typeof AgentRoleRegistration.Type;
+export declare const TaskFieldExtension: Schema.Struct<{
+    readonly id: Schema.String;
+    readonly fieldName: Schema.String;
+    readonly schemaJson: Schema.String;
+}>;
+export type TaskFieldExtension = typeof TaskFieldExtension.Type;
+export declare const TaskSourceKind: Schema.String;
+export type TaskSourceKind = string;
+export declare const TaskSourceRegistration: Schema.Struct<{
+    readonly id: Schema.String;
+    readonly kind: Schema.String;
+    readonly description: Schema.optional<Schema.String>;
+}>;
+export type TaskSourceRegistration = typeof TaskSourceRegistration.Type;
+export declare const CliCommandRegistration: Schema.Struct<{
+    readonly id: Schema.String;
+    readonly command: Schema.String;
+    readonly description: Schema.optional<Schema.String>;
+}>;
+export type CliCommandRegistration = typeof CliCommandRegistration.Type;
+export declare const PluginContributes: Schema.Struct<{
+    readonly validators: Schema.optional<Schema.$Array<Schema.Struct<{
+        readonly id: Schema.String;
+        readonly category: Schema.Literals<readonly ["boundary", "contract", "integration", "regression", "external", "custom"]>;
+        readonly description: Schema.optional<Schema.String>;
+    }>>>;
+    readonly hooks: Schema.optional<Schema.$Array<Schema.Struct<{
+        readonly id: Schema.String;
+        readonly event: Schema.Literals<readonly ["PreToolUse", "PostToolUse", "UserPromptSubmit", "Stop", "SessionStart", "SessionEnd"]>;
+        readonly matcher: Schema.Union<readonly [Schema.Struct<{
+            readonly kind: Schema.Literal<"all">;
+        }>, Schema.Struct<{
+            readonly kind: Schema.Literal<"tool">;
+            readonly name: Schema.String;
+        }>, Schema.Struct<{
+            readonly kind: Schema.Literal<"glob">;
+            readonly pattern: Schema.String;
+        }>]>;
+        /**
+         * Shell command Claude Code invokes when this hook fires. Resolved as-is by
+         * Claude Code's hook runner. Use absolute paths or expand
+         * `$CLAUDE_PROJECT_DIR` for project-relative paths.
+         *
+         * Alternative: leave `command` unset and ship a typed implementation via
+         * definePlugin's runtime channel (`{ hooks: { [hookId]: fn } }`) — see
+         * `HookContext`/`HookResult`/`HookImplementation` in plugin-hooks.ts. The
+         * runtime materializes a shim command for typed hooks automatically. A hook
+         * may not have both a `command` and a typed implementation.
+         */
+        readonly command: Schema.optional<Schema.String>;
+        readonly description: Schema.optional<Schema.String>;
+    }>>>;
+    readonly skills: Schema.optional<Schema.$Array<Schema.Struct<{
+        readonly id: Schema.String;
+        readonly path: Schema.String;
+        readonly description: Schema.optional<Schema.String>;
+    }>>>;
+    readonly repoSources: Schema.optional<Schema.$Array<Schema.Struct<{
+        readonly id: Schema.String;
+        readonly url: Schema.String;
+        readonly defaultPath: Schema.optional<Schema.String>;
+        readonly description: Schema.optional<Schema.String>;
+        readonly defaultBranch: Schema.optional<Schema.String>;
+        readonly remoteEnvVar: Schema.optional<Schema.String>;
+        readonly checkoutEnvVar: Schema.optional<Schema.String>;
+    }>>>;
+    readonly agentRoles: Schema.optional<Schema.$Array<Schema.Struct<{
+        readonly id: Schema.String;
+        readonly defaultModel: Schema.optional<Schema.String>;
+        readonly description: Schema.optional<Schema.String>;
+    }>>>;
+    readonly taskFieldSchemas: Schema.optional<Schema.$Array<Schema.Struct<{
+        readonly id: Schema.String;
+        readonly fieldName: Schema.String;
+        readonly schemaJson: Schema.String;
+    }>>>;
+    readonly taskSources: Schema.optional<Schema.$Array<Schema.Struct<{
+        readonly id: Schema.String;
+        readonly kind: Schema.String;
+        readonly description: Schema.optional<Schema.String>;
+    }>>>;
+    readonly cliCommands: Schema.optional<Schema.$Array<Schema.Struct<{
+        readonly id: Schema.String;
+        readonly command: Schema.String;
+        readonly description: Schema.optional<Schema.String>;
+    }>>>;
+}>;
+export type PluginContributes = typeof PluginContributes.Type;
+export declare const RigPlugin: Schema.Struct<{
+    readonly name: Schema.String;
+    readonly version: Schema.String;
+    readonly contributes: Schema.optional<Schema.Struct<{
+        readonly validators: Schema.optional<Schema.$Array<Schema.Struct<{
+            readonly id: Schema.String;
+            readonly category: Schema.Literals<readonly ["boundary", "contract", "integration", "regression", "external", "custom"]>;
+            readonly description: Schema.optional<Schema.String>;
+        }>>>;
+        readonly hooks: Schema.optional<Schema.$Array<Schema.Struct<{
+            readonly id: Schema.String;
+            readonly event: Schema.Literals<readonly ["PreToolUse", "PostToolUse", "UserPromptSubmit", "Stop", "SessionStart", "SessionEnd"]>;
+            readonly matcher: Schema.Union<readonly [Schema.Struct<{
+                readonly kind: Schema.Literal<"all">;
+            }>, Schema.Struct<{
+                readonly kind: Schema.Literal<"tool">;
+                readonly name: Schema.String;
+            }>, Schema.Struct<{
+                readonly kind: Schema.Literal<"glob">;
+                readonly pattern: Schema.String;
+            }>]>;
+            /**
+             * Shell command Claude Code invokes when this hook fires. Resolved as-is by
+             * Claude Code's hook runner. Use absolute paths or expand
+             * `$CLAUDE_PROJECT_DIR` for project-relative paths.
+             *
+             * Alternative: leave `command` unset and ship a typed implementation via
+             * definePlugin's runtime channel (`{ hooks: { [hookId]: fn } }`) — see
+             * `HookContext`/`HookResult`/`HookImplementation` in plugin-hooks.ts. The
+             * runtime materializes a shim command for typed hooks automatically. A hook
+             * may not have both a `command` and a typed implementation.
+             */
+            readonly command: Schema.optional<Schema.String>;
+            readonly description: Schema.optional<Schema.String>;
+        }>>>;
+        readonly skills: Schema.optional<Schema.$Array<Schema.Struct<{
+            readonly id: Schema.String;
+            readonly path: Schema.String;
+            readonly description: Schema.optional<Schema.String>;
+        }>>>;
+        readonly repoSources: Schema.optional<Schema.$Array<Schema.Struct<{
+            readonly id: Schema.String;
+            readonly url: Schema.String;
+            readonly defaultPath: Schema.optional<Schema.String>;
+            readonly description: Schema.optional<Schema.String>;
+            readonly defaultBranch: Schema.optional<Schema.String>;
+            readonly remoteEnvVar: Schema.optional<Schema.String>;
+            readonly checkoutEnvVar: Schema.optional<Schema.String>;
+        }>>>;
+        readonly agentRoles: Schema.optional<Schema.$Array<Schema.Struct<{
+            readonly id: Schema.String;
+            readonly defaultModel: Schema.optional<Schema.String>;
+            readonly description: Schema.optional<Schema.String>;
+        }>>>;
+        readonly taskFieldSchemas: Schema.optional<Schema.$Array<Schema.Struct<{
+            readonly id: Schema.String;
+            readonly fieldName: Schema.String;
+            readonly schemaJson: Schema.String;
+        }>>>;
+        readonly taskSources: Schema.optional<Schema.$Array<Schema.Struct<{
+            readonly id: Schema.String;
+            readonly kind: Schema.String;
+            readonly description: Schema.optional<Schema.String>;
+        }>>>;
+        readonly cliCommands: Schema.optional<Schema.$Array<Schema.Struct<{
+            readonly id: Schema.String;
+            readonly command: Schema.String;
+            readonly description: Schema.optional<Schema.String>;
+        }>>>;
+    }>>;
+}>;
+export type RigPlugin = typeof RigPlugin.Type;

package/dist/src/policy.d.ts

@@ -0,0 +1,16 @@
+import { Schema } from "effect";
+export declare const PolicyDecision: Schema.Literals<readonly ["allow", "warn", "block"]>;
+export type PolicyDecision = typeof PolicyDecision.Type;
+export declare const PolicyMode: Schema.Literals<readonly ["off", "observe", "enforce"]>;
+export type PolicyMode = typeof PolicyMode.Type;
+export declare const PolicyDecisionSummary: Schema.Struct<{
+    readonly id: Schema.Trim;
+    readonly runId: Schema.brand<Schema.Trim, "RunId">;
+    readonly actionId: Schema.NullOr<Schema.brand<Schema.Trim, "ActionId">>;
+    readonly decision: Schema.Literals<readonly ["allow", "warn", "block"]>;
+    readonly mode: Schema.Literals<readonly ["off", "observe", "enforce"]>;
+    readonly matchedRules: Schema.$Array<Schema.Trim>;
+    readonly reason: Schema.String;
+    readonly createdAt: Schema.String;
+}>;
+export type PolicyDecisionSummary = typeof PolicyDecisionSummary.Type;

package/dist/src/project.d.ts

@@ -0,0 +1,71 @@
+import { Schema } from "effect";
+export declare const ProjectSearchEntriesInput: Schema.Struct<{
+    readonly cwd: Schema.Trim;
+    readonly query: Schema.Trim;
+    readonly limit: Schema.Int;
+}>;
+export type ProjectSearchEntriesInput = typeof ProjectSearchEntriesInput.Type;
+export declare const ProjectEntry: Schema.Struct<{
+    readonly path: Schema.Trim;
+    readonly kind: Schema.Literals<readonly ["file", "directory"]>;
+    readonly parentPath: Schema.optional<Schema.Trim>;
+}>;
+export type ProjectEntry = typeof ProjectEntry.Type;
+export declare const ProjectSearchEntriesResult: Schema.Struct<{
+    readonly entries: Schema.$Array<Schema.Struct<{
+        readonly path: Schema.Trim;
+        readonly kind: Schema.Literals<readonly ["file", "directory"]>;
+        readonly parentPath: Schema.optional<Schema.Trim>;
+    }>>;
+    readonly truncated: Schema.Boolean;
+}>;
+export type ProjectSearchEntriesResult = typeof ProjectSearchEntriesResult.Type;
+export declare const ProjectListDirectoryInput: Schema.Struct<{
+    readonly cwd: Schema.Trim;
+    readonly relativePath: Schema.Trim;
+    readonly limit: Schema.Int;
+}>;
+export type ProjectListDirectoryInput = typeof ProjectListDirectoryInput.Type;
+export declare const ProjectDirectoryEntry: Schema.Struct<{
+    readonly name: Schema.Trim;
+    readonly relativePath: Schema.Trim;
+    readonly kind: Schema.Literals<readonly ["file", "directory"]>;
+    readonly sizeBytes: Schema.optional<Schema.Int>;
+    readonly modifiedAt: Schema.optional<Schema.String>;
+}>;
+export type ProjectDirectoryEntry = typeof ProjectDirectoryEntry.Type;
+export declare const ProjectListDirectoryResult: Schema.Struct<{
+    readonly entries: Schema.$Array<Schema.Struct<{
+        readonly name: Schema.Trim;
+        readonly relativePath: Schema.Trim;
+        readonly kind: Schema.Literals<readonly ["file", "directory"]>;
+        readonly sizeBytes: Schema.optional<Schema.Int>;
+        readonly modifiedAt: Schema.optional<Schema.String>;
+    }>>;
+    readonly truncated: Schema.Boolean;
+}>;
+export type ProjectListDirectoryResult = typeof ProjectListDirectoryResult.Type;
+export declare const ProjectWriteFileInput: Schema.Struct<{
+    readonly cwd: Schema.Trim;
+    readonly relativePath: Schema.Trim;
+    readonly contents: Schema.String;
+}>;
+export type ProjectWriteFileInput = typeof ProjectWriteFileInput.Type;
+export declare const ProjectWriteFileResult: Schema.Struct<{
+    readonly relativePath: Schema.Trim;
+}>;
+export type ProjectWriteFileResult = typeof ProjectWriteFileResult.Type;
+export declare const ProjectReadFileInput: Schema.Struct<{
+    readonly cwd: Schema.Trim;
+    readonly relativePath: Schema.Trim;
+}>;
+export type ProjectReadFileInput = typeof ProjectReadFileInput.Type;
+export declare const ProjectReadFileResult: Schema.Struct<{
+    readonly relativePath: Schema.Trim;
+    readonly contents: Schema.String;
+    readonly truncated: Schema.Boolean;
+    readonly sizeBytes: Schema.Int;
+    readonly maxBytes: Schema.Int;
+}>;
+export type ProjectReadFileResult = typeof ProjectReadFileResult.Type;
+export declare const PROJECT_READ_FILE_MAX_BYTES_VALUE: number;

package/dist/src/protocol-version.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Rig client–server protocol version.
+ *
+ * A single integer shared by the server (reported in the
+ * `GET /api/server/status` bootstrap payload as `protocolVersion`) and by
+ * clients that speak the HTTP/WS surface (the pi-rig bridge validates it at
+ * extension init and disables itself on mismatch instead of failing on a
+ * random later request).
+ *
+ * Bump rules:
+ * - Increment whenever a change to the server API surface would break an
+ *   older client (removed/renamed routes, changed payload shapes, changed
+ *   steering/event semantics).
+ * - Purely additive changes (new routes, new optional fields) do NOT require
+ *   a bump.
+ *
+ * History:
+ * - 1: first explicit version (2026-06). Servers older than this do not
+ *   report `protocolVersion` at all; clients treat the missing field as v0.
+ */
+export declare const RIG_PROTOCOL_VERSION = 1;

package/dist/src/provider.d.ts

@@ -0,0 +1,105 @@
+import { Schema } from "effect";
+export declare const ProviderSession: Schema.Struct<{
+    readonly provider: Schema.Literals<readonly ["codex", "claude"]>;
+    readonly status: Schema.Literals<readonly ["connecting", "ready", "running", "error", "closed"]>;
+    readonly runtimeMode: Schema.Literals<readonly ["approval-required", "full-access"]>;
+    readonly cwd: Schema.optional<Schema.Trim>;
+    readonly model: Schema.optional<Schema.Trim>;
+    readonly threadId: Schema.brand<Schema.Trim, "ThreadId">;
+    readonly resumeCursor: Schema.optional<Schema.Unknown>;
+    readonly activeTurnId: Schema.optional<Schema.brand<Schema.Trim, "TurnId">>;
+    readonly createdAt: Schema.String;
+    readonly updatedAt: Schema.String;
+    readonly lastError: Schema.optional<Schema.Trim>;
+}>;
+export type ProviderSession = typeof ProviderSession.Type;
+export declare const ProviderSessionStartInput: Schema.Struct<{
+    readonly threadId: Schema.brand<Schema.Trim, "ThreadId">;
+    readonly provider: Schema.optional<Schema.Literals<readonly ["codex", "claude"]>>;
+    readonly cwd: Schema.optional<Schema.Trim>;
+    readonly model: Schema.optional<Schema.Trim>;
+    readonly modelOptions: Schema.optional<Schema.Struct<{
+        readonly codex: Schema.optional<Schema.Struct<{
+            readonly reasoningEffort: Schema.optional<Schema.Literals<readonly ["xhigh", "high", "medium", "low"]>>;
+            readonly fastMode: Schema.optional<Schema.Boolean>;
+        }>>;
+        readonly claude: Schema.optional<Schema.Struct<{}>>;
+    }>>;
+    readonly resumeCursor: Schema.optional<Schema.Unknown>;
+    readonly serviceTier: Schema.optional<Schema.NullOr<Schema.Literals<readonly ["fast", "flex"]>>>;
+    readonly approvalPolicy: Schema.optional<Schema.Literals<readonly ["untrusted", "on-failure", "on-request", "never"]>>;
+    readonly sandboxMode: Schema.optional<Schema.Literals<readonly ["read-only", "workspace-write", "danger-full-access"]>>;
+    readonly providerOptions: Schema.optional<Schema.Struct<{
+        readonly codex: Schema.optional<Schema.Struct<{
+            readonly binaryPath: Schema.optional<Schema.Trim>;
+            readonly homePath: Schema.optional<Schema.Trim>;
+        }>>;
+    }>>;
+    readonly runtimeMode: Schema.Literals<readonly ["approval-required", "full-access"]>;
+}>;
+export type ProviderSessionStartInput = typeof ProviderSessionStartInput.Type;
+export declare const ProviderSendTurnInput: Schema.Struct<{
+    readonly threadId: Schema.brand<Schema.Trim, "ThreadId">;
+    readonly input: Schema.optional<Schema.Trim>;
+    readonly attachments: Schema.optional<Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+        readonly type: Schema.Literal<"image">;
+        readonly id: Schema.Trim;
+        readonly name: Schema.Trim;
+        readonly mimeType: Schema.Trim;
+        readonly sizeBytes: Schema.Int;
+    }>]>>>;
+    readonly model: Schema.optional<Schema.Trim>;
+    readonly serviceTier: Schema.optional<Schema.NullOr<Schema.Literals<readonly ["fast", "flex"]>>>;
+    readonly modelOptions: Schema.optional<Schema.Struct<{
+        readonly codex: Schema.optional<Schema.Struct<{
+            readonly reasoningEffort: Schema.optional<Schema.Literals<readonly ["xhigh", "high", "medium", "low"]>>;
+            readonly fastMode: Schema.optional<Schema.Boolean>;
+        }>>;
+        readonly claude: Schema.optional<Schema.Struct<{}>>;
+    }>>;
+    readonly interactionMode: Schema.optional<Schema.Literals<readonly ["default", "plan"]>>;
+}>;
+export type ProviderSendTurnInput = typeof ProviderSendTurnInput.Type;
+export declare const ProviderTurnStartResult: Schema.Struct<{
+    readonly threadId: Schema.brand<Schema.Trim, "ThreadId">;
+    readonly turnId: Schema.brand<Schema.Trim, "TurnId">;
+    readonly resumeCursor: Schema.optional<Schema.Unknown>;
+}>;
+export type ProviderTurnStartResult = typeof ProviderTurnStartResult.Type;
+export declare const ProviderInterruptTurnInput: Schema.Struct<{
+    readonly threadId: Schema.brand<Schema.Trim, "ThreadId">;
+    readonly turnId: Schema.optional<Schema.brand<Schema.Trim, "TurnId">>;
+}>;
+export type ProviderInterruptTurnInput = typeof ProviderInterruptTurnInput.Type;
+export declare const ProviderStopSessionInput: Schema.Struct<{
+    readonly threadId: Schema.brand<Schema.Trim, "ThreadId">;
+}>;
+export type ProviderStopSessionInput = typeof ProviderStopSessionInput.Type;
+export declare const ProviderRespondToRequestInput: Schema.Struct<{
+    readonly threadId: Schema.brand<Schema.Trim, "ThreadId">;
+    readonly requestId: Schema.brand<Schema.Trim, "ApprovalRequestId">;
+    readonly decision: Schema.Literals<readonly ["accept", "acceptForSession", "decline", "cancel"]>;
+}>;
+export type ProviderRespondToRequestInput = typeof ProviderRespondToRequestInput.Type;
+export declare const ProviderRespondToUserInputInput: Schema.Struct<{
+    readonly threadId: Schema.brand<Schema.Trim, "ThreadId">;
+    readonly requestId: Schema.brand<Schema.Trim, "ApprovalRequestId">;
+    readonly answers: Schema.$Record<Schema.String, Schema.Unknown>;
+}>;
+export type ProviderRespondToUserInputInput = typeof ProviderRespondToUserInputInput.Type;
+export declare const ProviderEvent: Schema.Struct<{
+    readonly id: Schema.brand<Schema.Trim, "EventId">;
+    readonly kind: Schema.Literals<readonly ["session", "notification", "request", "error"]>;
+    readonly provider: Schema.Literals<readonly ["codex", "claude"]>;
+    readonly threadId: Schema.brand<Schema.Trim, "ThreadId">;
+    readonly createdAt: Schema.String;
+    readonly method: Schema.Trim;
+    readonly message: Schema.optional<Schema.Trim>;
+    readonly turnId: Schema.optional<Schema.brand<Schema.Trim, "TurnId">>;
+    readonly itemId: Schema.optional<Schema.brand<Schema.Trim, "ProviderItemId">>;
+    readonly requestId: Schema.optional<Schema.brand<Schema.Trim, "ApprovalRequestId">>;
+    readonly requestKind: Schema.optional<Schema.Literals<readonly ["command", "file-read", "file-change"]>>;
+    readonly textDelta: Schema.optional<Schema.String>;
+    readonly payload: Schema.optional<Schema.Unknown>;
+}>;
+export type ProviderEvent = typeof ProviderEvent.Type;