@runtypelabs/sdk 9.3.0 → 9.3.1

package/dist/index.d.ts

@@ -11190,7 +11190,7 @@ interface paths {
                                 /** @default true */
                                 createVersionOnChange?: boolean;
                             };
-                            /** @description Execution-lane selector. `false` is DEPRECATED: the legacy agent engine is being retired, an agent dispatch that sends `false` still runs on it today with RFC 9745 `Deprecation` + `X-API-Deprecation-Warning` response headers, and a later release rejects it. Omitted (the default) runs an eligible agent on the @runtypelabs/runtime lane and folds a definition the lane cannot execute faithfully to legacy on its own; `true` is the strict opt-in that turns such a fold into a 400 instead. For FLOW dispatches the field is accepted but ignored: eligible flows always use the runtime lane, while ineligible flows still fold to legacy silently. */
+                            /** @description Execution-lane selector. `false` is RETIRED on AGENT dispatches: the legacy agent engine it selected has been deleted, so it is rejected with 400 LEGACY_AGENT_LANE_RETIRED (still carrying the RFC 9745 `Deprecation` + `X-API-Deprecation-Warning` response headers). Omitted and `true` are now IDENTICAL for agents: both run an eligible agent on the @runtypelabs/runtime lane, and both answer a definition the lane cannot execute faithfully with 400 RUNTIME_AGENT_PARITY_FOLD_UNSUPPORTED rather than degrading it. For FLOW dispatches the field is accepted but ignored: eligible flows always use the runtime lane, while ineligible flows still fold to legacy silently. */
                             useRuntimePackage?: boolean;
                             versionLabel?: string;
                             versionNotes?: string;
@@ -11206,7 +11206,7 @@ interface paths {
                             ownerId?: string;
                             type?: string;
                         };
-                        /** @description Retired. A NON-EMPTY map on an agent dispatch is rejected with 400 RUNTIME_AGENT_TRANSIENT_SECRETS_UNSUPPORTED, unless the deprecated `options.useRuntimePackage: false` opt-out routes the run to the legacy engine, which still honors it for single-turn (non-loop) agents until that engine is removed. An empty map is accepted and does nothing. Ignored on flow dispatches. Store credentials as managed secrets and reference them as {{secret:NAME}}. The field is kept on the wire for compatibility only. */
+                        /** @description Retired. A NON-EMPTY map on an agent dispatch is rejected with 400 RUNTIME_AGENT_TRANSIENT_SECRETS_UNSUPPORTED. There is no longer an exception: the legacy engine that honored it for single-turn agents behind `options.useRuntimePackage: false` has been removed, and that opt-out is itself a 400 now. An empty map is accepted and does nothing. Ignored on flow dispatches. Store credentials as managed secrets and reference them as {{secret:NAME}}. The field is kept on the wire for compatibility only. */
                         secrets?: {
                             [key: string]: string;
                         };
@@ -11565,7 +11565,7 @@ interface paths {
                                 /** @default true */
                                 createVersionOnChange?: boolean;
                             };
-                            /** @description Execution-lane selector. `false` is DEPRECATED: the legacy agent engine is being retired, an agent dispatch that sends `false` still runs on it today with RFC 9745 `Deprecation` + `X-API-Deprecation-Warning` response headers, and a later release rejects it. Omitted (the default) runs an eligible agent on the @runtypelabs/runtime lane and folds a definition the lane cannot execute faithfully to legacy on its own; `true` is the strict opt-in that turns such a fold into a 400 instead. For FLOW dispatches the field is accepted but ignored: eligible flows always use the runtime lane, while ineligible flows still fold to legacy silently. */
+                            /** @description Execution-lane selector. `false` is RETIRED on AGENT dispatches: the legacy agent engine it selected has been deleted, so it is rejected with 400 LEGACY_AGENT_LANE_RETIRED (still carrying the RFC 9745 `Deprecation` + `X-API-Deprecation-Warning` response headers). Omitted and `true` are now IDENTICAL for agents: both run an eligible agent on the @runtypelabs/runtime lane, and both answer a definition the lane cannot execute faithfully with 400 RUNTIME_AGENT_PARITY_FOLD_UNSUPPORTED rather than degrading it. For FLOW dispatches the field is accepted but ignored: eligible flows always use the runtime lane, while ineligible flows still fold to legacy silently. */
                             useRuntimePackage?: boolean;
                             versionLabel?: string;
                             versionNotes?: string;
@@ -11581,7 +11581,7 @@ interface paths {
                             ownerId?: string;
                             type?: string;
                         };
-                        /** @description Retired. A NON-EMPTY map on an agent dispatch is rejected with 400 RUNTIME_AGENT_TRANSIENT_SECRETS_UNSUPPORTED, unless the deprecated `options.useRuntimePackage: false` opt-out routes the run to the legacy engine, which still honors it for single-turn (non-loop) agents until that engine is removed. An empty map is accepted and does nothing. Ignored on flow dispatches. Store credentials as managed secrets and reference them as {{secret:NAME}}. The field is kept on the wire for compatibility only. */
+                        /** @description Retired. A NON-EMPTY map on an agent dispatch is rejected with 400 RUNTIME_AGENT_TRANSIENT_SECRETS_UNSUPPORTED. There is no longer an exception: the legacy engine that honored it for single-turn agents behind `options.useRuntimePackage: false` has been removed, and that opt-out is itself a 400 now. An empty map is accepted and does nothing. Ignored on flow dispatches. Store credentials as managed secrets and reference them as {{secret:NAME}}. The field is kept on the wire for compatibility only. */
                         secrets?: {
                             [key: string]: string;
                         };
@@ -46969,13 +46969,6 @@ type StreamEventOf<U, T extends string> = Extract<U, {
     type: T;
 }>;
 
-/**
- * SSE Stream Utilities for FlowBuilder
- *
- * Provides utilities for parsing Server-Sent Events (SSE) streams
- * from the Runtype API dispatch endpoint.
- */
-
 /**
  * Options for the flow stream consumers.
  *
@@ -47037,13 +47030,6 @@ declare function processStream(response: Response, callbacks?: StreamCallbacks,
  */
 declare function streamEvents(response: Response, _options?: StreamConsumeOptions): AsyncGenerator<StreamEvent>;
 
-/**
- * FlowResult - Wrapper for streaming flow execution responses
- *
- * Provides convenient methods for processing streaming responses
- * from the Runtype API dispatch endpoint.
- */
-
 /**
  * Result wrapper for flow execution
  *
@@ -47158,26 +47144,6 @@ declare class FlowResult {
     private ensureNotConsumed;
 }
 
-/**
- * FlowBuilder - Fluent builder for constructing dispatch configurations
- *
- * Provides a chainable API for building flows with steps, making flow
- * construction more readable and type-safe.
- *
- * @example
- * ```typescript
- * import { FlowBuilder } from '@runtypelabs/sdk'
- *
- * const config = new FlowBuilder()
- *   .createFlow({ name: "My Flow" })
- *   .withRecord({ name: "Record", type: "data", metadata: { key: "value" } })
- *   .fetchUrl({ name: "Fetch", url: "https://api.example.com", outputVariable: "data" })
- *   .prompt({ name: "Process", model: "gpt-4", userPrompt: "Analyze: {{data}}" })
- *   .withOptions({ streamResponse: true, flowMode: "virtual" })
- *   .build()
- * ```
- */
-
 interface PromptStepConfig$1 {
     name: string;
     model: string;
@@ -47653,10 +47619,11 @@ interface DispatchOptions$1 {
     loggingPolicy?: 'default' | 'on' | 'off';
     /**
      * Ignored for flows (runtime eligibility selects the engine). For agents,
-     * `false` is deprecated: the legacy agent engine is being retired, a `false`
-     * response carries `Deprecation` headers today, and a later release rejects
-     * it. Omit the field for the default runtime lane, or send `true` for the
-     * strict opt-in that fails loudly instead of folding to legacy.
+     * `false` is RETIRED: the legacy agent engine it selected has been deleted,
+     * so it is rejected with 400 `LEGACY_AGENT_LANE_RETIRED` (the response still
+     * carries `Deprecation` headers). Omit the field, or send `true` — for agents
+     * the two are now identical, and both answer a definition the runtime lane
+     * cannot execute faithfully with a 400 rather than degrading it.
      */
     useRuntimePackage?: boolean;
     localInference?: {
@@ -48863,10 +48830,9 @@ interface FlowToolConfig {
     flowId?: string;
     toolId?: string;
     /**
-     * Inline flow definition. Runtime-selected agent dispatches support this
-     * (the runtime lane is the default unless `options.useRuntimePackage: false`
-     * opts out); hosted flow definitions currently require a `flowId`/`toolId`
-     * reference.
+     * Inline flow definition. Agent dispatches support this — every eligible
+     * agent runs on the runtime lane, which resolves an inline flow — while
+     * hosted flow definitions currently require a `flowId`/`toolId` reference.
      */
     flow?: Record<string, unknown>;
     /** Registered-flow name key for the runtime lane (`flowName ?? flowId`). */
@@ -49014,10 +48980,9 @@ interface RuntimeFlowToolConfig {
     flowId?: string;
     toolId?: string;
     /**
-     * Inline flow definition. Runtime-selected agent dispatches support this
-     * (the runtime lane is the default unless `options.useRuntimePackage: false`
-     * opts out); hosted flow definitions currently require a `flowId`/`toolId`
-     * reference.
+     * Inline flow definition. Agent dispatches support this — every eligible
+     * agent runs on the runtime lane, which resolves an inline flow — while
+     * hosted flow definitions currently require a `flowId`/`toolId` reference.
      */
     flow?: Record<string, unknown>;
     /** Registered-flow name key for the runtime lane (`flowName ?? flowId`). */
@@ -49585,32 +49550,6 @@ interface BillingSpendAnalyticsParams {
     period?: 'billing_period' | 'current_month' | 'last_7_days' | 'last_30_days' | 'last_90_days';
 }
 
-/**
- * Eval config-as-code: `defineEval` + the grader builders.
- *
- * The authoring layer for code-colocated evals — define the evals for a flow or
- * agent right next to its `defineFlow` / `flows.ensure` definition. This module
- * is PURE and local (no I/O), the exact analog of `defineFlow` in
- * `flows-ensure.ts`: it validates and normalizes a loose `DefineEvalInput` into
- * a canonical `EvalDefinition` (target + cases + per-case graders) and computes
- * a content hash for hash-first convergence. The converge motion
- * (`client.evals.ensure` → `POST /eval/ensure`) and the `runtype eval` CLI build
- * on this contract in later increments.
- *
- * Grader types are MIRRORED INLINE from `@runtypelabs/shared`'s
- * `grader-types.ts` (the SDK is dependency-free by convention — see the same
- * pattern in `flows-ensure.ts`). The wire shapes must stay byte-identical to the
- * shared discriminated union so an eval authored here scores through the existing
- * `EvalScoringService` unchanged.
- *
- * Scope: the output + AI-judge union plus the trace graders (`called_tool` /
- * `tool_order` / `ran_step` / `completed` / `cost` / …), each scored server-side
- * by the same pure `runCheck` engine over the run's captured execution trace.
- * Severity (`.gate()` / `.soft()`) is deliberately NOT emitted here — it lands
- * with its own grader-engine extension. See
- * `docs/features/planning/2026-06-24-code-colocated-evals.md`.
- */
-
 /**
  * Per-grader severity (mirror of `@runtypelabs/shared`'s `GraderSeverity`). A
  * `gate` miss always fails the case; a `soft` miss is tracked-but-not-failing
@@ -50151,44 +50090,6 @@ declare function pullEval(client: RuntypeClient$1, name: string): Promise<EvalPu
  */
 declare function runEvalSuite(client: RuntypeClient$1, input: RunEvalInput): Promise<RunEvalResult>;
 
-/**
- * Flow config-as-code: `defineFlow`, `flows.ensure`, `flows.pull`.
- *
- * The non-executing sibling of `flows.upsert()` — `upsert` is the
- * dispatch-coupled save-and-run motion (it saves the flow AND executes it in
- * one request); `ensure` is the deploy-time convergence postcondition: "make
- * the platform's definition of this flow match this object; no-op if it
- * already does." Identity is name + account scope (the API key's org, else
- * personal); environment is whichever API the client points at. `ensure`
- * never deletes, and renaming a definition orphans the old flow and creates a
- * new one.
- *
- * Wire protocol (POST /v1/flows/ensure — APQ-shaped, both APQ scars fixed):
- *   1. Hash-only probe `{ name, contentHash }`. A match is
- *      `{ result: 'unchanged' }`; a miss is a NORMAL 200
- *      `{ result: 'definitionRequired' }`, never an error.
- *   2. On a miss, retry with the full `definition`. The server recomputes the
- *      canonical hash itself and returns it on every response — this SDK
- *      echoes the server's hash (memoized per client instance) rather than
- *      trusting its own serialization.
- *
- * The content hash is the SAME steps-only hash the flow upsert protocol uses
- * (`computeFlowContentHash` — mirrored from
- * `packages/shared/src/utils/flow-content-hash.ts`; this package is
- * dependency-free by convention), so ensure and upsert interoperate on the
- * same flow. The flow definition surface is `{ name, steps }` — description
- * is not part of the v1 ensure surface (the shared hash covers steps only).
- *
- * A `defineFlow` may also carry inline `evals` — eval suites to converge
- * alongside the flow. These are SDK-orchestrated: they are NOT part of the
- * flow content hash and NEVER ride the `/flows/ensure` wire (its server schema
- * is `.strict()` `{ name, steps }`). After the flow converges, `ensureFlow`
- * converges each inline suite through the existing `/eval/ensure` endpoint
- * (`ensureEval`), so eval semantics stay confined to the eval endpoints.
- *
- * See docs/adr/0003-agent-config-as-code-ensure.md for the design rationale.
- */
-
 /** SHA-256 (hex) over the canonical normalized step list (steps only). */
 declare function computeFlowContentHash(steps: unknown[]): Promise<string>;
 /**
@@ -50340,15 +50241,6 @@ declare class FlowDriftError extends Error {
     constructor(plan: EnsureFlowPlan);
 }
 
-/**
- * FlowsNamespace - Static namespace for flow operations
- *
- * Provides factory methods for creating flow builders with different modes:
- * - upsert: Create or update a flow by name
- * - virtual: One-off execution without saving
- * - use: Execute an existing flow by ID
- */
-
 interface LocalToolsOptions {
     localTools?: Record<string, (args: unknown) => Promise<unknown>>;
 }
@@ -50726,13 +50618,6 @@ declare class RuntypeFlowBuilder {
     private addStep;
 }
 
-/**
- * BatchesNamespace - Static namespace for batch operations
- *
- * Provides direct methods for scheduling and managing batch operations.
- * Batches are always asynchronous - they don't return results immediately.
- */
-
 interface BatchScheduleConfig {
     /** Flow ID to execute for each record */
     flowId: string;
@@ -50858,17 +50743,6 @@ declare class BatchesNamespace {
     }>;
 }
 
-/**
- * Eval-suite CRUD + case management + run — the SDK surface for the
- * `/v1/eval/suites` REST family (Beginner-First Evals).
- *
- * This is the imperative, id-addressed counterpart of the config-as-code
- * surface in `evals-ensure.ts` (`defineEval` / `ensure` / `pull`): use ensure
- * to converge a repo-authored suite on deploy, and this namespace to inspect
- * or manage suites, edit test cases (server-authoritative data), and start
- * runs. Exposed as `client.evals.suites.*`.
- */
-
 /** The most recent run of a suite, with its score once graded. */
 interface EvalSuiteLatestRun {
     runId: string;
@@ -51257,13 +51131,6 @@ declare class EvalSuitesNamespace {
     getCoverage(suiteId: string): Promise<EvalSuiteCoverage>;
 }
 
-/**
- * EvalsNamespace - Static namespace for evaluation operations
- *
- * Provides methods for running evaluations and comparing model performance.
- * Evals can be streamed for real-time results or submitted as batch jobs.
- */
-
 interface ModelOverride$1 {
     /** Name of the step to override */
     stepName: string;
@@ -51581,13 +51448,6 @@ declare class EvalsNamespace {
     }>;
 }
 
-/**
- * PromptsNamespace - Static namespace for prompt operations
- *
- * Provides CRUD operations for prompts and execution methods
- * with streaming and non-streaming options.
- */
-
 interface CreatePromptData {
     /** Prompt name */
     name: string;
@@ -51749,39 +51609,6 @@ declare class PromptsNamespace {
     delete(promptId: string): Promise<void>;
 }
 
-/**
- * Skill config-as-code: `defineSkill`, `skills.ensure`, `skills.pull`.
- *
- * The deploy-time convergence postcondition for Agent Skills: "make the
- * platform's definition of this skill match this manifest; no-op if it already
- * does." Identity is name + account scope (the API key's org, else personal);
- * environment is whichever API the client points at. `ensure` never deletes,
- * and renaming a manifest orphans the old skill and creates a new one.
- *
- * This is the admin/control-plane converge — API scopes only, no review queue.
- * It is NOT the deployed-agent `propose_skill` data plane.
- *
- * Wire protocol (POST /v1/skills/ensure — APQ-shaped, both APQ scars fixed):
- *   1. Hash-only probe `{ name, contentHash }`. A match is
- *      `{ result: 'unchanged' }`; a miss is a NORMAL 200
- *      `{ result: 'definitionRequired' }`, never an error.
- *   2. On a miss, retry with the full `definition`. The server recomputes the
- *      canonical hash itself and returns it on every response — this SDK echoes
- *      the server's hash (memoized per client instance) rather than trusting its
- *      own serialization.
- *
- * Like agents/flows (and unlike tools), skills HAVE version snapshots: every
- * change appends an immutable version, the result carries a `versionId`, and
- * `release: 'publish'` re-aims the published-version pointer.
- *
- * The content hash is the canonical skill hash (`computeSkillContentHash` —
- * mirrored from `packages/shared/src/utils/skill-content-hash.ts`; this package
- * is dependency-free by convention) over the manifest `{ frontmatter (name
- * excluded), runtype, body }`. `name` is identity, not content.
- *
- * See docs/adr/0003-agent-config-as-code-ensure.md for the design rationale.
- */
-
 interface SkillContentInput {
     /** Identity — excluded from the hash. */
     name: string;
@@ -51887,22 +51714,6 @@ declare class SkillDriftError extends Error {
     constructor(plan: EnsureSkillPlan);
 }
 
-/**
- * SkillsNamespace — admin/control-plane operations for Agent Skills.
- *
- * Skills are loadable context bundles (SKILL.md + capability bindings) for
- * deployed Runtype agents. This namespace wraps the admin REST surface
- * (`/v1/skills`, `/v1/skill-proposals`) — governed by API scopes only, no
- * review queue. The deployed-agent data plane (the `propose_skill` runtime
- * tool) is intentionally NOT exposed here; authoring a skill via the SDK is
- * authoring, and lands published when you ask it to.
- *
- * Types here mirror the canonical definitions in `@runtypelabs/shared`
- * (`skill-manifest-types.ts`) and the `skills` / `skill_versions` /
- * `agent_skill_bindings` / `skill_proposals` tables. Per SDK convention they
- * are defined inline rather than imported, to keep the package dependency-free.
- */
-
 /** Lifecycle status of a skill. */
 type SkillStatus = 'draft' | 'active' | 'archived';
 /** Trust level recorded on a skill (governs UI warnings). */
@@ -52299,35 +52110,6 @@ declare class SkillsNamespace {
     pull(name: string): Promise<SkillPullResult>;
 }
 
-/**
- * AgentsNamespace — agent config-as-code: `defineAgent`, `ensure`, `pull`.
- *
- * `ensure` is a convergence postcondition, not a save button: "make the
- * platform's definition of this agent match this object; no-op if it already
- * does." Identity is name + account scope (the API key's org, else personal);
- * environment is whichever API the client points at. `ensure` never deletes,
- * and renaming a definition orphans the old agent and creates a new one.
- *
- * Wire protocol (POST /v1/agents/ensure — APQ-shaped, both APQ scars fixed):
- *   1. Hash-only probe `{ name, contentHash }`. A match is
- *      `{ result: 'unchanged' }`; a miss is a NORMAL 200
- *      `{ result: 'definitionRequired' }`, never an error.
- *   2. On a miss, retry with the full `definition`. The server recomputes the
- *      canonical hash itself and returns it on every response — this SDK
- *      echoes the server's hash (memoized per client instance) rather than
- *      trusting its own serialization.
- *
- * The content-hash implementation below is an INLINED COPY of
- * `packages/shared/src/utils/agent-content-hash.ts` (this package is
- * dependency-free by convention, mirroring the flow content hash in
- * flows-namespace.ts). Parity is pinned by the shared fixture corpus in
- * `packages/shared/test-fixtures/agent-content-hash/cases.json`, asserted by
- * both packages' test suites. Change both copies (and regenerate the corpus)
- * in the same PR.
- *
- * See docs/adr/0003-agent-config-as-code-ensure.md for the design rationale.
- */
-
 /** Canonical normalized form — must stay byte-identical to the shared impl. */
 declare function normalizeAgentDefinition(definition: {
     name: string;
@@ -52567,36 +52349,6 @@ declare class ExecutionsNamespace {
     getStatus(executionId: string): Promise<AsyncExecutionStatus>;
 }
 
-/**
- * Tool config-as-code: `defineTool`, `tools.ensure`, `tools.pull`.
- *
- * The deploy-time convergence postcondition for saved tools: "make the
- * platform's definition of this tool match this object; no-op if it already
- * does." Identity is name + account scope (the API key's org, else personal);
- * environment is whichever API the client points at. `ensure` never deletes,
- * and renaming a definition orphans the old tool and creates a new one.
- *
- * Wire protocol (POST /v1/tools/ensure — APQ-shaped, both APQ scars fixed):
- *   1. Hash-only probe `{ name, contentHash }`. A match is
- *      `{ result: 'unchanged' }`; a miss is a NORMAL 200
- *      `{ result: 'definitionRequired' }`, never an error.
- *   2. On a miss, retry with the full `definition`. The server recomputes the
- *      canonical hash itself and returns it on every response — this SDK
- *      echoes the server's hash (memoized per client instance) rather than
- *      trusting its own serialization.
- *
- * Unlike agents/flows, tools have NO version snapshots: there is no
- * `release: 'publish'` option and no `versionId` on the result.
- *
- * The content hash is the canonical tool hash (`computeToolContentHash` —
- * mirrored from `packages/shared/src/utils/tool-content-hash.ts`; this package
- * is dependency-free by convention) over `{ toolType, description,
- * parametersSchema, config }`. `name` is identity, not content, so it is
- * excluded from the hash.
- *
- * See docs/adr/0003-agent-config-as-code-ensure.md for the design rationale.
- */
-
 /** Canonical normalized form of a tool definition (name excluded — identity). */
 declare function normalizeToolDefinition(definition: ToolContentInput): {
     toolType: string;
@@ -52710,14 +52462,6 @@ declare class ToolDriftError extends Error {
     constructor(plan: EnsureToolPlan);
 }
 
-/**
- * ToolsNamespace — config-as-code operations for saved tools.
- *
- * `tools.ensure` is the deploy-time, non-executing converge (create-or-update a
- * tool by name + account scope); `tools.pull` is the absorb-drift direction.
- * Both delegate to the implementation in `tools-ensure.ts`.
- */
-
 declare class ToolsNamespace {
     private getClient;
     constructor(getClient: () => RuntypeClient$1);
@@ -52751,42 +52495,6 @@ declare class ToolsNamespace {
     pull(name: string): Promise<ToolPullResult>;
 }
 
-/**
- * Product config-as-code: `defineProduct`, `products.ensure`, `products.pull`.
- *
- * The deploy-time convergence postcondition for the top-level product record:
- * "make the platform's definition of this product match this object; no-op if
- * it already does." Identity is name + account scope (the API key's org, else
- * personal); environment is whichever API the client points at. `ensure` never
- * deletes, and renaming a definition orphans the old product and creates a new
- * one.
- *
- * SCOPE (v1): the converge covers the TOP-LEVEL product record only — name
- * (identity), description, icon, and the `spec` (ProductSpec). It does NOT
- * converge nested capabilities/surfaces/tools/records/schedules, and it does
- * NOT converge `canvas` (architecture-viewer UI layout state).
- *
- * Wire protocol (POST /v1/products/ensure — APQ-shaped, both APQ scars fixed):
- *   1. Hash-only probe `{ name, contentHash }`. A match is
- *      `{ result: 'unchanged' }`; a miss is a NORMAL 200
- *      `{ result: 'definitionRequired' }`, never an error.
- *   2. On a miss, retry with the full `definition`. The server recomputes the
- *      canonical hash itself and returns it on every response — this SDK
- *      echoes the server's hash (memoized per client instance) rather than
- *      trusting its own serialization.
- *
- * Unlike agents/flows, products have NO version snapshots: there is no
- * `release: 'publish'` option and no `versionId` on the result.
- *
- * The content hash is the canonical product hash (`computeProductContentHash` —
- * mirrored from `packages/shared/src/utils/product-content-hash.ts`; this
- * package is dependency-free by convention) over `{ description, icon, spec }`.
- * `name` is identity, not content, so it is excluded from the hash; `canvas` is
- * UI state and is excluded too.
- *
- * See docs/adr/0003-agent-config-as-code-ensure.md for the design rationale.
- */
-
 /** Canonical normalized form of a product definition (name + canvas excluded). */
 declare function normalizeProductDefinition(definition: ProductContentInput): {
     description?: string;
@@ -52888,25 +52596,6 @@ declare class ProductDriftError extends Error {
     constructor(plan: EnsureProductPlan);
 }
 
-/**
- * SDK config-as-code converge for an entire Full Product Object (FPO).
- *
- * `products.ensureFpo` converges the whole nested product graph in one request
- * by POSTing the FPO to `POST /v1/products/ensure-fpo`, where the server fans
- * out to the per-entity ensure services. Unlike `products.ensure` (top-level
- * record only), there is no hash-only probe in this release: the full FPO is
- * always shipped and the server returns the canonical whole-FPO hash + a
- * per-entity report. (The hash-only fast-probe lands once the server persists a
- * per-product FPO hash — see the plan's PR3.)
- *
- * `computeFpoContentHash` is inlined here (the SDK avoids a `@runtypelabs/shared`
- * dependency) and pinned byte-for-byte against the canonical implementation by
- * the shared fixture corpus (`packages/shared/test-fixtures/fpo-content-hash/`)
- * asserted from BOTH packages. A normalization change in
- * `packages/shared/src/utils/fpo-content-hash.ts` MUST be mirrored here in the
- * same PR.
- */
-
 /** An FPO for hashing/sending. Permissive — the server validates the rich contract. */
 type FpoInput = Record<string, unknown>;
 /**
@@ -52981,18 +52670,6 @@ declare function ensureFpo(client: RuntypeClient$1, fpo: FpoInput, options?: Ens
  */
 declare function pullFpo(client: RuntypeClient$1, name: string): Promise<PullFpoResult>;
 
-/**
- * ProductsNamespace — config-as-code operations for products.
- *
- * `products.ensure` is the deploy-time, non-executing converge (create-or-update
- * a product by name + account scope); `products.pull` is the absorb-drift
- * direction. Both delegate to the implementation in `products-ensure.ts`.
- *
- * SCOPE (v1): the converge covers the top-level product record only
- * (description, icon, spec). Nested capabilities/surfaces/tools and the
- * `canvas` UI layout state are not converged.
- */
-
 declare class ProductsNamespace {
     private getClient;
     constructor(getClient: () => RuntypeClient$1);
@@ -53059,38 +52736,6 @@ declare class ProductsNamespace {
     pullFpo(name: string): Promise<PullFpoResult>;
 }
 
-/**
- * Surface config-as-code: `defineSurface`, `surfaces.ensure`, `surfaces.pull`.
- *
- * The deploy-time convergence postcondition for product surfaces: "make the
- * platform's definition of this surface match this object; no-op if it already
- * does." Surfaces are PRODUCT-scoped: identity is (productId, name) — NOT
- * account scope. `ensure` never deletes, and renaming a definition orphans the
- * old surface and creates a new one.
- *
- * Wire protocol (POST /v1/products/{id}/surfaces/ensure — APQ-shaped, both APQ
- * scars fixed):
- *   1. Hash-only probe `{ name, contentHash }`. A match is
- *      `{ result: 'unchanged' }`; a miss is a NORMAL 200
- *      `{ result: 'definitionRequired' }`, never an error.
- *   2. On a miss, retry with the full `definition`. The server recomputes the
- *      canonical hash itself and returns it on every response — this SDK echoes
- *      the server's hash (memoized per client instance) rather than trusting
- *      its own serialization.
- *
- * Unlike agents/flows, surfaces have NO version snapshots: there is no
- * `release: 'publish'` option and no `versionId` on the result.
- *
- * The content hash is the canonical surface hash (`computeSurfaceContentHash` —
- * mirrored from `packages/shared/src/utils/surface-content-hash.ts`; this
- * package is dependency-free by convention) over `{ type, behavior, status,
- * environment }`. `name` is identity, not content, so it is excluded; `inbound` /
- * `outbound` are also EXCLUDED — they carry sealed secrets that hash
- * non-deterministically against the stored row (see `normalizeSurfaceDefinition`).
- *
- * See docs/adr/0003-agent-config-as-code-ensure.md for the design rationale.
- */
-
 /**
  * Canonical normalized form of a surface definition (name excluded — identity).
  * `inbound` / `outbound` are EXCLUDED — they carry sealed secrets that hash
@@ -53212,16 +52857,6 @@ declare class SurfaceDriftError extends Error {
     constructor(plan: EnsureSurfacePlan);
 }
 
-/**
- * SurfacesNamespace — config-as-code operations for product surfaces.
- *
- * `surfaces.ensure` is the deploy-time, non-executing converge (create-or-update
- * a surface by name within a product); `surfaces.pull` is the absorb-drift
- * direction. Both delegate to the implementation in `surfaces-ensure.ts`.
- *
- * Surfaces are PRODUCT-scoped: every operation takes the owning `productId`.
- */
-
 declare class SurfacesNamespace {
     private getClient;
     constructor(getClient: () => RuntypeClient$1);
@@ -53254,49 +52889,6 @@ declare class SurfacesNamespace {
     pull(productId: string, name: string): Promise<SurfacePullResult>;
 }
 
-/**
- * Runtype - The unified SDK client for building and executing flows, batches, evals, and prompts
- *
- * Provides a fluent API with static namespaces for all product areas.
- *
- * @example
- * ```typescript
- * import { Runtype } from '@runtypelabs/sdk'
- *
- * // Global configuration (once per app)
- * Runtype.configure({ apiKey: process.env.RUNTYPE_API_KEY })
- *
- * // Build and stream a flow
- * const stream = await Runtype.flows.upsert({ name: 'My Flow' })
- *   .withRecord({ name: 'Test', metadata: {} })
- *   .prompt({ name: 'Analyze', model: 'gpt-4o', userPrompt: '...' })
- *   .stream()
- *
- * // Get complete result
- * const result = await Runtype.flows.use('flow_123')
- *   .withRecord({ name: 'Test' })
- *   .result()
- *
- * // Schedule a batch
- * const batch = await Runtype.batches.schedule({
- *   flowId: 'flow_123',
- *   recordType: 'customers',
- * })
- *
- * // Run an eval with streaming
- * const evalStream = await Runtype.evals.run({
- *   flowId: 'flow_123',
- *   recordType: 'test_data',
- *   models: [{ stepName: 'Analyze', model: 'gpt-4o' }]
- * }).stream()
- *
- * // Execute a prompt
- * const promptResult = await Runtype.prompts.run('prompt_123', {
- *   recordId: 'rec_456'
- * }).result()
- * ```
- */
-
 interface RuntypeConfig {
     /** API key for authentication */
     apiKey?: string;
@@ -53384,9 +52976,46 @@ declare class RuntypeClient$1 {
     private transformResponse;
 }
 /**
- * Runtype - Main entry point for the SDK
+ * Runtype - The unified SDK client for building and executing flows, batches, evals, and prompts.
+ *
+ * Provides a fluent API with static namespaces for all product areas.
  *
- * Use static methods and namespaces to interact with the API.
+ * @example
+ * ```typescript
+ * import { Runtype } from '@runtypelabs/sdk'
+ *
+ * // Global configuration (once per app)
+ * Runtype.configure({ apiKey: process.env.RUNTYPE_API_KEY })
+ *
+ * // Build and stream a flow
+ * const stream = await Runtype.flows.upsert({ name: 'My Flow' })
+ *   .withRecord({ name: 'Test', metadata: {} })
+ *   .prompt({ name: 'Analyze', model: 'gpt-4o', userPrompt: '...' })
+ *   .stream()
+ *
+ * // Get complete result
+ * const result = await Runtype.flows.use('flow_123')
+ *   .withRecord({ name: 'Test' })
+ *   .result()
+ *
+ * // Schedule a batch
+ * const batch = await Runtype.batches.schedule({
+ *   flowId: 'flow_123',
+ *   recordType: 'customers',
+ * })
+ *
+ * // Run an eval with streaming
+ * const evalStream = await Runtype.evals.run({
+ *   flowId: 'flow_123',
+ *   recordType: 'test_data',
+ *   models: [{ stepName: 'Analyze', model: 'gpt-4o' }]
+ * }).stream()
+ *
+ * // Execute a prompt
+ * const promptResult = await Runtype.prompts.run('prompt_123', {
+ *   recordId: 'rec_456'
+ * }).result()
+ * ```
  */
 declare class Runtype {
     /**
@@ -54168,15 +53797,6 @@ type TypedCreateRecordRequest<S extends string> = Omit<CreateRecordRequest, 'typ
     metadata?: CollectionMeta<S>;
 };
 
-/**
- * Pluggable workflow architecture for marathon task execution.
- *
- * A WorkflowDefinition describes the phases an agent goes through
- * (e.g. research → planning → execution) and the rules for each phase.
- * The default implementation mirrors the existing hardcoded behavior;
- * consumers can supply custom workflows for different strategies (TDD, etc.).
- */
-
 interface RunTaskStateSlice {
     agentId: string;
     taskName: string;
@@ -54318,10 +53938,6 @@ interface WorkflowDefinition {
     buildCandidateBlock?: (state: RunTaskStateSlice) => string;
 }
 
-/**
- * API endpoint handlers with automatic camelCase/snake_case transformation
- */
-
 interface ApiClient {
     get<T>(path: string, params?: {
         [key: string]: any;
@@ -55537,7 +55153,7 @@ interface AgentMediaEvent extends BaseAgentEvent {
  *
  * Local SDK copy of `ExternalAgentContext` from `@runtypelabs/shared`'s
  * `sse-parser.ts`. The SDK has zero production dependencies and
- * re-derives wire types by design (Phase 9 — see
+ * re-derives wire types by design (see
  * `docs/features/shipped/2026-02-25-user-cloud-deployment.md`). Keep
  * the shape identical to `@runtypelabs/shared`'s `ExternalAgentContext`.
  */
@@ -55572,7 +55188,7 @@ interface AgentElicitationRequest {
  *
  * Local SDK copy of `unifiedElicitationSchema` from `@runtypelabs/shared`'s
  * `unified-sse-event-schemas.ts`. The SDK has zero production dependencies and
- * re-derives wire types by design (Phase 9). Keep the shape identical.
+ * re-derives wire types by design. Keep the shape identical.
  */
 interface AgentElicitation {
     /** `form` answers with text; `url` sends the human to {@link url} first. */
@@ -57111,18 +56727,6 @@ declare class ToolApprovalGrantsEndpoint {
     }>;
 }
 
-/**
- * @layer sdk
- * @case camelCase (SDK and API both use native camelCase - no conversion needed)
- *
- * Main Runtype API Client.
- *
- * The SDK and API both use native camelCase for all request/response bodies.
- * No case transformation is performed.
- *
- * @see packages/client/src/transform.ts for pass-through utilities
- */
-
 type LocalToolHandler = (args: unknown) => Promise<unknown>;
 /**
  * Richer local tool entry that pairs a handler with the wire schema the
@@ -57404,44 +57008,6 @@ declare function parseOffloadedOutputId(value: string): string | undefined;
 /** Parse the tree-log-relative artifact path out of a ledger offload reference. */
 declare function parseLedgerArtifactRelativePath(value: string): string | undefined;
 
-/**
- * Unified wire → stable SDK callback adapter (the client-side mirror of the api's
- * `apps/api/src/lib/unified-event-stream.ts`).
- *
- * As of the unified-SSE cutover (runtypelabs/core unified-sse-default) the
- * execution streams the SDK consumes — `/dispatch`, `/dispatch/resume`,
- * `/agents/{id}/execute`, `/agents/{id}/resume` — use the 35-event unified
- * vocabulary (`unifiedSSEEventSchema` in `@runtypelabs/shared`). The SDK
- * translates those frames back into its stable, hand-written callback shapes
- * here.
- *
- * Why translate instead of rewriting every consumer switch: the SDK's public
- * callback contracts (`StreamCallbacks`, `AgentStreamCallbacks`) and their event
- * types are part of the published surface. Reversing the wire at the parse
- * boundary moves the SDK onto the unified format on the wire while keeping that
- * surface byte-stable for downstream consumers. The translation is the inverse
- * of the api edge translator's mapping table
- * (`docs/features/planning/2026-06-16-persona-sse-event-merged-spec.md`).
- *
- * Scope: only the events the SDK's consumers actually read are reconstructed;
- * everything else (artifact channel, `source`, the `state_snapshot` /
- * `state_delta` agent-state channel, `custom`, fallback live-beat, `step_skip`)
- * maps to zero callback events. The state channel is recognized as unified
- * vocabulary (so `isUnifiedEventType` is true and the wire union stays exhaustive)
- * but has no stable SDK callback shape to project onto; surfacing it to the SDK
- * callback surface is a separate additive slice, not a wire-translation concern.
- * Two unified-contract folds are NOT reconstructed because the unified
- * vocabulary deliberately discards them:
- *  - `agent_iteration_start` / `agent_iteration_complete` are folded into the
- *    `iteration` field on turn/tool frames, so `onIterationStart` /
- *    `onIterationComplete` no longer fire.
- *  - the additive `fallback` summary on `step_complete` / `turn_complete` is
- *    dropped (the SDK callback surface never consumed `fallback_*` events).
- *
- * Each translator is STATEFUL (channel block ids, current step/turn/iteration,
- * media accumulation) and therefore must be constructed once PER STREAM — never
- * shared across executions.
- */
 type Json = Record<string, unknown>;
 /**
  * @deprecated Unified events are now the only public execution-stream format.
@@ -57587,41 +57153,6 @@ declare class ClientBatchBuilder extends BatchBuilder {
     run(): Promise<BatchResult>;
 }
 
-/**
- * EvalBuilder - Fluent builder for evaluation runs
- *
- * Provides a chainable API for building evaluation configurations
- * that test flows against records with model overrides and comparisons.
- *
- * @example
- * ```typescript
- * import { EvalBuilder } from '@runtypelabs/sdk'
- *
- * // Single model eval with overrides
- * const eval1 = await new EvalBuilder()
- *   .useFlow('flow_abc123')
- *   .forRecordType('test_data')
- *   .withModelOverrides([{ stepName: 'Analyze', model: 'gpt-4o' }])
- *   .run(apiClient)
- *
- * // Multi-model comparison
- * const eval2 = await new EvalBuilder()
- *   .useFlow('flow_abc123')
- *   .forRecordType('test_data')
- *   .compareModels([
- *     { stepName: 'Analyze', model: 'gpt-5.4' },
- *     { stepName: 'Analyze', model: 'claude-opus-4-6' },
- *   ])
- *   .run(apiClient)
- *
- * // Virtual flow eval
- * const eval3 = await new EvalBuilder()
- *   .useVirtualFlow(flowBuilder)
- *   .forRecordType('test_data')
- *   .run(apiClient)
- * ```
- */
-
 interface ModelOverride {
     /** Name of the step to override */
     stepName: string;
@@ -57813,16 +57344,6 @@ declare class ClientEvalBuilder extends EvalBuilder {
     run(): Promise<EvalResult>;
 }
 
-/**
- * SDK Code Generation Metadata
- *
- * Type-safe field registry for generating SDK code from flow step configs.
- * Co-located with the step config interfaces so that adding or removing a
- * field on any config interface produces a compile error here, preventing
- * silent drift between the SDK and downstream code generators (e.g. the
- * dashboard's sdk-code-generator.ts).
- */
-
 /** How to serialize a field value into TypeScript source code. */
 type FieldFormat = 'json' | 'template' | 'raw' | 'value';
 /** Describes one field in a step config for code emission. */
@@ -58538,20 +58059,6 @@ declare const STEP_TYPE_TO_METHOD: {
     readonly 'memory-summary': "memorySummary";
 };
 
-/**
- * Named workflow hook registry.
- *
- * Workflow configs (the data form compiled by `compileWorkflowConfig`) can
- * reference behavior by name instead of carrying functions: `builtin:*` names
- * are reserved for the hooks that power the default workflow, and consumers
- * register their own under a custom namespace (e.g. `acme:my-completion`).
- *
- * Every hook declares which SLOT KIND it implements so a config that wires a
- * hook into the wrong slot fails at load/compile time with an actionable
- * error — not mid-marathon. Hook misfires in this system don't crash, they
- * stall, which is the worst failure mode to debug.
- */
-
 interface WorkflowHookSignatures {
     /** WorkflowPhase.buildInstructions — used verbatim (no header is added) */
     instructions: (state: RunTaskStateSlice) => string;
@@ -58605,27 +58112,6 @@ declare function listWorkflowHooks(): Array<{
 /** Test seam: remove a custom hook (builtin entries cannot be removed). */
 declare function unregisterWorkflowHook(name: string): boolean;
 
-/**
- * Declarative workflow configs and the compiler that turns them into a
- * `WorkflowDefinition`.
- *
- * This is the single compile path for marathon workflows-as-data: the CLI
- * playbook loader parses YAML/JSON into a `WorkflowConfig` and delegates here,
- * and the shipped default workflow is itself a `WorkflowConfig`
- * (`defaultWorkflowConfig` in default-workflow.ts) compiled through the same
- * function — so playbooks and the default cannot drift in semantics.
- *
- * Each behavior slot accepts either INLINE DATA (strings, declarative
- * criteria, policy rules) or a HOOK REFERENCE (`"<namespace>:<id>"`, see
- * hook-registry.ts) resolved against the registry with slot-kind validation
- * at compile time.
- *
- * The compiler is environment-free: no fs, no YAML, no glob library. Glob
- * matching for policy rules is injected via `WorkflowCompileDeps` (the CLI
- * passes micromatch); configs that use glob policies without a matcher fail
- * at compile time with an actionable error.
- */
-
 declare const DEFAULT_RECOVERY_AFTER_EMPTY_SESSIONS = 2;
 /** A `"<namespace>:<id>"` reference into the workflow hook registry. */
 type WorkflowHookRef = string;
@@ -58770,14 +58256,6 @@ declare function buildPolicyGuidance(policy?: WorkflowPolicyConfig): string[];
  */
 declare function compileWorkflowConfig(config: WorkflowConfig, deps?: WorkflowCompileDeps): WorkflowDefinition;
 
-/**
- * Default marathon workflow: research → planning → execution.
- *
- * This is a data-driven extraction of the previously hardcoded logic
- * in AgentsEndpoint. It handles both "modify" and "create" task variants
- * via the `workflowVariant` / `isCreationTask` flags on state.
- */
-
 /**
  * Register the default workflow's behaviors as `builtin:*` hooks. Idempotent.
  * Importing this module (or anything that pulls in `defaultWorkflow`) calls it
@@ -58797,58 +58275,10 @@ declare function ensureDefaultWorkflowHooks(): void;
 declare const defaultWorkflowConfig: WorkflowConfig;
 declare const defaultWorkflow: WorkflowDefinition;
 
-/**
- * Deploy workflow: scaffold → deploy.
- *
- * A streamlined two-phase workflow for tasks where the goal is to build
- * code and deploy it to a sandbox with a live preview URL, rather than
- * editing files in the local repository.
- *
- * Phase 1 (scaffold): Understand what the user wants built. Quick —
- * auto-advances after the agent has acknowledged the task.
- *
- * Phase 2 (deploy): Write code and call deploy_sandbox to get a live
- * preview URL. Iterate on errors until the deployment succeeds.
- */
-
 declare const deployWorkflow: WorkflowDefinition;
 
-/**
- * Game workflow: design → build → verify.
- *
- * A three-phase workflow for tasks where the goal is to build a game
- * (Three.js, Phaser, WebGL, etc.) and deploy it to a Daytona sandbox.
- *
- * The key difference from the deploy workflow is that game code often
- * uses template literals, which break when embedded inside Express
- * `res.send()` template literals. This workflow instructs the agent to
- * use the `files` parameter for multi-file deployment (Express static
- * server + separate HTML/JS/CSS files).
- *
- * Phase 1 (design): Understand game requirements. Auto-advances after
- * the first session.
- *
- * Phase 2 (build): Write game code using multi-file deployment. The
- * agent uses `code` for a minimal Express static server and `files`
- * for the actual game assets (HTML, JS, CSS).
- *
- * Phase 3 (verify): Confirm the game is running and playable. Auto-
- * accepts completion when deploy_sandbox has succeeded.
- */
-
 declare const gameWorkflow: WorkflowDefinition;
 
-/**
- * Helpers for WorkflowDefinition.stallPolicy: what happens when an agent
- * produces consecutive sessions with no tool actions.
- *
- * All thresholds count the run-level `consecutiveEmptySessions` counter (a
- * session is empty when it performed no write/read/discovery/verification
- * tool action), so narration-only sessions escalate here even though they
- * carry text output. Absent policy values preserve the legacy behavior:
- * no nudge, no escalation signal, stop after 3.
- */
-
 declare const DEFAULT_STALL_STOP_AFTER = 3;
 /** Resolve how many consecutive empty sessions end the run as 'stalled'. */
 declare function resolveStallStopAfter(policy?: WorkflowStallPolicy): number;