@treeseed/sdk 0.13.0-rc.2 → 0.13.0-rc.21

package/dist/capacity-provider/client.js

@@ -1,256 +1,163 @@
-import {
-  REMOTE_CONTRACT_HEADER,
-  REMOTE_CONTRACT_VERSION
-} from "../entrypoints/clients/remote.js";
-import {
-  CAPACITY_PROVIDER_ENDPOINTS,
-  CAPACITY_PROVIDER_GOVERNANCE_ENDPOINTS
-} from "./protocol.js";
-import {
-  assertCapacityProviderOkEnvelope,
-  buildCapacityProviderAuthHeaders
-} from "./security/http.js";
+import { ControlPlaneClient, ControlPlaneClientError } from "../entrypoints/clients/control-plane-client.js";
+import { CONTROL_PLANE_OPERATIONS } from "../operator-contracts/index.js";
 class CapacityProviderApiError extends Error {
   constructor(message, status, payload) {
     super(message);
     this.status = status;
     this.payload = payload;
     this.name = "CapacityProviderApiError";
-    this.code = isRecord(payload) && typeof payload.code === "string" ? payload.code : "capacity_provider_request_failed";
-    this.details = isRecord(payload) ? payload.details : void 0;
+    this.code = payload && typeof payload === "object" && typeof payload.code === "string" ? String(payload.code) : "capacity_provider_request_failed";
   }
   status;
   payload;
   code;
-  details;
 }
 function normalizeBaseUrl(value) {
-  const trimmed = value.trim().replace(/\/+$/u, "");
-  if (!trimmed) throw new Error("Capacity provider Market URL is required.");
-  return trimmed;
-}
-function isRecord(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function requireString(record, key, label) {
-  const value = record[key];
-  if (typeof value !== "string" || value.length === 0) throw new Error(`${label} is missing required string field "${key}".`);
-  return value;
-}
-function requireNumber(record, key, label) {
-  const value = record[key];
-  if (typeof value !== "number" || !Number.isFinite(value)) throw new Error(`${label} is missing required numeric field "${key}".`);
-  return value;
-}
-function assertAvailabilitySessionEnvelope(value) {
-  assertCapacityProviderOkEnvelope(value, "Capacity provider availability session response");
-  const envelope = value;
-  if (!isRecord(envelope.payload)) throw new Error("Capacity provider availability session response is missing payload.");
-  requireString(envelope.payload, "id", "Capacity provider availability session");
-  requireString(envelope.payload, "membershipId", "Capacity provider availability session");
-  requireString(envelope.payload, "teamId", "Capacity provider availability session");
-  requireString(envelope.payload, "providerId", "Capacity provider availability session");
-  requireString(envelope.payload, "status", "Capacity provider availability session");
-  requireNumber(envelope.payload, "sequence", "Capacity provider availability session");
+  const normalized = value.trim().replace(/\/+$/u, "");
+  if (!normalized) throw new Error("Capacity provider control-plane URL is required.");
+  return normalized;
 }
 class ProviderProtocolClient {
-  marketUrl;
+  controlPlaneUrl;
   accessToken;
   accessTokenProvider;
   fetchImpl;
   userAgent;
   requestTimeoutMs;
   constructor(options) {
-    this.marketUrl = normalizeBaseUrl(options.marketUrl);
+    this.controlPlaneUrl = normalizeBaseUrl(options.controlPlaneUrl);
     this.accessToken = options.accessToken?.trim() || void 0;
     this.accessTokenProvider = options.accessTokenProvider;
     this.fetchImpl = options.fetchImpl ?? fetch;
     this.userAgent = options.userAgent;
     this.requestTimeoutMs = Math.max(1e3, Number(options.requestTimeoutMs ?? 3e4) || 3e4);
   }
-  async requestJson(path, options = {}) {
-    const currentAccessToken = options.authorization === void 0 && this.accessTokenProvider ? (await this.accessTokenProvider()).trim() : this.accessToken ?? "";
-    if (currentAccessToken) this.accessToken = currentAccessToken;
-    const authorization = options.authorization === void 0 ? buildCapacityProviderAuthHeaders(currentAccessToken).authorization : options.authorization;
-    const headers = {
-      accept: "application/json",
-      [REMOTE_CONTRACT_HEADER]: String(REMOTE_CONTRACT_VERSION),
-      ...authorization ? { authorization } : {},
-      ...options.headers
-    };
-    if (this.userAgent) headers["user-agent"] = this.userAgent;
-    if (options.body !== void 0) headers["content-type"] = "application/json";
+  async bearer(required = true) {
+    const resolved = this.accessTokenProvider ? (await this.accessTokenProvider()).trim() : this.accessToken ?? "";
+    if (resolved) this.accessToken = resolved;
+    if (required && !resolved) throw new Error("Capacity provider membership access token is required.");
+    return resolved ? `Bearer ${resolved}` : null;
+  }
+  async invoke(operation, input, options = {}) {
     const controller = new AbortController();
     const timeout = setTimeout(() => controller.abort(), this.requestTimeoutMs);
-    let response;
-    let payload;
     try {
-      response = await this.fetchImpl(`${this.marketUrl}${path}`, {
-        method: options.method ?? "GET",
-        headers,
-        body: options.body === void 0 ? void 0 : JSON.stringify(options.body),
-        signal: controller.signal
-      });
-      payload = await response.json().catch((error) => {
-        if (controller.signal.aborted) throw error;
-        return {};
+      const authorization = options.authorization === void 0 ? await this.bearer(options.requireBearer ?? true) : options.authorization;
+      const client = new ControlPlaneClient({
+        profile: { serverId: "provider-control-plane", label: "Provider control plane", baseUrl: this.controlPlaneUrl },
+        fetchImpl: this.fetchImpl,
+        userAgent: this.userAgent
       });
+      const response = await client.invoke(operation, {
+        path: input.path ?? {},
+        query: input.query ?? {},
+        body: input.body
+      }, { authorization, headers: options.headers, idempotencyKey: options.idempotencyKey, signal: controller.signal });
+      return response.data;
     } catch (error) {
-      const message = controller.signal.aborted || error instanceof Error && error.name === "AbortError" ? `Capacity provider request timed out after ${this.requestTimeoutMs}ms: ${path}` : error instanceof Error ? error.message : String(error);
-      throw new CapacityProviderApiError(message, 0, { path, timeoutMs: this.requestTimeoutMs });
+      if (error instanceof CapacityProviderApiError) throw error;
+      if (error instanceof ControlPlaneClientError) throw new CapacityProviderApiError(error.message, error.status, error.problem);
+      const timedOut = controller.signal.aborted || error instanceof Error && error.name === "AbortError";
+      throw new CapacityProviderApiError(
+        timedOut ? `Capacity provider request timed out after ${this.requestTimeoutMs}ms.` : error instanceof Error ? error.message : String(error),
+        0,
+        { timeoutMs: this.requestTimeoutMs }
+      );
     } finally {
       clearTimeout(timeout);
     }
-    if (!response.ok) {
-      const message = isRecord(payload) && typeof payload.error === "string" ? payload.error : `Capacity provider request failed with ${response.status}.`;
-      throw new CapacityProviderApiError(message, response.status, payload);
-    }
-    return payload;
-  }
-  async requestOkJson(path, options = {}) {
-    const response = await this.requestJson(path, options);
-    assertCapacityProviderOkEnvelope(response);
-    return response;
-  }
-  async requestPayload(path, options) {
-    const response = await this.requestJson(path, options);
-    if (isRecord(response) && "payload" in response) return response.payload;
-    return response;
   }
   register(registrationKey, submission, idempotencyKey) {
     const key = registrationKey.trim();
     if (!key) throw new Error("Team capacity registration key is required.");
-    return this.requestPayload(CAPACITY_PROVIDER_GOVERNANCE_ENDPOINTS.registrations, {
-      method: "POST",
-      authorization: `Treeseed-Registration ${key}`,
-      headers: { "idempotency-key": idempotencyKey },
-      body: submission
-    });
+    return this.invoke(CONTROL_PLANE_OPERATIONS.providers.register, { body: submission }, { authorization: `Treeseed-Registration ${key}`, idempotencyKey });
   }
   registrationStatus(requestId, proof) {
-    return this.requestPayload(CAPACITY_PROVIDER_GOVERNANCE_ENDPOINTS.registration(requestId), {
+    return this.invoke(CONTROL_PLANE_OPERATIONS.providers.registration, { path: { requestId } }, {
       authorization: null,
       headers: { "x-treeseed-provider-proof": Buffer.from(JSON.stringify(proof)).toString("base64url") }
     });
   }
   exchangeCredential(requestId, proof, idempotencyKey) {
-    return this.requestPayload(CAPACITY_PROVIDER_GOVERNANCE_ENDPOINTS.registrationCredential(requestId), {
-      method: "POST",
-      authorization: null,
-      headers: { "idempotency-key": idempotencyKey },
-      body: { proof }
-    });
+    return this.invoke(CONTROL_PLANE_OPERATIONS.providers.exchangeCredential, { path: { requestId }, body: { proof } }, { authorization: null, idempotencyKey });
   }
   issueAccessToken(credential, credentialId, proof, idempotencyKey, requestedValiditySeconds) {
     const value = credential.trim();
     if (!value) throw new Error("Provider team credential is required.");
-    return this.requestPayload(CAPACITY_PROVIDER_GOVERNANCE_ENDPOINTS.accessTokens, {
-      method: "POST",
-      authorization: `Treeseed-Credential ${value}`,
-      headers: { "idempotency-key": idempotencyKey },
-      body: { credentialId, requestedValiditySeconds, proof }
-    });
+    return this.invoke(CONTROL_PLANE_OPERATIONS.providers.issueAccessToken, { body: { credentialId, requestedValiditySeconds, proof } }, { authorization: `Treeseed-Credential ${value}`, idempotencyKey });
   }
   leaveMembership(accessToken, idempotencyKey) {
-    return this.requestPayload(CAPACITY_PROVIDER_GOVERNANCE_ENDPOINTS.membershipLeave, {
-      method: "POST",
-      authorization: buildCapacityProviderAuthHeaders(accessToken).authorization,
-      headers: { "idempotency-key": idempotencyKey },
-      body: {}
-    });
+    return this.invoke(CONTROL_PLANE_OPERATIONS.providers.leaveMembership, { body: {} }, { authorization: `Bearer ${accessToken}`, idempotencyKey });
   }
   authorizeCredentialRotation(accessToken, idempotencyKey) {
-    return this.requestPayload(CAPACITY_PROVIDER_GOVERNANCE_ENDPOINTS.credentialRotation, {
-      method: "POST",
-      authorization: buildCapacityProviderAuthHeaders(accessToken).authorization,
-      headers: { "idempotency-key": idempotencyKey },
-      body: {}
-    });
+    return this.invoke(CONTROL_PLANE_OPERATIONS.providers.rotateCredential, { body: {} }, { authorization: `Bearer ${accessToken}`, idempotencyKey });
   }
   rotateIdentity(accessToken, request, idempotencyKey) {
-    return this.requestPayload(CAPACITY_PROVIDER_GOVERNANCE_ENDPOINTS.identityRotate, {
-      method: "POST",
-      authorization: buildCapacityProviderAuthHeaders(accessToken).authorization,
-      headers: { "idempotency-key": idempotencyKey },
-      body: request
-    });
+    return this.invoke(CONTROL_PLANE_OPERATIONS.providers.rotateIdentity, { body: request }, { authorization: `Bearer ${accessToken}`, idempotencyKey });
   }
   createAvailabilitySession(request = {}) {
-    return this.requestOkJson(CAPACITY_PROVIDER_ENDPOINTS.sessions, { method: "POST", body: request }).then((response) => {
-      assertAvailabilitySessionEnvelope(response);
-      return response;
-    });
+    return this.invoke(CONTROL_PLANE_OPERATIONS.providers.createAvailability, { body: request });
   }
   refreshAvailabilitySession(sessionId, request = {}) {
-    return this.requestOkJson(CAPACITY_PROVIDER_ENDPOINTS.sessionRefresh(sessionId), { method: "PUT", body: request }).then((response) => {
-      assertAvailabilitySessionEnvelope(response);
-      return response;
-    });
+    return this.invoke(CONTROL_PLANE_OPERATIONS.providers.refreshAvailability, { path: { sessionId }, body: request });
   }
   closeAvailabilitySession(sessionId) {
-    return this.requestOkJson(CAPACITY_PROVIDER_ENDPOINTS.sessionClose(sessionId), { method: "POST", body: {} }).then((response) => {
-      assertAvailabilitySessionEnvelope(response);
-      return response;
-    });
+    return this.invoke(CONTROL_PLANE_OPERATIONS.providers.closeAvailability, { path: { sessionId }, body: {} });
   }
   assignment(assignmentId) {
-    return this.requestOkJson(CAPACITY_PROVIDER_ENDPOINTS.assignment(assignmentId));
+    return this.invoke(CONTROL_PLANE_OPERATIONS.providers.assignment, { path: { assignmentId } });
   }
   assignmentExplanation(assignmentId) {
-    return this.requestOkJson(CAPACITY_PROVIDER_ENDPOINTS.assignmentExplanation(assignmentId));
+    return this.invoke(CONTROL_PLANE_OPERATIONS.providers.assignmentExplanation, { path: { assignmentId } });
   }
   nextAssignment(request = {}) {
-    return this.requestOkJson(CAPACITY_PROVIDER_ENDPOINTS.nextAssignment, { method: "POST", body: request });
+    return this.invoke(CONTROL_PLANE_OPERATIONS.providers.nextAssignment, { body: request });
   }
   renewAssignment(assignmentId, request = {}) {
-    return this.requestOkJson(CAPACITY_PROVIDER_ENDPOINTS.assignmentRenew(assignmentId), { method: "POST", body: request });
+    return this.invoke(CONTROL_PLANE_OPERATIONS.providers.renewAssignment, { path: { assignmentId }, body: request });
   }
   startAssignmentExecution(assignmentId, request) {
-    return this.requestOkJson(CAPACITY_PROVIDER_ENDPOINTS.assignmentExecutionStart(assignmentId), { method: "POST", body: request });
+    return this.invoke(CONTROL_PLANE_OPERATIONS.providers.startExecution, { path: { assignmentId }, body: request });
   }
   startAssignmentCloseout(assignmentId, request) {
-    return this.requestOkJson(CAPACITY_PROVIDER_ENDPOINTS.assignmentCloseoutStart(assignmentId), { method: "POST", body: request });
+    return this.invoke(CONTROL_PLANE_OPERATIONS.providers.startCloseout, { path: { assignmentId }, body: request });
   }
   preflightAssignmentCompletion(assignmentId, request) {
-    return this.requestOkJson(CAPACITY_PROVIDER_ENDPOINTS.assignmentCompletionPreflight(assignmentId), { method: "POST", body: request });
+    return this.invoke(CONTROL_PLANE_OPERATIONS.providers.completionPreflight, { path: { assignmentId }, body: request });
   }
   returnAssignment(assignmentId, request = {}) {
-    return this.requestOkJson(CAPACITY_PROVIDER_ENDPOINTS.assignmentReturn(assignmentId), { method: "POST", body: request });
+    return this.invoke(CONTROL_PLANE_OPERATIONS.providers.returnAssignment, { path: { assignmentId }, body: request });
   }
   completeAssignment(assignmentId, request = {}) {
-    return this.requestOkJson(CAPACITY_PROVIDER_ENDPOINTS.assignmentComplete(assignmentId), { method: "POST", body: request });
+    return this.invoke(CONTROL_PLANE_OPERATIONS.providers.completeAssignment, { path: { assignmentId }, body: request });
   }
   failAssignment(assignmentId, request = {}) {
-    return this.requestOkJson(CAPACITY_PROVIDER_ENDPOINTS.assignmentFail(assignmentId), { method: "POST", body: request });
+    return this.invoke(CONTROL_PLANE_OPERATIONS.providers.failAssignment, { path: { assignmentId }, body: request });
   }
   reportAssignmentUsage(assignmentId, request, idempotencyKey) {
-    return this.requestOkJson(CAPACITY_PROVIDER_ENDPOINTS.assignmentUsage(assignmentId), { method: "POST", body: request, headers: { "idempotency-key": idempotencyKey } });
+    return this.invoke(CONTROL_PLANE_OPERATIONS.providers.reportUsage, { path: { assignmentId }, body: request }, { idempotencyKey });
   }
   settleAssignment(assignmentId, request, idempotencyKey) {
-    return this.requestOkJson(CAPACITY_PROVIDER_ENDPOINTS.assignmentSettle(assignmentId), { method: "POST", body: request, headers: { "idempotency-key": idempotencyKey } });
+    return this.invoke(CONTROL_PLANE_OPERATIONS.providers.settleAssignment, { path: { assignmentId }, body: request }, { idempotencyKey });
   }
   createAssignmentModeRun(assignmentId, request) {
-    return this.requestOkJson(CAPACITY_PROVIDER_ENDPOINTS.assignmentModeRuns(assignmentId), { method: "POST", body: request });
+    return this.invoke(CONTROL_PLANE_OPERATIONS.providers.createModeRun, { path: { assignmentId }, body: request });
   }
   createAssignmentEvent(assignmentId, request) {
-    return this.requestOkJson(CAPACITY_PROVIDER_ENDPOINTS.assignmentEvents(assignmentId), { method: "POST", body: request });
+    return this.invoke(CONTROL_PLANE_OPERATIONS.providers.createEvent, { path: { assignmentId }, body: request });
   }
   publishAssignmentSignal(assignmentId, request) {
-    return this.requestOkJson(CAPACITY_PROVIDER_ENDPOINTS.assignmentSignals(assignmentId), { method: "POST", body: request });
+    return this.invoke(CONTROL_PLANE_OPERATIONS.providers.publishSignal, { path: { assignmentId }, body: request });
   }
   dispatchAssignmentWorkflowOperation(assignmentId, operationId, request) {
-    return this.requestOkJson(CAPACITY_PROVIDER_ENDPOINTS.assignmentWorkflowOperationDispatch(assignmentId, operationId), { method: "POST", body: request });
+    return this.invoke(CONTROL_PLANE_OPERATIONS.providers.dispatchWorkflow, { path: { assignmentId, operationId }, body: request });
   }
   getAssignmentWorkflowRun(assignmentId, runId) {
-    return this.requestOkJson(CAPACITY_PROVIDER_ENDPOINTS.assignmentWorkflowRun(assignmentId, runId));
+    return this.invoke(CONTROL_PLANE_OPERATIONS.providers.workflowRun, { path: { assignmentId, runId } });
   }
 }
 export {
   CapacityProviderApiError,
   ProviderProtocolClient,
-  assertAvailabilitySessionEnvelope,
-  isRecord,
-  normalizeBaseUrl,
-  requireNumber,
-  requireString
+  normalizeBaseUrl
 };

package/dist/capacity-provider/contracts/governance.d.ts

@@ -236,32 +236,39 @@ export interface CapacityExecutionProvider {
 }
 /** Optional provider-global lane that narrows an execution provider's limits. */
 export interface CapacityProviderLane {
-    schemaVersion: 1;
+    schemaVersion: 2;
     id: string;
     providerId: string;
-    executionProviderId: string;
     displayName: string;
     purpose: import('../../agent-capacity/contracts/capacity/communication/communication-records.js').ProviderLanePurpose;
     status: CapacityProviderLaneStatus;
+    priority: number;
+    reservedConcurrentWorkers: number;
+    borrowWhenIdle: boolean;
+    lendWhenIdle: boolean;
+    reclaimPolicy: 'admission';
+    queueLimit: number;
+    timeoutSeconds: number;
     capabilities: string[];
-    maxConcurrentRunners: number;
+    maxConcurrentWorkers: number;
     minimumAssignmentDuration?: MinimumAssignmentDuration;
-    nativeLimits: CapacityExecutionProviderNativeLimit[];
     metadata?: Record<string, unknown>;
     createdAt: string;
     updatedAt: string;
 }
 export interface ProviderLaneSnapshot {
     id: string;
-    executionProviderId: string;
     purpose: import('../../agent-capacity/contracts/capacity/communication/communication-records.js').ProviderLanePurpose;
     status: CapacityProviderLaneStatus;
+    priority: number;
+    reservedConcurrentWorkers: number;
+    borrowedWorkers: number;
+    lentWorkers: number;
+    queuedAssignments: number;
     capabilities: string[];
-    maxConcurrentRunners: number;
-    activeRunners: number;
+    maxConcurrentWorkers: number;
+    activeWorkers: number;
     minimumAssignmentDuration?: MinimumAssignmentDuration;
-    preferred?: boolean;
-    nativeLimits: Record<string, unknown>;
 }
 export type MinimumAssignmentDuration = {
     amount: number;
@@ -275,28 +282,31 @@ export type MinimumAssignmentDuration = {
         holidayDates?: string[];
     };
 };
-export interface ProviderExecutionProviderSnapshot {
+export interface ProviderExecutionAdapterSnapshot {
     id: string;
     adapter: string;
+    isolation: 'process' | 'worker';
     status: 'available' | 'degraded' | 'unavailable';
     capabilities: string[];
-    maxConcurrentRunners: number;
-    activeRunners: number;
+    laneIds: string[];
+    maxConcurrentWorkers: number;
+    activeWorkers: number;
     minimumAssignmentDuration?: MinimumAssignmentDuration;
     nativeLimits: Record<string, unknown>;
     observations?: Record<string, unknown>;
-    lanes: ProviderLaneSnapshot[];
 }
 export interface ProviderAvailabilitySnapshot {
     sequence: number;
     availableFrom: string;
     availableUntil?: string | null;
     pressure: 'idle' | 'normal' | 'busy' | 'throttled' | 'exhausted';
-    maxConcurrentAssignments: number;
+    maxConcurrentWorkers: number;
     activeAssignmentIds: string[];
-    executionProviders: ProviderExecutionProviderSnapshot[];
-    communicationReady: boolean;
-    communicationBlockers: string[];
+    reservedWorkers: number;
+    borrowedWorkers: number;
+    availableWorkers: number;
+    adapters: ProviderExecutionAdapterSnapshot[];
+    lanes: ProviderLaneSnapshot[];
     capabilities: string[];
     constraints?: Record<string, unknown>;
 }
@@ -315,9 +325,9 @@ export interface ProviderAvailabilitySession {
 }
 export interface ProviderConnectionConfig {
     id: string;
-    marketProfile?: string;
-    marketUrl?: string;
-    marketAudience?: string;
+    serverProfile?: string;
+    controlPlaneUrl?: string;
+    controlPlaneAudience?: string;
     teamId: string;
     providerId: string;
     membershipId: string;
@@ -329,15 +339,14 @@ export interface ProviderConnectionConfig {
 /** One-time onboarding input. It is never valid durable provider runtime configuration. */
 export interface CapacityProviderJoinInput {
     id: string;
-    marketProfile?: string;
-    marketUrl?: string;
-    marketAudience?: string;
+    serverProfile?: string;
+    controlPlaneUrl?: string;
+    controlPlaneAudience?: string;
     registrationKeyRef: string;
     offer: ProviderSupplyOffer;
 }
-export interface CapacityProviderManifestV2 {
-    schemaVersion: 2;
-    providerClass: 'agent' | 'platform-operation';
+export interface CapacityProviderManifestV3 {
+    schemaVersion: 3;
     ownership: {
         type: 'team' | 'external';
         teamId?: string;
@@ -350,8 +359,15 @@ export interface CapacityProviderManifestV2 {
         privateKeyRef: string;
         displayName: string;
     };
-    supplyCeilings: {
-        maxConcurrentAssignments: number;
+    capacity: {
+        maxConcurrentWorkers: number;
+        cpuCores?: number;
+        memoryBytes?: number;
+        accelerators?: Array<{
+            kind: string;
+            count: number;
+            memoryBytes?: number;
+        }>;
         maxActiveSeconds?: number;
         maxInputTokens?: number;
         maxOutputTokens?: number;
@@ -359,16 +375,30 @@ export interface CapacityProviderManifestV2 {
         currency?: string;
         maxAttempts?: number;
     };
-    credentialBindings?: Array<{
+    credentialProfiles?: Array<{
         id: string;
         source: 'service-vault' | 'process-environment';
         reference: string;
         required: boolean;
     }>;
-    defaultExecutionProviderId?: string;
-    executionProviders: Array<{
+    lanes: Array<{
+        id: string;
+        purpose: import('../../agent-capacity/contracts/capacity/communication/communication-records.js').ProviderLanePurpose;
+        priority: number;
+        reservedConcurrentWorkers: number;
+        maxConcurrentWorkers: number;
+        borrowWhenIdle: boolean;
+        lendWhenIdle: boolean;
+        reclaimPolicy: 'admission';
+        queueLimit: number;
+        timeoutSeconds: number;
+        minimumAssignmentDuration?: MinimumAssignmentDuration;
+        capabilities?: string[];
+    }>;
+    adapters: Array<{
         id: string;
         adapter: string;
+        isolation: 'process' | 'worker';
         profile?: string;
         module?: string;
         protocol?: 'responses' | 'chat-completions';
@@ -377,7 +407,9 @@ export interface CapacityProviderManifestV2 {
             baseUrl?: string;
             model?: string;
         };
-        credentialBindings?: string[];
+        credentialProfiles?: string[];
+        laneIds: string[];
+        maxConcurrentWorkers: number;
         healthProbe?: string;
         versionConstraint?: string;
         configurationDigest?: string;
@@ -385,14 +417,6 @@ export interface CapacityProviderManifestV2 {
         nativeLimits: Record<string, unknown>;
         researchSourcePolicy?: ResearchSourcePolicy;
         capabilities?: string[];
-        lanes?: Array<{
-            id: string;
-            purpose: import('../../agent-capacity/contracts/capacity/communication/communication-records.js').ProviderLanePurpose;
-            maxConcurrentRunners: number;
-            minimumAssignmentDuration?: MinimumAssignmentDuration;
-            capabilities?: string[];
-            nativeLimits?: Record<string, unknown>;
-        }>;
     }>;
     connections: ProviderConnectionConfig[];
     metadata?: Record<string, unknown>;

package/dist/capacity-provider/index.d.ts

@@ -1,8 +1,3 @@
 export * from './client.js';
-export * from './config/index.js';
 export * from './contracts/index.js';
-export * from './protocol.js';
-export * from './runtime-status.js';
-export * from './security/index.js';
-export * from './timing/index.js';
 export * from './validation.js';

package/dist/capacity-provider/index.js

@@ -1,8 +1,3 @@
 export * from "./client.js";
-export * from "./config/index.js";
 export * from "./contracts/index.js";
-export * from "./protocol.js";
-export * from "./runtime-status.js";
-export * from "./security/index.js";
-export * from "./timing/index.js";
 export * from "./validation.js";

package/dist/capacity-provider/validation.d.ts

@@ -1,4 +1,4 @@
-import { type CapacityProviderManifestV2, type CapacityProviderProofPayload, type CapacityProviderPublicJwk, type ProviderSupplyOffer } from './contracts/index.js';
+import { type CapacityProviderManifestV3, type CapacityProviderProofPayload, type CapacityProviderPublicJwk, type ProviderSupplyOffer } from './contracts/index.js';
 export interface CapacityProviderContractDiagnostic {
     code: string;
     path: string;
@@ -19,7 +19,7 @@ export declare function validateCapacityProviderProofPayload(payload: CapacityPr
     expectedAudience?: string;
 }): CapacityProviderContractValidation;
 export declare function validateProviderSupplyOffer(offer: ProviderSupplyOffer, path?: string): CapacityProviderContractValidation;
-export declare function validateCapacityProviderManifestV2(manifest: CapacityProviderManifestV2): CapacityProviderContractValidation;
+export declare function validateCapacityProviderManifestV3(manifest: CapacityProviderManifestV3): CapacityProviderContractValidation;
 export declare function capacityProviderSecurityDefaults(): {
     proofTtlSeconds: number;
     accessTokenTtlSeconds: number;