@ziggs-ai/api-client 0.13.0 → 0.14.1

package/dist/relay/provisionRelayWorkers.js

@@ -1,267 +0,0 @@
-import { ContextGrantsClient, GrantsClient, claimOpenAgreement, delegateAgreement, getMyAgreements, pullOffers, } from '../http/index.js';
-function providerAgentId(agreement) {
-    return agreement.parties?.provider?.actor ?? null;
-}
-function isActiveAgreement(agreement) {
-    return agreement.status === 'active';
-}
-export function findExistingWorkerDelegation(hireAgreementId, assigneeId, agreements) {
-    const matches = agreements.filter((a) => {
-        if (a.parentAgreementId !== hireAgreementId)
-            return false;
-        if (!isActiveAgreement(a))
-            return false;
-        return providerAgentId(a) === assigneeId;
-    });
-    matches.sort((a, b) => {
-        const ta = a.updatedAt ?? a.createdAt ?? '';
-        const tb = b.updatedAt ?? b.createdAt ?? '';
-        return tb.localeCompare(ta);
-    });
-    return matches[0] ?? null;
-}
-export function findOpenOfferForAgent(assigneeId, offers) {
-    return (offers.find((o) => {
-        if (o.status !== 'open' && o.status !== 'active')
-            return false;
-        return providerAgentId(o) === assigneeId;
-    }) ?? null);
-}
-/**
- * The default grant plumbing, built on the two clients that own these routes.
- *
- * A thin function seam rather than the clients themselves, so a test can drive
- * provisioning without a backend — the same reason the agreement calls are
- * injected.
- */
-export function defaultRelayProvisionDeps() {
-    return {
-        getMyAgreements,
-        pullOffers,
-        claimOpenAgreement,
-        delegateAgreement,
-        listAgreementGrants: async ({ agreementId, role }, creds) => {
-            const client = new GrantsClient(creds.operatorKey, creds.agentId);
-            return client.listAllGrants({
-                scopeKind: 'agreement',
-                scopeId: agreementId,
-                role,
-                health: 'active',
-            });
-        },
-        delegateAgreementGrant: async ({ parentGrantId, holderId, agreementId }, creds) => {
-            const client = new ContextGrantsClient(creds.operatorKey, creds.agentId);
-            return client.delegateGrant(parentGrantId, {
-                holderId,
-                holderKind: 'agent',
-                // `write` is exactly what `canActUnderAgreement` tests. Deliberately not
-                // `admit`: that would let a coordinator widen its own crew.
-                kind: 'write',
-                scope: { kind: 'agreement', id: agreementId },
-                // from-start, not from-now: the contract predates the grant, so a
-                // from-now watermark would exclude the very row the grant is about.
-                temporal: 'from-start',
-            });
-        },
-    };
-}
-/**
- * Hand the coordinator a pass on one worker contract.
- *
- * Membership in work is a grant, which is what lets a coordinator create work
- * under a contract it is not a party to. Issuing that grant is the half that has
- * to happen here: without it the recipe fails at the coordinator's first
- * `task_create` with "Caller <coordinator> holds no grant on agreement <worker>,
- * so it cannot create work citing it."
- *
- * Reused before minted, because provisioning is re-run: a second call after an
- * agreement activates should not stack a second pass on a contract that already
- * has one.
- */
-async function grantCoordinatorAccess(args, deps) {
-    const { agreementId, coordinatorId, status, creds } = args;
-    // Participation grants are minted at ACTIVATION, so a contract still waiting
-    // on a signature has nothing to delegate from yet. Say so rather than
-    // reporting a failure the caller cannot act on.
-    if (status !== 'active') {
-        return {
-            status: 'deferred',
-            error: `${agreementId} is not active yet, so there is no participation grant to ` +
-                'delegate from — provision again once it activates',
-        };
-    }
-    try {
-        const alreadyIssued = await deps.listAgreementGrants({ agreementId, role: 'issuer' }, creds);
-        const existing = alreadyIssued.find((g) => g.holderId === coordinatorId);
-        if (existing?.grantId)
-            return { status: 'reused', grantId: existing.grantId };
-        const held = await deps.listAgreementGrants({ agreementId, role: 'holder' }, creds);
-        // Only a `write` or `admit` parent can beget the `write` child the act rule
-        // tests; a `read` participation grant cannot be widened by delegating it.
-        // `access` is optional on GrantView because some rails do not record it —
-        // context grants always do, so an absent value here is a malformed row and
-        // must not be treated as strong enough.
-        const parent = held.find((g) => g.access === 'write' || g.access === 'admit');
-        if (!parent?.grantId) {
-            return {
-                status: 'failed',
-                error: `no write-or-stronger grant on ${agreementId} to delegate from (found ` +
-                    `${held.length ? held.map((g) => g.access ?? 'unstated').join(', ') : 'none'}) — ` +
-                    'the initiator must be a party to the worker contract it is provisioning',
-            };
-        }
-        const result = await deps.delegateAgreementGrant({ parentGrantId: parent.grantId, holderId: coordinatorId, agreementId }, creds);
-        if (result.status === 'pending_approval') {
-            return { status: 'pending_approval', approvalAgreementId: result.agreementId };
-        }
-        return { status: 'granted', grantId: result.grant.grantId };
-    }
-    catch (err) {
-        return {
-            status: 'failed',
-            error: err instanceof Error ? err.message : String(err),
-        };
-    }
-}
-export async function provisionRelayWorkers(input, deps = defaultRelayProvisionDeps()) {
-    const { creds, hireAgreementId, coordinatorId, chatId, steps, inputArtifactIds } = input;
-    if (!steps.length)
-        throw new Error('steps must not be empty');
-    if (!coordinatorId?.trim()) {
-        throw new Error('coordinatorId is required: provisioning a worker for a coordinator means both ' +
-            'the contract and an agreement-scope grant to that coordinator on it, and ' +
-            'without the grant every branch of the run is refused');
-    }
-    const myAgreements = (await deps.getMyAgreements({}, creds));
-    let offersCache = null;
-    // The contracts first, then the passes. Two passes rather than one because a
-    // grant can only be delegated from a participation grant, which exists only
-    // once the contract is active — so the grant decision needs the settled
-    // status of the row, not the intent that created it.
-    const contracted = [];
-    const pendingApprovals = [];
-    for (const step of steps) {
-        const existing = findExistingWorkerDelegation(hireAgreementId, step.assigneeId, myAgreements);
-        if (existing?.agreementId) {
-            contracted.push({
-                stepId: step.stepId,
-                order: step.order,
-                agreementId: existing.agreementId,
-                assigneeId: step.assigneeId,
-                description: step.description,
-                provisionMethod: 'existing',
-                status: 'active',
-            });
-            continue;
-        }
-        if (step.offerAgreementId) {
-            const { agreement: claimed } = await deps.claimOpenAgreement(step.offerAgreementId, creds);
-            const agreementId = claimed.agreementId;
-            const status = isActiveAgreement(claimed)
-                ? 'active'
-                : 'pending_approval';
-            if (status === 'pending_approval')
-                pendingApprovals.push(agreementId);
-            contracted.push({
-                stepId: step.stepId,
-                order: step.order,
-                agreementId,
-                assigneeId: step.assigneeId,
-                description: step.description,
-                provisionMethod: 'claim',
-                status,
-            });
-            continue;
-        }
-        if (!offersCache) {
-            offersCache = await deps.pullOffers({ limit: 100 }, creds);
-        }
-        const openOffer = findOpenOfferForAgent(step.assigneeId, offersCache);
-        if (openOffer?.agreementId) {
-            const { agreement: claimed } = await deps.claimOpenAgreement(openOffer.agreementId, creds);
-            const agreementId = claimed.agreementId;
-            const status = isActiveAgreement(claimed)
-                ? 'active'
-                : 'pending_approval';
-            if (status === 'pending_approval')
-                pendingApprovals.push(agreementId);
-            contracted.push({
-                stepId: step.stepId,
-                order: step.order,
-                agreementId,
-                assigneeId: step.assigneeId,
-                description: step.description,
-                provisionMethod: 'claim',
-                status,
-            });
-            continue;
-        }
-        if (!chatId?.trim()) {
-            throw new Error(`No standing offer found for ${step.assigneeId} and chatId is required to propose a delegation under the hire`);
-        }
-        const delegated = await deps.delegateAgreement({
-            description: step.description,
-            executorId: step.assigneeId,
-            chatId: chatId.trim(),
-            parentAgreementId: hireAgreementId,
-            agreementDescription: `Relay step ${step.stepId}: ${step.description}`,
-            lifecycle: 'count-bound',
-            maxExecutions: 50,
-            price: 0,
-        }, creds);
-        const agreementId = delegated.agreementId;
-        const status = isActiveAgreement(delegated)
-            ? 'active'
-            : 'pending_approval';
-        if (status === 'pending_approval')
-            pendingApprovals.push(agreementId);
-        contracted.push({
-            stepId: step.stepId,
-            order: step.order,
-            agreementId,
-            assigneeId: step.assigneeId,
-            description: step.description,
-            provisionMethod: 'delegate',
-            status,
-        });
-    }
-    contracted.sort((a, b) => a.order - b.order);
-    // ── the second act of provisioning: the coordinator's passes ─────────────
-    const provisioned = [];
-    for (const step of contracted) {
-        const grant = await grantCoordinatorAccess({
-            agreementId: step.agreementId,
-            coordinatorId,
-            status: step.status,
-            creds,
-        }, deps);
-        if (grant.status === 'pending_approval' && grant.approvalAgreementId) {
-            pendingApprovals.push(grant.approvalAgreementId);
-        }
-        provisioned.push({ ...step, grant });
-    }
-    const payload = {
-        inputArtifactIds,
-        steps: provisioned.map(({ stepId, order, agreementId, assigneeId, description }) => ({
-            stepId,
-            order,
-            agreementId,
-            assigneeId,
-            description,
-        })),
-    };
-    /**
-     * Ready means BOTH acts are done for every step. A run whose contracts are all
-     * active but whose coordinator holds no passes looks provisioned and has every
-     * branch refused, so the grant has to count here or this flag goes on lying.
-     */
-    const readyForKickoff = pendingApprovals.length === 0 &&
-        provisioned.every((s) => s.status === 'active' &&
-            (s.grant.status === 'granted' || s.grant.status === 'reused'));
-    return {
-        payload,
-        steps: provisioned,
-        pendingApprovals,
-        readyForKickoff,
-    };
-}