@treeseed/sdk 0.10.28 → 0.11.0

package/README.md

@@ -4,6 +4,21 @@
 
 For most consumers, the right entrypoint is `AgentSdk`.
 
+Use the SDK when you are writing automation, services, scripts, agents, or package internals that need Treeseed data, graph, workflow, config, reconciliation, hosting, package, or TreeDX integration primitives. Use the CLI when you want an operator command. Use Admin when you want a browser UI. Use API when you need the deployed backend service. Use UI when you need reusable components.
+
+## How SDK Fits With Treeseed
+
+The SDK is the shared platform substrate used by:
+
+- `@treeseed/core` for site runtime, content, plugin, and hosting integration
+- `@treeseed/admin` for admin contracts, view models, API facades, and platform primitives
+- `@treeseed/api` for backend contracts, reconciliation, operation state, and shared data models
+- `@treeseed/cli` for workflow, config, hosting, release, and reconciliation commands
+- `@treeseed/agent` for provider contracts and runtime coordination
+- root `@treeseed/market` for tenant config, content, and hosted workflow integration
+
+The SDK is not a UI package, admin portal, backend server, CLI parser, capacity-provider runtime, or ecommerce implementation. See the root [Package Ownership](../../docs/package-ownership.md) guide for the full system map.
+
 ## Which Surface Should I Use?
 
 Treeseed exposes three public SDK surfaces, but they are not peers:
@@ -24,9 +39,44 @@ If you are unsure, use `AgentSdk`.
 - operational runtime state such as messages, runs, cursors, and leases
 - control-plane orchestration for work days, tasks, task events, graph runs, and reports
 - provider-neutral capacity scheduling contracts for task classification, admission, execution profiles, routing, estimates, planning proposals, attention load, utility, predictive reserve, hybrid execution, checkpoints, and usage actuals
+- hosting graph compilation, deployment readiness, live hosted-service checks, Treeseed runner smoke helpers, and verification cache support for Treeseed workflows
 - graph-first context retrieval through `parseGraphDsl()`, `resolveSeeds()`, `queryGraph()`, and `buildContextPack()`
 - agent scoping through `scopeForAgent()`
 
+## Workflow And Hosting Support
+
+The SDK owns the shared implementation behind the fail-fast `trsd` deployment workflow.
+It also owns the canonical reconciliation platform for desired-state infrastructure. See the root workspace `docs/reconciliation-platform.md` for the full contract.
+
+Current workflow-support exports include:
+
+```ts
+import {
+  collectTreeseedDeploymentReadiness,
+  collectTreeseedLiveHostedServiceChecks,
+  formatTreeseedReadinessReport,
+  runTreeseedOperationsRunnerSmoke,
+} from '@treeseed/sdk/workflow-support';
+```
+
+These helpers are used by:
+
+- `trsd ready <local|staging|prod>`
+- `trsd hosting plan|apply|verify --environment <env> --service <id>`
+- `trsd audit hosting --environment <env> --live`
+- `trsd doctor --live --hosted-services`
+- `trsd operations smoke --environment <env> --service operationsRunner`
+- `trsd stage|release --verify-deployed-resources`
+
+For the API app, the expected hosted backend services are the API service, indexed Treeseed operations runner, PostgreSQL, and public TreeDX federation nodes owned by `packages/api`. The root web app remains a web UI and `/v1/*` proxy/client surface, with admin routes contributed by `@treeseed/admin` and visual primitives contributed by `@treeseed/ui`.
+
+Reconciliation guarantees:
+
+- command surfaces compile desired resources before provider mutation
+- cached state can locate resources but live observation proves readiness
+- hosted apply cannot report `ok: true` when live postconditions fail
+- adapter reports use `desiredGraph`, `observedGraph`, `stateGraph`, `diff`, `actions`, `postconditions`, `blockedDrift`, `providerLimitations`, `liveVerification`, and `ok`
+
 ## Install
 
 ```bash
@@ -61,6 +111,16 @@ const sdk = AgentSdk.createLocal({
 });
 ```
 
+## TreeDX Content Repository
+
+TreeDX is the generic repository service used by Treeseed when TreeDX service configuration is available. The SDK is the Treeseed integration and client layer: it configures the TreeDX portfolio, maps Treeseed model registry behavior onto generic repository/ref/path/frontmatter/body/query requests, and keeps product semantics outside TreeDX. The API package may host public TreeDX federation nodes as part of backend reconciliation.
+
+Project site code and optional project repositories remain local filesystem/git
+workspace concerns by default. Use `contentRepository: { adapter: 'local' }` or
+`AgentSdk.createLocal()` for explicit local content behavior.
+
+See [TreeDX Content Repository](./docs/treedx-content-repository.md).
+
 ## Preferred Graph Workflow
 
 The preferred graph API for new integrations is:
@@ -91,7 +151,7 @@ The public `ctx` syntax is:
 
 ```text
 ctx <target>
-  [for <stage>]
+  [for <focus>]
   [in <scope>]
   [via <relation[,relation...]>]
   [depth <0-3>]
@@ -103,9 +163,150 @@ ctx <target>
 
 The old `key=value` graph DSL is no longer supported.
 
+## TreeDX Remote Repository Mode
+
+TreeDX support is opt-in. Local SDK behavior remains the default.
+
+Use the low-level TreeDX client when you want direct repository, workspace, query, graph, registry, or context calls:
+
+```ts
+import { TreeDxClient } from '@treeseed/sdk/treedx';
+
+const treeDx = new TreeDxClient({
+  baseUrl: 'http://localhost:4000',
+  token: process.env.TREEDX_TOKEN,
+  repoId: 'repo_123',
+});
+
+const whoami = await treeDx.whoami();
+const file = await treeDx.readRepositoryFile({
+  path: 'docs/readme.md',
+  parseFrontmatter: true,
+});
+```
+
+`AgentSdk` can delegate content-backed model and graph calls to TreeDX when configured explicitly:
+
+```ts
+import { AgentSdk, TreeDxClient } from '@treeseed/sdk';
+
+const treeDx = new TreeDxClient({
+  baseUrl: 'http://localhost:4000',
+  token: process.env.TREEDX_TOKEN,
+  repoId: 'repo_123',
+});
+
+const sdk = new AgentSdk({
+  repoRoot: process.cwd(),
+  treeDx: {
+    enabled: true,
+    client: treeDx,
+    repoId: 'repo_123',
+    defaultRef: 'refs/heads/main',
+  },
+});
+
+const docs = await sdk.search({
+  model: 'knowledge',
+  filters: [{ field: 'status', op: 'eq', value: 'published' }],
+});
+```
+
+TreeDX mode keeps TreeSeed model semantics in the SDK model registry. TreeDX receives generic repository/ref/path/frontmatter/body/query requests and returns generic repository/file/query/graph results.
+
+TreeDX auth, policy, audit, and federation helpers are available on the same client:
+
+```ts
+const mode = await treeDx.authMode();
+const scope = await treeDx.effectiveScope({ repoId: 'repo_123' });
+
+await treeDx.putCapabilityGrant({
+  actorId: 'actor_agent',
+  tenantId: 'tenant_demo',
+  repoIds: ['repo_123'],
+  capabilities: ['files:read', 'files:search'],
+  refs: ['refs/heads/main'],
+  paths: ['docs/**'],
+});
+
+const audit = await treeDx.listAuditEvents({
+  repoId: 'repo_123',
+  eventType: 'repo.query_executed',
+  limit: 25,
+});
+
+const plan = await treeDx.planFederatedQuery({
+  repoIds: ['repo_123'],
+  capabilities: ['files:search'],
+  paths: { repo_123: ['docs/**'] },
+});
+
+const search = await treeDx.federatedSearch({
+  repoIds: ['repo_123'],
+  refs: { repo_123: 'refs/heads/main' },
+  paths: { repo_123: ['docs/**'] },
+  query: 'release',
+  includeErrors: true,
+});
+```
+
+Federation planning performs scope reduction before execution. The SDK delegates global execution to TreeDX instead of fanning out across every node and filtering locally.
+
+Snapshot, artifact, mirror sync, and migration helpers are also available on `TreeDxClient`:
+
+```ts
+const snapshot = await treeDx.buildSnapshot({
+  ref: 'refs/heads/main',
+  kind: 'repository_snapshot',
+  paths: ['docs/**'],
+  includeGraph: true,
+});
+
+const artifact = await treeDx.exportArtifact({
+  snapshotId: snapshot.snapshotId,
+});
+
+const download = await treeDx.downloadArtifact({
+  snapshotId: snapshot.snapshotId,
+});
+
+await treeDx.syncMirror({
+  mirrorId: 'mirror_123',
+  remoteName: 'origin',
+});
+
+await treeDx.createMigration({
+  targetNodeId: 'node_mirror',
+  mode: 'primary_transfer',
+  dryRun: true,
+  requireMirrorSynced: false,
+});
+
+await treeDx.ready();
+await treeDx.deepHealth();
+await treeDx.metrics();
+```
+
+`downloadArtifact()` returns an `ArrayBuffer` plus content type, filename, checksum, and snapshot headers. These APIs are generic TreeDX repository operations; TreeSeed package or release semantics are not encoded in TreeDX.
+
+Mocked end-to-end TreeDX contract tests prove the SDK can drive the TreeDX repository loop without an agent-side clone when `contentPathMap` is supplied:
+
+```bash
+npx vitest run --config ./vitest.config.ts test/utils/treedx-e2e-contract.test.ts
+```
+
+The optional live contract command reports `not configured` and exits
+successfully unless all of these are set:
+
+```text
+TREEDX_LIVE_URL
+TREEDX_LIVE_TOKEN
+TREEDX_LIVE_REPO_ID
+```
+
 ## Capacity Scheduling Contracts
 
-The SDK owns the provider-neutral capacity runtime helpers used by the agent manager, workers, and market control plane. These helpers keep work estimation separate from provider cost by normalizing `taskSignature + executionProfileId` estimates, then routing against grants, provider lanes, quality requirements, quota/congestion pressure, attention/context saturation, utility, predictive reserve, and hybrid phase metadata.
+The SDK owns the provider-neutral capacity runtime helpers used by the agent manager, workers, and market control plane. These helpers keep work estimation separate from provider cost by normalizing `taskSignature + executionProfileId` estimates, then routing against grants, provider lanes, quality requirements, quota/congestion pressure, attention/context saturation, utility, predictive reserve, and hybrid execution metadata.
 
 Capacity records remain metadata-compatible: advanced scheduling data lives in task payload JSON, routing decision candidates/scores, reservation metadata, capacity plan metadata, checkpoint artifacts, and usage actual metadata. Missing metadata is neutral, so older callers continue to use the credit-only behavior.
 
@@ -165,10 +366,10 @@ const scoped = sdk.scopeForAgent({
 
 ## Reference Docs
 
-- [SDK Interface Reference](/home/adrian/Projects/treeseed/market/src/content/knowledge/sdk/interface-reference.mdx)
-- [Graph API Guide](/home/adrian/Projects/treeseed/market/src/content/knowledge/sdk/graph-api-guide.mdx)
-- [ctx Query Language](/home/adrian/Projects/treeseed/market/src/content/knowledge/sdk/ctx-query-language.mdx)
-- [How ctx Works](/home/adrian/Projects/treeseed/market/src/content/knowledge/sdk/ctx-query-engine.mdx)
+- [SDK Interface Reference](../../src/content/knowledge/sdk/interface-reference.mdx)
+- [Graph API Guide](../../src/content/knowledge/sdk/graph-api-guide.mdx)
+- [ctx Query Language](../../src/content/knowledge/sdk/ctx-query-language.mdx)
+- [How ctx Works](../../src/content/knowledge/sdk/ctx-query-engine.mdx)
 
 ## Other Public Capabilities
 

package/dist/capacity-provider.d.ts

@@ -1,4 +1,5 @@
 import type { NativeUsageObservation } from './sdk-types.ts';
+import type { ProjectRepositoryTopology } from './sdk-types.ts';
 export declare const CAPACITY_PROVIDER_ENDPOINTS: {
     readonly register: "/v1/provider/register";
     readonly heartbeat: "/v1/provider/heartbeat";
@@ -12,7 +13,7 @@ export declare const CAPACITY_PROVIDER_ENDPOINTS: {
     readonly reports: "/v1/provider/reports";
 };
 export declare const CAPACITY_PROVIDER_SCOPES: readonly ["provider:register", "provider:heartbeat", "provider:portfolio:read", "provider:tasks:claim", "provider:tasks:update", "provider:usage:report", "provider:reports:write", "provider:capabilities:write"];
-export declare const CAPACITY_PROVIDER_ENV_KEYS: readonly ["TREESEED_MARKET_URL", "TREESEED_MARKET_ID", "TREESEED_CAPACITY_PROVIDER_API_KEY", "TREESEED_PROVIDER_HOST_DATA_DIR", "TREESEED_PROVIDER_DATA_DIR", "TREESEED_PROVIDER_API_PORT", "TREESEED_PROVIDER_HOST_API_PORT", "TREESEED_PROVIDER_ENVIRONMENT", "TREESEED_PROVIDER_CAPABILITIES_FILE", "TREESEED_PROVIDER_BUDGET_FILE", "TREESEED_PROVIDER_MAX_CONCURRENT_WORKDAYS", "TREESEED_PROVIDER_MAX_CONCURRENT_RUNNERS", "TREESEED_PROVIDER_DAILY_CREDIT_BUDGET", "TREESEED_PROVIDER_MONTHLY_CREDIT_BUDGET", "TREESEED_PROVIDER_STARTUP_MODE", "TREESEED_CODEX_AUTH_FILE", "TREESEED_CODEX_AUTH_JSON_B64", "TREESEED_CODEX_AUTH_OVERWRITE"];
+export declare const CAPACITY_PROVIDER_ENV_KEYS: readonly ["TREESEED_MARKET_URL", "TREESEED_MANAGER_ID", "TREESEED_CAPACITY_PROVIDER_API_KEY", "TREESEED_PROVIDER_HOST_DATA_DIR", "TREESEED_PROVIDER_DATA_DIR", "TREESEED_PROVIDER_API_PORT", "TREESEED_PROVIDER_HOST_API_PORT", "TREESEED_PROVIDER_ENVIRONMENT", "TREESEED_PROVIDER_CAPABILITIES_FILE", "TREESEED_PROVIDER_BUDGET_FILE", "TREESEED_PROVIDER_MAX_CONCURRENT_WORKDAYS", "TREESEED_PROVIDER_MAX_CONCURRENT_RUNNERS", "TREESEED_PROVIDER_DAILY_CREDIT_BUDGET", "TREESEED_PROVIDER_MONTHLY_CREDIT_BUDGET", "TREESEED_PROVIDER_STARTUP_MODE", "TREESEED_CODEX_AUTH_FILE", "TREESEED_CODEX_AUTH_JSON_B64", "TREESEED_CODEX_AUTH_OVERWRITE"];
 export type CapacityProviderScope = (typeof CAPACITY_PROVIDER_SCOPES)[number];
 export type CapacityProviderEnvironmentName = 'local' | 'staging' | 'prod' | 'production' | string;
 export type CapacityProviderLaunchMode = 'self_hosted' | 'managed_market_host' | 'connected_host';
@@ -154,6 +155,7 @@ export interface CapacityProviderPortfolioProject {
         submodulePath?: string | null;
         webUrl?: string | null;
     };
+    repositoryTopology?: ProjectRepositoryTopology;
     agentSpecs: {
         root: string;
         testsRoot: string;

package/dist/capacity-provider.js

@@ -32,7 +32,7 @@ const CAPACITY_PROVIDER_SCOPES = [
 ];
 const CAPACITY_PROVIDER_ENV_KEYS = [
   "TREESEED_MARKET_URL",
-  "TREESEED_MARKET_ID",
+  "TREESEED_MANAGER_ID",
   "TREESEED_CAPACITY_PROVIDER_API_KEY",
   "TREESEED_PROVIDER_HOST_DATA_DIR",
   "TREESEED_PROVIDER_DATA_DIR",
@@ -158,6 +158,26 @@ function assertCapacityProviderPortfolioManifest(value) {
     requireString(project, "slug", `Capacity provider portfolio project ${index}`);
     requireString(project, "name", `Capacity provider portfolio project ${index}`);
     if (!isRecord(project.repository)) throw new Error(`Capacity provider portfolio project ${index} is missing repository.`);
+    if (project.repositoryTopology !== void 0) {
+      if (!isRecord(project.repositoryTopology)) {
+        throw new Error(`Capacity provider portfolio project ${index} repositoryTopology must be an object.`);
+      }
+      if (!isRecord(project.repositoryTopology.contentRepository)) {
+        throw new Error(`Capacity provider portfolio project ${index} repositoryTopology is missing contentRepository.`);
+      }
+      if (project.repositoryTopology.contentRepository.accessMode !== "treedx") {
+        throw new Error(`Capacity provider portfolio project ${index} contentRepository must use treedx access.`);
+      }
+      if (!isRecord(project.repositoryTopology.siteRepository)) {
+        throw new Error(`Capacity provider portfolio project ${index} repositoryTopology is missing siteRepository.`);
+      }
+      if (project.repositoryTopology.siteRepository.accessMode !== "filesystem") {
+        throw new Error(`Capacity provider portfolio project ${index} siteRepository must use filesystem access.`);
+      }
+      if (project.repositoryTopology.projectRepository !== void 0 && project.repositoryTopology.projectRepository !== null && (!isRecord(project.repositoryTopology.projectRepository) || project.repositoryTopology.projectRepository.accessMode !== "filesystem")) {
+        throw new Error(`Capacity provider portfolio project ${index} projectRepository must use filesystem access.`);
+      }
+    }
     if (!isRecord(project.agentSpecs)) throw new Error(`Capacity provider portfolio project ${index} is missing agentSpecs.`);
     if (!isRecord(project.workPolicy)) throw new Error(`Capacity provider portfolio project ${index} is missing workPolicy.`);
   }
@@ -165,13 +185,13 @@ function assertCapacityProviderPortfolioManifest(value) {
 function resolveCapacityProviderEnvironment(input) {
   const env = {
     TREESEED_MARKET_URL: normalizeBaseUrl(input.marketUrl),
-    TREESEED_MARKET_ID: input.marketId.trim(),
+    TREESEED_MANAGER_ID: input.marketId.trim(),
     TREESEED_CAPACITY_PROVIDER_API_KEY: input.apiKey.trim(),
     TREESEED_PROVIDER_DATA_DIR: input.providerDataDir ?? "/data",
     TREESEED_PROVIDER_API_PORT: stringValue(input.providerApiPort, "3100"),
     TREESEED_PROVIDER_ENVIRONMENT: input.providerEnvironment ?? "local"
   };
-  if (!env.TREESEED_MARKET_ID) throw new Error("Capacity provider Market ID is required.");
+  if (!env.TREESEED_MANAGER_ID) throw new Error("Capacity provider Market ID is required.");
   if (!env.TREESEED_CAPACITY_PROVIDER_API_KEY) throw new Error("Capacity provider API key is required.");
   if (input.providerHostDataDir) env.TREESEED_PROVIDER_HOST_DATA_DIR = input.providerHostDataDir;
   if (input.capabilitiesFile) env.TREESEED_PROVIDER_CAPABILITIES_FILE = input.capabilitiesFile;
@@ -230,7 +250,7 @@ function resolveCapacityProviderLaunchEnvironment(input = {}) {
   }
   const required = [
     "TREESEED_MARKET_URL",
-    "TREESEED_MARKET_ID",
+    "TREESEED_MANAGER_ID",
     ...diagnostic ? [] : ["TREESEED_CAPACITY_PROVIDER_API_KEY"],
     "TREESEED_PROVIDER_HOST_DATA_DIR"
   ];
@@ -262,7 +282,7 @@ function persistCapacityProviderConnectionToTreeseedConfig(input) {
   const entryById = new Map(registryEntries.map((entry) => [entry.id, entry]));
   const keys = [
     "TREESEED_MARKET_URL",
-    "TREESEED_MARKET_ID",
+    "TREESEED_MANAGER_ID",
     "TREESEED_CAPACITY_PROVIDER_API_KEY",
     "TREESEED_PROVIDER_HOST_DATA_DIR",
     "TREESEED_PROVIDER_ENVIRONMENT"

package/dist/control-plane.d.ts

@@ -91,6 +91,7 @@ export interface ControlPlaneReporterOptions {
     baseUrl?: string | null;
     runnerToken?: string | null;
     fetchImpl?: typeof fetch;
+    requestTimeoutMs?: number | null;
 }
 export interface ResolveControlPlaneReporterOptions extends ControlPlaneReporterOptions {
     hostingKind?: TreeseedHostingKind | null;

package/dist/control-plane.js

@@ -21,8 +21,8 @@ function resolveReporterKind(options) {
   if (hostingKind === "self_hosted_project" && registration === "optional") {
     return "market_http";
   }
-  if (hostingKind === "market_control_plane") {
-    return normalizeUrl(options.baseUrl ?? process.env.TREESEED_MARKET_API_BASE_URL ?? options.deployConfig?.hosting?.marketBaseUrl) ? "self_http" : "noop";
+  if (hostingKind === "treeseed_control_plane") {
+    return normalizeUrl(options.baseUrl ?? process.env.TREESEED_API_BASE_URL ?? options.deployConfig?.hosting?.marketBaseUrl) ? "self_http" : "noop";
   }
   return "noop";
 }
@@ -60,13 +60,14 @@ class NoopControlPlaneReporter {
   }
 }
 class HttpControlPlaneReporter {
-  constructor(kind, projectId, baseUrl, runnerToken, fetchImpl = fetch) {
+  constructor(kind, projectId, baseUrl, runnerToken, fetchImpl = fetch, requestTimeoutMs) {
     this.kind = kind;
     this.projectId = projectId;
     this.baseUrl = baseUrl;
     this.runnerToken = runnerToken;
     this.fetchImpl = fetchImpl;
     this.enabled = Boolean(this.projectId && this.baseUrl && this.runnerToken);
+    this.requestTimeoutMs = normalizeRequestTimeoutMs(requestTimeoutMs);
   }
   kind;
   projectId;
@@ -74,18 +75,32 @@ class HttpControlPlaneReporter {
   runnerToken;
   fetchImpl;
   enabled;
+  requestTimeoutMs;
   async request(method, pathname, body) {
     if (!this.enabled || !this.baseUrl || !this.runnerToken) {
       return null;
     }
-    const response = await this.fetchImpl(new URL(pathname, this.baseUrl), {
-      method,
-      headers: {
-        authorization: `Bearer ${this.runnerToken}`,
-        "content-type": "application/json"
-      },
-      body: body === void 0 ? void 0 : JSON.stringify(body)
-    });
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), this.requestTimeoutMs);
+    let response;
+    try {
+      response = await this.fetchImpl(new URL(pathname, this.baseUrl), {
+        method,
+        headers: {
+          authorization: `Bearer ${this.runnerToken}`,
+          "content-type": "application/json"
+        },
+        body: body === void 0 ? void 0 : JSON.stringify(body),
+        signal: controller.signal
+      });
+    } catch (error) {
+      if (controller.signal.aborted) {
+        throw new Error(`Control-plane request timed out for ${pathname} after ${this.requestTimeoutMs}ms.`);
+      }
+      throw error;
+    } finally {
+      clearTimeout(timeout);
+    }
     if (!response.ok) {
       throw new Error(`Control-plane request failed for ${pathname}: ${response.status} ${response.statusText}`);
     }
@@ -154,6 +169,16 @@ class HttpControlPlaneReporter {
     return this.request("POST", `/v1/projects/${this.projectId}/runner/approval-requests`, input);
   }
 }
+function normalizeRequestTimeoutMs(value) {
+  if (Number.isFinite(value) && Number(value) > 0) {
+    return Number(value);
+  }
+  const fromEnv = Number.parseInt(String(process.env.TREESEED_CONTROL_PLANE_REQUEST_TIMEOUT_MS ?? ""), 10);
+  if (Number.isFinite(fromEnv) && fromEnv > 0) {
+    return fromEnv;
+  }
+  return 15e3;
+}
 function createControlPlaneReporter(options = {}) {
   const kind = resolveReporterKind(options);
   if (kind === "noop") {
@@ -163,13 +188,13 @@ function createControlPlaneReporter(options = {}) {
     options.projectId ?? process.env.TREESEED_PROJECT_ID ?? options.deployConfig?.hosting?.projectId ?? ""
   ).trim() || null;
   const baseUrl = normalizeUrl(
-    options.baseUrl ?? process.env.TREESEED_MARKET_API_BASE_URL ?? options.deployConfig?.hosting?.marketBaseUrl ?? null
+    options.baseUrl ?? process.env.TREESEED_API_BASE_URL ?? options.deployConfig?.hosting?.marketBaseUrl ?? null
   );
   const runnerToken = String(options.runnerToken ?? process.env.TREESEED_PROJECT_RUNNER_TOKEN ?? "").trim() || null;
   if (!projectId || !baseUrl || !runnerToken) {
     return new NoopControlPlaneReporter();
   }
-  return new HttpControlPlaneReporter(kind, projectId, baseUrl, runnerToken, options.fetchImpl);
+  return new HttpControlPlaneReporter(kind, projectId, baseUrl, runnerToken, options.fetchImpl, options.requestTimeoutMs);
 }
 export {
   createControlPlaneReporter