mthds 0.9.0 → 0.10.0

package/dist/protocol/models.d.ts

@@ -0,0 +1,95 @@
+/**
+ * Wire models for the MTHDS Protocol — exact mirror of `mthds/protocol/models.py`
+ * (which mirrors `mthds-protocol.openapi.yaml`, the standard's normative artifact).
+ *
+ *   POST /execute  : -> RunResultExecute (200: pipeline_run_id + pipe_output)
+ *   POST /start    : -> RunResultStart   (202: pipeline_run_id only)
+ *   POST /validate :              -> ValidationReport
+ *   GET  /models   :              -> ModelDeck
+ *   GET  /version  :              -> VersionInfo
+ *
+ * Response models declare the protocol's BASE fields only and are
+ * extension-open: an implementation may return more, and those server-specific
+ * fields are preserved (via the index signature) — the response side of the
+ * same passthrough principle as the request-side `extra`.
+ */
+/** The MTHDS Protocol version this SDK implements (the MTHDS standard version). */
+export declare const MTHDS_PROTOCOL_VERSION = "0.6.0";
+/**
+ * `POST /execute` 200 — the completed run.
+ *
+ * Two base fields: the authoritative server-generated `pipeline_run_id` and
+ * the method's `pipe_output` (always present — a completed run has output).
+ * Generic in the output type so `protocol/` never names a runner-side concrete:
+ * the default `DictPipeOutput` binding (`DictRunResultExecute`) lives in
+ * `runners/api/models.ts`. Extension-open: anything more an implementation
+ * returns (a run state, timestamps, output naming) rides the index signature,
+ * never named by this SDK.
+ */
+export interface RunResultExecute<TPipeOutput = unknown> {
+    pipeline_run_id: string;
+    pipe_output: TPipeOutput;
+    /** Implementation extension fields — defined and documented by the server. */
+    [extension: string]: unknown;
+}
+/**
+ * `POST /start` 202 (and the optional `/execute` 202 degrade) — the started
+ * run's authoritative `pipeline_run_id`, nothing else.
+ *
+ * A started run has no output yet; how it is delivered later (polling,
+ * callbacks, anything else) is implementation-defined and outside the
+ * protocol. Extension-open: an implementation may add its own fields (a
+ * workflow id, a created-at timestamp), preserved via the index signature.
+ */
+export interface RunResultStart {
+    pipeline_run_id: string;
+    /** Implementation extension fields — defined and documented by the server. */
+    [extension: string]: unknown;
+}
+/** Model categories accepted by the protocol's `GET /models?type=` filter. */
+export type ModelCategory = "llm" | "extract" | "img_gen" | "search";
+export declare const MODEL_CATEGORIES: readonly ModelCategory[];
+/** One entry of the model deck (`ModelDeck.models[]`) — base fields + extensions. */
+export interface ModelInfo {
+    name: string;
+    type?: ModelCategory | null;
+}
+/**
+ * The model deck a runner can route to — `GET /models`.
+ *
+ * The protocol's base is the `models` list; implementations may add their own
+ * routing metadata (aliases, fallback chains, anything else) as extensions,
+ * preserved via the index signature.
+ */
+export interface ModelDeck {
+    models: ModelInfo[];
+    /** Implementation extension fields (e.g. `aliases`, `waterfalls`). */
+    [extension: string]: unknown;
+}
+/**
+ * Verdict of `POST /validate` for a VALID bundle — the 200 status IS the verdict.
+ *
+ * Failures never reach this shape — they are RFC 7807 problems (HTTP 422,
+ * surfaced as `ApiResponseError`). The protocol declares no body fields;
+ * implementations may include their own artifacts (parsed structures, graphs,
+ * anything else), preserved here as extension fields.
+ */
+export interface ValidationReport {
+    /** Implementation extension fields (e.g. `blueprint`, `graph_spec`, `pipe_structures`). */
+    [extension: string]: unknown;
+}
+/**
+ * Protocol + runner versions — `GET /version` (always public).
+ *
+ * The handshake clients use for feature detection. The protocol defines two
+ * base fields (`protocol_version`, optional `runner_version`); implementations
+ * may add their own identification (an `implementation` name, an underlying
+ * runtime version, anything else) as extensions, preserved via the index
+ * signature and read by the api runner's bare-runner detection.
+ */
+export interface VersionInfo {
+    protocol_version: string;
+    runner_version?: string | null;
+    /** Implementation extension fields (e.g. `implementation`, `runtime_version`). */
+    [extension: string]: unknown;
+}

package/dist/protocol/models.js

@@ -0,0 +1,24 @@
+/**
+ * Wire models for the MTHDS Protocol — exact mirror of `mthds/protocol/models.py`
+ * (which mirrors `mthds-protocol.openapi.yaml`, the standard's normative artifact).
+ *
+ *   POST /execute  : -> RunResultExecute (200: pipeline_run_id + pipe_output)
+ *   POST /start    : -> RunResultStart   (202: pipeline_run_id only)
+ *   POST /validate :              -> ValidationReport
+ *   GET  /models   :              -> ModelDeck
+ *   GET  /version  :              -> VersionInfo
+ *
+ * Response models declare the protocol's BASE fields only and are
+ * extension-open: an implementation may return more, and those server-specific
+ * fields are preserved (via the index signature) — the response side of the
+ * same passthrough principle as the request-side `extra`.
+ */
+/** The MTHDS Protocol version this SDK implements (the MTHDS standard version). */
+export const MTHDS_PROTOCOL_VERSION = "0.6.0";
+export const MODEL_CATEGORIES = [
+    "llm",
+    "extract",
+    "img_gen",
+    "search",
+];
+//# sourceMappingURL=models.js.map

package/dist/protocol/models.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"models.js","sourceRoot":"","sources":["../../src/protocol/models.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,mFAAmF;AACnF,MAAM,CAAC,MAAM,sBAAsB,GAAG,OAAO,CAAC;AA0C9C,MAAM,CAAC,MAAM,gBAAgB,GAA6B;IACxD,KAAK;IACL,SAAS;IACT,SAAS;IACT,QAAQ;CACT,CAAC"}

package/dist/protocol/options.d.ts

@@ -0,0 +1,60 @@
+/**
+ * The MTHDS Protocol's request-argument surface — the named arguments of
+ * `execute` / `start`.
+ *
+ * The protocol has no request *model*: a runner takes the request's basic
+ * arguments as named parameters and serializes the wire body directly, merging
+ * any server-specific extension args (`extra`) as top-level properties. These
+ * option/request shapes are the TS expression of that argument surface.
+ */
+import type { VariableMultiplicity } from "./pipe_output.js";
+import type { PipelineInputs } from "./pipeline_inputs.js";
+/**
+ * Body of the protocol's `POST /execute` — mirrors `RunRequest` in
+ * `mthds-protocol.openapi.yaml`. At least one of `pipe_code` /
+ * `mthds_contents` is required.
+ */
+export interface RunRequest {
+    /** Code of the pipe to execute (registered, or defined in `mthds_contents`). */
+    pipe_code?: string | null;
+    /** MTHDS bundle contents to load (always an array, even for one file). */
+    mthds_contents?: string[] | null;
+    /** Method inputs: map of input name to content (loose here, strict in the runtime). */
+    inputs?: PipelineInputs | Record<string, unknown> | null;
+    /** Name of the output slot to return as the main output. */
+    output_name?: string | null;
+    /** Output multiplicity override (`false`/`true` or an exact count). */
+    output_multiplicity?: VariableMultiplicity | null;
+    /** Override for the dynamic output concept reference. */
+    dynamic_output_concept_ref?: string | null;
+}
+/**
+ * Body of the protocol's `POST /start` — the same basic arguments as `RunRequest`.
+ *
+ * The protocol declares no start-only request fields. Anything an
+ * implementation accepts on top (a client-supplied run id, anything else) is
+ * an extension arg — the server that defines it is the one that handles it;
+ * callers pass it through the generic `extra` option.
+ */
+export type StartRequest = RunRequest;
+/**
+ * The generic extension passthrough: server-specific args merged into the
+ * request body as top-level properties — the server you call defines and
+ * handles them; this SDK only passes them through. Protocol args inside
+ * `extra` are rejected client-side.
+ */
+export interface ExtensionOptions {
+    extra?: Record<string, unknown> | null;
+}
+/**
+ * Options for `MTHDSProtocol.execute` — the `RunRequest` fields plus the
+ * generic `extra` extension passthrough. (The options surface and the wire
+ * body are intentionally the same shape.)
+ */
+export type RunOptions = RunRequest & ExtensionOptions;
+/**
+ * Options for `MTHDSProtocol.start` — the `StartRequest` wire fields (the
+ * protocol's basic execution arguments) plus the generic `extra` extension
+ * passthrough (server-specific args, merged into the body).
+ */
+export type StartOptions = StartRequest & ExtensionOptions;

package/dist/protocol/options.js

@@ -0,0 +1,11 @@
+/**
+ * The MTHDS Protocol's request-argument surface — the named arguments of
+ * `execute` / `start`.
+ *
+ * The protocol has no request *model*: a runner takes the request's basic
+ * arguments as named parameters and serializes the wire body directly, merging
+ * any server-specific extension args (`extra`) as top-level properties. These
+ * option/request shapes are the TS expression of that argument surface.
+ */
+export {};
+//# sourceMappingURL=options.js.map

package/dist/protocol/options.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"options.js","sourceRoot":"","sources":["../../src/protocol/options.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG"}

package/dist/protocol/pipe_output.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Pipe-output domain shapes — exact mirror of `mthds/protocol/pipe_output.py`
+ * (`VariableMultiplicity`, `PipeOutputAbstract`). The Dict-serialized concrete
+ * (`DictPipeOutput`) is runner-side (`runners/api/models.ts`).
+ */
+import type { WorkingMemoryAbstract } from "./working_memory.js";
+export type VariableMultiplicity = boolean | number;
+export interface PipeOutputAbstract<TWorkingMemory extends WorkingMemoryAbstract = WorkingMemoryAbstract> {
+    working_memory: TWorkingMemory;
+    pipeline_run_id: string;
+}

package/dist/protocol/pipe_output.js

@@ -0,0 +1,7 @@
+/**
+ * Pipe-output domain shapes — exact mirror of `mthds/protocol/pipe_output.py`
+ * (`VariableMultiplicity`, `PipeOutputAbstract`). The Dict-serialized concrete
+ * (`DictPipeOutput`) is runner-side (`runners/api/models.ts`).
+ */
+export {};
+//# sourceMappingURL=pipe_output.js.map

package/dist/protocol/pipe_output.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pipe_output.js","sourceRoot":"","sources":["../../src/protocol/pipe_output.ts"],"names":[],"mappings":"AAAA;;;;GAIG"}

package/dist/protocol/pipeline_inputs.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Pipeline input value shapes — exact mirror of `mthds/protocol/pipeline_inputs.py`
+ * (`StuffContentOrData`, `PipelineInputs`). The abstract input shapes only; the
+ * Dict-serialized concrete (`DictStuff`) is runner-side (`runners/api/models.ts`).
+ */
+import type { StuffContentAbstract } from "./stuff.js";
+export type StuffContentOrData = string | string[] | StuffContentAbstract | StuffContentAbstract[] | Record<string, unknown>;
+export type PipelineInputs = Record<string, StuffContentOrData>;

package/dist/protocol/pipeline_inputs.js

@@ -0,0 +1,7 @@
+/**
+ * Pipeline input value shapes — exact mirror of `mthds/protocol/pipeline_inputs.py`
+ * (`StuffContentOrData`, `PipelineInputs`). The abstract input shapes only; the
+ * Dict-serialized concrete (`DictStuff`) is runner-side (`runners/api/models.ts`).
+ */
+export {};
+//# sourceMappingURL=pipeline_inputs.js.map

package/dist/protocol/pipeline_inputs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pipeline_inputs.js","sourceRoot":"","sources":["../../src/protocol/pipeline_inputs.ts"],"names":[],"mappings":"AAAA;;;;GAIG"}

package/dist/protocol/protocol.d.ts

@@ -0,0 +1,47 @@
+import type { RunOptions, StartOptions } from "./options.js";
+import type { ModelCategory, ModelDeck, RunResultExecute, RunResultStart, ValidationReport, VersionInfo } from "./models.js";
+/**
+ * The MTHDS Protocol — the contract every MTHDS runner implements. Exact
+ * mirror of `mthds/protocol/protocol.py` (`MTHDSProtocol`, generic in the
+ * pipe-output type).
+ *
+ * Mirrors the standard's five routes (`mthds-protocol.openapi.yaml`):
+ * `execute`, `start`, `validate`, `models`, `version`. A runner is just a
+ * runner: it executes and validates methods, and reports its model deck and
+ * version. Run polling is NOT part of the protocol — it is a hosted-API
+ * extension carried by `MthdsApiClient` and the `Runner` interface only.
+ *
+ * Generic in `PipeOutputT` (mirroring python's `Generic[PipeOutputT]`): the
+ * generic is the mechanism that keeps `protocol/` pure — `execute` returns
+ * `RunResultExecute<PipeOutputT>` without the protocol ever naming the
+ * runner-side `DictPipeOutput` concrete.
+ */
+export interface MTHDSProtocol<PipeOutputT = unknown> {
+    /**
+     * Execute a method synchronously and wait for its completion.
+     *
+     * Throws `RunStillRunningError` if the server answers 202 (the
+     * protocol's optional async degrade) instead of a final result.
+     */
+    execute(options: RunOptions): Promise<RunResultExecute<PipeOutputT>>;
+    /**
+     * Start a method asynchronously without waiting for completion.
+     *
+     * Carries the protocol's basic arguments only; server-specific extension
+     * args ride `options.extra`. Returns `RunResultStart` — the authoritative
+     * server-generated `pipeline_run_id`, no output yet.
+     */
+    start(options: StartOptions): Promise<RunResultStart>;
+    /**
+     * Parse, validate, and dry-run an MTHDS bundle.
+     *
+     * Returns the structural artifacts of a VALID bundle; invalid bundles throw
+     * (HTTP 422 problem on API runners). `allowSignatures` tolerates
+     * unimplemented pipe signatures (strict by default).
+     */
+    validate(mthdsContents: string[], allowSignatures?: boolean): Promise<ValidationReport>;
+    /** The model deck this runner can route to, optionally filtered by category. */
+    models(category?: ModelCategory): Promise<ModelDeck>;
+    /** Protocol + implementation versions — the handshake for feature detection. */
+    version(): Promise<VersionInfo>;
+}

package/dist/{client → protocol}/protocol.js.map

@@ -1 +1 @@
-{"version":3,"file":"protocol.js","sourceRoot":"","sources":["../../src/client/protocol.ts"],"names":[],"mappings":""}
+{"version":3,"file":"protocol.js","sourceRoot":"","sources":["../../src/protocol/protocol.ts"],"names":[],"mappings":""}

package/dist/protocol/stuff.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Stuff domain shapes — exact mirror of `mthds/protocol/stuff.py`
+ * (`StuffAbstract`, `StuffContentAbstract`). The protocol-level abstract stuff;
+ * the Dict-serialized concrete (`DictStuff`) is runner-side
+ * (`runners/api/models.ts`).
+ */
+import type { ConceptAbstract } from "./concept.js";
+/** Marker base for a stuff's content payload (mirrors python `StuffContentAbstract`). */
+export interface StuffContentAbstract {
+}
+export interface StuffAbstract<TConcept extends ConceptAbstract = ConceptAbstract, TContent extends StuffContentAbstract = StuffContentAbstract> {
+    stuff_code: string;
+    stuff_name?: string | null;
+    concept: TConcept;
+    content: TContent;
+}

package/dist/protocol/stuff.js

@@ -0,0 +1,8 @@
+/**
+ * Stuff domain shapes — exact mirror of `mthds/protocol/stuff.py`
+ * (`StuffAbstract`, `StuffContentAbstract`). The protocol-level abstract stuff;
+ * the Dict-serialized concrete (`DictStuff`) is runner-side
+ * (`runners/api/models.ts`).
+ */
+export {};
+//# sourceMappingURL=stuff.js.map

package/dist/{client/models → protocol}/stuff.js.map

@@ -1 +1 @@
-{"version":3,"file":"stuff.js","sourceRoot":"","sources":["../../../src/client/models/stuff.ts"],"names":[],"mappings":""}
+{"version":3,"file":"stuff.js","sourceRoot":"","sources":["../../src/protocol/stuff.ts"],"names":[],"mappings":"AAAA;;;;;GAKG"}

package/dist/protocol/working_memory.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Working-memory domain shape — exact mirror of `mthds/protocol/working_memory.py`
+ * (`WorkingMemoryAbstract`). The Dict-serialized concrete (`DictWorkingMemory`)
+ * is runner-side (`runners/api/models.ts`).
+ */
+import type { StuffAbstract } from "./stuff.js";
+export interface WorkingMemoryAbstract<TStuff extends StuffAbstract = StuffAbstract> {
+    root: Record<string, TStuff>;
+    aliases: Record<string, string>;
+}

package/dist/protocol/working_memory.js

@@ -0,0 +1,7 @@
+/**
+ * Working-memory domain shape — exact mirror of `mthds/protocol/working_memory.py`
+ * (`WorkingMemoryAbstract`). The Dict-serialized concrete (`DictWorkingMemory`)
+ * is runner-side (`runners/api/models.ts`).
+ */
+export {};
+//# sourceMappingURL=working_memory.js.map

package/dist/protocol/working_memory.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"working_memory.js","sourceRoot":"","sources":["../../src/protocol/working_memory.ts"],"names":[],"mappings":"AAAA;;;;GAIG"}

package/dist/runners/api/client.d.ts

@@ -0,0 +1,170 @@
+import { BaseRunner } from "../base-runner.js";
+import type { Runner, RunnerType, BuildInputsRequest, BuildOutputRequest, BuildRunnerRequest, BuildRunnerResponse, ConceptRequest, ConceptResponse, PipeSpecRequest, PipeSpecResponse } from "../types.js";
+import type { RunOptions, StartOptions } from "../../protocol/options.js";
+import type { ModelCategory, ModelDeck, RunResultStart, ValidationReport, VersionInfo } from "../../protocol/models.js";
+import type { DictRunResultExecute } from "./models.js";
+import type { RunRead, RunResults, RunResultState, WaitForResultOptions } from "./runs.js";
+interface MthdsApiClientOptions {
+    /** API token (Bearer). Falls back to `MTHDS_API_KEY`. Optional for anonymous bare runners. */
+    apiToken?: string;
+    /**
+     * API base URL — host only, NO version prefix (e.g. `https://api.pipelex.com`
+     * or `http://localhost:8081`). Every endpoint composes as
+     * `{baseUrl}/v1/{endpoint}`. Falls back to `MTHDS_API_URL`, then the hosted
+     * default.
+     */
+    baseUrl?: string;
+}
+/** Hosted default — the SDK composes every endpoint as `{base}/v1/{endpoint}`. */
+export declare const DEFAULT_API_BASE_URL = "https://api.pipelex.com";
+/**
+ * Client for any MTHDS runner — and THE API runner (parity D8). One class,
+ * two consumers: `pipelex-app` instantiates it directly as a protocol client,
+ * the CLI gets it via `createRunner()` as a full `Runner`. `extends BaseRunner
+ * implements Runner` so it carries the protocol surface, the Pipelex build
+ * extensions, and the lifecycle composites (`waitForResult` /
+ * `startAndWaitForResult`, inherited from `BaseRunner`).
+ *
+ * One base URL (`MTHDS_API_URL`); every endpoint is `<base>/v1/<endpoint>`:
+ * - **protocol** (`execute` / `start` / `validate` / `models` / `version`) — works
+ *   against any MTHDS-compliant runner, hosted or bare.
+ * - **run lifecycle** (`getRunStatus` / `getRunResult` / `waitForResult`) — the
+ *   durable polling extension that survives long runs and lets a caller resume by
+ *   id. Served only by a deployment that includes the platform block (the hosted
+ *   MTHDS API); a bare `pipelex-api` runner 404s those routes, which the lifecycle
+ *   methods translate into a clear `RunLifecycleUnavailableError`.
+ */
+export declare class MthdsApiClient extends BaseRunner implements Runner {
+    readonly type: RunnerType;
+    private readonly apiToken;
+    private readonly baseUrl;
+    /** Origin root derived from the base URL — `/health` lives here, not under `/v1`. */
+    private readonly originUrl;
+    /** Cached `/v1/version` handshake outcome — whether the durable lifecycle is served. */
+    private lifecycleAvailable;
+    constructor(options?: MthdsApiClientOptions);
+    /** Build an API URL: `<base>/v1/<endpoint>`. */
+    private url;
+    /**
+     * Issue one HTTP request and return the raw status/headers/body. Wraps
+     * DNS/connect/TLS/timeout failures as `ApiUnreachableError`; a caller-driven
+     * abort (Ctrl-C / agent walk-away) propagates as-is so the poll loop can stop
+     * cleanly. Non-2xx interpretation is left to the caller. `url` is a fully
+     * resolved absolute URL.
+     */
+    private requestRaw;
+    /**
+     * Issue a request and parse the JSON body, throwing a plain `Error` on a
+     * non-2xx response. Used by the build extensions and `health` — surfaces
+     * that don't need the protocol's structured error taxonomy.
+     */
+    private requestJson;
+    private postApi;
+    private throwApiResponseError;
+    /**
+     * Translate a "route absent" 404 (a bare pipelex-api with no platform block)
+     * into a clear `RunLifecycleUnavailableError`. The platform's own 404s (run
+     * not found / cross-org) carry a structured error envelope (a `code` field)
+     * and are left for normal handling.
+     */
+    private throwIfLifecycleUnavailable;
+    /**
+     * Map the protocol's optional 202 execute degrade to a typed
+     * error. Hosted does not emit 202 today, but the protocol permits it;
+     * raising a typed error (with the `pipeline_run_id` + `Location` + `Retry-After`
+     * hints) beats a generic parse failure on an unexpected body shape.
+     */
+    private throwIfExecuteDegraded;
+    health(): Promise<Record<string, unknown>>;
+    /**
+     * Execute a method synchronously and wait for its completion —
+     * `POST /v1/execute`.
+     *
+     * Behind the hosted gateway, synchronous requests terminate at ~30s; a run
+     * that exceeds that surfaces as `PipelineExecuteTimeoutError` pointing at the
+     * durable start+poll path. Throws `RunStillRunningError` on the protocol's
+     * optional 202 degrade.
+     */
+    execute(options: RunOptions): Promise<DictRunResultExecute>;
+    /**
+     * Start a method asynchronously — `POST /v1/start` (202, no output yet).
+     *
+     * Server-specific extension args ride `options.extra` and merge into the
+     * request body — the server you call defines and handles them (including a
+     * client-supplied run id where a server supports one). The returned
+     * `pipeline_run_id` is always authoritative; on a hosted deployment it is
+     * durable — poll `getRunStatus` / `getRunResult`.
+     */
+    start(options: StartOptions): Promise<RunResultStart>;
+    /**
+     * Parse, validate, and dry-run an MTHDS bundle — `POST /v1/validate`.
+     *
+     * Returns the structural artifacts of a valid bundle; an invalid bundle is
+     * an HTTP 422 problem, surfaced as `ApiResponseError`.
+     */
+    validate(mthdsContents: string[], allowSignatures?: boolean): Promise<ValidationReport>;
+    /** The model deck the runner can route to — `GET /v1/models[?type=]`. */
+    models(category?: ModelCategory): Promise<ModelDeck>;
+    /**
+     * Protocol + implementation versions — `GET /v1/version` (always public).
+     * The handshake for feature detection (hosted extensions or not).
+     */
+    version(): Promise<VersionInfo>;
+    buildInputs(request: BuildInputsRequest): Promise<unknown>;
+    buildOutput(request: BuildOutputRequest): Promise<unknown>;
+    buildRunner(request: BuildRunnerRequest): Promise<BuildRunnerResponse>;
+    concept(request: ConceptRequest): Promise<ConceptResponse>;
+    pipeSpec(request: PipeSpecRequest): Promise<PipeSpecResponse>;
+    /**
+     * Fetch a run's status by bare id — `GET /v1/runs/{pipeline_run_id}/status`.
+     *
+     * Self-healing: a finished-but-unrecorded run resolves to its true terminal
+     * status on read. `degraded: true` means Temporal was unreachable and
+     * `status` is the last-known value; `retry_after_seconds` carries the
+     * server's backoff hint when present. Throws `RunLifecycleUnavailableError`
+     * when the lifecycle routes are absent (a bare runner).
+     */
+    getRunStatus(runId: string, options?: {
+        signal?: AbortSignal;
+    }): Promise<RunRead>;
+    /**
+     * Single-shot result lookup — `GET /v1/runs/{pipeline_run_id}/results`.
+     * Maps the server's poll semantics to a discriminated union:
+     * - HTTP 202 → `running` (with the `Retry-After` hint)
+     * - HTTP 200 → `completed` (with the result artifacts)
+     * - HTTP 409 → `failed` (terminal non-`COMPLETED`)
+     * - HTTP 503 → `running` (Temporal degraded — retry, never fail a poller)
+     *
+     * Throws `RunLifecycleUnavailableError` when the lifecycle routes are absent
+     * (a bare runner).
+     */
+    getRunResult(runId: string, options?: {
+        signal?: AbortSignal;
+    }): Promise<RunResultState>;
+    /**
+     * Whether the configured server serves the durable run lifecycle, decided
+     * via the `GET /v1/version` handshake (master D2) and cached for the
+     * client's lifetime. A bare `pipelex-api` runner has no run store; anything
+     * else is assumed hosted. When the handshake itself fails, assume hosted
+     * (the SDK default) and let the start call surface the real error.
+     */
+    private supportsRunLifecycle;
+    /**
+     * Start a run and wait for its result.
+     *
+     * - **Hosted** (per the `/v1/version` handshake): durable start + poll (the
+     *   `BaseRunner` composite), the path that survives the gateway's ~30s
+     *   synchronous ceiling.
+     * - **Bare runner** (no run store): the blocking `POST /v1/execute`, which
+     *   has no gateway cap off-platform and returns the native `pipe_output`.
+     */
+    startAndWaitForResult(options: StartOptions, pollOptions?: WaitForResultOptions): Promise<RunResults>;
+    /**
+     * Blocking `POST /v1/execute` adapted onto `RunResults` — the bare-runner
+     * path. Forwards every protocol field PLUS the `extra` extension passthrough:
+     * an extension-only call (`{ extra }` with no pipe_code/bundle) or a vendor
+     * selector riding `extra` must survive this path, not just the durable one.
+     */
+    private executeBlocking;
+}
+export {};