@treeseed/sdk 0.12.62 → 0.13.0-rc.10

package/dist/agent-capacity/workday.js

@@ -0,0 +1,105 @@
+function uniqueStrings(value) {
+  if (!Array.isArray(value)) return [];
+  return [...new Set(value.map((item) => String(item).trim()).filter(Boolean))].sort();
+}
+function normalizeWorkdayAgentSelection(value) {
+  const input = record(value);
+  return {
+    classIds: uniqueStrings(input.classIds),
+    classSlugs: uniqueStrings(input.classSlugs),
+    agentSlugs: uniqueStrings(input.agentSlugs),
+    activityTypes: uniqueStrings(input.activityTypes),
+    mode: input.mode === "union" ? "union" : "intersection"
+  };
+}
+function workdayAgentSelectionActive(selection) {
+  return selection.classIds.length > 0 || selection.classSlugs.length > 0 || selection.agentSlugs.length > 0 || selection.activityTypes.length > 0;
+}
+function selectWorkdayAgents(agents, value) {
+  const selection = normalizeWorkdayAgentSelection(value);
+  if (!workdayAgentSelectionActive(selection)) return agents;
+  const classSelectors = /* @__PURE__ */ new Set([...selection.classIds, ...selection.classSlugs]);
+  const agentSelectors = new Set(selection.agentSlugs);
+  const activitySelectors = new Set(selection.activityTypes);
+  return agents.filter((agent) => {
+    const classMatch = classSelectors.size === 0 || [agent.projectAgentClassId, agent.projectAgentClassSlug].some((candidate) => candidate && [...classSelectors].some((selector) => selector === candidate || selector.endsWith(`:${candidate}`)));
+    const agentMatch = agentSelectors.size === 0 || agentSelectors.has(agent.slug);
+    const activityMatch = activitySelectors.size === 0 || Boolean(agent.activityType && activitySelectors.has(agent.activityType));
+    if (selection.mode === "union") {
+      return classSelectors.size > 0 && classMatch || agentSelectors.size > 0 && agentMatch || activitySelectors.size > 0 && activityMatch;
+    }
+    return classMatch && agentMatch && activityMatch;
+  });
+}
+function record(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+function selectFairPlanningAgentCycles(projectId, agents, existingAssignments, limit) {
+  if (!agents.length || limit <= 0) return [];
+  const uniqueAgents = [...new Map(agents.filter((agent) => agent.slug.trim()).map((agent) => [agent.slug, agent])).values()];
+  if (!uniqueAgents.length) return [];
+  const cyclesByAgent = /* @__PURE__ */ new Map();
+  for (const assignment of existingAssignments) {
+    const metadata = record(assignment.metadata);
+    const assignmentProjectId = String(assignment.projectId ?? assignment.project_id ?? "");
+    const agentSlug = String(assignment.agentId ?? assignment.agent_id ?? metadata.agentSlug ?? "");
+    const cycle = Number(metadata.cycle ?? 1);
+    if (assignmentProjectId !== projectId || !agentSlug || !Number.isFinite(cycle) || cycle <= 0) continue;
+    const normalizedCycle = Math.floor(cycle);
+    const cycles = cyclesByAgent.get(agentSlug) ?? /* @__PURE__ */ new Set();
+    cycles.add(normalizedCycle);
+    cyclesByAgent.set(agentSlug, cycles);
+  }
+  const classes = /* @__PURE__ */ new Map();
+  for (const agent of uniqueAgents) {
+    const classSlug = String(agent.projectAgentClassSlug ?? agent.projectAgentClassId ?? "planning");
+    classes.set(classSlug, [...classes.get(classSlug) ?? [], agent]);
+  }
+  const defaultClassPercent = classes.size > 0 ? 100 / classes.size : 100;
+  const shares = /* @__PURE__ */ new Map();
+  for (const classAgents of classes.values()) {
+    const configured = classAgents.map((agent) => Number(agent.planningAllocationPercent ?? Number.NaN)).find((value) => Number.isFinite(value) && value > 0);
+    const share = (configured ?? defaultClassPercent) / Math.max(1, classAgents.length);
+    for (const agent of classAgents) shares.set(agent.slug, Math.max(0.01, share));
+  }
+  const selected = [];
+  const nextCycle = (agent) => {
+    const claimed = cyclesByAgent.get(agent.slug) ?? /* @__PURE__ */ new Set();
+    let cycle = 1;
+    while (claimed.has(cycle)) cycle += 1;
+    return cycle;
+  };
+  while (selected.length < limit) {
+    const minimumCycle = Math.min(...uniqueAgents.map(nextCycle));
+    const ranked = uniqueAgents.filter((agent2) => nextCycle(agent2) === minimumCycle).sort((left, right) => {
+      const leftCount = cyclesByAgent.get(left.slug)?.size ?? 0;
+      const rightCount = cyclesByAgent.get(right.slug)?.size ?? 0;
+      const delta = leftCount / (shares.get(left.slug) ?? 1) - rightCount / (shares.get(right.slug) ?? 1);
+      return Math.abs(delta) > 1e-6 ? delta : left.slug.localeCompare(right.slug);
+    });
+    const agent = ranked[0];
+    if (!agent) break;
+    const cycle = nextCycle(agent);
+    selected.push({ agent, cycle });
+    const cycles = cyclesByAgent.get(agent.slug) ?? /* @__PURE__ */ new Set();
+    cycles.add(cycle);
+    cyclesByAgent.set(agent.slug, cycles);
+  }
+  return selected;
+}
+function evaluateWorkdayContinuation(input) {
+  if (input.status !== "active" && input.status !== "running") return { continue: false, reason: "workday_not_active" };
+  const deadline = input.deadlineAt ? Date.parse(input.deadlineAt) : Number.POSITIVE_INFINITY;
+  if (Number.isFinite(deadline) && deadline <= Date.parse(input.now)) return { continue: false, reason: "duration_bound_reached" };
+  if (input.totalSeconds - input.committedSeconds <= 0) return { continue: false, reason: "budget_bound_reached" };
+  if (!input.usefulEligibleWork) return { continue: false, reason: "no_useful_eligible_work" };
+  return { continue: true, reason: "within_duration_and_budget" };
+}
+export {
+  evaluateWorkdayContinuation,
+  normalizeWorkdayAgentSelection,
+  record,
+  selectFairPlanningAgentCycles,
+  selectWorkdayAgents,
+  workdayAgentSelectionActive
+};

package/dist/ai-appliance/contracts.d.ts

@@ -0,0 +1,90 @@
+export declare const AI_APPLIANCE_SCHEMA_VERSION: "treeseed.ai-appliance/v1";
+export declare const EXECUTION_PROVIDER_MODULE_SCHEMA_VERSION: "treeseed.execution-provider/v1";
+export declare const DEFAULT_AI_CONTROL_PLANE_URL: "https://api.treeseed.dev";
+export declare const DEFAULT_AI_MANAGEMENT_URL: "http://127.0.0.1:4770";
+export declare const DEFAULT_AI_GATEWAY_URL: "http://127.0.0.1:4771";
+export declare const DEFAULT_AI_MODEL_ALIAS: "treeseed-qwen3.5-4b";
+export declare const DEFAULT_AI_MODEL_ID: "Qwen/Qwen3.5-4B";
+export type AiApplianceMode = 'joined' | 'standalone';
+export type InferenceProtocol = 'responses' | 'chat-completions';
+export type ExecutionProviderProfile = 'subscription' | 'key' | 'treeseed' | string;
+export interface AiApplianceManifest {
+    schemaVersion: typeof AI_APPLIANCE_SCHEMA_VERSION;
+    mode: AiApplianceMode;
+    management: {
+        socket: string;
+        loopbackUrl?: string;
+    };
+    controlPlane: {
+        enabled: boolean;
+        url: string;
+        audience: string;
+    };
+    inference: {
+        publicAlias: string;
+        model: string;
+        gatewayUrl: string;
+        rawVllmUrl: string;
+        maxModelLength: number;
+        maxConcurrentSequences: number;
+        gpuMemoryUtilization: number;
+        apiKeyRef?: string;
+    };
+    providers: {
+        agent: AiApplianceProviderSelection;
+        platformOperation: AiApplianceProviderSelection;
+    };
+    standalone?: {
+        localControlPlane: {
+            enabled: boolean;
+            apiUrl: string;
+            webUrl: string;
+        };
+    };
+}
+export interface AiApplianceProviderSelection {
+    enabled: boolean;
+    manifest: string;
+}
+export interface ExecutionProviderRuntimeConfiguration {
+    profile?: ExecutionProviderProfile;
+    module?: string;
+    protocol?: InferenceProtocol;
+    model?: {
+        endpointRef?: string;
+        baseUrl?: string;
+        model?: string;
+    };
+    credentialBindings?: string[];
+    healthProbe?: string;
+    versionConstraint?: string;
+    configurationDigest?: string;
+}
+export interface ExecutionProviderModuleManifest {
+    schemaVersion: typeof EXECUTION_PROVIDER_MODULE_SCHEMA_VERSION;
+    id: string;
+    package: string;
+    version: string;
+    apiVersion: typeof EXECUTION_PROVIDER_MODULE_SCHEMA_VERSION;
+    entrypoint: string;
+    adapters: string[];
+    permissions: {
+        network: string[];
+        credentials: string[];
+    };
+    digest: `sha256:${string}`;
+    signature?: {
+        keyId: string;
+        value: string;
+    };
+}
+export interface AiApplianceDiagnostic {
+    code: string;
+    path: string;
+    severity: 'warning' | 'error';
+    message: string;
+}
+export interface AiApplianceValidationResult {
+    ok: boolean;
+    diagnostics: AiApplianceDiagnostic[];
+}

package/dist/ai-appliance/contracts.js

@@ -0,0 +1,16 @@
+const AI_APPLIANCE_SCHEMA_VERSION = "treeseed.ai-appliance/v1";
+const EXECUTION_PROVIDER_MODULE_SCHEMA_VERSION = "treeseed.execution-provider/v1";
+const DEFAULT_AI_CONTROL_PLANE_URL = "https://api.treeseed.dev";
+const DEFAULT_AI_MANAGEMENT_URL = "http://127.0.0.1:4770";
+const DEFAULT_AI_GATEWAY_URL = "http://127.0.0.1:4771";
+const DEFAULT_AI_MODEL_ALIAS = "treeseed-qwen3.5-4b";
+const DEFAULT_AI_MODEL_ID = "Qwen/Qwen3.5-4B";
+export {
+  AI_APPLIANCE_SCHEMA_VERSION,
+  DEFAULT_AI_CONTROL_PLANE_URL,
+  DEFAULT_AI_GATEWAY_URL,
+  DEFAULT_AI_MANAGEMENT_URL,
+  DEFAULT_AI_MODEL_ALIAS,
+  DEFAULT_AI_MODEL_ID,
+  EXECUTION_PROVIDER_MODULE_SCHEMA_VERSION
+};

package/dist/ai-appliance/validation.d.ts

@@ -0,0 +1,4 @@
+import { type AiApplianceManifest, type AiApplianceValidationResult, type ExecutionProviderModuleManifest, type ExecutionProviderRuntimeConfiguration } from './contracts.js';
+export declare function validateAiApplianceManifest(manifest: AiApplianceManifest): AiApplianceValidationResult;
+export declare function validateExecutionProviderRuntimeConfiguration(value: ExecutionProviderRuntimeConfiguration, path?: string): AiApplianceValidationResult;
+export declare function validateExecutionProviderModuleManifest(manifest: ExecutionProviderModuleManifest): AiApplianceValidationResult;

package/dist/ai-appliance/validation.js

@@ -0,0 +1,62 @@
+import {
+  AI_APPLIANCE_SCHEMA_VERSION,
+  EXECUTION_PROVIDER_MODULE_SCHEMA_VERSION
+} from "./contracts.js";
+function text(value) {
+  return typeof value === "string" && value.trim().length > 0;
+}
+function diagnostic(diagnostics, code, path, message) {
+  diagnostics.push({ code, path, severity: "error", message });
+}
+function httpUrl(value) {
+  if (!text(value)) return false;
+  try {
+    return ["http:", "https:"].includes(new URL(value).protocol);
+  } catch {
+    return false;
+  }
+}
+function secretReference(value) {
+  return text(value) && value.includes("://");
+}
+function validateAiApplianceManifest(manifest) {
+  const diagnostics = [];
+  if (manifest?.schemaVersion !== AI_APPLIANCE_SCHEMA_VERSION) diagnostic(diagnostics, "ai_appliance_schema_invalid", "schemaVersion", `schemaVersion must be ${AI_APPLIANCE_SCHEMA_VERSION}.`);
+  if (!["joined", "standalone"].includes(manifest?.mode)) diagnostic(diagnostics, "ai_appliance_mode_invalid", "mode", "mode must be joined or standalone.");
+  if (!text(manifest?.management?.socket) || !manifest.management.socket.startsWith("/")) diagnostic(diagnostics, "ai_appliance_management_socket_invalid", "management.socket", "management.socket must be an absolute path.");
+  if (manifest?.management?.loopbackUrl && !httpUrl(manifest.management.loopbackUrl)) diagnostic(diagnostics, "ai_appliance_management_url_invalid", "management.loopbackUrl", "management.loopbackUrl must be an HTTP URL.");
+  if (!httpUrl(manifest?.controlPlane?.url) || !httpUrl(manifest?.controlPlane?.audience)) diagnostic(diagnostics, "ai_appliance_control_plane_url_invalid", "controlPlane", "Control-plane URL and audience must be HTTP URLs.");
+  if (!text(manifest?.inference?.publicAlias) || !text(manifest?.inference?.model)) diagnostic(diagnostics, "ai_appliance_model_required", "inference", "Inference model and public alias are required.");
+  if (!httpUrl(manifest?.inference?.gatewayUrl) || !httpUrl(manifest?.inference?.rawVllmUrl)) diagnostic(diagnostics, "ai_appliance_inference_url_invalid", "inference", "Inference gateway and raw vLLM URLs must be HTTP URLs.");
+  if (!Number.isInteger(manifest?.inference?.maxModelLength) || manifest.inference.maxModelLength < 1024) diagnostic(diagnostics, "ai_appliance_context_invalid", "inference.maxModelLength", "maxModelLength must be an integer of at least 1024.");
+  if (!Number.isInteger(manifest?.inference?.maxConcurrentSequences) || manifest.inference.maxConcurrentSequences < 1) diagnostic(diagnostics, "ai_appliance_concurrency_invalid", "inference.maxConcurrentSequences", "maxConcurrentSequences must be a positive integer.");
+  if (!Number.isFinite(manifest?.inference?.gpuMemoryUtilization) || manifest.inference.gpuMemoryUtilization <= 0 || manifest.inference.gpuMemoryUtilization >= 1) diagnostic(diagnostics, "ai_appliance_gpu_utilization_invalid", "inference.gpuMemoryUtilization", "gpuMemoryUtilization must be greater than zero and less than one.");
+  if (manifest?.inference?.apiKeyRef && !secretReference(manifest.inference.apiKeyRef)) diagnostic(diagnostics, "ai_appliance_api_key_ref_invalid", "inference.apiKeyRef", "apiKeyRef must be a secret reference.");
+  for (const [name, provider] of Object.entries(manifest?.providers ?? {})) if (provider.enabled && !text(provider.manifest)) diagnostic(diagnostics, "ai_appliance_provider_manifest_required", `providers.${name}.manifest`, "Enabled providers require a manifest path.");
+  if (manifest?.mode === "standalone" && manifest?.standalone?.localControlPlane?.enabled !== true) diagnostic(diagnostics, "ai_appliance_local_control_plane_required", "standalone.localControlPlane.enabled", "Standalone mode requires the local control plane.");
+  return { ok: diagnostics.length === 0, diagnostics };
+}
+function validateExecutionProviderRuntimeConfiguration(value, path = "executionProvider") {
+  const diagnostics = [];
+  if (value.protocol && !["responses", "chat-completions"].includes(value.protocol)) diagnostic(diagnostics, "execution_provider_protocol_invalid", `${path}.protocol`, "protocol must be responses or chat-completions.");
+  if (value.module && !/^(?:builtin:[a-z0-9-]+|module:[a-z0-9-]+)$/u.test(value.module)) diagnostic(diagnostics, "execution_provider_module_invalid", `${path}.module`, "module must use a builtin: or module: identifier.");
+  if (value.model?.baseUrl && !httpUrl(value.model.baseUrl)) diagnostic(diagnostics, "execution_provider_base_url_invalid", `${path}.model.baseUrl`, "model.baseUrl must be an HTTP URL.");
+  if (value.credentialBindings && (new Set(value.credentialBindings).size !== value.credentialBindings.length || value.credentialBindings.some((entry) => !text(entry)))) diagnostic(diagnostics, "execution_provider_credentials_invalid", `${path}.credentialBindings`, "credentialBindings must contain unique non-empty IDs.");
+  if (value.configurationDigest && !/^sha256:[a-f0-9]{64}$/u.test(value.configurationDigest)) diagnostic(diagnostics, "execution_provider_configuration_digest_invalid", `${path}.configurationDigest`, "configurationDigest must be a SHA-256 digest.");
+  return { ok: diagnostics.length === 0, diagnostics };
+}
+function validateExecutionProviderModuleManifest(manifest) {
+  const diagnostics = [];
+  if (manifest?.schemaVersion !== EXECUTION_PROVIDER_MODULE_SCHEMA_VERSION || manifest?.apiVersion !== EXECUTION_PROVIDER_MODULE_SCHEMA_VERSION) diagnostic(diagnostics, "execution_provider_module_schema_invalid", "schemaVersion", `Module schema and API version must be ${EXECUTION_PROVIDER_MODULE_SCHEMA_VERSION}.`);
+  for (const [path, value] of Object.entries({ id: manifest?.id, package: manifest?.package, version: manifest?.version, entrypoint: manifest?.entrypoint })) if (!text(value)) diagnostic(diagnostics, "execution_provider_module_field_required", path, `${path} is required.`);
+  if (manifest?.entrypoint?.startsWith("/") || manifest?.entrypoint?.split("/").includes("..")) diagnostic(diagnostics, "execution_provider_module_entrypoint_unsafe", "entrypoint", "Module entrypoint must remain inside the installed artifact.");
+  if (!Array.isArray(manifest?.adapters) || !manifest.adapters.length || manifest.adapters.some((entry) => !text(entry))) diagnostic(diagnostics, "execution_provider_module_adapters_invalid", "adapters", "At least one adapter is required.");
+  if (!Array.isArray(manifest?.permissions?.network) || !Array.isArray(manifest?.permissions?.credentials)) diagnostic(diagnostics, "execution_provider_module_permissions_invalid", "permissions", "Network and credential permission arrays are required.");
+  if (!/^sha256:[a-f0-9]{64}$/u.test(manifest?.digest ?? "")) diagnostic(diagnostics, "execution_provider_module_digest_invalid", "digest", "Module digest must be an exact SHA-256 digest.");
+  return { ok: diagnostics.length === 0, diagnostics };
+}
+export {
+  validateAiApplianceManifest,
+  validateExecutionProviderModuleManifest,
+  validateExecutionProviderRuntimeConfiguration
+};

package/dist/capacity/agents/agent-capacity.d.ts

@@ -0,0 +1,21 @@
+export type { AgentKernelPolicy, AgentKernelProfile, ProjectAgentClass, ProjectAgentClassStatus } from '../../agent-capacity/contracts/projects/agents/project-agent-class.js';
+export * from '../../agent-capacity/validation/index.js';
+export * from '../../agent-capacity/contracts/capacity/assignments/assignment-records.js';
+export * from '../../agent-capacity/contracts/capacity/communication/communication-records.js';
+export * from '../../agent-capacity/contracts/capacity/providers/supply-policy.js';
+export * from '../../agent-capacity/contracts/capacity/workdays/workday-records.js';
+export * from '../../agent-capacity/contracts/configuration/configuration.js';
+export * from '../../agent-capacity/contracts/operations/research-workflow.js';
+export * from '../../agent-capacity/contracts/operations/workflow-promotion.js';
+export * from '../../agent-capacity/contracts/projects/agents/project-agent-class.js';
+export * from '../../agent-capacity/contracts/runtime/runtime-observability.js';
+export * from '../../agent-capacity/contracts/support/decision-work.js';
+export * from '../../agent-capacity/contracts/support/agent-lab-monitoring.js';
+export * from '../../agent-capacity/contracts/support/agent-atlas.js';
+export * from '../../agent-capacity/contracts/support/failure-records.js';
+export * from '../../agent-capacity/contracts/support/financial-records.js';
+export * from '../../agent-capacity/contracts/support/time-capacity.js';
+export * from '../../agent-capacity/contracts/support/authority/execution-mode.js';
+export * from '../../agent-capacity/contracts/support/planning-records.js';
+export * from '../../agent-capacity/contracts/support/research-citation.js';
+export * from '../../agent-capacity/contracts/support/research-source-policy.js';

package/dist/capacity/agents/agent-capacity.js

@@ -0,0 +1,20 @@
+export * from "../../agent-capacity/validation/index.js";
+export * from "../../agent-capacity/contracts/capacity/assignments/assignment-records.js";
+export * from "../../agent-capacity/contracts/capacity/communication/communication-records.js";
+export * from "../../agent-capacity/contracts/capacity/providers/supply-policy.js";
+export * from "../../agent-capacity/contracts/capacity/workdays/workday-records.js";
+export * from "../../agent-capacity/contracts/configuration/configuration.js";
+export * from "../../agent-capacity/contracts/operations/research-workflow.js";
+export * from "../../agent-capacity/contracts/operations/workflow-promotion.js";
+export * from "../../agent-capacity/contracts/projects/agents/project-agent-class.js";
+export * from "../../agent-capacity/contracts/runtime/runtime-observability.js";
+export * from "../../agent-capacity/contracts/support/decision-work.js";
+export * from "../../agent-capacity/contracts/support/agent-lab-monitoring.js";
+export * from "../../agent-capacity/contracts/support/agent-atlas.js";
+export * from "../../agent-capacity/contracts/support/failure-records.js";
+export * from "../../agent-capacity/contracts/support/financial-records.js";
+export * from "../../agent-capacity/contracts/support/time-capacity.js";
+export * from "../../agent-capacity/contracts/support/authority/execution-mode.js";
+export * from "../../agent-capacity/contracts/support/planning-records.js";
+export * from "../../agent-capacity/contracts/support/research-citation.js";
+export * from "../../agent-capacity/contracts/support/research-source-policy.js";

package/dist/capacity/capacity-core/capacity-pagination.d.ts

@@ -0,0 +1,18 @@
+export declare const DEFAULT_CAPACITY_PAGE_LIMIT = 50;
+export declare const MAX_CAPACITY_PAGE_LIMIT = 200;
+export interface CapacityPageInfo {
+    limit: number;
+    hasMore: boolean;
+    nextCursor: string | null;
+}
+export interface CapacityPage<T> {
+    items: T[];
+    page: CapacityPageInfo;
+}
+export interface CapacityPageCursor {
+    createdAt: string;
+    id: string;
+}
+export declare function normalizeCapacityPageLimit(value: unknown): number;
+export declare function encodeCapacityPageCursor(cursor: CapacityPageCursor): string;
+export declare function decodeCapacityPageCursor(value: unknown): CapacityPageCursor | null;

package/dist/capacity/capacity-core/capacity-pagination.js

@@ -0,0 +1,33 @@
+const DEFAULT_CAPACITY_PAGE_LIMIT = 50;
+const MAX_CAPACITY_PAGE_LIMIT = 200;
+function normalizeCapacityPageLimit(value) {
+  if (value === void 0 || value === null || value === "") return DEFAULT_CAPACITY_PAGE_LIMIT;
+  const parsed = typeof value === "number" ? value : Number(value);
+  if (!Number.isInteger(parsed) || parsed < 1 || parsed > MAX_CAPACITY_PAGE_LIMIT) {
+    throw new Error(`Capacity page limit must be an integer from 1 through ${MAX_CAPACITY_PAGE_LIMIT}.`);
+  }
+  return parsed;
+}
+function encodeCapacityPageCursor(cursor) {
+  return Buffer.from(JSON.stringify({ v: 1, createdAt: cursor.createdAt, id: cursor.id }), "utf8").toString("base64url");
+}
+function decodeCapacityPageCursor(value) {
+  if (value === void 0 || value === null || value === "") return null;
+  if (typeof value !== "string") throw new Error("Capacity page cursor must be a string.");
+  try {
+    const decoded = JSON.parse(Buffer.from(value, "base64url").toString("utf8"));
+    if (decoded.v !== 1 || typeof decoded.createdAt !== "string" || !decoded.createdAt || typeof decoded.id !== "string" || !decoded.id) {
+      throw new Error("invalid payload");
+    }
+    return { createdAt: decoded.createdAt, id: decoded.id };
+  } catch {
+    throw new Error("Capacity page cursor is invalid.");
+  }
+}
+export {
+  DEFAULT_CAPACITY_PAGE_LIMIT,
+  MAX_CAPACITY_PAGE_LIMIT,
+  decodeCapacityPageCursor,
+  encodeCapacityPageCursor,
+  normalizeCapacityPageLimit
+};

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

@@ -0,0 +1 @@
+export * from '../../capacity-provider/index.js';

package/dist/capacity/providers/capacity-provider.js

@@ -0,0 +1 @@
+export * from "../../capacity-provider/index.js";

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

@@ -0,0 +1,56 @@
+import type { ProviderAssignmentLifecycleRequest, ProviderAssignmentLifecycleResult, ProviderNextAssignmentRequest } from '../capacity/agents/agent-capacity.js';
+import type { ProviderRuntimeEventInput } from '../agent-capacity/contracts/capacity/workdays/workday-records.js';
+import type { CapacityProviderIdentity, CapacityProviderIdentityRotationRequest, CapacityProviderSignedProof, ProviderAccessTokenIssue, ProviderAvailabilitySession, ProviderCredentialIssuanceAuthorization, ProviderRegistrationRequest, ProviderRegistrationSubmission, ProviderTeamCredentialIssue } from './contracts/index.js';
+export interface ProviderProtocolClientOptions {
+    controlPlaneUrl: string;
+    accessToken?: string;
+    accessTokenProvider?: () => Promise<string>;
+    fetchImpl?: typeof fetch;
+    userAgent?: string;
+    requestTimeoutMs?: number;
+}
+export declare class CapacityProviderApiError extends Error {
+    readonly status: number;
+    readonly payload: unknown;
+    readonly code: string;
+    constructor(message: string, status: number, payload: unknown);
+}
+export declare function normalizeBaseUrl(value: string): string;
+export declare class ProviderProtocolClient {
+    private readonly controlPlaneUrl;
+    private accessToken?;
+    private readonly accessTokenProvider?;
+    private readonly fetchImpl;
+    private readonly userAgent?;
+    private readonly requestTimeoutMs;
+    constructor(options: ProviderProtocolClientOptions);
+    private bearer;
+    private invoke;
+    register(registrationKey: string, submission: ProviderRegistrationSubmission, idempotencyKey: string): Promise<ProviderRegistrationRequest>;
+    registrationStatus(requestId: string, proof: CapacityProviderSignedProof): Promise<ProviderRegistrationRequest>;
+    exchangeCredential(requestId: string, proof: CapacityProviderSignedProof, idempotencyKey: string): Promise<ProviderTeamCredentialIssue>;
+    issueAccessToken(credential: string, credentialId: string, proof: CapacityProviderSignedProof, idempotencyKey: string, requestedValiditySeconds?: number): Promise<ProviderAccessTokenIssue>;
+    leaveMembership(accessToken: string, idempotencyKey: string): Promise<Record<string, unknown>>;
+    authorizeCredentialRotation(accessToken: string, idempotencyKey: string): Promise<ProviderCredentialIssuanceAuthorization>;
+    rotateIdentity(accessToken: string, request: CapacityProviderIdentityRotationRequest, idempotencyKey: string): Promise<CapacityProviderIdentity>;
+    createAvailabilitySession(request?: Record<string, unknown>): Promise<ProviderAvailabilitySession>;
+    refreshAvailabilitySession(sessionId: string, request?: Record<string, unknown>): Promise<ProviderAvailabilitySession>;
+    closeAvailabilitySession(sessionId: string): Promise<ProviderAvailabilitySession>;
+    assignment(assignmentId: string): Promise<Record<string, unknown>>;
+    assignmentExplanation(assignmentId: string): Promise<Record<string, unknown>>;
+    nextAssignment(request?: ProviderNextAssignmentRequest): Promise<ProviderAssignmentLifecycleResult>;
+    renewAssignment(assignmentId: string, request?: ProviderAssignmentLifecycleRequest): Promise<ProviderAssignmentLifecycleResult>;
+    startAssignmentExecution(assignmentId: string, request: Record<string, unknown>): Promise<Record<string, unknown>>;
+    startAssignmentCloseout(assignmentId: string, request: Record<string, unknown>): Promise<Record<string, unknown>>;
+    preflightAssignmentCompletion(assignmentId: string, request: Record<string, unknown>): Promise<Record<string, unknown>>;
+    returnAssignment(assignmentId: string, request?: ProviderAssignmentLifecycleRequest): Promise<ProviderAssignmentLifecycleResult>;
+    completeAssignment(assignmentId: string, request?: ProviderAssignmentLifecycleRequest): Promise<ProviderAssignmentLifecycleResult>;
+    failAssignment(assignmentId: string, request?: ProviderAssignmentLifecycleRequest): Promise<ProviderAssignmentLifecycleResult>;
+    reportAssignmentUsage(assignmentId: string, request: Record<string, unknown>, idempotencyKey: string): Promise<Record<string, unknown>>;
+    settleAssignment(assignmentId: string, request: Record<string, unknown>, idempotencyKey: string): Promise<Record<string, unknown>>;
+    createAssignmentModeRun(assignmentId: string, request: Record<string, unknown>): Promise<Record<string, unknown>>;
+    createAssignmentEvent(assignmentId: string, request: ProviderRuntimeEventInput): Promise<Record<string, unknown>>;
+    publishAssignmentSignal(assignmentId: string, request: Record<string, unknown>): Promise<Record<string, unknown>>;
+    dispatchAssignmentWorkflowOperation(assignmentId: string, operationId: string, request: Record<string, unknown>): Promise<Record<string, unknown>>;
+    getAssignmentWorkflowRun(assignmentId: string, runId: string): Promise<Record<string, unknown>>;
+}

package/dist/capacity-provider/client.js

@@ -0,0 +1,163 @@
+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 = payload && typeof payload === "object" && typeof payload.code === "string" ? String(payload.code) : "capacity_provider_request_failed";
+  }
+  status;
+  payload;
+  code;
+}
+function normalizeBaseUrl(value) {
+  const normalized = value.trim().replace(/\/+$/u, "");
+  if (!normalized) throw new Error("Capacity provider control-plane URL is required.");
+  return normalized;
+}
+class ProviderProtocolClient {
+  controlPlaneUrl;
+  accessToken;
+  accessTokenProvider;
+  fetchImpl;
+  userAgent;
+  requestTimeoutMs;
+  constructor(options) {
+    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 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);
+    try {
+      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) {
+      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);
+    }
+  }
+  register(registrationKey, submission, idempotencyKey) {
+    const key = registrationKey.trim();
+    if (!key) throw new Error("Team capacity registration key is required.");
+    return this.invoke(CONTROL_PLANE_OPERATIONS.providers.register, { body: submission }, { authorization: `Treeseed-Registration ${key}`, idempotencyKey });
+  }
+  registrationStatus(requestId, proof) {
+    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.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.invoke(CONTROL_PLANE_OPERATIONS.providers.issueAccessToken, { body: { credentialId, requestedValiditySeconds, proof } }, { authorization: `Treeseed-Credential ${value}`, idempotencyKey });
+  }
+  leaveMembership(accessToken, idempotencyKey) {
+    return this.invoke(CONTROL_PLANE_OPERATIONS.providers.leaveMembership, { body: {} }, { authorization: `Bearer ${accessToken}`, idempotencyKey });
+  }
+  authorizeCredentialRotation(accessToken, idempotencyKey) {
+    return this.invoke(CONTROL_PLANE_OPERATIONS.providers.rotateCredential, { body: {} }, { authorization: `Bearer ${accessToken}`, idempotencyKey });
+  }
+  rotateIdentity(accessToken, request, idempotencyKey) {
+    return this.invoke(CONTROL_PLANE_OPERATIONS.providers.rotateIdentity, { body: request }, { authorization: `Bearer ${accessToken}`, idempotencyKey });
+  }
+  createAvailabilitySession(request = {}) {
+    return this.invoke(CONTROL_PLANE_OPERATIONS.providers.createAvailability, { body: request });
+  }
+  refreshAvailabilitySession(sessionId, request = {}) {
+    return this.invoke(CONTROL_PLANE_OPERATIONS.providers.refreshAvailability, { path: { sessionId }, body: request });
+  }
+  closeAvailabilitySession(sessionId) {
+    return this.invoke(CONTROL_PLANE_OPERATIONS.providers.closeAvailability, { path: { sessionId }, body: {} });
+  }
+  assignment(assignmentId) {
+    return this.invoke(CONTROL_PLANE_OPERATIONS.providers.assignment, { path: { assignmentId } });
+  }
+  assignmentExplanation(assignmentId) {
+    return this.invoke(CONTROL_PLANE_OPERATIONS.providers.assignmentExplanation, { path: { assignmentId } });
+  }
+  nextAssignment(request = {}) {
+    return this.invoke(CONTROL_PLANE_OPERATIONS.providers.nextAssignment, { body: request });
+  }
+  renewAssignment(assignmentId, request = {}) {
+    return this.invoke(CONTROL_PLANE_OPERATIONS.providers.renewAssignment, { path: { assignmentId }, body: request });
+  }
+  startAssignmentExecution(assignmentId, request) {
+    return this.invoke(CONTROL_PLANE_OPERATIONS.providers.startExecution, { path: { assignmentId }, body: request });
+  }
+  startAssignmentCloseout(assignmentId, request) {
+    return this.invoke(CONTROL_PLANE_OPERATIONS.providers.startCloseout, { path: { assignmentId }, body: request });
+  }
+  preflightAssignmentCompletion(assignmentId, request) {
+    return this.invoke(CONTROL_PLANE_OPERATIONS.providers.completionPreflight, { path: { assignmentId }, body: request });
+  }
+  returnAssignment(assignmentId, request = {}) {
+    return this.invoke(CONTROL_PLANE_OPERATIONS.providers.returnAssignment, { path: { assignmentId }, body: request });
+  }
+  completeAssignment(assignmentId, request = {}) {
+    return this.invoke(CONTROL_PLANE_OPERATIONS.providers.completeAssignment, { path: { assignmentId }, body: request });
+  }
+  failAssignment(assignmentId, request = {}) {
+    return this.invoke(CONTROL_PLANE_OPERATIONS.providers.failAssignment, { path: { assignmentId }, body: request });
+  }
+  reportAssignmentUsage(assignmentId, request, idempotencyKey) {
+    return this.invoke(CONTROL_PLANE_OPERATIONS.providers.reportUsage, { path: { assignmentId }, body: request }, { idempotencyKey });
+  }
+  settleAssignment(assignmentId, request, idempotencyKey) {
+    return this.invoke(CONTROL_PLANE_OPERATIONS.providers.settleAssignment, { path: { assignmentId }, body: request }, { idempotencyKey });
+  }
+  createAssignmentModeRun(assignmentId, request) {
+    return this.invoke(CONTROL_PLANE_OPERATIONS.providers.createModeRun, { path: { assignmentId }, body: request });
+  }
+  createAssignmentEvent(assignmentId, request) {
+    return this.invoke(CONTROL_PLANE_OPERATIONS.providers.createEvent, { path: { assignmentId }, body: request });
+  }
+  publishAssignmentSignal(assignmentId, request) {
+    return this.invoke(CONTROL_PLANE_OPERATIONS.providers.publishSignal, { path: { assignmentId }, body: request });
+  }
+  dispatchAssignmentWorkflowOperation(assignmentId, operationId, request) {
+    return this.invoke(CONTROL_PLANE_OPERATIONS.providers.dispatchWorkflow, { path: { assignmentId, operationId }, body: request });
+  }
+  getAssignmentWorkflowRun(assignmentId, runId) {
+    return this.invoke(CONTROL_PLANE_OPERATIONS.providers.workflowRun, { path: { assignmentId, runId } });
+  }
+}
+export {
+  CapacityProviderApiError,
+  ProviderProtocolClient,
+  normalizeBaseUrl
+};