import { z } from "#compiled/zod/index.js";
/**
 * Eve-owned `tool-call` action requested by the model.
 *
 * Depending on the tool definition, it can execute locally, be provider
 * executed, or be handled later by the runtime.
 */
export type RuntimeToolCallActionRequest = z.infer<typeof runtimeToolCallActionRequestSchema>;
/**
 * Zod schema for one Eve-owned `tool-call` action request.
 */
export declare const runtimeToolCallActionRequestSchema: z.ZodObject<{
    callId: z.ZodString;
    input: z.ZodType<import("../../shared/json.ts").JsonObject, unknown, z.core.$ZodTypeInternals<import("../../shared/json.ts").JsonObject, unknown>>;
    kind: z.ZodLiteral<"tool-call">;
    toolName: z.ZodString;
}, z.core.$strict>;
/**
 * Runtime-owned subagent-call request surfaced by a harness and executed later
 * by workflow-backed runtime code.
 */
export type RuntimeSubagentCallActionRequest = z.infer<typeof runtimeSubagentCallActionRequestSchema>;
/**
 * Zod schema for one runtime-owned subagent-call action request.
 */
declare const runtimeSubagentCallActionRequestSchema: z.ZodObject<{
    callId: z.ZodString;
    description: z.ZodString;
    input: z.ZodType<import("../../shared/json.ts").JsonObject, unknown, z.core.$ZodTypeInternals<import("../../shared/json.ts").JsonObject, unknown>>;
    kind: z.ZodLiteral<"subagent-call">;
    name: z.ZodString;
    nodeId: z.ZodString;
    subagentName: z.ZodString;
}, z.core.$strict>;
/**
 * Runtime-owned remote-agent-call request surfaced by a harness and executed
 * later by workflow-backed runtime code.
 */
export type RuntimeRemoteAgentCallActionRequest = z.infer<typeof runtimeRemoteAgentCallActionRequestSchema>;
/**
 * Zod schema for one runtime-owned remote-agent-call action request.
 */
export declare const runtimeRemoteAgentCallActionRequestSchema: z.ZodObject<{
    callId: z.ZodString;
    description: z.ZodString;
    input: z.ZodType<import("../../shared/json.ts").JsonObject, unknown, z.core.$ZodTypeInternals<import("../../shared/json.ts").JsonObject, unknown>>;
    kind: z.ZodLiteral<"remote-agent-call">;
    name: z.ZodString;
    nodeId: z.ZodString;
    remoteAgentName: z.ZodString;
}, z.core.$strict>;
/**
 * Eve-owned `load-skill` action requested by the model.
 */
type RuntimeLoadSkillActionRequest = z.infer<typeof runtimeLoadSkillActionRequestSchema>;
/**
 * Zod schema for one Eve-owned `load-skill` action request.
 */
declare const runtimeLoadSkillActionRequestSchema: z.ZodObject<{
    callId: z.ZodString;
    input: z.ZodType<import("../../shared/json.ts").JsonObject, unknown, z.core.$ZodTypeInternals<import("../../shared/json.ts").JsonObject, unknown>>;
    kind: z.ZodLiteral<"load-skill">;
}, z.core.$strict>;
/**
 * Eve-owned action request surfaced by the harness.
 *
 * A `tool-call` is one action kind, alongside control-plane work such as
 * `load-skill` and runtime-dispatched subagent calls.
 */
export type RuntimeActionRequest = RuntimeLoadSkillActionRequest | RuntimeRemoteAgentCallActionRequest | RuntimeSubagentCallActionRequest | RuntimeToolCallActionRequest;
/**
 * Zod schema for one runtime action request.
 */
export declare const runtimeActionRequestSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
    callId: z.ZodString;
    input: z.ZodType<import("../../shared/json.ts").JsonObject, unknown, z.core.$ZodTypeInternals<import("../../shared/json.ts").JsonObject, unknown>>;
    kind: z.ZodLiteral<"load-skill">;
}, z.core.$strict>, z.ZodObject<{
    callId: z.ZodString;
    description: z.ZodString;
    input: z.ZodType<import("../../shared/json.ts").JsonObject, unknown, z.core.$ZodTypeInternals<import("../../shared/json.ts").JsonObject, unknown>>;
    kind: z.ZodLiteral<"remote-agent-call">;
    name: z.ZodString;
    nodeId: z.ZodString;
    remoteAgentName: z.ZodString;
}, z.core.$strict>, z.ZodObject<{
    callId: z.ZodString;
    description: z.ZodString;
    input: z.ZodType<import("../../shared/json.ts").JsonObject, unknown, z.core.$ZodTypeInternals<import("../../shared/json.ts").JsonObject, unknown>>;
    kind: z.ZodLiteral<"subagent-call">;
    name: z.ZodString;
    nodeId: z.ZodString;
    subagentName: z.ZodString;
}, z.core.$strict>, z.ZodObject<{
    callId: z.ZodString;
    input: z.ZodType<import("../../shared/json.ts").JsonObject, unknown, z.core.$ZodTypeInternals<import("../../shared/json.ts").JsonObject, unknown>>;
    kind: z.ZodLiteral<"tool-call">;
    toolName: z.ZodString;
}, z.core.$strict>], "kind">;
/**
 * Runtime-owned authored tool-result projected back into a harness resume call.
 */
export type RuntimeToolResultActionResult = z.infer<typeof runtimeToolResultActionResultSchema>;
/**
 * Zod schema for one runtime-owned authored tool-result action result.
 */
declare const runtimeToolResultActionResultSchema: z.ZodObject<{
    callId: z.ZodString;
    isError: z.ZodOptional<z.ZodBoolean>;
    kind: z.ZodLiteral<"tool-result">;
    output: z.ZodType<import("../../shared/json.ts").JsonValue, unknown, z.core.$ZodTypeInternals<import("../../shared/json.ts").JsonValue, unknown>>;
    toolName: z.ZodString;
}, z.core.$strict>;
/**
 * Subagent result produced by a dispatched child session and delivered back
 * through the parent's resume hook.
 *
 * Results bind to the pending call by callId alone: possession of the
 * parent's callback token is the authorization to settle, so no further
 * identity verification happens here. Under the accepted at-least-once
 * dispatch window a replay-orphaned duplicate child holds the same token
 * and callId and may settle the call in place of the owned child — its
 * output is computed from the same input, and this is an accepted
 * trade-off, not an oversight.
 *
 * `outcome` is the child engine's explicit lifecycle verdict for the settled
 * turn. The parent settles the agent handle from `outcome.kind` and folds
 * `outcome.usageDelta` into its session totals; `output`/`isError` remain
 * the tool-result projection shown to the model. Every producer states the
 * envelope explicitly — task-mode boundaries synthesize a terminal one —
 * so the parent never infers lifecycle from an absent field. `usage`
 * carries the turn's token spend so the caller can attribute the
 * subagent's tokens.
 */
export type RuntimeSubagentChildResult = z.infer<typeof runtimeSubagentChildResultSchema>;
/**
 * Zod schema for one child-produced subagent result.
 */
declare const runtimeSubagentChildResultSchema: z.ZodObject<{
    callId: z.ZodString;
    isError: z.ZodOptional<z.ZodBoolean>;
    kind: z.ZodLiteral<"subagent-result">;
    origin: z.ZodLiteral<"child">;
    outcome: z.ZodType<import("#shared/agent-turn-outcome.js").AgentTurnOutcome, unknown, z.core.$ZodTypeInternals<import("#shared/agent-turn-outcome.js").AgentTurnOutcome, unknown>>;
    output: z.ZodType<import("../../shared/json.ts").JsonValue, unknown, z.core.$ZodTypeInternals<import("../../shared/json.ts").JsonValue, unknown>>;
    subagentName: z.ZodString;
    usage: z.ZodOptional<z.ZodObject<{
        cacheReadTokens: z.ZodNumber;
        cacheWriteTokens: z.ZodNumber;
        inputTokens: z.ZodNumber;
        outputTokens: z.ZodNumber;
    }, z.core.$strip>>;
}, z.core.$strict>;
/**
 * Subagent failure synthesized on the parent side when no child produced a
 * result: dispatch rejections, start failures, and agentId-continuation
 * delivery errors. Always an error. Enters the harness only through the
 * trusted step-result path, never through the shared callback inbox.
 */
export type RuntimeSubagentDispatchFailure = z.infer<typeof runtimeSubagentDispatchFailureSchema>;
/**
 * Zod schema for one parent-synthesized subagent dispatch failure.
 */
declare const runtimeSubagentDispatchFailureSchema: z.ZodObject<{
    callId: z.ZodString;
    isError: z.ZodLiteral<true>;
    kind: z.ZodLiteral<"subagent-result">;
    origin: z.ZodLiteral<"dispatch">;
    output: z.ZodType<import("../../shared/json.ts").JsonValue, unknown, z.core.$ZodTypeInternals<import("../../shared/json.ts").JsonValue, unknown>>;
    subagentName: z.ZodString;
}, z.core.$strict>;
/**
 * Runtime-owned subagent result projected back into a harness resume call,
 * discriminated on `origin`: `child` results come from a dispatched child
 * session and must bind to a running agent handle; `dispatch` failures are
 * parent-synthesized and trusted by construction.
 */
export type RuntimeSubagentResult = RuntimeSubagentChildResult | RuntimeSubagentDispatchFailure;
/**
 * Runtime-owned action result produced by framework-owned loading code.
 */
type RuntimeLoadSkillActionResult = z.infer<typeof runtimeLoadSkillActionResultSchema>;
/**
 * Zod schema for one runtime-owned load-skill action result.
 *
 * The result still reports whether a skill became active during the turn; the
 * action name reflects how the model requests those instructions.
 */
declare const runtimeLoadSkillActionResultSchema: z.ZodObject<{
    callId: z.ZodString;
    isError: z.ZodOptional<z.ZodBoolean>;
    kind: z.ZodLiteral<"load-skill-result">;
    output: z.ZodType<import("../../shared/json.ts").JsonValue, unknown, z.core.$ZodTypeInternals<import("../../shared/json.ts").JsonValue, unknown>>;
    name: z.ZodOptional<z.ZodString>;
}, z.core.$strict>;
/**
 * Runtime-owned action result produced by framework-owned runtime code.
 */
export type RuntimeActionResult = RuntimeLoadSkillActionResult | RuntimeSubagentResult | RuntimeToolResultActionResult;
export {};