@claxedo/agent-runtime-contract 0.8.0 → 0.10.1

package/dist/agent-runtime-event.d.ts

@@ -0,0 +1,975 @@
+import type { BackgroundWork } from "./background-work";
+import type { AgentSubagentUpdate, RuntimeGoalSnapshot } from "./subagents";
+import type { RuntimeQuestion, RuntimeUsageObservation } from "./events";
+import type { AgentSessionCommand } from "./sessions";
+import type { RuntimeToolCallContent } from "./runtime-content";
+import type { FirstTurnErrorClass } from "./turn-error-classes";
+import type { TurnAccount } from "./turn-account";
+import type { RuntimeDiagnostic } from "./diagnostics";
+import type { RawHarnessEvent } from "./raw-harness-event";
+import type { AgentConfigOption } from "./content";
+export declare const AGENT_RUNTIME_EVENT_CONTRACT_VERSION = 9;
+export type RuntimeStatus = "busy" | "idle" | "error";
+export type RuntimeToolStatus = "pending" | "running" | "completed" | "failed";
+export type RuntimeNoticeSeverity = "debug" | "info" | "warn" | "error";
+export type SubagentUpdatedEvent = {
+    type: "subagent-updated";
+} & AgentSubagentUpdate;
+export type ToolIntent = "shell" | "read" | "lint" | "edit" | "search" | "list" | "fetch" | "move" | "delete" | "reasoning" | "task" | "todos" | "question" | "mcp" | "image" | "computer" | "switch_mode" | "generic";
+type RuntimeEventMeta = {
+    harness?: string;
+    threadId?: string;
+    raw?: RawHarnessEvent;
+    diagnostics?: RuntimeDiagnostic[];
+};
+/**
+ * Preserve supplied image bytes inline. Native image-view results that report
+ * only a path use tool-file: an absolute reference read by the owning runtime.
+ * Existing workspace-file records remain workspace-relative.
+ */
+export type RuntimeToolAttachment = {
+    mime: string;
+    filename?: string;
+} & ({
+    kind: "tool-file";
+    path: string;
+} | {
+    kind: "workspace-file";
+    path: string;
+    sourcePath: string;
+} | {
+    kind: "inline";
+    url: string;
+} | {
+    kind: "unretained";
+    sourcePath?: string;
+    bytes: number;
+});
+export type ToolDisplay = {
+    kind?: string;
+    intent?: ToolIntent;
+    mode?: string;
+    summary?: string;
+    description?: string;
+    command?: string;
+    path?: string;
+    filePath?: string;
+    pattern?: string;
+    query?: string;
+    url?: string;
+    sourcePath?: string;
+    targetPath?: string;
+    sessionId?: string;
+    agentId?: string;
+    subagentType?: unknown;
+    durationMs?: number;
+    files?: string[];
+    locations?: Array<{
+        path: string;
+        line?: number;
+    }>;
+    input?: Record<string, unknown>;
+};
+export type AgentRuntimeEvent = RuntimeEventMeta & ({
+    type: "text-delta";
+    delta: string;
+} | {
+    type: "thinking-delta";
+    delta: string;
+} | {
+    type: "tool-start";
+    toolCallId: string;
+    toolName: string;
+    kind?: string;
+    display?: ToolDisplay;
+    metadata?: Record<string, unknown>;
+} | {
+    type: "tool-input";
+    toolCallId: string;
+    input: unknown;
+    display?: ToolDisplay;
+    metadata?: Record<string, unknown>;
+} | {
+    type: "tool-status";
+    toolCallId: string;
+    status: RuntimeToolStatus;
+    display?: ToolDisplay;
+    metadata?: Record<string, unknown>;
+} | {
+    type: "tool-content";
+    toolCallId: string;
+    content: RuntimeToolCallContent;
+    display?: ToolDisplay;
+    metadata?: Record<string, unknown>;
+} | {
+    type: "tool-output";
+    toolCallId: string;
+    output: unknown;
+    attachments?: RuntimeToolAttachment[];
+    display?: ToolDisplay;
+    metadata?: Record<string, unknown>;
+} | {
+    type: "tool-error";
+    toolCallId: string;
+    error: string;
+    display?: ToolDisplay;
+    metadata?: Record<string, unknown>;
+} | {
+    type: "file-diff";
+    toolCallId?: string;
+    path: string;
+    oldText?: string;
+    newText: string;
+} | {
+    type: "step-start";
+    newMessageId: string;
+}
+/** The provider took this submitted message into its conversation; `messageId` is the id Claxedo submitted it under. */
+ | {
+    type: "input-incorporated";
+    messageId: string;
+} | {
+    type: "permission-request";
+    requestId: string;
+    tool: string;
+    paths: string[];
+    details?: {
+        command?: string;
+        reason?: string;
+    };
+    options?: {
+        id: string;
+        label: string;
+        description?: string;
+    }[];
+} | {
+    type: "question";
+    requestId: string;
+    questions: RuntimeQuestion[];
+} | {
+    type: "question-answered";
+    requestId: string;
+    answers: Record<string, string | string[]>;
+} | {
+    type: "proposed-plan-delta";
+    delta: string;
+} | {
+    type: "proposed-plan-complete";
+    planMarkdown: string;
+} | {
+    type: "todo-update";
+    todos: Array<{
+        id: string;
+        description: string;
+        status: string;
+        priority?: string;
+    }>;
+} | {
+    type: "session-status";
+    status: RuntimeStatus;
+} | {
+    type: "session-compaction";
+    phase: "started" | "completed";
+    reason?: string;
+    summary?: string;
+    metadata?: Record<string, unknown>;
+} | {
+    type: "harness-notice";
+    code: string;
+    message: string;
+    severity?: RuntimeNoticeSeverity;
+    details?: unknown;
+    eventId?: string;
+} | {
+    type: "agent-message";
+    eventId: string;
+    sender: string;
+    senderName?: string;
+    message: string;
+    senderTaskId?: string;
+    sourceSessionId?: string;
+}
+/** The harness is retrying a failed model request itself; `attempt` and `delayMs` only when it reports them. */
+ | {
+    type: "session-retry";
+    message: string;
+    attempt?: number;
+    delayMs?: number;
+}
+/** The model began a response; the content after it, until the next start, is that response's. */
+ | {
+    type: "response-start";
+    responseId: string;
+}
+/** The harness withdrew these responses; their content stays on record, marked withdrawn. */
+ | {
+    type: "response-retracted";
+    responseIds: string[];
+    reason: string;
+}
+/** The harness discarded its conversation (Claude's `/clear`); the turns after it start from fresh context in the same session. */
+ | {
+    type: "conversation-reset";
+    trigger: string;
+} | {
+    type: "auth-status";
+    status: "authenticated" | "unauthenticated" | "unknown";
+    authMode?: string | null;
+    planType?: string | null;
+    metadata?: Record<string, unknown>;
+} | {
+    type: "rate-limit";
+    status: "ok" | "limited";
+    usedPercent?: number;
+    resetsAt?: number | null;
+    windowDurationMins?: number | null;
+    limitId?: string | null;
+    limitName?: string | null;
+    reason?: string | null;
+    metadata?: Record<string, unknown>;
+} | {
+    type: "mcp-server-status";
+    serverName: string;
+    status: "starting" | "ready" | "failed" | "cancelled";
+    error?: string | null;
+} | {
+    type: "goal-updated";
+    sessionId: string;
+    goal: RuntimeGoalSnapshot;
+} | {
+    type: "goal-cleared";
+    sessionId: string;
+} | SubagentUpdatedEvent | {
+    type: "finish";
+    sessionId: string;
+}
+/** The turn ended because it was stopped. Its own terminal, never inferred from `session-status` idle. */
+ | {
+    type: "cancelled";
+    sessionId: string;
+}
+/**
+ * `errorClass` is set only from the harness's own structured error, never
+ * guessed from `error`; `account` is the one the turn was launched on.
+ */
+ | {
+    type: "error";
+    error: string;
+    errorClass?: FirstTurnErrorClass;
+    account?: TurnAccount;
+} | {
+    type: "image-delta";
+    mimeType: string;
+    data: string;
+} | {
+    type: "audio-delta";
+    mimeType: string;
+    data: string;
+} | {
+    type: "resource-link-delta";
+    uri: string;
+    name: string;
+    mimeType?: string;
+    title?: string;
+} | {
+    type: "thinking-audio-delta";
+    mimeType: string;
+    data: string;
+} | {
+    type: "thinking-resource-link-delta";
+    uri: string;
+    name: string;
+    mimeType?: string;
+    title?: string;
+} | {
+    type: "resource-delta";
+    resource: unknown;
+    channel: "assistant" | "thinking";
+} | {
+    type: "tool-location";
+    toolCallId: string;
+    locations: Array<{
+        path: string;
+        line?: number;
+    }>;
+} | {
+    type: "tool-terminal";
+    toolCallId: string;
+    terminalId: string;
+} | {
+    type: "available-commands-update";
+    commands: AgentSessionCommand[];
+} | {
+    type: "session-agent";
+    agentId: string;
+} | {
+    type: "config-update";
+    options: AgentConfigOption[];
+} | {
+    type: "session-info";
+    title?: string | null;
+    updatedAt?: string | null;
+    parentID?: string;
+    /** Authoritative placement identity for non-workspace session hosts. */
+    sessionRef?: string;
+    host?: "workspace";
+    workspaceID?: string;
+} | {
+    type: "session-title";
+    title: string;
+    titleSource?: "harness" | "user";
+}
+/** The work the harness runs for the session outside any turn (background agents, shells, other tasks), restated whole whenever it changes; all zero once it settled. Never a turn state. */
+ | ({
+    type: "background-work";
+} & BackgroundWork) | {
+    type: "usage";
+    contextSize: number;
+    contextUsed: number;
+    observation?: RuntimeUsageObservation;
+    cost?: {
+        amount: number;
+        currency: string;
+    };
+    /** The account the turn was launched on, which these tokens were spent on. */
+    account?: TurnAccount;
+} | {
+    type: "diagnostic";
+    diagnostic: RuntimeDiagnostic;
+});
+export type AgentRuntimeEventType = AgentRuntimeEvent["type"];
+export type AgentRuntimeEventOf<T extends AgentRuntimeEventType> = Extract<AgentRuntimeEvent, {
+    type: T;
+}>;
+export type AgentRuntimeEventInput<T extends AgentRuntimeEventType> = Omit<AgentRuntimeEventOf<T>, "type">;
+export declare const AGENT_RUNTIME_EVENT_TYPE_REGISTRY: {
+    "text-delta": true;
+    "thinking-delta": true;
+    "tool-start": true;
+    "tool-input": true;
+    "tool-status": true;
+    "tool-content": true;
+    "tool-output": true;
+    "tool-error": true;
+    "file-diff": true;
+    "step-start": true;
+    "input-incorporated": true;
+    "permission-request": true;
+    question: true;
+    "question-answered": true;
+    "proposed-plan-delta": true;
+    "proposed-plan-complete": true;
+    "todo-update": true;
+    "session-status": true;
+    "session-compaction": true;
+    "harness-notice": true;
+    "agent-message": true;
+    "session-retry": true;
+    "response-start": true;
+    "response-retracted": true;
+    "conversation-reset": true;
+    "auth-status": true;
+    "rate-limit": true;
+    "mcp-server-status": true;
+    "goal-updated": true;
+    "goal-cleared": true;
+    "subagent-updated": true;
+    finish: true;
+    cancelled: true;
+    error: true;
+    "image-delta": true;
+    "audio-delta": true;
+    "resource-link-delta": true;
+    "thinking-audio-delta": true;
+    "thinking-resource-link-delta": true;
+    "resource-delta": true;
+    "tool-location": true;
+    "tool-terminal": true;
+    "available-commands-update": true;
+    "session-agent": true;
+    "config-update": true;
+    "session-info": true;
+    "session-title": true;
+    "background-work": true;
+    usage: true;
+    diagnostic: true;
+};
+/** Sound because the registry is `satisfies Record<AgentRuntimeEventType, true>`: its keys are exactly the union. */
+export declare function isAgentRuntimeEventType(value: string): value is AgentRuntimeEventType;
+export declare const AGENT_RUNTIME_EVENT_TYPES: AgentRuntimeEventType[];
+export declare const AGENT_RUNTIME_EVENT_FACTORY_TYPES: {
+    readonly textDelta: "text-delta";
+    readonly thinkingDelta: "thinking-delta";
+    readonly toolStart: "tool-start";
+    readonly toolInput: "tool-input";
+    readonly toolStatus: "tool-status";
+    readonly toolContent: "tool-content";
+    readonly toolOutput: "tool-output";
+    readonly toolError: "tool-error";
+    readonly fileDiff: "file-diff";
+    readonly stepStart: "step-start";
+    readonly inputIncorporated: "input-incorporated";
+    readonly permissionRequest: "permission-request";
+    readonly question: "question";
+    readonly questionAnswered: "question-answered";
+    readonly proposedPlanDelta: "proposed-plan-delta";
+    readonly proposedPlanComplete: "proposed-plan-complete";
+    readonly todoUpdate: "todo-update";
+    readonly sessionStatus: "session-status";
+    readonly sessionCompaction: "session-compaction";
+    readonly harnessNotice: "harness-notice";
+    readonly agentMessage: "agent-message";
+    readonly sessionRetry: "session-retry";
+    readonly responseStart: "response-start";
+    readonly responseRetracted: "response-retracted";
+    readonly conversationReset: "conversation-reset";
+    readonly authStatus: "auth-status";
+    readonly rateLimit: "rate-limit";
+    readonly mcpServerStatus: "mcp-server-status";
+    readonly goalUpdated: "goal-updated";
+    readonly goalCleared: "goal-cleared";
+    readonly subagentUpdated: "subagent-updated";
+    readonly finish: "finish";
+    readonly cancelled: "cancelled";
+    readonly error: "error";
+    readonly imageDelta: "image-delta";
+    readonly audioDelta: "audio-delta";
+    readonly resourceLinkDelta: "resource-link-delta";
+    readonly thinkingAudioDelta: "thinking-audio-delta";
+    readonly thinkingResourceLinkDelta: "thinking-resource-link-delta";
+    readonly resourceDelta: "resource-delta";
+    readonly toolLocation: "tool-location";
+    readonly toolTerminal: "tool-terminal";
+    readonly availableCommandsUpdate: "available-commands-update";
+    readonly sessionAgent: "session-agent";
+    readonly configUpdate: "config-update";
+    readonly sessionInfo: "session-info";
+    readonly sessionTitle: "session-title";
+    readonly backgroundWork: "background-work";
+    readonly usage: "usage";
+    readonly diagnostic: "diagnostic";
+};
+/**
+ * One factory per runtime event type. Written out rather than generated so every
+ * entry is checked against the union: `satisfies` rejects a missing name, an
+ * unknown name, and a body whose payload does not match the event it names.
+ */
+export declare const agentRuntimeEvent: {
+    textDelta: (input: AgentRuntimeEventInput<"text-delta">) => {
+        harness?: string;
+        threadId?: string;
+        raw?: RawHarnessEvent;
+        diagnostics?: RuntimeDiagnostic[];
+        delta: string;
+        type: "text-delta";
+    };
+    thinkingDelta: (input: AgentRuntimeEventInput<"thinking-delta">) => {
+        harness?: string;
+        threadId?: string;
+        raw?: RawHarnessEvent;
+        diagnostics?: RuntimeDiagnostic[];
+        delta: string;
+        type: "thinking-delta";
+    };
+    toolStart: (input: AgentRuntimeEventInput<"tool-start">) => {
+        harness?: string;
+        threadId?: string;
+        raw?: RawHarnessEvent;
+        diagnostics?: RuntimeDiagnostic[];
+        toolCallId: string;
+        toolName: string;
+        kind?: string;
+        display?: ToolDisplay;
+        metadata?: Record<string, unknown>;
+        type: "tool-start";
+    };
+    toolInput: (input: AgentRuntimeEventInput<"tool-input">) => {
+        harness?: string;
+        threadId?: string;
+        raw?: RawHarnessEvent;
+        diagnostics?: RuntimeDiagnostic[];
+        toolCallId: string;
+        input: unknown;
+        display?: ToolDisplay;
+        metadata?: Record<string, unknown>;
+        type: "tool-input";
+    };
+    toolStatus: (input: AgentRuntimeEventInput<"tool-status">) => {
+        harness?: string;
+        threadId?: string;
+        raw?: RawHarnessEvent;
+        diagnostics?: RuntimeDiagnostic[];
+        toolCallId: string;
+        status: RuntimeToolStatus;
+        display?: ToolDisplay;
+        metadata?: Record<string, unknown>;
+        type: "tool-status";
+    };
+    toolContent: (input: AgentRuntimeEventInput<"tool-content">) => {
+        harness?: string;
+        threadId?: string;
+        raw?: RawHarnessEvent;
+        diagnostics?: RuntimeDiagnostic[];
+        toolCallId: string;
+        content: RuntimeToolCallContent;
+        display?: ToolDisplay;
+        metadata?: Record<string, unknown>;
+        type: "tool-content";
+    };
+    toolOutput: (input: AgentRuntimeEventInput<"tool-output">) => {
+        harness?: string;
+        threadId?: string;
+        raw?: RawHarnessEvent;
+        diagnostics?: RuntimeDiagnostic[];
+        toolCallId: string;
+        output: unknown;
+        attachments?: RuntimeToolAttachment[];
+        display?: ToolDisplay;
+        metadata?: Record<string, unknown>;
+        type: "tool-output";
+    };
+    toolError: (input: AgentRuntimeEventInput<"tool-error">) => {
+        harness?: string;
+        threadId?: string;
+        raw?: RawHarnessEvent;
+        diagnostics?: RuntimeDiagnostic[];
+        toolCallId: string;
+        error: string;
+        display?: ToolDisplay;
+        metadata?: Record<string, unknown>;
+        type: "tool-error";
+    };
+    fileDiff: (input: AgentRuntimeEventInput<"file-diff">) => {
+        harness?: string;
+        threadId?: string;
+        raw?: RawHarnessEvent;
+        diagnostics?: RuntimeDiagnostic[];
+        toolCallId?: string;
+        path: string;
+        oldText?: string;
+        newText: string;
+        type: "file-diff";
+    };
+    stepStart: (input: AgentRuntimeEventInput<"step-start">) => {
+        harness?: string;
+        threadId?: string;
+        raw?: RawHarnessEvent;
+        diagnostics?: RuntimeDiagnostic[];
+        newMessageId: string;
+        type: "step-start";
+    };
+    inputIncorporated: (input: AgentRuntimeEventInput<"input-incorporated">) => {
+        harness?: string;
+        threadId?: string;
+        raw?: RawHarnessEvent;
+        diagnostics?: RuntimeDiagnostic[];
+        messageId: string;
+        type: "input-incorporated";
+    };
+    permissionRequest: (input: AgentRuntimeEventInput<"permission-request">) => {
+        harness?: string;
+        threadId?: string;
+        raw?: RawHarnessEvent;
+        diagnostics?: RuntimeDiagnostic[];
+        requestId: string;
+        tool: string;
+        paths: string[];
+        details?: {
+            command?: string;
+            reason?: string;
+        };
+        options?: {
+            id: string;
+            label: string;
+            description?: string;
+        }[];
+        type: "permission-request";
+    };
+    question: (input: AgentRuntimeEventInput<"question">) => {
+        harness?: string;
+        threadId?: string;
+        raw?: RawHarnessEvent;
+        diagnostics?: RuntimeDiagnostic[];
+        requestId: string;
+        questions: RuntimeQuestion[];
+        type: "question";
+    };
+    questionAnswered: (input: AgentRuntimeEventInput<"question-answered">) => {
+        harness?: string;
+        threadId?: string;
+        raw?: RawHarnessEvent;
+        diagnostics?: RuntimeDiagnostic[];
+        requestId: string;
+        answers: Record<string, string | string[]>;
+        type: "question-answered";
+    };
+    proposedPlanDelta: (input: AgentRuntimeEventInput<"proposed-plan-delta">) => {
+        harness?: string;
+        threadId?: string;
+        raw?: RawHarnessEvent;
+        diagnostics?: RuntimeDiagnostic[];
+        delta: string;
+        type: "proposed-plan-delta";
+    };
+    proposedPlanComplete: (input: AgentRuntimeEventInput<"proposed-plan-complete">) => {
+        harness?: string;
+        threadId?: string;
+        raw?: RawHarnessEvent;
+        diagnostics?: RuntimeDiagnostic[];
+        planMarkdown: string;
+        type: "proposed-plan-complete";
+    };
+    todoUpdate: (input: AgentRuntimeEventInput<"todo-update">) => {
+        harness?: string;
+        threadId?: string;
+        raw?: RawHarnessEvent;
+        diagnostics?: RuntimeDiagnostic[];
+        todos: Array<{
+            id: string;
+            description: string;
+            status: string;
+            priority?: string;
+        }>;
+        type: "todo-update";
+    };
+    sessionStatus: (input: AgentRuntimeEventInput<"session-status">) => {
+        harness?: string;
+        threadId?: string;
+        raw?: RawHarnessEvent;
+        diagnostics?: RuntimeDiagnostic[];
+        status: RuntimeStatus;
+        type: "session-status";
+    };
+    sessionCompaction: (input: AgentRuntimeEventInput<"session-compaction">) => {
+        harness?: string;
+        threadId?: string;
+        raw?: RawHarnessEvent;
+        diagnostics?: RuntimeDiagnostic[];
+        phase: "started" | "completed";
+        reason?: string;
+        summary?: string;
+        metadata?: Record<string, unknown>;
+        type: "session-compaction";
+    };
+    harnessNotice: (input: AgentRuntimeEventInput<"harness-notice">) => {
+        harness?: string;
+        threadId?: string;
+        raw?: RawHarnessEvent;
+        diagnostics?: RuntimeDiagnostic[];
+        code: string;
+        message: string;
+        severity?: RuntimeNoticeSeverity;
+        details?: unknown;
+        eventId?: string;
+        type: "harness-notice";
+    };
+    agentMessage: (input: AgentRuntimeEventInput<"agent-message">) => {
+        harness?: string;
+        threadId?: string;
+        raw?: RawHarnessEvent;
+        diagnostics?: RuntimeDiagnostic[];
+        eventId: string;
+        sender: string;
+        senderName?: string;
+        message: string;
+        senderTaskId?: string;
+        sourceSessionId?: string;
+        type: "agent-message";
+    };
+    sessionRetry: (input: AgentRuntimeEventInput<"session-retry">) => {
+        harness?: string;
+        threadId?: string;
+        raw?: RawHarnessEvent;
+        diagnostics?: RuntimeDiagnostic[];
+        message: string;
+        attempt?: number;
+        delayMs?: number;
+        type: "session-retry";
+    };
+    responseStart: (input: AgentRuntimeEventInput<"response-start">) => {
+        harness?: string;
+        threadId?: string;
+        raw?: RawHarnessEvent;
+        diagnostics?: RuntimeDiagnostic[];
+        responseId: string;
+        type: "response-start";
+    };
+    responseRetracted: (input: AgentRuntimeEventInput<"response-retracted">) => {
+        harness?: string;
+        threadId?: string;
+        raw?: RawHarnessEvent;
+        diagnostics?: RuntimeDiagnostic[];
+        responseIds: string[];
+        reason: string;
+        type: "response-retracted";
+    };
+    conversationReset: (input: AgentRuntimeEventInput<"conversation-reset">) => {
+        harness?: string;
+        threadId?: string;
+        raw?: RawHarnessEvent;
+        diagnostics?: RuntimeDiagnostic[];
+        trigger: string;
+        type: "conversation-reset";
+    };
+    authStatus: (input: AgentRuntimeEventInput<"auth-status">) => {
+        harness?: string;
+        threadId?: string;
+        raw?: RawHarnessEvent;
+        diagnostics?: RuntimeDiagnostic[];
+        status: "authenticated" | "unauthenticated" | "unknown";
+        authMode?: string | null;
+        planType?: string | null;
+        metadata?: Record<string, unknown>;
+        type: "auth-status";
+    };
+    rateLimit: (input: AgentRuntimeEventInput<"rate-limit">) => {
+        harness?: string;
+        threadId?: string;
+        raw?: RawHarnessEvent;
+        diagnostics?: RuntimeDiagnostic[];
+        status: "ok" | "limited";
+        usedPercent?: number;
+        resetsAt?: number | null;
+        windowDurationMins?: number | null;
+        limitId?: string | null;
+        limitName?: string | null;
+        reason?: string | null;
+        metadata?: Record<string, unknown>;
+        type: "rate-limit";
+    };
+    mcpServerStatus: (input: AgentRuntimeEventInput<"mcp-server-status">) => {
+        harness?: string;
+        threadId?: string;
+        raw?: RawHarnessEvent;
+        diagnostics?: RuntimeDiagnostic[];
+        serverName: string;
+        status: "starting" | "ready" | "failed" | "cancelled";
+        error?: string | null;
+        type: "mcp-server-status";
+    };
+    goalUpdated: (input: AgentRuntimeEventInput<"goal-updated">) => {
+        harness?: string;
+        threadId?: string;
+        raw?: RawHarnessEvent;
+        diagnostics?: RuntimeDiagnostic[];
+        sessionId: string;
+        goal: RuntimeGoalSnapshot;
+        type: "goal-updated";
+    };
+    goalCleared: (input: AgentRuntimeEventInput<"goal-cleared">) => {
+        harness?: string;
+        threadId?: string;
+        raw?: RawHarnessEvent;
+        diagnostics?: RuntimeDiagnostic[];
+        sessionId: string;
+        type: "goal-cleared";
+    };
+    subagentUpdated: (input: AgentRuntimeEventInput<"subagent-updated">) => {
+        subagentKey: string;
+        revision: number;
+        toolCallId?: string;
+        toolCallRole?: import("./subagents").SubagentToolCallRole;
+        mode?: import("./subagents").SubagentMode;
+        status?: import("./subagents").SubagentStatus;
+        runRevision?: number;
+        label?: string;
+        subagentType?: string;
+        description?: string;
+        providerId?: string;
+        providerKind?: string;
+        childSessionId?: string;
+        transcript?: import("./subagents").SubagentTranscript;
+        attention?: number;
+        wake?: import("./subagents").SubagentWake;
+        harness?: string;
+        threadId?: string;
+        raw?: RawHarnessEvent;
+        diagnostics?: RuntimeDiagnostic[];
+        type: "subagent-updated";
+    };
+    finish: (input: AgentRuntimeEventInput<"finish">) => {
+        harness?: string;
+        threadId?: string;
+        raw?: RawHarnessEvent;
+        diagnostics?: RuntimeDiagnostic[];
+        sessionId: string;
+        type: "finish";
+    };
+    cancelled: (input: AgentRuntimeEventInput<"cancelled">) => {
+        harness?: string;
+        threadId?: string;
+        raw?: RawHarnessEvent;
+        diagnostics?: RuntimeDiagnostic[];
+        sessionId: string;
+        type: "cancelled";
+    };
+    error: (input: AgentRuntimeEventInput<"error">) => {
+        harness?: string;
+        threadId?: string;
+        raw?: RawHarnessEvent;
+        diagnostics?: RuntimeDiagnostic[];
+        error: string;
+        errorClass?: FirstTurnErrorClass;
+        account?: TurnAccount;
+        type: "error";
+    };
+    imageDelta: (input: AgentRuntimeEventInput<"image-delta">) => {
+        harness?: string;
+        threadId?: string;
+        raw?: RawHarnessEvent;
+        diagnostics?: RuntimeDiagnostic[];
+        mimeType: string;
+        data: string;
+        type: "image-delta";
+    };
+    audioDelta: (input: AgentRuntimeEventInput<"audio-delta">) => {
+        harness?: string;
+        threadId?: string;
+        raw?: RawHarnessEvent;
+        diagnostics?: RuntimeDiagnostic[];
+        mimeType: string;
+        data: string;
+        type: "audio-delta";
+    };
+    resourceLinkDelta: (input: AgentRuntimeEventInput<"resource-link-delta">) => {
+        harness?: string;
+        threadId?: string;
+        raw?: RawHarnessEvent;
+        diagnostics?: RuntimeDiagnostic[];
+        uri: string;
+        name: string;
+        mimeType?: string;
+        title?: string;
+        type: "resource-link-delta";
+    };
+    thinkingAudioDelta: (input: AgentRuntimeEventInput<"thinking-audio-delta">) => {
+        harness?: string;
+        threadId?: string;
+        raw?: RawHarnessEvent;
+        diagnostics?: RuntimeDiagnostic[];
+        mimeType: string;
+        data: string;
+        type: "thinking-audio-delta";
+    };
+    thinkingResourceLinkDelta: (input: AgentRuntimeEventInput<"thinking-resource-link-delta">) => {
+        harness?: string;
+        threadId?: string;
+        raw?: RawHarnessEvent;
+        diagnostics?: RuntimeDiagnostic[];
+        uri: string;
+        name: string;
+        mimeType?: string;
+        title?: string;
+        type: "thinking-resource-link-delta";
+    };
+    resourceDelta: (input: AgentRuntimeEventInput<"resource-delta">) => {
+        harness?: string;
+        threadId?: string;
+        raw?: RawHarnessEvent;
+        diagnostics?: RuntimeDiagnostic[];
+        resource: unknown;
+        channel: "assistant" | "thinking";
+        type: "resource-delta";
+    };
+    toolLocation: (input: AgentRuntimeEventInput<"tool-location">) => {
+        harness?: string;
+        threadId?: string;
+        raw?: RawHarnessEvent;
+        diagnostics?: RuntimeDiagnostic[];
+        toolCallId: string;
+        locations: Array<{
+            path: string;
+            line?: number;
+        }>;
+        type: "tool-location";
+    };
+    toolTerminal: (input: AgentRuntimeEventInput<"tool-terminal">) => {
+        harness?: string;
+        threadId?: string;
+        raw?: RawHarnessEvent;
+        diagnostics?: RuntimeDiagnostic[];
+        toolCallId: string;
+        terminalId: string;
+        type: "tool-terminal";
+    };
+    availableCommandsUpdate: (input: AgentRuntimeEventInput<"available-commands-update">) => {
+        harness?: string;
+        threadId?: string;
+        raw?: RawHarnessEvent;
+        diagnostics?: RuntimeDiagnostic[];
+        commands: AgentSessionCommand[];
+        type: "available-commands-update";
+    };
+    sessionAgent: (input: AgentRuntimeEventInput<"session-agent">) => {
+        harness?: string;
+        threadId?: string;
+        raw?: RawHarnessEvent;
+        diagnostics?: RuntimeDiagnostic[];
+        agentId: string;
+        type: "session-agent";
+    };
+    configUpdate: (input: AgentRuntimeEventInput<"config-update">) => {
+        harness?: string;
+        threadId?: string;
+        raw?: RawHarnessEvent;
+        diagnostics?: RuntimeDiagnostic[];
+        options: AgentConfigOption[];
+        type: "config-update";
+    };
+    sessionInfo: (input: AgentRuntimeEventInput<"session-info">) => {
+        harness?: string;
+        threadId?: string;
+        raw?: RawHarnessEvent;
+        diagnostics?: RuntimeDiagnostic[];
+        title?: string | null;
+        updatedAt?: string | null;
+        parentID?: string;
+        sessionRef?: string;
+        host?: "workspace";
+        workspaceID?: string;
+        type: "session-info";
+    };
+    sessionTitle: (input: AgentRuntimeEventInput<"session-title">) => {
+        harness?: string;
+        threadId?: string;
+        raw?: RawHarnessEvent;
+        diagnostics?: RuntimeDiagnostic[];
+        title: string;
+        titleSource?: "harness" | "user";
+        type: "session-title";
+    };
+    backgroundWork: (input: AgentRuntimeEventInput<"background-work">) => {
+        agents: number;
+        shells: number;
+        other: number;
+        harness?: string;
+        threadId?: string;
+        raw?: RawHarnessEvent;
+        diagnostics?: RuntimeDiagnostic[];
+        type: "background-work";
+    };
+    usage: (input: AgentRuntimeEventInput<"usage">) => {
+        harness?: string;
+        threadId?: string;
+        raw?: RawHarnessEvent;
+        diagnostics?: RuntimeDiagnostic[];
+        contextSize: number;
+        contextUsed: number;
+        observation?: RuntimeUsageObservation;
+        cost?: {
+            amount: number;
+            currency: string;
+        };
+        account?: TurnAccount;
+        type: "usage";
+    };
+    diagnostic: (input: AgentRuntimeEventInput<"diagnostic">) => {
+        harness?: string;
+        threadId?: string;
+        raw?: RawHarnessEvent;
+        diagnostics?: RuntimeDiagnostic[];
+        diagnostic: RuntimeDiagnostic;
+        type: "diagnostic";
+    };
+};
+export {};