@vibedgc/sdk 0.6.4

package/dist/runtime.d.ts

@@ -0,0 +1,31 @@
+import type { Env } from "./types.ts";
+export declare const REPO_ROOT: string;
+/** True when this file runs from a DGC source checkout (sdk/typescript inside the repository). */
+export declare function isCheckout(): boolean;
+/** The installed CLI launcher: `dgc` on PATH, then the vibedgc.com installer's ~/.local/bin/dgc. */
+export declare function installedLauncher(env?: Env): string | undefined;
+/** True when `python` has `-P` (3.11+): it keeps the working directory off sys.path. */
+export declare function supportsSafePath(python: string, env?: Env): boolean;
+/**
+ * `python -m dgc serve`, with `-P` where the interpreter has it: `-m` puts the working directory
+ * (the session cwd) first on sys.path, so a workspace with its own `dgc/` package would replace
+ * the runtime.
+ */
+export declare function pythonRuntime(python: string, env?: Env): string[];
+/**
+ * How to start `dgc serve`: DGC_PYTHON, then this checkout's .venv (source checkouts only),
+ * then the installed `dgc` launcher, then `python3 -m dgc`. The ready handshake checks the
+ * protocol either way.
+ */
+export declare function defaultRuntime(env?: Env): string[];
+/** Host variables every runtime child receives: program lookup, locale, terminal, time zone,
+ *  temp and certificate locations. None is a credential; anything else must be passed on purpose
+ *  (`extraEnv`, `inheritEnv`). Mirrors the Python SDK's BASE_ENV. */
+export declare const BASE_ENV: ReadonlySet<string>;
+/**
+ * The runtime child's environment. `inheritEnv` false (default) passes only BASE_ENV, a list of
+ * names adds those host variables, true passes everything (the host DGC_*_API_KEY values are
+ * still dropped in isolated mode). With `inherit` (inheritUserState) DGC_* and XDG_* variables
+ * pass too, since they locate the user's own DGC state.
+ */
+export declare function isolatedEnv(stateDir: string, extra?: Record<string, string>, inherit?: boolean, projectRoot?: string, inheritEnv?: boolean | readonly string[], hostEnv?: Env): Env;

package/dist/runtime.js

@@ -0,0 +1,148 @@
+import { accessSync, constants, existsSync, mkdirSync, statSync } from "node:fs";
+import { homedir } from "node:os";
+import { delimiter, join } from "node:path";
+import { execFileSync } from "node:child_process";
+import { fileURLToPath } from "node:url";
+import { DGCConfigError } from "./errors.js";
+import { privateDir } from "./state.js";
+export const REPO_ROOT = fileURLToPath(new URL("../../..", import.meta.url)).replace(/\/$/, "");
+/** True when this file runs from a DGC source checkout (sdk/typescript inside the repository). */
+export function isCheckout() {
+    return existsSync(join(REPO_ROOT, "dgc", "__init__.py"))
+        && existsSync(join(REPO_ROOT, "sdk", "typescript", "package.json"));
+}
+function executable(path) {
+    try {
+        accessSync(path, constants.X_OK);
+        return statSync(path).isFile();
+    }
+    catch {
+        return false;
+    }
+}
+/** The installed CLI launcher: `dgc` on PATH, then the vibedgc.com installer's ~/.local/bin/dgc. */
+export function installedLauncher(env = process.env) {
+    for (const dir of (env.PATH || "").split(delimiter)) {
+        if (dir && executable(join(dir, "dgc")))
+            return join(dir, "dgc");
+    }
+    const local = join(env.HOME || homedir(), ".local", "bin", "dgc");
+    return executable(local) ? local : undefined;
+}
+const SAFE_PATH_CACHE = new Map();
+/** True when `python` has `-P` (3.11+): it keeps the working directory off sys.path. */
+export function supportsSafePath(python, env = process.env) {
+    const key = `${python}\0${env.PATH || ""}`;
+    const cached = SAFE_PATH_CACHE.get(key);
+    if (cached !== undefined)
+        return cached;
+    let answer = false;
+    if (python.includes("/") ? executable(python) : true) {
+        try {
+            const out = execFileSync(python, ["-c", "import sys; print(int(sys.version_info >= (3, 11)))"], {
+                encoding: "utf8", stdio: ["ignore", "pipe", "ignore"], timeout: 10_000,
+                env: { PATH: env.PATH || "", PYTHONDONTWRITEBYTECODE: "1" },
+            });
+            answer = out.trim() === "1";
+        }
+        catch {
+            answer = false;
+        }
+    }
+    SAFE_PATH_CACHE.set(key, answer);
+    return answer;
+}
+/**
+ * `python -m dgc serve`, with `-P` where the interpreter has it: `-m` puts the working directory
+ * (the session cwd) first on sys.path, so a workspace with its own `dgc/` package would replace
+ * the runtime.
+ */
+export function pythonRuntime(python, env = process.env) {
+    return supportsSafePath(python, env) ? [python, "-P", "-m", "dgc", "serve"] : [python, "-m", "dgc", "serve"];
+}
+/**
+ * How to start `dgc serve`: DGC_PYTHON, then this checkout's .venv (source checkouts only),
+ * then the installed `dgc` launcher, then `python3 -m dgc`. The ready handshake checks the
+ * protocol either way.
+ */
+export function defaultRuntime(env = process.env) {
+    if (env.DGC_PYTHON)
+        return pythonRuntime(env.DGC_PYTHON, env);
+    const checkoutPython = join(REPO_ROOT, ".venv/bin/python");
+    if (isCheckout() && existsSync(checkoutPython))
+        return pythonRuntime(checkoutPython, env);
+    const launcher = installedLauncher(env);
+    if (launcher)
+        return [launcher, "serve"];
+    return pythonRuntime("python3", env);
+}
+/** Host variables every runtime child receives: program lookup, locale, terminal, time zone,
+ *  temp and certificate locations. None is a credential; anything else must be passed on purpose
+ *  (`extraEnv`, `inheritEnv`). Mirrors the Python SDK's BASE_ENV. */
+export const BASE_ENV = new Set([
+    "PATH", "HOME", "USER", "LOGNAME", "SHELL", "LANG", "LANGUAGE", "LC_ALL", "LC_CTYPE",
+    "LC_MESSAGES", "LC_COLLATE", "LC_NUMERIC", "LC_TIME", "LC_MONETARY", "TERM", "COLORTERM",
+    "NO_COLOR", "TZ", "TMPDIR", "TEMP", "TMP", "SSL_CERT_FILE", "SSL_CERT_DIR",
+    "REQUESTS_CA_BUNDLE", "CURL_CA_BUNDLE", "SYSTEMROOT", "SYSTEMDRIVE", "WINDIR", "COMSPEC",
+    "PATHEXT",
+]);
+const SECRET_ENV = ["DGC_API_KEY", "DGC_SEARCH_API_KEY", "DGC_SUBAGENT_API_KEY", "DGC_FALLBACK_API_KEY"];
+/**
+ * The runtime child's environment. `inheritEnv` false (default) passes only BASE_ENV, a list of
+ * names adds those host variables, true passes everything (the host DGC_*_API_KEY values are
+ * still dropped in isolated mode). With `inherit` (inheritUserState) DGC_* and XDG_* variables
+ * pass too, since they locate the user's own DGC state.
+ */
+export function isolatedEnv(stateDir, extra, inherit = false, projectRoot, inheritEnv = false, hostEnv = process.env) {
+    let env;
+    if (inheritEnv === true) {
+        env = { ...hostEnv };
+    }
+    else {
+        env = {};
+        for (const [key, value] of Object.entries(hostEnv)) {
+            const upper = key.toUpperCase();
+            if (BASE_ENV.has(upper) || (inherit && (upper.startsWith("DGC_") || upper.startsWith("XDG_")))) {
+                env[key] = value;
+            }
+        }
+        for (const name of inheritEnv || []) {
+            if (!name || name.includes("=") || name.includes("\0")) {
+                throw new DGCConfigError(`inheritEnv has an invalid variable name: ${JSON.stringify(name)}`);
+            }
+            if (hostEnv[name] !== undefined)
+                env[name] = hostEnv[name];
+        }
+    }
+    env.PYTHONUNBUFFERED = "1";
+    env.PYTHONDONTWRITEBYTECODE = "1";
+    if (!inherit) {
+        for (const key of SECRET_ENV)
+            delete env[key];
+        const home = privateDir(join(stateDir, "home"));
+        privateDir(join(home, ".dgc"));
+        mkdirSync(join(home, ".config"), { recursive: true });
+        mkdirSync(join(home, ".local/share"), { recursive: true });
+        mkdirSync(join(home, ".local/state"), { recursive: true });
+        env.HOME = home;
+        env.USERPROFILE = home;
+        env.DGC_HOME = home;
+        env.DGC_SDK_ISOLATED = "1";
+        if (projectRoot)
+            env.DGC_PROJECT_ROOT = projectRoot;
+        env.XDG_CONFIG_HOME = join(home, ".config");
+        env.XDG_DATA_HOME = join(home, ".local/share");
+        env.XDG_STATE_HOME = join(home, ".local/state");
+    }
+    Object.assign(env, extra);
+    // Only a source checkout puts its own dgc/ on the child's path. An installed package must not:
+    // REPO_ROOT is then node_modules, and anything importable there would shadow the CLI's own
+    // pinned dependencies.
+    if (isCheckout()) {
+        const pathParts = [REPO_ROOT];
+        if (env.PYTHONPATH)
+            pathParts.push(env.PYTHONPATH);
+        env.PYTHONPATH = pathParts.join(delimiter);
+    }
+    return env;
+}

package/dist/schema.d.ts

@@ -0,0 +1,4 @@
+/** Harness-side JSON Schema subset used for outputSchema. Unsupported keywords are rejected. */
+export declare function assertSupported(schema: unknown): void;
+export declare function extractJson(text: string): unknown;
+export declare function validate(value: unknown, schema: Record<string, unknown>, path?: string): string[];

package/dist/schema.js

@@ -0,0 +1,124 @@
+/** Harness-side JSON Schema subset used for outputSchema. Unsupported keywords are rejected. */
+const ALLOWED = new Set([
+    "type", "properties", "required", "items", "enum", "additionalProperties",
+    "minLength", "maxLength", "minimum", "maximum", "minItems", "maxItems",
+    "description", "title", "default",
+]);
+const JSON_FENCE = /```(?:json)?\s*(\{[\s\S]*?\}|\[[\s\S]*?\])\s*```/;
+export function assertSupported(schema) {
+    if (!schema || typeof schema !== "object" || Array.isArray(schema) || !Object.keys(schema).length) {
+        throw new Error("outputSchema must be a non-empty object");
+    }
+    walk(schema);
+}
+function walk(node) {
+    if (!node || typeof node !== "object" || Array.isArray(node))
+        return;
+    const record = node;
+    if ("$ref" in record || "$id" in record || "$schema" in record) {
+        throw new Error("outputSchema must not use $ref, $id, or $schema");
+    }
+    for (const key of Object.keys(record)) {
+        if (!ALLOWED.has(key))
+            throw new Error(`outputSchema has unsupported keyword: ${key}`);
+    }
+    if (record.properties && typeof record.properties === "object") {
+        for (const child of Object.values(record.properties))
+            walk(child);
+    }
+    if (record.items && typeof record.items === "object")
+        walk(record.items);
+}
+export function extractJson(text) {
+    let raw = (text || "").trim();
+    if (!raw)
+        throw new Error("final text is empty");
+    const fenced = JSON_FENCE.exec(raw);
+    if (fenced)
+        raw = fenced[1];
+    else {
+        const obj = raw.indexOf("{");
+        const arr = raw.indexOf("[");
+        const starts = [obj, arr].filter((index) => index >= 0);
+        if (starts.length)
+            raw = raw.slice(Math.min(...starts));
+    }
+    return JSON.parse(raw);
+}
+export function validate(value, schema, path = "$") {
+    const errors = [];
+    const expected = schema.type;
+    if (expected) {
+        const types = Array.isArray(expected) ? expected : [expected];
+        if (!types.some((kind) => isType(value, String(kind)))) {
+            errors.push(`${path} should be ${expected}`);
+            return errors;
+        }
+    }
+    if ("enum" in schema && !(schema.enum || []).includes(value)) {
+        errors.push(`${path} is not one of the allowed values`);
+    }
+    if (typeof value === "string") {
+        if (typeof schema.minLength === "number" && value.length < schema.minLength) {
+            errors.push(`${path} is shorter than minLength`);
+        }
+        if (typeof schema.maxLength === "number" && value.length > schema.maxLength) {
+            errors.push(`${path} is longer than maxLength`);
+        }
+    }
+    if (typeof value === "number" && !Number.isNaN(value)) {
+        if (typeof schema.minimum === "number" && value < schema.minimum)
+            errors.push(`${path} is below minimum`);
+        if (typeof schema.maximum === "number" && value > schema.maximum)
+            errors.push(`${path} is above maximum`);
+    }
+    if (Array.isArray(value)) {
+        if (typeof schema.minItems === "number" && value.length < schema.minItems)
+            errors.push(`${path} has too few items`);
+        if (typeof schema.maxItems === "number" && value.length > schema.maxItems)
+            errors.push(`${path} has too many items`);
+        if (schema.items && typeof schema.items === "object" && !Array.isArray(schema.items)) {
+            value.forEach((item, index) => {
+                errors.push(...validate(item, schema.items, `${path}[${index}]`));
+            });
+        }
+    }
+    if (value && typeof value === "object" && !Array.isArray(value)) {
+        const record = value;
+        const props = (schema.properties && typeof schema.properties === "object")
+            ? schema.properties : {};
+        const required = Array.isArray(schema.required) ? schema.required : [];
+        for (const key of required) {
+            if (!(key in record))
+                errors.push(`${path}.${key} is required`);
+        }
+        const additional = schema.additionalProperties === undefined ? true : schema.additionalProperties;
+        for (const [key, item] of Object.entries(record)) {
+            if (key in props)
+                errors.push(...validate(item, props[key], `${path}.${key}`));
+            else if (additional === false)
+                errors.push(`${path}.${key} is not allowed`);
+            else if (additional && typeof additional === "object") {
+                errors.push(...validate(item, additional, `${path}.${key}`));
+            }
+        }
+    }
+    return errors;
+}
+function isType(value, kind) {
+    if (kind === "object")
+        return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+    if (kind === "array")
+        return Array.isArray(value);
+    if (kind === "string")
+        return typeof value === "string";
+    if (kind === "integer")
+        return typeof value === "number" && Number.isInteger(value);
+    if (kind === "number")
+        return typeof value === "number" && !Number.isNaN(value);
+    if (kind === "boolean")
+        return typeof value === "boolean";
+    if (kind === "null")
+        return value === null;
+    return false;
+}

package/dist/session.d.ts

@@ -0,0 +1,264 @@
+import type { Transport } from "./transport.ts";
+import type { ToolHub } from "./tools.ts";
+import type { AuditLog } from "./audit.ts";
+import type { UsageLog, UsageTotals } from "./usage.ts";
+import { type Snapshot } from "./changes.ts";
+import { type Policy } from "./policy.ts";
+import type { StateLock } from "./state.ts";
+import type { AbortSignalLike, Artifact, Denial, Checkpoint, Pricing, RunEvent, RunOptions, RunResult, SandboxStatus, SessionInfo, SessionOptions, TaskItem } from "./types.ts";
+/** Best-effort category for a `tool_denied` reason (see {@link Denial}). */
+export declare function denialSource(reason: string): Denial["source"];
+/** Pump-side state of one run. Outcome events for its prompt ids land here, whoever reads them. */
+export declare class Run {
+    readonly result: RunResult;
+    readonly requestId: string;
+    readonly ids: Set<string>;
+    readonly expect: Set<string>;
+    readonly steers: Set<string>;
+    readonly unresolved: Set<string>;
+    readonly returned: Set<string>;
+    readonly rejected: Map<string, string>;
+    readonly turnIds: Set<string>;
+    readonly startedIds: Set<string>;
+    liveTurn: string;
+    started: boolean;
+    cancelReason: "" | "cancelled" | "timeout" | "decision_failed";
+    cancelAt: number;
+    cancelSent: boolean;
+    decisionError: string;
+    usage: UsageTotals;
+    billed: number;
+    pendingBills: number;
+    usageUnknown: boolean;
+    done: boolean;
+    handle: RunHandle | null;
+    pumpStarted: boolean;
+    holdsFollowups: boolean;
+    held: boolean;
+    /** The workspace when this run's last turn ended: its "after", and a follow-up's "before". */
+    after: Snapshot | null;
+    private cancelWaiters;
+    private doneWaiters;
+    constructor(result: RunResult, requestId: string);
+    /** Resolves once a cancel (of any reason) is requested. */
+    cancelled(): Promise<void>;
+    noteCancel(): void;
+    markDone(): void;
+    waitDone(timeoutMs: number): Promise<void>;
+}
+/**
+ * Streaming handle. Iterate its events (`for await`), then call {@link result}. Leaving the loop
+ * early (`break`, `return`, a throw) cancels the run and waits (bounded) for DGC to stop, so the
+ * session is free again. `result()` drains whatever was not iterated.
+ */
+export declare class RunHandle implements AsyncIterable<RunEvent> {
+    private readonly session;
+    /** @internal */
+    readonly run: Run;
+    private gen;
+    private primed;
+    private chain;
+    private finished;
+    private detach;
+    constructor(session: Session, run: Run);
+    get runId(): string;
+    /** True once the run is over and every event was consumed. */
+    get done(): boolean;
+    /**
+     * @internal Attach the pump. `prime` starts it now, so the prompt is sent when stream()
+     * returns; a run queued behind another starts when it is iterated or awaited (starting it here
+     * would drain the run in front of it behind its caller's back).
+     */
+    begin(gen: AsyncGenerator<RunEvent>, signal: AbortSignalLike | undefined, prime: boolean): void;
+    private step;
+    private finish;
+    [Symbol.asyncIterator](): AsyncIterator<RunEvent>;
+    /**
+     * Drain the run and return its result. `timeoutMs` bounds this wait (undefined/null waits until
+     * the run ends, which the run's own timeout bounds); if the run is still going when it lapses,
+     * DGCTimeoutError is thrown and the run keeps going (call {@link cancel} to stop it).
+     */
+    result(timeoutMs?: number | null): Promise<RunResult>;
+    /** Cancel this run. The result settles with `status: "cancelled"`. */
+    cancel(): void;
+    /** Cancel if still going, then drain (bounded); used when the consumer went away. */
+    abandon(timeoutMs?: number): Promise<void>;
+    private close;
+}
+/** @internal What DGC.session() hands a Session. */
+export type SessionInit = {
+    options: SessionOptions;
+    unhandled: "deny" | "callback";
+    instructions: string;
+    toolHub: ToolHub | null;
+    cwd: string | null;
+    policy: Policy | null;
+    pricing?: Pricing;
+    department: string;
+    usageLog: UsageLog | null;
+    auditLog: AuditLog | null;
+    model: string;
+    permissionMode: string;
+    isolated: boolean;
+    maxTurns?: number;
+    verifyCommand: string;
+    stateLock: StateLock | null;
+    excludePaths: string[];
+    requestTimeoutMs: number;
+    sandbox: SandboxStatus;
+};
+export declare class Session {
+    sessionId: string;
+    sessionPath: string;
+    readonly transport: Transport;
+    readonly protocolVersion: unknown;
+    readonly capabilities: Record<string, unknown>;
+    /** Whether this session's shell commands run inside the OS sandbox. */
+    readonly sandbox: SandboxStatus;
+    private readonly init;
+    private closed;
+    private pending;
+    private owners;
+    private active;
+    private queued;
+    private turn;
+    private usageLast;
+    private billTo;
+    private taskIds;
+    private taskRevision;
+    private answeredIds;
+    private maxTurnsDirty;
+    private modelSeen;
+    constructor(transport: Transport, ready: Record<string, unknown>, init: SessionInit);
+    /** Advanced transport. Prefer {@link run} / {@link stream}. */
+    get raw(): Transport;
+    /** @internal The verify command, for the accumulator. */
+    get verifyCommand(): string;
+    close(): Promise<void>;
+    run(prompt: string, runOptions?: RunOptions): Promise<RunResult>;
+    /**
+     * Send `prompt` and return a handle over its events. `timeoutMs` limits each turn of the run
+     * (default 180 000; null for none). `maxTurns` caps tool iterations for this run only; the
+     * session's own setting is restored afterwards. `signal` cancels the run when aborted.
+     */
+    stream(prompt: string, runOptions?: RunOptions): RunHandle;
+    /**
+     * Queue a prompt behind the active run and return a handle for its own turn. With no run in
+     * flight this is {@link stream}. A follow-up is observed, audited and billed like any run.
+     * Behind a run with its own `maxTurns` or `outputSchema`, it is sent when that run is over (so
+     * it runs under the session's own settings). It does not run when the run in front of it is
+     * cancelled or times out.
+     */
+    followup(text: string, runOptions?: Omit<RunOptions, "maxTurns" | "workflow">): RunHandle;
+    /** Cancel the active run. DGC's stop also hands back prompts queued behind it. */
+    cancel(): void;
+    /**
+     * Add `text` to the run in flight. Throws unless a run is active. If DGC cannot fold it into
+     * the live turn, it runs as a further turn of the same run (its tool calls are part of that
+     * run's result, audit and usage).
+     */
+    steer(text: string): void;
+    /**
+     * Fill `sessionPath` once this session's own transcript exists. Only a transcript whose file
+     * name is this session's id is used; another session's transcript is never adopted.
+     */
+    bindIdentity(): Promise<void>;
+    private newResult;
+    private request;
+    /** Hold the stateDir lock around commands that make DGC save the isolated config. */
+    private configScope;
+    listSessions(): Promise<SessionInfo[]>;
+    listCheckpoints(): Promise<Checkpoint[]>;
+    rewind(index: number): Promise<Record<string, unknown>>;
+    fork(name?: string): Promise<Record<string, unknown>>;
+    history(): Promise<Record<string, unknown>>;
+    listSkills(): Promise<Array<{
+        name: string;
+        description: string;
+        source: string;
+        enabled: boolean;
+    }>>;
+    getGoal(): Promise<Record<string, unknown>>;
+    setGoal(text: string, status?: string): Promise<Record<string, unknown>>;
+    listMonitors(): Promise<unknown[]>;
+    listHooks(): Promise<Record<string, unknown>>;
+    getMemory(): Promise<Record<string, unknown>>;
+    addMemory(text: string, scope?: "project" | "user"): Promise<Record<string, unknown>>;
+    listPermissions(): Promise<Array<{
+        action: string;
+        rule: string;
+    }>>;
+    /**
+     * Add a rule. In an isolated session it lasts for this state_dir's sessions until the next
+     * session rewrites the config; a RuntimePolicy is not installed this way (it is per session).
+     */
+    addPermissionRule(action: "allow" | "ask" | "deny", rule: string): Promise<Array<{
+        action: string;
+        rule: string;
+    }>>;
+    removePermissionRule(action: "allow" | "ask" | "deny", rule: string): Promise<Array<{
+        action: string;
+        rule: string;
+    }>>;
+    addMcpServer(name: string, command: string, args?: string[]): Promise<unknown[]>;
+    listMcpServers(): Promise<unknown[]>;
+    getSkill(name: string): Promise<Record<string, unknown>>;
+    setSkillEnabled(name: string, enabled: boolean): Promise<unknown>;
+    stopMonitor(id?: string): Promise<unknown[]>;
+    listArtifacts(): Promise<Artifact[]>;
+    listAgents(): Promise<unknown[]>;
+    clearTodos(): Promise<TaskItem[]>;
+    getPlan(): Promise<Record<string, unknown>>;
+    getConfig(): Promise<Record<string, unknown>>;
+    getUsage(range?: string): Promise<Record<string, unknown>>;
+    newSession(): Promise<Record<string, unknown>>;
+    nameSession(name: string): Promise<Record<string, unknown>>;
+    deleteSession(path: string): Promise<SessionInfo[]>;
+    generateHandoff(save?: boolean): Promise<Record<string, unknown>>;
+    private read;
+    /**
+     * Bookkeeping every event gets, whichever reader takes it: turn ownership, prompt outcomes,
+     * usage billing, the audit row, and identity.
+     */
+    private observe;
+    /** A workflow prompt's turn carries no request id; give it to the run waiting for it. */
+    private adoptable;
+    private noteOutcome;
+    private account;
+    /** Drop control events left on the pipe (after resume/fork/rewind); stop at anything else. */
+    discardIdle(timeoutMs?: number): Promise<void>;
+    /** @internal */
+    cancelRun(run: Run, reason: "cancelled" | "timeout" | "decision_failed"): void;
+    /** @internal Drop a queued run nobody will drive. */
+    forget(run: Run): void;
+    private composePrompt;
+    /** Apply a run-scoped max_turns; DGC persists set_config, so it is restored after. */
+    private setRunMaxTurns;
+    private restoreMaxTurns;
+    private sendPrompt;
+    private pump;
+    /** Pump events until every turn this run owns has ended. */
+    private turns;
+    private completion;
+    /** The usage totals for a turn arrive right after its turn_end. */
+    private awaitBilling;
+    private finish;
+    private applySchema;
+    /** @internal */
+    projectTasks(rows: unknown): TaskItem[];
+    private recordUsage;
+    private finishUsage;
+    private answer;
+    private respond;
+    /**
+     * Ask an application callback (sync or async). `decisionTimeoutMs: null` waits as long as it
+     * takes; a cancel always wins. A callback that throws, times out, or returns an invalid answer
+     * gets `fallback`; with `permissions.unhandled: "callback"` that also stops the run.
+     */
+    private decide;
+    private permission;
+    private plan;
+    private answerOptions;
+    private answerMcp;
+}
+export declare function rowsToSessions(raw: unknown): SessionInfo[];