@suwujs/king-ai 0.2.0

package/dist/src/host-runs.js

@@ -0,0 +1,195 @@
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { dirname } from "node:path";
+import { HOST_RUNS_PATH } from "./paths.js";
+import { createHostLaunchPlan, formatHostLaunchPlanSummary, toJsonSafeHostLaunchPlan } from "./host-run-spec.js";
+export async function submitHostRunRequest(input, options = {}) {
+    const createdAt = (options.now ?? (() => new Date()))().toISOString();
+    const launchPlan = createHostLaunchPlan(input, options.env ?? process.env, options.availableEngines);
+    const request = {
+        id: cleanId(input.requestId) || launchPlan.runId,
+        status: "pending",
+        createdAt,
+        spec: input,
+        ready: launchPlan.ready,
+        effectiveEngine: launchPlan.effectiveEngine,
+        summary: formatHostLaunchPlanSummary(launchPlan),
+        executor: normalizeExecutor(input.executor)
+    };
+    await appendHostRunRequest(request, options.path);
+    return {
+        request,
+        launchPlan: toJsonSafeHostLaunchPlan(launchPlan),
+        summary: formatHostRunRequestSummary(request)
+    };
+}
+export async function listHostRunRequests(input = {}, path = HOST_RUNS_PATH) {
+    const limit = normalizeLimit(input.limit);
+    const requests = await readMergedHostRunRequests(path);
+    const status = normalizeStatus(input.status, true);
+    const filtered = status ? requests.filter((request) => request.status === status) : requests;
+    return filtered.slice(-limit).reverse();
+}
+export async function getHostRunRequest(input, path = HOST_RUNS_PATH) {
+    const id = cleanRequiredId(input.id, "run request id");
+    const requests = await readMergedHostRunRequests(path);
+    return requests.find((request) => request.id === id) ?? null;
+}
+export async function updateHostRunRequest(input, options = {}) {
+    const id = cleanRequiredId(input.id, "run request id");
+    const status = normalizeStatus(input.status, false);
+    const existing = await getHostRunRequest({ id }, options.path);
+    if (!existing)
+        throw new Error(`host run request not found: ${id}`);
+    const update = {
+        id,
+        status,
+        updatedAt: (options.now ?? (() => new Date()))().toISOString(),
+        detail: cleanString(input.detail),
+        result: normalizeExecutionResult(input.result)
+    };
+    await appendHostRunRecord(update, options.path);
+    const request = applyHostRunUpdate(existing, update);
+    return {
+        request,
+        summary: formatHostRunRequestSummary(request)
+    };
+}
+export function formatHostRunRequests(requests) {
+    if (requests.length === 0)
+        return "no host run requests";
+    return requests.map(formatHostRunRequestSummary).join("\n\n");
+}
+export function formatHostRunRequestSummary(request) {
+    return [
+        `host run request: ${request.id} ${request.status}`,
+        `created: ${request.createdAt}`,
+        request.updatedAt ? `updated: ${request.updatedAt}` : "",
+        `ready: ${request.ready ? "yes" : "no"}`,
+        `effective engine: ${request.effectiveEngine ?? "(none)"}`,
+        request.detail ? `detail: ${request.detail}` : "",
+        request.executor ? `executor: ${request.executor.kind} ${request.executor.command}` : "",
+        request.result ? `result: ${request.result.command} ${request.result.ok ? "ok" : "failed"} exit=${request.result.exitCode}` : "",
+        request.summary
+    ].filter(Boolean).join("\n");
+}
+async function appendHostRunRequest(request, path = HOST_RUNS_PATH) {
+    await appendHostRunRecord(request, path);
+}
+async function appendHostRunRecord(record, path = HOST_RUNS_PATH) {
+    await mkdir(dirname(path), { recursive: true });
+    await writeFile(path, `${JSON.stringify(record)}\n`, { encoding: "utf8", flag: "a" });
+}
+async function readMergedHostRunRequests(path = HOST_RUNS_PATH) {
+    const text = await readFile(path, "utf8").catch((err) => {
+        if (err && typeof err === "object" && "code" in err && err.code === "ENOENT")
+            return "";
+        throw err;
+    });
+    const byId = new Map();
+    for (const line of text.split(/\r?\n/).map((entry) => entry.trim()).filter(Boolean)) {
+        const parsed = JSON.parse(line);
+        if (isHostRunRequest(parsed)) {
+            byId.set(parsed.id, parsed);
+            continue;
+        }
+        if (isHostRunRequestUpdate(parsed)) {
+            const existing = byId.get(parsed.id);
+            if (existing)
+                byId.set(parsed.id, applyHostRunUpdate(existing, parsed));
+        }
+    }
+    return [...byId.values()];
+}
+function applyHostRunUpdate(request, update) {
+    return {
+        ...request,
+        status: update.status,
+        updatedAt: update.updatedAt,
+        detail: update.detail ?? request.detail,
+        result: update.result ?? request.result
+    };
+}
+function normalizeLimit(value) {
+    if (value === undefined)
+        return 20;
+    const limit = typeof value === "number" ? value : Number.parseInt(String(value), 10);
+    if (!Number.isFinite(limit) || limit < 1)
+        throw new Error("host run request limit must be a positive integer");
+    return Math.floor(limit);
+}
+function cleanId(value) {
+    if (typeof value !== "string" || !value.trim())
+        return undefined;
+    return value.trim().replace(/[^a-zA-Z0-9_.:-]+/g, "-").slice(0, 80);
+}
+function cleanRequiredId(value, label) {
+    const id = cleanId(value);
+    if (!id)
+        throw new Error(`${label} is required`);
+    return id;
+}
+function cleanString(value) {
+    if (typeof value !== "string" || !value.trim())
+        return undefined;
+    return value.trim().slice(0, 1000);
+}
+function normalizeExecutor(value) {
+    if (!value || typeof value !== "object")
+        return undefined;
+    const executor = value;
+    if (executor.kind !== "host-command")
+        return undefined;
+    const command = cleanString(executor.command);
+    if (!command)
+        return undefined;
+    return {
+        kind: "host-command",
+        command,
+        input: executor.input,
+        format: executor.format === "json" ? "json" : "text",
+        actorRole: cleanString(executor.actorRole),
+        trusted: executor.trusted === true
+    };
+}
+function normalizeExecutionResult(value) {
+    if (!value || typeof value !== "object")
+        return undefined;
+    const result = value;
+    const command = cleanString(result.command);
+    if (!command || typeof result.ok !== "boolean")
+        return undefined;
+    const exitCode = Number(result.exitCode);
+    return {
+        command,
+        ok: result.ok,
+        exitCode: Number.isFinite(exitCode) ? Math.floor(exitCode) : result.ok ? 0 : 1,
+        textPreview: cleanString(result.textPreview),
+        error: cleanString(result.error)
+    };
+}
+function normalizeStatus(value, allowPending) {
+    if (value === undefined)
+        return undefined;
+    if (value === "pending" && allowPending)
+        return value;
+    if (value === "running" || value === "completed" || value === "failed" || value === "cancelled")
+        return value;
+    throw new Error(`host run request status must be ${allowPending ? "pending, " : ""}running, completed, failed, or cancelled`);
+}
+function isHostRunRequest(value) {
+    return Boolean(value) &&
+        typeof value === "object" &&
+        typeof value.id === "string" &&
+        value.status === "pending" &&
+        typeof value.createdAt === "string" &&
+        typeof value.ready === "boolean" &&
+        typeof value.summary === "string";
+}
+function isHostRunRequestUpdate(value) {
+    const status = value?.status;
+    return Boolean(value) &&
+        typeof value === "object" &&
+        typeof value.id === "string" &&
+        typeof value.updatedAt === "string" &&
+        (status === "running" || status === "completed" || status === "failed" || status === "cancelled");
+}

package/dist/src/host-sdk.d.ts

@@ -0,0 +1,412 @@
+import type { HostStatusSnapshot } from "./host-api.js";
+import type { HostCommandDefinition, HostCommandRequest, HostCommandResult } from "./host-control.js";
+import type { DoctorResult } from "./daemon.js";
+import type { HostExportInput, HostExportPlan, HostExportResult } from "./host-export.js";
+import type { HostLoopEvent, HostLoopEventsInput, HostLoopEventsResult, HostLoopResultsInput, HostLoopResultsTable } from "./host-loop-events.js";
+import type { HostRunExecuteResult } from "./host-run-executor.js";
+import type { HostRunHeartbeatReadInput, HostRunHeartbeatReadResult } from "./host-run-heartbeat.js";
+import type { HostRunMetaReadInput, HostRunMetaReadResult } from "./host-run-meta.js";
+import type { HostRunLayoutResult } from "./host-run-layout.js";
+import type { HostPolicyCheck } from "./host-policy.js";
+import type { HostRunSpecInput, JsonSafeHostLaunchPlan, ProjectRunSpec, ThreadSyncSpec } from "./host-run-spec.js";
+import type { HostRunRequest, HostRunRequestStatus, HostRunSubmitInput, HostRunSubmitResult, HostRunUpdateResult } from "./host-runs.js";
+import type { HostTimelineEvent } from "./host-timeline.js";
+import type { EngineId } from "./types.js";
+import type { UsageExpenseRow, UsageSummary } from "./usage.js";
+export interface HostSdkOptions {
+    baseUrl?: string;
+    fetch?: typeof fetch;
+}
+export type HostSdkEnvLike = Partial<Record<string, string | undefined>>;
+export interface KingHostSdkConfig extends HostSdkOptions {
+    env?: HostSdkEnvLike;
+}
+export interface HostSdkEnvOptions extends Omit<HostSdkOptions, "baseUrl"> {
+    env?: HostSdkEnvLike;
+}
+export interface HostSdkLocationLike {
+    protocol: string;
+    hostname: string;
+    port?: string;
+    origin?: string;
+}
+export interface HostSdkBrowserOptions extends HostSdkOptions {
+    location?: HostSdkLocationLike;
+    port?: number | string;
+    useCurrentOrigin?: boolean;
+}
+export interface HostSdkWaitOptions {
+    timeoutMs?: number;
+    intervalMs?: number;
+    requireDaemon?: boolean;
+}
+export interface HostSdkWaitForRunOptions {
+    timeoutMs?: number;
+    intervalMs?: number;
+    terminalStatuses?: HostRunRequestStatus[];
+}
+export interface HostSdkStatusStreamOptions {
+    intervalMs?: number;
+    signal?: AbortSignal;
+}
+export interface HostSdkTimelineStreamOptions {
+    intervalMs?: number;
+    limit?: number;
+    signal?: AbortSignal;
+}
+export interface HostSdkRunRequestsStreamOptions {
+    intervalMs?: number;
+    limit?: number;
+    status?: HostRunRequestStatus;
+    signal?: AbortSignal;
+}
+export interface HostSdkRunRequestStreamOptions {
+    intervalMs?: number;
+    signal?: AbortSignal;
+}
+export interface HostSdkRunEventsOptions extends Omit<HostLoopEventsInput, "id"> {
+}
+export interface HostSdkRunEventEmitInput extends HostLoopEvent {
+    payload?: unknown;
+}
+export interface HostSdkRunResultsOptions extends Omit<HostLoopResultsInput, "id"> {
+}
+export interface HostSdkRunHeartbeatOptions extends Omit<HostRunHeartbeatReadInput, "id"> {
+}
+export interface HostSdkRunMetaOptions extends Omit<HostRunMetaReadInput, "id"> {
+}
+export interface HostSdkRunStateFrame {
+    request: HostRunRequest | null;
+    heartbeat: HostRunHeartbeatReadResult["heartbeat"];
+    meta: HostRunMetaReadResult["meta"];
+}
+export interface HostSdkHostStreamOptions {
+    intervalMs?: number;
+    limit?: number;
+    timelineLimit?: number;
+    runLimit?: number;
+    status?: HostRunRequestStatus;
+    signal?: AbortSignal;
+}
+export interface HostSdkWatchOptions extends HostSdkHostStreamOptions {
+    includeInitialSnapshot?: boolean;
+}
+export type HostSdkStreamFrame = {
+    event: "status";
+    data: HostStatusSnapshot;
+} | {
+    event: "timeline";
+    data: HostTimelineEvent[];
+} | {
+    event: "runs";
+    data: HostRunRequest[];
+};
+export type HostSdkWatchFrame = {
+    event: "snapshot";
+    data: HostSnapshotResponse;
+} | HostSdkStreamFrame;
+export interface HostSdkRunOptions {
+    loops?: number;
+    pollInterval?: number;
+    pollIntervalSeconds?: number;
+    infinite?: boolean;
+    runtime?: EngineId;
+    engine?: EngineId;
+    codexModel?: string;
+    model?: string;
+    fastModel?: string;
+    codexReasoningEffort?: "low" | "medium" | "high" | "xhigh";
+    configPath?: string;
+    workerUrl?: string;
+    workerModel?: string;
+    workerKey?: string;
+    noBrain?: boolean;
+    enableBrain?: boolean;
+    projectDir?: string;
+    repoSourceDir?: string;
+    repoCloneUrl?: string;
+    workspaceRoot?: string;
+    gitRoot?: string;
+    outputDir?: string;
+    output?: string;
+    keepArtifacts?: boolean;
+    keep?: boolean;
+    errorLimit?: number;
+}
+export interface HostSdkTakeoverOptions extends HostSdkRunOptions {
+    projectPath?: string;
+    goalOverride?: string;
+}
+export type RunOptions = HostSdkRunOptions;
+export type { ProjectRunSpec, ThreadSyncSpec };
+export type KingHostRunOptions = HostSdkRunOptions;
+export type KingHostRunInvocation = HostSdkRunOptions;
+export type KingHostTakeoverOptions = HostSdkTakeoverOptions;
+export interface KingHostSdkBindings {
+    hostEnv: HostSdkEnvLike;
+}
+export interface KingHostSdkAdapters<TProjectRunSpec, TPreparedTakeoverPlan, TConcreteTakeoverOptions extends object> {
+    runGoal(goal: string, options: HostSdkRunOptions, spec: TProjectRunSpec, bindings: KingHostSdkBindings): Promise<void>;
+    prepareTakeoverPlan(options: TConcreteTakeoverOptions): TPreparedTakeoverPlan;
+    executePreparedTakeoverPlan(plan: TPreparedTakeoverPlan, options: HostSdkRunOptions, bindings: KingHostSdkBindings): Promise<void>;
+    normalizeTakeoverOptions(options: TConcreteTakeoverOptions | KingHostTakeoverOptions): TConcreteTakeoverOptions;
+}
+export interface HostHealth {
+    ok: boolean;
+    service: string;
+    readOnly: boolean;
+    commands: string[];
+}
+export interface HostCommandsResponse {
+    ok: boolean;
+    commands: HostCommandDefinition[];
+}
+export interface HostCapabilitiesResponse extends HostCommandsResponse {
+    service: string;
+    readOnly: boolean;
+    localhostOnly: boolean;
+    cors?: {
+        enabled: boolean;
+        allowedOrigins: string[];
+    };
+    resources: string[];
+    streams: string[];
+    safeExecutorCommands: string[];
+    destructiveCommands: string[];
+    commandEnvelope: {
+        path: string;
+        method: string;
+    };
+}
+export interface HostEventsResponse {
+    ok: boolean;
+    events: HostStatusSnapshot["events"];
+}
+export interface HostTimelineResponse {
+    events: HostTimelineEvent[];
+}
+export interface HostSnapshotResponse {
+    ok: boolean;
+    status: HostStatusSnapshot;
+    capabilities: HostCapabilitiesResponse;
+    timeline: HostTimelineEvent[];
+    runs: HostRunRequest[];
+}
+export interface HostDoctorResponse {
+    results: DoctorResult[];
+    exitCode: number;
+}
+export interface HostExpensesResponse {
+    expenses: UsageExpenseRow[];
+    usage: UsageSummary;
+}
+export interface HostRunRequestsResponse {
+    requests: HostRunRequest[];
+}
+export interface HostRunRequestResponse {
+    request: HostRunRequest;
+}
+export interface HostSdkPrepareRunLayoutInput extends HostRunSpecInput {
+    force?: boolean;
+    confirmed?: boolean;
+    confirmation?: string;
+}
+export interface HostSdkSubmitAndExecuteResult {
+    submitted: HostCommandResult & {
+        json?: HostRunSubmitResult;
+    };
+    executed: HostCommandResult & {
+        json?: HostRunExecuteResult;
+    };
+}
+export interface HostSdkPreparedTakeover {
+    options: HostSdkTakeoverOptions;
+    runOptions: HostSdkRunOptions;
+    input: HostRunSpecInput;
+    preflight: HostCommandResult & {
+        json?: JsonSafeHostLaunchPlan;
+    };
+}
+export interface HostSdkSubmitAndWatchOptions extends HostSdkRunRequestStreamOptions {
+    terminalStatuses?: HostRunRequestStatus[];
+}
+export type HostSdkSubmitAndWatchFrame = {
+    event: "submitted";
+    data: HostCommandResult & {
+        json?: HostRunSubmitResult;
+    };
+} | {
+    event: "run";
+    data: HostRunRequest | null;
+};
+export type HostSdkSubmitAndWatchStateFrame = {
+    event: "submitted";
+    data: HostCommandResult & {
+        json?: HostRunSubmitResult;
+    };
+} | {
+    event: "state";
+    data: HostSdkRunStateFrame;
+};
+export type HostSdk = ReturnType<typeof createHostSdk>;
+export interface KingAdapterHostSdk<TProjectRunSpec = unknown, TPreparedTakeoverPlan = unknown, TTakeoverInvocation = KingHostTakeoverOptions> {
+    run(goal: string, options?: KingHostRunInvocation, spec?: TProjectRunSpec): Promise<void>;
+    prepareTakeover(options: TTakeoverInvocation): TPreparedTakeoverPlan;
+    executePreparedTakeover(plan: TPreparedTakeoverPlan, options?: KingHostRunInvocation): Promise<void>;
+    takeover(options: TTakeoverInvocation, runOptions?: KingHostRunInvocation): Promise<void>;
+}
+export type KingHostSdk<TProjectRunSpec = unknown, TPreparedTakeoverPlan = unknown, TTakeoverInvocation = KingHostTakeoverOptions> = HostSdk | KingAdapterHostSdk<TProjectRunSpec, TPreparedTakeoverPlan, TTakeoverInvocation>;
+export declare function createDefaultHostSdkRunOptions(overrides?: HostSdkRunOptions): HostSdkRunOptions;
+export declare function createHostSdkRunOptions(overrides?: HostSdkRunOptions): HostSdkRunOptions;
+export declare function createHostSdkTakeoverRunOptions(overrides?: HostSdkRunOptions): HostSdkRunOptions;
+export declare const createDefaultRunOptions: typeof createDefaultHostSdkRunOptions;
+export declare const createRunOptions: typeof createHostSdkRunOptions;
+export declare const createTakeoverRunOptions: typeof createHostSdkTakeoverRunOptions;
+export declare function createHostSdk(options?: HostSdkOptions): {
+    health: () => Promise<HostHealth>;
+    status: () => Promise<HostStatusSnapshot>;
+    statusStream: (streamOptions?: HostSdkStatusStreamOptions) => AsyncGenerator<HostStatusSnapshot, any, any>;
+    events: () => Promise<HostEventsResponse>;
+    usage: () => Promise<HostCommandResult & {
+        json?: UsageSummary;
+    }>;
+    expenses: () => Promise<HostCommandResult & {
+        json?: HostExpensesResponse;
+    }>;
+    doctor: () => Promise<HostCommandResult & {
+        json?: HostDoctorResponse;
+    }>;
+    commands: () => Promise<HostCommandsResponse>;
+    capabilities: () => Promise<HostCapabilitiesResponse>;
+    snapshot: (limit?: number, status?: HostRunRequestStatus) => Promise<HostSnapshotResponse>;
+    waitForReady: (waitOptions?: HostSdkWaitOptions) => Promise<HostStatusSnapshot>;
+    watch: (watchOptions?: HostSdkWatchOptions) => AsyncGenerator<HostSdkWatchFrame, any, any>;
+    hostStream: (streamOptions?: HostSdkHostStreamOptions) => AsyncGenerator<HostSdkStreamFrame, any, any>;
+    timelineStream: (streamOptions?: HostSdkTimelineStreamOptions) => AsyncGenerator<HostTimelineEvent[], any, any>;
+    run: (goal: string, options?: HostSdkRunOptions, spec?: Partial<HostRunSpecInput>) => Promise<HostCommandResult & {
+        json?: JsonSafeHostLaunchPlan;
+    }>;
+    runAndWatch: (goal: string, options?: HostSdkRunOptions, spec?: Partial<HostRunSubmitInput>, watchOptions?: HostSdkSubmitAndWatchOptions) => AsyncGenerator<HostSdkSubmitAndWatchFrame, any, any>;
+    runAndWatchState: (goal: string, options?: HostSdkRunOptions, spec?: Partial<HostRunSubmitInput>, watchOptions?: HostSdkSubmitAndWatchOptions) => AsyncGenerator<HostSdkSubmitAndWatchStateFrame, any, any>;
+    takeover: (options: HostSdkTakeoverOptions, runOptions?: HostSdkRunOptions) => Promise<HostCommandResult & {
+        json?: JsonSafeHostLaunchPlan;
+    }>;
+    prepareTakeover: (options: HostSdkTakeoverOptions, runOptions?: HostSdkRunOptions) => Promise<HostSdkPreparedTakeover>;
+    executePreparedTakeover: (prepared: HostSdkPreparedTakeover, spec?: Partial<HostRunSubmitInput>, watchOptions?: HostSdkSubmitAndWatchOptions) => AsyncGenerator<HostSdkSubmitAndWatchFrame, any, any>;
+    executePreparedTakeoverState: (prepared: HostSdkPreparedTakeover, spec?: Partial<HostRunSubmitInput>, watchOptions?: HostSdkSubmitAndWatchOptions) => AsyncGenerator<HostSdkSubmitAndWatchStateFrame, any, any>;
+    takeoverAndWatch: (options: HostSdkTakeoverOptions, runOptions?: HostSdkRunOptions, spec?: Partial<HostRunSubmitInput>, watchOptions?: HostSdkSubmitAndWatchOptions) => AsyncGenerator<HostSdkSubmitAndWatchFrame, any, any>;
+    takeoverAndWatchState: (options: HostSdkTakeoverOptions, runOptions?: HostSdkRunOptions, spec?: Partial<HostRunSubmitInput>, watchOptions?: HostSdkSubmitAndWatchOptions) => AsyncGenerator<HostSdkSubmitAndWatchStateFrame, any, any>;
+    runCommand: <TJson = unknown>(request: HostCommandRequest) => Promise<HostCommandResult & {
+        json?: TJson | undefined;
+    }>;
+    planRun: (input: HostRunSpecInput) => Promise<HostCommandResult & {
+        json?: JsonSafeHostLaunchPlan;
+    }>;
+    preflight: (input: HostRunSpecInput) => Promise<HostCommandResult & {
+        json?: JsonSafeHostLaunchPlan;
+    }>;
+    prepareRunLayout: (input: HostSdkPrepareRunLayoutInput) => Promise<HostCommandResult & {
+        json?: HostRunLayoutResult;
+    }>;
+    submitRun: (input: HostRunSubmitInput) => Promise<HostCommandResult & {
+        json?: HostRunSubmitResult;
+    }>;
+    submitAndExecuteRun: (input: HostRunSubmitInput) => Promise<HostSdkSubmitAndExecuteResult>;
+    submitAndWatchRun: (input: HostRunSubmitInput, watchOptions?: HostSdkSubmitAndWatchOptions) => AsyncGenerator<HostSdkSubmitAndWatchFrame, any, any>;
+    submitAndWatchRunState: (input: HostRunSubmitInput, watchOptions?: HostSdkSubmitAndWatchOptions) => AsyncGenerator<HostSdkSubmitAndWatchStateFrame, any, any>;
+    runRequests: (limit?: number, status?: HostRunRequestStatus) => Promise<HostCommandResult & {
+        json?: HostRunRequestsResponse;
+    }>;
+    runRequestsStream: (streamOptions?: HostSdkRunRequestsStreamOptions) => AsyncGenerator<HostRunRequest[], any, any>;
+    runRequest: (id: string) => Promise<HostCommandResult & {
+        json?: HostRunRequestResponse;
+    }>;
+    runRequestStream: (id: string, streamOptions?: HostSdkRunRequestStreamOptions) => AsyncGenerator<HostRunRequest | null, any, any>;
+    runStateStream: (id: string, streamOptions?: HostSdkRunRequestStreamOptions) => AsyncGenerator<HostSdkRunStateFrame, any, any>;
+    emitRunEvent: (id: string, event: HostSdkRunEventEmitInput) => Promise<HostCommandResult & {
+        json?: {
+            file: string;
+            event: HostLoopEvent;
+        };
+    }>;
+    runEvents: (id: string, eventsOptions?: HostSdkRunEventsOptions) => Promise<HostCommandResult & {
+        json?: HostLoopEventsResult;
+    }>;
+    watchRun: (id: string, eventsOptions?: HostSdkRunEventsOptions) => Promise<HostCommandResult & {
+        json?: HostLoopEventsResult;
+    }>;
+    runResults: (id: string, resultsOptions?: HostSdkRunResultsOptions) => Promise<HostCommandResult & {
+        json?: HostLoopResultsTable;
+    }>;
+    runHeartbeat: (id: string, heartbeatOptions?: HostSdkRunHeartbeatOptions) => Promise<HostCommandResult & {
+        json?: HostRunHeartbeatReadResult;
+    }>;
+    runMeta: (id: string, metaOptions?: HostSdkRunMetaOptions) => Promise<HostCommandResult & {
+        json?: HostRunMetaReadResult;
+    }>;
+    waitForRun: (id: string, waitOptions?: HostSdkWaitForRunOptions) => Promise<HostCommandResult & {
+        json?: HostRunRequestResponse;
+    }>;
+    updateRun: (id: string, status: Exclude<HostRunRequestStatus, "pending">, detail?: string) => Promise<HostCommandResult & {
+        json?: HostRunUpdateResult;
+    }>;
+    completeRun: (id: string, detail?: string) => Promise<HostCommandResult & {
+        json?: HostRunUpdateResult;
+    }>;
+    failRun: (id: string, detail?: string) => Promise<HostCommandResult & {
+        json?: HostRunUpdateResult;
+    }>;
+    cancelRun: (id: string, detail?: string) => Promise<HostCommandResult & {
+        json?: HostRunUpdateResult;
+    }>;
+    executeRun: (id?: string) => Promise<HostCommandResult & {
+        json?: HostRunExecuteResult;
+    }>;
+    planExport: (input: HostExportInput) => Promise<HostCommandResult & {
+        json?: HostExportPlan;
+    }>;
+    exportArtifacts: (input: HostExportInput & {
+        confirmed?: boolean;
+        confirmation?: string;
+    }) => Promise<HostCommandResult & {
+        json?: HostExportResult;
+    }>;
+    policy: (command: string, input?: {
+        confirmed?: boolean;
+        confirmation?: string;
+    }) => Promise<HostCommandResult & {
+        json?: HostPolicyCheck;
+    }>;
+    timeline: (limit?: number) => Promise<HostCommandResult & {
+        json?: HostTimelineResponse;
+    }>;
+};
+export declare function createKingHostSdk(config?: HostSdkOptions): HostSdk;
+export declare function createKingHostSdk<TProjectRunSpec = unknown, TPreparedTakeoverPlan = unknown, TConcreteTakeoverOptions extends object = KingHostTakeoverOptions>(config: KingHostSdkConfig, adapters: KingHostSdkAdapters<TProjectRunSpec, TPreparedTakeoverPlan, TConcreteTakeoverOptions>): KingAdapterHostSdk<TProjectRunSpec, TPreparedTakeoverPlan, TConcreteTakeoverOptions | KingHostTakeoverOptions>;
+export declare function createEnvBackedHostSdk(env?: HostSdkEnvLike, options?: Omit<HostSdkOptions, "baseUrl">): HostSdk;
+export declare function createEnvBackedKingHostSdk(env?: HostSdkEnvLike, options?: Omit<HostSdkOptions, "baseUrl">): HostSdk;
+export declare function createEnvBackedKingHostSdk<TProjectRunSpec = unknown, TPreparedTakeoverPlan = unknown, TConcreteTakeoverOptions extends object = KingHostTakeoverOptions>(env: HostSdkEnvLike, config: Omit<KingHostSdkConfig, "env">, adapters: KingHostSdkAdapters<TProjectRunSpec, TPreparedTakeoverPlan, TConcreteTakeoverOptions>): KingAdapterHostSdk<TProjectRunSpec, TPreparedTakeoverPlan, TConcreteTakeoverOptions | KingHostTakeoverOptions>;
+export declare function createBrowserHostSdk(options?: HostSdkBrowserOptions): HostSdk;
+export declare function hostBaseUrlFromEnv(env?: HostSdkEnvLike): string;
+export declare function hostBaseUrlFromLocation(location: HostSdkLocationLike | undefined, options?: {
+    port?: number | string;
+    useCurrentOrigin?: boolean;
+}): string;
+export declare function waitForHostReady(fetchImpl: typeof fetch, baseUrl: string, options?: HostSdkWaitOptions): Promise<HostStatusSnapshot>;
+export declare function waitForHostRun(fetchImpl: typeof fetch, baseUrl: string, id: string, options?: HostSdkWaitForRunOptions): Promise<HostCommandResult & {
+    json?: HostRunRequestResponse;
+}>;
+export declare function submitAndExecuteHostRun(fetchImpl: typeof fetch, baseUrl: string, input: HostRunSubmitInput): Promise<HostSdkSubmitAndExecuteResult>;
+export declare function submitAndWatchHostRun(fetchImpl: typeof fetch, baseUrl: string, input: HostRunSubmitInput, options?: HostSdkSubmitAndWatchOptions): AsyncGenerator<HostSdkSubmitAndWatchFrame>;
+export declare function submitAndWatchHostRunState(fetchImpl: typeof fetch, baseUrl: string, input: HostRunSubmitInput, options?: HostSdkSubmitAndWatchOptions): AsyncGenerator<HostSdkSubmitAndWatchStateFrame>;
+export declare function prepareHostSdkTakeover(fetchImpl: typeof fetch, baseUrl: string, options: HostSdkTakeoverOptions, runOptions?: HostSdkRunOptions): Promise<HostSdkPreparedTakeover>;
+export declare function streamHostStatus(fetchImpl: typeof fetch, baseUrl: string, options?: HostSdkStatusStreamOptions): AsyncGenerator<HostStatusSnapshot>;
+export declare function streamHostTimeline(fetchImpl: typeof fetch, baseUrl: string, options?: HostSdkTimelineStreamOptions): AsyncGenerator<HostTimelineEvent[]>;
+export declare function streamHostFrames(fetchImpl: typeof fetch, baseUrl: string, options?: HostSdkHostStreamOptions): AsyncGenerator<HostSdkStreamFrame>;
+export declare function watchHost(fetchImpl: typeof fetch, baseUrl: string, options?: HostSdkWatchOptions): AsyncGenerator<HostSdkWatchFrame>;
+export declare function streamHostRunRequests(fetchImpl: typeof fetch, baseUrl: string, options?: HostSdkRunRequestsStreamOptions): AsyncGenerator<HostRunRequest[]>;
+export declare function streamHostRunRequest(fetchImpl: typeof fetch, baseUrl: string, id: string, options?: HostSdkRunRequestStreamOptions): AsyncGenerator<HostRunRequest | null>;
+export declare function streamHostRunState(fetchImpl: typeof fetch, baseUrl: string, id: string, options?: HostSdkRunRequestStreamOptions): AsyncGenerator<HostSdkRunStateFrame>;
+export declare function runHostSdkCommand<TJson = unknown>(fetchImpl: typeof fetch, baseUrl: string, request: HostCommandRequest): Promise<HostCommandResult & {
+    json?: TJson;
+}>;