@treeseed/sdk 0.13.0-rc.6 → 0.13.0-rc.8

package/dist/reconcile/capacity/capacity-core/live-acceptance-capacity-competition.js

@@ -1,179 +0,0 @@
-import { ProviderProtocolClient } from "../../../capacity/providers/capacity-provider.js";
-import { activateInternalCapacityAllocationSet, createInternalCapacityAllocationSet } from "../../../market-client/internal-capacity-allocation.js";
-function projectRecord(payload) {
-  const project = payload.project ?? payload;
-  if (!project.id) throw new Error("Capacity competition project creation omitted its project id.");
-  return { id: project.id, slug: project.slug ?? project.id };
-}
-async function provisionLocalCapacityCompetition(input) {
-  const prefix = `capacity-competition:${input.runId}`;
-  const projectSlug = `cap-${input.runId.replace(/[^a-z0-9]/giu, "").toLowerCase().slice(-20)}-work`.slice(0, 39).replace(/-+$/u, "");
-  const createdProject = await input.adminClient.createProject(input.runtime.teamId, {
-    slug: projectSlug,
-    name: `Capacity competition ${input.runId}`,
-    description: "Isolated two-team provider-global final-slot acceptance project.",
-    metadata: { liveAcceptance: true, runId: input.runId, purpose: "provider-global-final-slot" }
-  });
-  const project = projectRecord(createdProject.payload);
-  const providerClient = new ProviderProtocolClient({
-    marketUrl: input.apiUrl,
-    accessToken: input.runtime.providerAccessToken,
-    fetchImpl: input.fetchImpl,
-    userAgent: `treeseed-capacity-competition/${input.runId}`
-  });
-  let sessionId = "";
-  const agentClassId = `competition-testing-${input.runId}`;
-  const grantId = `competition-${input.runId}-grant`;
-  const allocationId = `competition-${input.runId}-allocation`;
-  const workdayId = `competition-${input.runId}-workday`;
-  const assignmentId = `competition-${input.runId}-assignment`;
-  let sessionCreated = false;
-  let grantCreated = false;
-  let workdayCreated = false;
-  let assignmentCreated = false;
-  const cleanup = async () => {
-    const errors = [];
-    const run = async (label, operation) => {
-      try {
-        await operation();
-      } catch (error) {
-        errors.push(`${label}: ${error instanceof Error ? error.message : String(error)}`);
-      }
-    };
-    if (assignmentCreated) await run("cancel competing assignment", () => input.adminClient.cancelCapacityAssignment(input.runtime.teamId, assignmentId, { idempotencyKey: `${prefix}:assignment-cancel`, reason: "final-slot acceptance completed" }));
-    if (workdayCreated) await run("complete competing workday", () => input.adminClient.completeWorkday(workdayId, `${prefix}:workday-complete`));
-    if (sessionCreated) await run("close competing availability", () => providerClient.closeAvailabilitySession(sessionId));
-    if (grantCreated) await run("revoke competing grant", () => input.adminClient.transitionCapacityGrant(input.runtime.teamId, grantId, "revoke", `${prefix}:grant-revoke`));
-    if (errors.length) throw new Error(`Capacity competition cleanup failed: ${errors.join("; ")}`);
-  };
-  try {
-    let availability = await providerClient.createAvailabilitySession({
-      environment: "local",
-      status: "open",
-      capabilities: ["planning", "repo_read", "agent_mode_run", "usage_report"],
-      grants: [],
-      nativeLimits: { availableAgentSeconds: 600, maxConcurrentRunners: 1 },
-      runnerPressure: { activeRunners: 0, maxConcurrentRunners: 1 },
-      metadata: { liveAcceptance: true, runId: input.runId },
-      executionProviders: [{
-        id: "codex",
-        adapter: "codex",
-        status: "available",
-        capabilities: ["planning", "repo_read", "agent_mode_run", "usage_report"],
-        maxConcurrentRunners: 1,
-        activeRunners: 0,
-        nativeLimits: { availableAgentSeconds: 600 },
-        lanes: [{ id: "codex-operation", executionProviderId: "codex", purpose: "operation", status: "active", capabilities: [], maxConcurrentRunners: 1, activeRunners: 0, nativeLimits: {} }]
-      }]
-    });
-    sessionId = String(availability.payload.id ?? "");
-    if (!sessionId) throw new Error("Capacity competition availability session omitted its id.");
-    sessionCreated = true;
-    await input.adminClient.createProjectAgentClass(project.id, {
-      id: agentClassId,
-      slug: agentClassId,
-      name: "Competition testing agents",
-      status: "active",
-      allowedModes: ["planning"],
-      requiredCapabilities: ["agent_mode_run"],
-      metadata: { liveAcceptance: true, runId: input.runId }
-    }, `${prefix}:agent-class`);
-    await input.adminClient.createCapacityGrant(input.runtime.teamId, {
-      schemaVersion: 2,
-      id: grantId,
-      membershipId: input.runtime.membershipId,
-      providerId: input.runtime.providerId,
-      projectId: project.id,
-      environment: "local",
-      status: "planned",
-      executionProviderIds: ["codex"],
-      laneIds: [],
-      capabilities: ["planning", "repo_read", "agent_mode_run", "usage_report"],
-      allowedModes: ["planning"],
-      dailyAgentSecondsLimit: 600,
-      monthlyAgentSecondsLimit: 600,
-      maxConcurrentAssignments: 1,
-      metadata: { liveAcceptance: true, runId: input.runId }
-    }, `${prefix}:grant-create`);
-    grantCreated = true;
-    await input.adminClient.transitionCapacityGrant(input.runtime.teamId, grantId, "activate", `${prefix}:grant-activate`);
-    const allocation = await createInternalCapacityAllocationSet(input.adminClient, input.runtime.teamId, {
-      id: allocationId,
-      effectiveFrom: new Date(Date.now() - 1e3).toISOString(),
-      effectiveUntil: new Date(Date.now() + 10 * 6e4).toISOString(),
-      reservePolicy: { percent: 0, overflow: "deny" },
-      slices: [{ id: `${allocationId}:project`, scope: "project", targetId: project.id, policy: { minPercent: 0, targetPercent: 100, maxPercent: 100, hardCapPercent: 100 } }],
-      borrowingRules: [],
-      metadata: { liveAcceptance: true, runId: input.runId }
-    }, `${prefix}:allocation-create`);
-    const activeAllocation = await activateInternalCapacityAllocationSet(input.adminClient, input.runtime.teamId, String(allocation.payload.id), `${prefix}:allocation-activate`);
-    availability = await providerClient.refreshAvailabilitySession(sessionId, {
-      expectedSequence: availability.payload.sequence,
-      environment: "local",
-      status: "open",
-      capabilities: ["planning", "repo_read", "agent_mode_run", "usage_report"],
-      grants: [{ grantId, projectId: project.id, teamId: input.runtime.teamId, grantScope: "project" }],
-      nativeLimits: { availableAgentSeconds: 600, maxConcurrentRunners: 1 },
-      runnerPressure: { activeRunners: 0, maxConcurrentRunners: 1 },
-      metadata: { liveAcceptance: true, runId: input.runId },
-      executionProviders: [{
-        id: "codex",
-        adapter: "codex",
-        status: "available",
-        capabilities: ["planning", "repo_read", "agent_mode_run", "usage_report"],
-        maxConcurrentRunners: 1,
-        activeRunners: 0,
-        nativeLimits: { availableAgentSeconds: 600 },
-        lanes: [{ id: "codex-operation", executionProviderId: "codex", purpose: "operation", status: "active", capabilities: [], maxConcurrentRunners: 1, activeRunners: 0, nativeLimits: {} }]
-      }]
-    });
-    await input.adminClient.createWorkday({
-      id: workdayId,
-      projectId: project.id,
-      allocationSetId: activeAllocation.payload.id,
-      environment: "local",
-      status: "active",
-      availableSeconds: 600,
-      envelope: { availableSeconds: 600, metadata: { liveAcceptance: true, runId: input.runId } },
-      metadata: { liveAcceptance: true, runId: input.runId, grantId }
-    }, `${prefix}:workday-create`);
-    workdayCreated = true;
-    await input.adminClient.admitCapacityAssignment(input.runtime.teamId, {
-      assignmentId,
-      reservationId: `${assignmentId}-reservation`,
-      projectId: project.id,
-      providerId: input.runtime.providerId,
-      membershipId: input.runtime.membershipId,
-      environment: "local",
-      providerSessionId: sessionId,
-      projectAgentClassId: agentClassId,
-      executionProviderId: "codex",
-      workDayId: workdayId,
-      requestedSeconds: 300,
-      mode: "planning",
-      capacityEnvelope: { teamId: input.runtime.teamId, projectId: project.id, providerId: input.runtime.providerId, workDayId: workdayId, mode: "planning", limits: { wallMinutes: 5 }, metadata: { liveAcceptance: true, runId: input.runId } },
-      decisionInput: { kind: "provider_global_final_slot_competition", runId: input.runId },
-      workspaceContext: { liveAcceptance: true, runId: input.runId },
-      metadata: { liveAcceptance: true, runId: input.runId, priority: 1e6 }
-    }, `${prefix}:assignment-admit`);
-    assignmentCreated = true;
-    return {
-      connection: {
-        ...input.runtime,
-        projectId: project.id,
-        providerSessionId: sessionId,
-        providerSessionSequence: Number(availability.payload.sequence),
-        assignmentId
-      },
-      cleanup
-    };
-  } catch (error) {
-    await cleanup().catch((cleanupError) => {
-      throw new AggregateError([error, cleanupError], "Capacity competition provisioning and cleanup both failed.");
-    });
-    throw error;
-  }
-}
-export {
-  provisionLocalCapacityCompetition
-};

package/dist/reconcile/capacity/capacity-core/live-acceptance-capacity-context.d.ts

@@ -1,132 +0,0 @@
-import { type AgentSignalContract } from '../../../agent-capacity/validation/agent-signal.js';
-import { type ProposalTypeContract } from '../../../agent-capacity/validation/proposal-type.js';
-import { MarketClient } from '../../../entrypoints/clients/market-client.js';
-import { type LiveAcceptanceEnv } from '../../support/acceptance/live-acceptance-values.js';
-import type { LiveReconcileEnvironment } from '../../support/acceptance/live-acceptance.js';
-import type { CapacityGovernanceAcceptanceProof } from './live-acceptance-capacity-governance.js';
-export declare function capacityAcceptanceConfig(env: LiveAcceptanceEnv, environment: LiveReconcileEnvironment): {
-    apiUrl: string;
-    adminToken: string;
-    teamId: string;
-    projectId: string;
-    projectSlug: string;
-    providerId: string;
-    membershipId: string;
-    agentClassId: string;
-    providerAccessToken: string;
-    missing: string[];
-};
-export declare function resolveLocalCapacityAcceptanceScope(adminClient: MarketClient, configuredProjectId: string): Promise<{
-    projectId: any;
-    projectSlug: any;
-    teamId: any;
-}>;
-export declare function bindLocalCapacityTreeDxRepository(adminClient: MarketClient, scope: {
-    projectId: string;
-    projectSlug: string;
-    teamId: string;
-}, input: {
-    repositoryName: string;
-    contentPath: string;
-}): Promise<any>;
-export declare function ensureLocalCapacityTreeDxBinding(adminClient: MarketClient, scope: {
-    projectId: string;
-    projectSlug: string;
-    teamId: string;
-}): Promise<any>;
-export declare function syncLocalAcceptanceAgentClasses(adminClient: MarketClient, input: {
-    projectId: string;
-    repositoryId: string;
-    agentPaths: string[];
-    runId: string;
-    ref?: string;
-}): Promise<{
-    agentClasses: any[];
-    resolvedRef: string;
-    signalContracts: Record<string, AgentSignalContract>;
-    proposalTypeContracts: Record<string, ProposalTypeContract>;
-}>;
-export declare function syncLocalAcceptanceAgentClass(adminClient: MarketClient, input: {
-    projectId: string;
-    agentClassId: string;
-    runId: string;
-}): Promise<any>;
-export declare function provisionLocalCapacityAcceptanceProvider(input: {
-    adminClient: MarketClient;
-    apiUrl: string;
-    teamId: string;
-    runId: string;
-    fetchImpl: typeof fetch;
-    capabilities?: string[];
-    maxConcurrentRunners?: number;
-    purpose?: string;
-}): Promise<{
-    providerId: string;
-    membershipId: any;
-    providerAccessToken: string;
-    credentialId: string;
-    membershipCredential: string;
-    privateJwk: import("../../../capacity-provider/index.js").CapacityProviderPrivateJwk;
-    cleanup: () => any;
-}>;
-export interface CapacityAcceptanceProof {
-    sessionId: string;
-    assignmentId: string;
-    modeRunId: string;
-    finalStatus: string;
-    mode: string;
-    runnerId: string;
-    modeRunCount: number;
-    artifactCount: number;
-    toolEventCount: number;
-    usageActualCount: number;
-    ledgerEntryCount: number;
-    starterPlanning?: {
-        starter: 'research';
-        projectId: string;
-        assignmentId: string;
-        agentId: string;
-        handlerId: string;
-        artifactCount: number;
-        usageActualCount: number;
-        ledgerEntryCount: number;
-        completedAssignments?: number;
-        workflowStatus?: string;
-        citationCount?: number;
-        revisionCount?: number;
-    };
-    starterEngineering?: {
-        starter: 'engineering';
-        projectId: string;
-        assignmentId: string;
-        completedAssignments: number;
-        artifactCount: number;
-        usageActualCount: number;
-        ledgerEntryCount: number;
-        graphStatus: string;
-        graphNodeCount: number;
-        revisionNodeCount: number;
-        exactBaseRef: string;
-        participatingAgents: string[];
-    };
-    starterConcurrency?: {
-        projectIds: string[];
-        assignmentIds: string[];
-        workspaceIds: string[];
-        overlapMs: number;
-        artifactCount: number;
-        usageActualCount: number;
-        ledgerEntryCount: number;
-    };
-    governance?: CapacityGovernanceAcceptanceProof;
-}
-export declare function capacityGrantForAcceptance(grants: unknown[], config: ReturnType<typeof capacityAcceptanceConfig>, environment: LiveReconcileEnvironment): Record<string, unknown> | null;
-export declare function effectiveActiveAllocation(allocations: unknown[], now?: number): Record<string, unknown> | null;
-export declare function createTreeDxProxyAuditEvidence(input: {
-    fetchImpl: typeof fetch;
-    apiUrl: string;
-    providerAccessToken: string;
-    projectId: string;
-    assignmentId: string;
-    runId: string;
-}): Promise<void>;