/**
 * Background tool-runs transport — the `/api/tool-runs*` surface.
 *
 * This is a SELF-CONTAINED api-client module (its own zod, not the shared
 * `schemas.ts`), so the tools feature owns these wire types end to end. The
 * `createApiClient` object wires three thin methods onto it (`submitToolRun`,
 * `getToolRun`, `listToolRuns`) since only it holds the `ApiConfig` (base URL +
 * auth token).
 *
 * The background surface detaches a run from its HTTP request: submit returns a
 * `run_id` immediately (202), then the caller POLLS the single-run GET until the
 * status is terminal (`succeeded | failed | lost | parked`). The list GET returns
 * the recent runs for one tool — id/status/timestamps only, never `result`/`error`.
 */
import { z } from 'zod';
import type { ApiConfig } from './http';
import type { StateSubject } from './schemas/states';
/** A run's lifecycle state. `lost` = the server restarted mid-run; the result is
 * unrecoverable. `parked` = the run's tool async-parked; its `result` is the park
 * answer (see {@link toolRunParkAnswer}). `running` is the only non-terminal state. */
export declare const toolRunStatus: z.ZodEnum<{
    running: "running";
    failed: "failed";
    parked: "parked";
    succeeded: "succeeded";
    lost: "lost";
}>;
/** `POST /api/tool-runs` → the handle for the detached run. */
export declare const toolRunSubmitResult: z.ZodObject<{
    run_id: z.ZodString;
}, z.core.$strip>;
/** `GET /api/tool-runs/{run_id}` → the full record. `result` is arbitrary JSON: the
 * tool's own value on `succeeded`, the park answer ({@link toolRunParkAnswer}) on
 * `parked`. `error` is present only on `failed`. `resumed_interactions` is the parked
 * interaction ids the run resumed or took while it executed (`[]` when it resumed none). */
export declare const toolRunRecord: z.ZodObject<{
    run_id: z.ZodString;
    tool_name: z.ZodString;
    status: z.ZodEnum<{
        running: "running";
        failed: "failed";
        parked: "parked";
        succeeded: "succeeded";
        lost: "lost";
    }>;
    started_at: z.ZodString;
    finished_at: z.ZodOptional<z.ZodString>;
    result: z.ZodOptional<z.ZodUnknown>;
    error: z.ZodOptional<z.ZodString>;
    resumed_interactions: z.ZodOptional<z.ZodArray<z.ZodString>>;
}, z.core.$strip>;
/** One entry of `GET /api/tool-runs?tool_name=...` — id/status/timestamps only,
 * deliberately carrying NO `result`/`error` (the list is not secret-bearing). */
export declare const toolRunListItem: z.ZodObject<{
    run_id: z.ZodString;
    tool_name: z.ZodString;
    status: z.ZodEnum<{
        running: "running";
        failed: "failed";
        parked: "parked";
        succeeded: "succeeded";
        lost: "lost";
    }>;
    started_at: z.ZodString;
    finished_at: z.ZodOptional<z.ZodString>;
}, z.core.$strip>;
export declare const toolRunList: z.ZodArray<z.ZodObject<{
    run_id: z.ZodString;
    tool_name: z.ZodString;
    status: z.ZodEnum<{
        running: "running";
        failed: "failed";
        parked: "parked";
        succeeded: "succeeded";
        lost: "lost";
    }>;
    started_at: z.ZodString;
    finished_at: z.ZodOptional<z.ZodString>;
}, z.core.$strip>>;
/**
 * The `result` a `parked` record carries — the SAME park answer the synchronous run-tool
 * door returns: either the caller-ask envelope `{asks: [...]}` (the tool asked its CALLER
 * and parked) or the suspension receipt (the run parked only USER asks, ids only). A poller
 * reads it to tell a caller-ask park from a user-only one, exactly as the sync door's caller does.
 */
export declare const toolRunParkAnswer: z.ZodUnion<readonly [z.ZodObject<{
    asks: z.ZodArray<z.ZodObject<{
        id: z.ZodString;
        status: z.ZodEnum<{
            running: "running";
            failed: "failed";
            asking: "asking";
            finished: "finished";
        }>;
        to: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
            user: "user";
            caller: "caller";
        }>>>;
        question: z.ZodOptional<z.ZodNullable<z.ZodString>>;
        payload: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
        asked_by: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
    }, z.core.$strip>>;
}, z.core.$strip>, z.ZodObject<{
    interaction_id: z.ZodString;
    interaction_ids: z.ZodArray<z.ZodString>;
    caller_interaction_ids: z.ZodDefault<z.ZodArray<z.ZodString>>;
}, z.core.$strip>]>;
export type ToolRunStatus = z.infer<typeof toolRunStatus>;
export type ToolRunParkAnswer = z.infer<typeof toolRunParkAnswer>;
export type ToolRunSubmitResult = z.infer<typeof toolRunSubmitResult>;
export type ToolRunRecord = z.infer<typeof toolRunRecord>;
export type ToolRunListItem = z.infer<typeof toolRunListItem>;
/** Body for `POST /api/tool-runs`. */
export interface SubmitToolRunArgs {
    readonly tool_name: string;
    readonly arguments?: Record<string, unknown>;
    /** The addressed subject an async park of the detached run indexes under. Omitted
     * from the request body when unset. */
    readonly subject?: StateSubject;
}
/** Submit a tool for detached background execution; resolves with its `run_id`. */
export declare function submitToolRun(config: ApiConfig, args: SubmitToolRunArgs, signal?: AbortSignal): Promise<ToolRunSubmitResult>;
/** Read one background run's current record (the poll target). */
export declare function getToolRun(config: ApiConfig, runId: string, signal?: AbortSignal): Promise<ToolRunRecord>;
/** List the recent background runs for one tool (newest first). */
export declare function listToolRuns(config: ApiConfig, toolName: string, signal?: AbortSignal): Promise<ToolRunListItem[]>;
/** Whether a run has reached a terminal state (polling stops here). */
export declare function isTerminalRunStatus(status: ToolRunStatus): boolean;
//# sourceMappingURL=tool-runs.d.ts.map