@treeseed/sdk 0.9.0 → 0.10.5

package/dist/api/types.d.ts

@@ -0,0 +1,232 @@
+import type { Hono } from 'hono';
+import type { AgentSdk } from '../sdk.ts';
+import type { ApiPrincipal, ApiScope, DeviceCodeApproveRequest as SdkDeviceCodeApproveRequest, DeviceCodePollRequest, DeviceCodePollResponse, DeviceCodeStartRequest, DeviceCodeStartResponse, RemoteWorkflowOperationRequest as WorkflowHttpOperationRequest, RemoteWorkflowOperationResponse as ApiWorkflowOperationResponse, RemoteSdkOperationRequest as SdkHttpOperationRequest, TokenRefreshRequest, TokenRefreshResponse } from '../remote.ts';
+export type { ApiPrincipal, ApiScope, DeviceCodePollRequest, DeviceCodePollResponse, DeviceCodeStartRequest, DeviceCodeStartResponse, WorkflowHttpOperationRequest, ApiWorkflowOperationResponse, SdkHttpOperationRequest, TokenRefreshRequest, TokenRefreshResponse, };
+export type DeviceCodeApproveRequest = SdkDeviceCodeApproveRequest;
+export interface ApiAuthProvider {
+    readonly id: string;
+    startDeviceFlow(request: DeviceCodeStartRequest): Promise<DeviceCodeStartResponse>;
+    pollDeviceFlow(request: DeviceCodePollRequest): Promise<DeviceCodePollResponse>;
+    refreshAccessToken(request: TokenRefreshRequest): Promise<TokenRefreshResponse>;
+    approveDeviceFlow(request: DeviceCodeApproveRequest): Promise<{
+        ok: true;
+    }>;
+    authenticateBearerToken(token: string): Promise<{
+        principal: ApiPrincipal;
+        credential: ApiCredential;
+    } | null>;
+    authenticateServiceCredential(serviceId: string, secret: string): Promise<{
+        principal: ApiPrincipal;
+        credential: ApiCredential;
+    } | null>;
+    createPersonalAccessToken(userId: string, input: {
+        name: string;
+        scopes?: string[];
+        expiresAt?: string | null;
+    }): Promise<{
+        id: string;
+        token: string;
+        prefix: string;
+        name: string;
+        expiresAt: string | null;
+    }>;
+    listPersonalAccessTokens(userId: string): Promise<Array<{
+        id: string;
+        name: string;
+        token_prefix: string;
+        expires_at: string | null;
+        last_used_at: string | null;
+        revoked_at: string | null;
+        created_at: string;
+    }>>;
+    revokePersonalAccessToken(userId: string, tokenId: string): Promise<void>;
+    syncUserIdentity(identity: UserIdentityProfileInput): Promise<{
+        principal: ApiPrincipal;
+        userId: string;
+        identityId: string | null;
+    }>;
+    createUser?(input: {
+        email?: string | null;
+        username?: string | null;
+        displayName?: string | null;
+        metadata?: Record<string, unknown>;
+    }): Promise<{
+        principal: ApiPrincipal;
+        userId: string;
+    }>;
+    setUserRoles?(userId: string, roles: string[]): Promise<{
+        principal: ApiPrincipal;
+        userId: string;
+    }>;
+    createServiceToken(input: {
+        serviceId: string;
+        name: string;
+        roles?: string[];
+        permissions?: string[];
+    }): Promise<{
+        id: string;
+        serviceId: string;
+        secret: string;
+    }>;
+    rotateServiceToken(serviceId: string): Promise<{
+        id: string;
+        serviceId: string;
+        secret: string;
+    }>;
+    createTrustedUserAssertion(claims: TrustedUserAssertionClaims): string;
+    verifyTrustedUserAssertion(assertion: string): TrustedUserAssertionClaims | null;
+    exchangeTrustedUserAssertion(claims: TrustedUserAssertionClaims): Promise<{
+        ok: true;
+        accessToken: string;
+        tokenType: 'Bearer';
+        expiresAt: string;
+        expiresInSeconds: number;
+        principal: ApiPrincipal;
+    }>;
+}
+export type ApiRuntimeProviderSelections = {
+    auth: string;
+    agents: {
+        execution: string;
+        queue: string;
+        notification: string;
+        repository: string;
+        verification: string;
+    };
+};
+export interface ApiConfig {
+    name: string;
+    host: string;
+    port: number;
+    baseUrl: string;
+    authApprovalBaseUrl?: string;
+    issuer: string;
+    repoRoot: string;
+    projectId: string;
+    authSecret: string;
+    projectApiKey?: string;
+    projectApiLabel: string;
+    projectApiPermissions: string[];
+    cloudflareAccountId?: string;
+    cloudflareApiToken?: string;
+    d1DatabaseId?: string;
+    d1DatabaseName?: string;
+    d1LocalPersistTo?: string;
+    d1WranglerConfigPath?: string;
+    webServiceId: string;
+    webServiceSecret: string;
+    webAssertionSecret: string;
+    webExchangeTtlSeconds: number;
+    bootstrapAdminAllowlist: string[];
+    accessTokenTtlSeconds: number;
+    refreshTokenTtlSeconds: number;
+    deviceCodeTtlSeconds: number;
+    deviceCodePollIntervalSeconds: number;
+    templateCatalogPath?: string;
+    providers: ApiRuntimeProviderSelections;
+}
+export interface AppVariables {
+    requestId: string;
+    config: ApiConfig;
+    principal: ApiPrincipal | null;
+    actingUser: ApiPrincipal | null;
+    credential: ApiCredential | null;
+    actorType: 'anonymous' | 'user' | 'service' | 'project';
+    permissionGrants: string[];
+}
+export interface ApiCredential {
+    type: 'access_token' | 'personal_access_token' | 'service_secret' | 'service_token' | 'project_api_key' | 'team_api_key';
+    id: string;
+    label?: string;
+}
+export interface TrustedUserAssertionClaims {
+    userId: string;
+    sessionId: string;
+    identityId?: string | null;
+    teamId?: string | null;
+    projectId?: string | null;
+    membershipId?: string | null;
+    teamRoles?: string[];
+    teamCapabilities?: string[];
+    authTime: string;
+    expiresAt: string;
+    nonce: string;
+}
+export interface UserIdentityProfileInput {
+    provider: string;
+    providerSubject: string;
+    email?: string | null;
+    emailVerified?: boolean;
+    username?: string | null;
+    displayName?: string | null;
+    profile?: Record<string, unknown>;
+}
+export type ApiProviderFactory<T> = (options: {
+    config: ApiConfig;
+}) => T;
+export interface ApiRuntimeProviders {
+    auth?: Record<string, ApiProviderFactory<ApiAuthProvider>>;
+    agentExecution?: Record<string, unknown>;
+    agentQueue?: Record<string, unknown>;
+    agentNotification?: Record<string, unknown>;
+    agentRepository?: Record<string, unknown>;
+    agentVerification?: Record<string, unknown>;
+}
+export interface ResolvedApiRuntimeProviders {
+    auth: ApiAuthProvider;
+    registries: {
+        auth: Map<string, ApiProviderFactory<ApiAuthProvider>>;
+        agentExecution: Map<string, unknown>;
+        agentQueue: Map<string, unknown>;
+        agentNotification: Map<string, unknown>;
+        agentRepository: Map<string, unknown>;
+        agentVerification: Map<string, unknown>;
+    };
+    selections: ApiRuntimeProviderSelections;
+}
+export interface ApiResolvedSettings {
+    config: ApiConfig;
+    surfaces: {
+        auth: boolean;
+        templates: boolean;
+        sdk: boolean;
+        operations: boolean;
+    };
+    scopes: {
+        authMe: ApiScope;
+        sdk: ApiScope;
+        operations: ApiScope;
+    };
+}
+export interface ApiAppRuntime {
+    resolved: ApiResolvedSettings;
+    runtimeProviders: ResolvedApiRuntimeProviders;
+    sharedSdk: AgentSdk;
+    internalPrefix: string;
+}
+export type TreeseedApiContext = ApiAppRuntime;
+export interface TreeseedApiExtension {
+    name: string;
+    mount(app: Hono<any>, context: TreeseedApiContext): void | Promise<void>;
+}
+export interface ApiServerOptions {
+    config?: Partial<ApiConfig>;
+    runtimeProviders?: ApiRuntimeProviders;
+    sdk?: AgentSdk;
+    workflowExecutor?: (operation: string, request: WorkflowHttpOperationRequest) => Promise<ApiWorkflowOperationResponse>;
+    surfaces?: Partial<{
+        auth: boolean;
+        templates: boolean;
+        sdk: boolean;
+        operations: boolean;
+    }>;
+    scopes?: Partial<{
+        authMe: ApiScope;
+        sdk: ApiScope;
+        operations: ApiScope;
+    }>;
+    internalPrefix?: string;
+    extensions?: TreeseedApiExtension[];
+    extendApp?: (app: Hono<any>, runtime: ApiAppRuntime) => void;
+    log?: (message: string, details?: Record<string, unknown>) => void;
+}

package/dist/capacity-provider.d.ts

@@ -0,0 +1,383 @@
+export declare const CAPACITY_PROVIDER_ENDPOINTS: {
+    readonly register: "/v1/provider/register";
+    readonly heartbeat: "/v1/provider/heartbeat";
+    readonly portfolio: "/v1/provider/portfolio";
+    readonly workdays: "/v1/provider/workdays";
+    readonly claimTask: "/v1/provider/tasks/claim";
+    readonly taskEvents: (taskId: string) => string;
+    readonly completeTask: (taskId: string) => string;
+    readonly failTask: (taskId: string) => string;
+    readonly usage: "/v1/provider/usage";
+    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 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';
+export type CapacityProviderStatus = 'pending' | 'online' | 'offline' | 'disabled' | 'rotation_required' | string;
+export type CapacityProviderConnectionState = 'waiting_for_provider' | 'connected' | 'auth_failed' | 'stale' | 'disabled' | string;
+export type CapacityProviderDeploymentStatus = 'not_deployed' | 'deploying' | 'deployed' | 'failed' | string;
+export type CapacityProviderDeploymentServiceRole = 'api' | 'manager' | 'runner';
+export declare const CAPACITY_PROVIDER_DEPLOYMENT_SERVICE_ROLES: readonly ["api", "manager", "runner"];
+export interface CapacityProviderRuntimeInfo {
+    package: '@treeseed/agent' | string;
+    version: string;
+    entrypoint: string;
+    roles: string[];
+}
+export interface CapacityProviderCapability {
+    id: string;
+    agents: string[];
+    operations: string[];
+    models: string[];
+    repositoryAccess: string;
+    verification: string[];
+    metadata?: Record<string, unknown>;
+}
+export interface CapacityProviderBudgetCapacity {
+    dailyCreditBudget?: number | null;
+    monthlyCreditBudget?: number | null;
+    maxConcurrentWorkdays?: number | null;
+    maxConcurrentRunners?: number | null;
+    [key: string]: unknown;
+}
+export interface CapacityProviderHealthState {
+    dataDirWritable?: boolean;
+    codexReady?: boolean;
+    [key: string]: unknown;
+}
+export interface CapacityProviderRegistrationRequest {
+    marketId: string;
+    runtime: CapacityProviderRuntimeInfo;
+    capabilities: CapacityProviderCapability[];
+    budgets: CapacityProviderBudgetCapacity;
+    health: CapacityProviderHealthState;
+}
+export interface CapacityProviderRegistrationResponse {
+    ok: true;
+    provider: {
+        id: string;
+        teamId: string;
+        name: string;
+        status: CapacityProviderStatus;
+        connectionState?: CapacityProviderConnectionState;
+    };
+    portfolioManifestUrl: string;
+    heartbeatIntervalSeconds: number;
+}
+export interface CapacityProviderHeartbeatRequest {
+    marketId: string;
+    providerId?: string | null;
+    runtime?: CapacityProviderRuntimeInfo;
+    capabilities?: CapacityProviderCapability[];
+    budgets?: CapacityProviderBudgetCapacity;
+    health?: CapacityProviderHealthState;
+    status?: CapacityProviderStatus;
+    connectionState?: CapacityProviderConnectionState;
+}
+export interface CapacityProviderHeartbeatResponse {
+    ok: true;
+    provider?: CapacityProviderRegistrationResponse['provider'];
+    heartbeatIntervalSeconds?: number;
+}
+export interface CapacityProviderPortfolioManifest {
+    team: {
+        id: string;
+        slug: string;
+        name: string;
+    };
+    projects: CapacityProviderPortfolioProject[];
+}
+export interface CapacityProviderPortfolioProject {
+    id: string;
+    slug: string;
+    name: string;
+    repository: {
+        provider: string;
+        role?: string | null;
+        owner: string;
+        name: string;
+        defaultBranch: string;
+        cloneUrl: string;
+        currentBranch?: string | null;
+        checkoutPath?: string | null;
+        submodulePath?: string | null;
+        webUrl?: string | null;
+    };
+    agentSpecs: {
+        root: string;
+        testsRoot: string;
+    };
+    workPolicy: {
+        enabled: boolean;
+        startCron?: string | null;
+        durationMinutes?: number | null;
+        dailyCreditBudget?: number | null;
+        maxRunners?: number | null;
+        maxWorkersPerRunner?: number | null;
+        [key: string]: unknown;
+    };
+    metadata?: Record<string, unknown>;
+}
+export interface ProviderWorkdayRequest {
+    projectId: string;
+    environment: CapacityProviderEnvironmentName;
+    idempotencyKey?: string | null;
+    kind?: string;
+    summary?: Record<string, unknown> | null;
+    metadata?: Record<string, unknown> | null;
+}
+export interface ProviderWorkdayResponse {
+    ok: true;
+    workDay: Record<string, unknown>;
+}
+export interface ProviderTaskClaimRequest {
+    providerId?: string | null;
+    runnerId?: string | null;
+    projectId?: string | null;
+    environment?: CapacityProviderEnvironmentName | null;
+    limit?: number;
+    capabilities?: string[];
+}
+export interface ProviderTaskClaimResponse {
+    ok: true;
+    tasks: Record<string, unknown>[];
+    leaseSeconds?: number;
+}
+export interface ProviderTaskEventRequest {
+    kind: string;
+    data?: Record<string, unknown>;
+    runnerId?: string | null;
+}
+export interface ProviderTaskEventResponse {
+    ok: true;
+    event?: Record<string, unknown>;
+}
+export interface ProviderTaskCompleteRequest {
+    output?: Record<string, unknown> | null;
+    outputRef?: string | null;
+    summary?: Record<string, unknown> | null;
+    usage?: ProviderUsageReport | null;
+}
+export interface ProviderTaskCompleteResponse {
+    ok: true;
+    task: Record<string, unknown>;
+}
+export interface ProviderTaskFailRequest {
+    errorCode?: string | null;
+    errorMessage: string;
+    retryable?: boolean;
+    nextVisibleAt?: string | null;
+    usage?: ProviderUsageReport | null;
+}
+export interface ProviderTaskFailResponse {
+    ok: true;
+    task: Record<string, unknown>;
+}
+export interface ProviderUsageReport {
+    taskId?: string | null;
+    workDayId?: string | null;
+    projectId?: string | null;
+    taskSignature?: string | null;
+    executionProfileId?: string | null;
+    modelName?: string | null;
+    inputTokens?: number | null;
+    outputTokens?: number | null;
+    cachedInputTokens?: number | null;
+    quotaMinutes?: number | null;
+    wallMinutes?: number | null;
+    filesOpened?: number | null;
+    filesChanged?: number | null;
+    diffLinesAdded?: number | null;
+    diffLinesRemoved?: number | null;
+    testRuns?: number | null;
+    retryCount?: number | null;
+    actualCredits: number;
+    actualUsd?: number | null;
+    metadata?: Record<string, unknown> | null;
+}
+export interface ProviderUsageReportResponse {
+    ok: true;
+    usage?: Record<string, unknown>;
+}
+export interface ProviderReportRequest {
+    workDayId: string;
+    kind: string;
+    body: Record<string, unknown>;
+    renderedRef?: string | null;
+    metadata?: Record<string, unknown> | null;
+}
+export interface ProviderReportResponse {
+    ok: true;
+    report: Record<string, unknown>;
+}
+export interface CapacityProviderDeploymentIntent {
+    teamId: string;
+    capacityProviderId: string;
+    launchMode: CapacityProviderLaunchMode;
+    hostKind: string;
+    hostId?: string | null;
+    imageRef?: string | null;
+    serviceRefs?: Record<string, unknown>;
+    envRefs?: Record<string, unknown>;
+}
+export interface CapacityProviderDeploymentResult {
+    id: string;
+    teamId: string;
+    capacityProviderId: string;
+    launchMode: CapacityProviderLaunchMode;
+    hostKind: string;
+    hostId?: string | null;
+    status: CapacityProviderDeploymentStatus;
+    imageRef?: string | null;
+    serviceRefs: Record<string, unknown>;
+    envRefs: Record<string, unknown>;
+    result: Record<string, unknown>;
+    error?: Record<string, unknown> | null;
+    createdAt?: string;
+    updatedAt?: string;
+    completedAt?: string | null;
+}
+export interface CapacityProviderDeploymentServiceSpec {
+    role: CapacityProviderDeploymentServiceRole;
+    serviceName: string;
+    imageRef: string;
+    startCommand: string;
+    env: Record<string, string>;
+    redactedEnv: Record<string, string>;
+}
+export interface CapacityProviderDeploymentServiceResult {
+    role: CapacityProviderDeploymentServiceRole;
+    serviceName: string;
+    serviceId?: string | null;
+    url?: string | null;
+    status?: CapacityProviderDeploymentStatus;
+    envRefs?: Record<string, unknown>;
+    metadata?: Record<string, unknown>;
+}
+export interface CapacityProviderDeploymentAdapter {
+    provisionService(spec: CapacityProviderDeploymentServiceSpec): Promise<CapacityProviderDeploymentServiceResult> | CapacityProviderDeploymentServiceResult;
+}
+export interface CapacityProviderDeploymentPrimitiveInput {
+    intent: CapacityProviderDeploymentIntent;
+    env: Record<string, string>;
+    redactedEnv?: Record<string, string>;
+    imageRef?: string | null;
+    serviceNamePrefix?: string | null;
+    adapter?: CapacityProviderDeploymentAdapter;
+    now?: Date;
+}
+export interface CapacityProviderDeploymentPrimitiveResult {
+    ok: boolean;
+    launchMode: CapacityProviderLaunchMode;
+    hostKind: string;
+    imageRef: string;
+    status: CapacityProviderDeploymentStatus;
+    serviceRefs: Record<CapacityProviderDeploymentServiceRole, CapacityProviderDeploymentServiceResult>;
+    envRefs: Record<string, unknown>;
+    diagnostics: string[];
+    deployedAt?: string | null;
+    error?: Record<string, unknown> | null;
+}
+export interface CapacityProviderEnvironmentInput {
+    marketUrl: string;
+    marketId: string;
+    apiKey: string;
+    providerDataDir?: string;
+    providerApiPort?: number | string;
+    providerEnvironment?: CapacityProviderEnvironmentName;
+    providerHostDataDir?: string;
+    capabilitiesFile?: string;
+    budgetFile?: string;
+    maxConcurrentWorkdays?: number | string;
+    maxConcurrentRunners?: number | string;
+    dailyCreditBudget?: number | string;
+    monthlyCreditBudget?: number | string;
+    codexAuthFile?: string;
+    codexAuthJsonB64?: string;
+    codexAuthOverwrite?: boolean | number | string;
+}
+export interface CapacityProviderSelfHostInstructions {
+    composeFile: string;
+    commands: string[];
+    env: Record<string, string>;
+    redactedEnv: Record<string, string>;
+    summary: string;
+}
+export interface CapacityProviderLaunchEnvironmentInput {
+    tenantRoot?: string | null;
+    scope?: 'local' | 'staging' | 'prod' | string;
+    env?: NodeJS.ProcessEnv;
+    overrides?: Record<string, string | number | boolean | null | undefined>;
+    requireConnection?: boolean;
+    diagnostic?: boolean;
+}
+export interface CapacityProviderLaunchEnvironment {
+    env: Record<string, string>;
+    redactedEnv: Record<string, string>;
+    missing: string[];
+    diagnostic: boolean;
+    source: 'treeseed-config' | 'process-env';
+}
+export interface CapacityProviderConnectionConfigInput extends CapacityProviderEnvironmentInput {
+    tenantRoot: string;
+    scope?: 'local' | 'staging' | 'prod' | string;
+    providerHostDataDir?: string;
+    providerEnvironment?: CapacityProviderEnvironmentName;
+}
+export interface CapacityProviderConnectionConfigResult {
+    env: Record<string, string>;
+    redactedEnv: Record<string, string>;
+    scope: string;
+    writtenKeys: string[];
+}
+export interface MarketProviderClientOptions extends CapacityProviderEnvironmentInput {
+    fetchImpl?: typeof fetch;
+    userAgent?: string;
+}
+export declare class CapacityProviderApiError extends Error {
+    readonly status: number;
+    readonly payload: unknown;
+    constructor(message: string, status: number, payload: unknown);
+}
+export declare function buildCapacityProviderAuthHeaders(apiKey: string): {
+    authorization: string;
+};
+export declare function assertCapacityProviderOkEnvelope(value: unknown, label?: string): asserts value is {
+    ok: true;
+};
+export declare function assertCapacityProviderRegistrationResponse(value: unknown): asserts value is CapacityProviderRegistrationResponse;
+export declare function assertCapacityProviderPortfolioManifest(value: unknown): asserts value is CapacityProviderPortfolioManifest;
+export declare function resolveCapacityProviderEnvironment(input: CapacityProviderEnvironmentInput): Record<string, string>;
+export declare function resolveCapacityProviderLaunchEnvironment(input?: CapacityProviderLaunchEnvironmentInput): CapacityProviderLaunchEnvironment;
+export declare function persistCapacityProviderConnectionToTreeseedConfig(input: CapacityProviderConnectionConfigInput): CapacityProviderConnectionConfigResult;
+export declare function redactCapacityProviderSecret(value: string): string;
+export declare function isCapacityProviderSecretEnvKey(key: string): boolean;
+export declare function redactCapacityProviderEnv(env: Record<string, string>): Record<string, string>;
+export declare function renderCapacityProviderSelfHostInstructions(input: CapacityProviderEnvironmentInput): CapacityProviderSelfHostInstructions;
+export declare function deployCapacityProviderToRailway(input: CapacityProviderDeploymentPrimitiveInput): Promise<CapacityProviderDeploymentPrimitiveResult>;
+export declare function deployCapacityProviderToManagedMarketHost(input: CapacityProviderDeploymentPrimitiveInput): Promise<CapacityProviderDeploymentPrimitiveResult>;
+export declare class MarketProviderClient {
+    private readonly marketUrl;
+    private readonly marketId;
+    private readonly apiKey;
+    private readonly fetchImpl;
+    private readonly userAgent?;
+    constructor(options: MarketProviderClientOptions);
+    private requestJson;
+    register(request: Omit<CapacityProviderRegistrationRequest, 'marketId'> & {
+        marketId?: string;
+    }): Promise<CapacityProviderRegistrationResponse>;
+    heartbeat(request?: Omit<CapacityProviderHeartbeatRequest, 'marketId'> & {
+        marketId?: string;
+    }): Promise<CapacityProviderHeartbeatResponse>;
+    portfolio(): Promise<CapacityProviderPortfolioManifest>;
+    createWorkday(request: ProviderWorkdayRequest): Promise<ProviderWorkdayResponse>;
+    claimTask(request?: ProviderTaskClaimRequest): Promise<ProviderTaskClaimResponse>;
+    appendTaskEvent(taskId: string, request: ProviderTaskEventRequest): Promise<ProviderTaskEventResponse>;
+    completeTask(taskId: string, request?: ProviderTaskCompleteRequest): Promise<ProviderTaskCompleteResponse>;
+    failTask(taskId: string, request: ProviderTaskFailRequest): Promise<ProviderTaskFailResponse>;
+    reportUsage(request: ProviderUsageReport): Promise<ProviderUsageReportResponse>;
+    writeReport(request: ProviderReportRequest): Promise<ProviderReportResponse>;
+}