@ziggs-ai/api-client 0.12.0 → 0.14.0

package/dist/http/IntroductionsClient.d.ts

@@ -0,0 +1,60 @@
+/** What became of one hello. `expired` is derived by the server, not stored. */
+export type IntroductionStatus = 'open' | 'redeemed' | 'declined' | 'revoked' | 'expired';
+export type IntroductionOutcome = 'link_pending' | 'already_teammates' | 'already_linked';
+export interface IntroductionView {
+    token: string;
+    status: IntroductionStatus;
+    outcome: IntroductionOutcome | null;
+    from: {
+        label: string;
+        agentId: string | null;
+        orgId: string;
+    };
+    venue: string | null;
+    venueRef: string | null;
+    note: string | null;
+    agreementId: string | null;
+    redeemedBy: {
+        agentId: string | null;
+        orgId: string | null;
+    } | null;
+    expiresAt: string;
+    /** The public page the string points at. This is what you hand over. */
+    url: string;
+    /**
+     * Returned to a redeemer only: the two ids the meeting is now worth, and what
+     * each is for. `agentId` is where messages go; `principal` is who can be a
+     * party to an agreement. Passing one where the other belongs is refused as if
+     * the agent did not exist, which is the wall this field exists to remove.
+     */
+    counterparty?: {
+        principal: string;
+        agentId: string | null;
+        label: string;
+        nextStep: string;
+    };
+}
+export interface MintIntroductionInput {
+    venue?: string;
+    venueRef?: string;
+    note?: string;
+}
+/**
+ * Introduction tokens — the one object to exchange when you meet an
+ * agent somewhere Ziggs does not own.
+ *
+ * The token carries no authority, which is why minting one is free: it widens
+ * nobody's reach. Redeeming one stages a link proposal the two humans sign.
+ */
+export declare class IntroductionsClient {
+    private readonly operatorKey;
+    private readonly agentId?;
+    private readonly baseUrl;
+    constructor(operatorKey: string, agentId?: string, baseUrl?: string);
+    mint(input?: MintIntroductionInput): Promise<IntroductionView>;
+    redeem(token: string): Promise<IntroductionView>;
+    decline(token: string): Promise<IntroductionView>;
+    revoke(token: string): Promise<IntroductionView>;
+    listMine(limit?: number): Promise<IntroductionView[]>;
+    private call;
+}

package/dist/http/IntroductionsClient.js

@@ -0,0 +1,54 @@
+import { getBackendUrl } from '../utils/urlUtils.js';
+import { throwApiError } from '../shared/apiError.js';
+import { buildOperatorHeaders } from './operatorHeaders.js';
+/**
+ * Introduction tokens — the one object to exchange when you meet an
+ * agent somewhere Ziggs does not own.
+ *
+ * The token carries no authority, which is why minting one is free: it widens
+ * nobody's reach. Redeeming one stages a link proposal the two humans sign.
+ */
+export class IntroductionsClient {
+    operatorKey;
+    agentId;
+    baseUrl;
+    constructor(operatorKey, agentId, baseUrl) {
+        if (!operatorKey) {
+            throw new Error('IntroductionsClient: operatorKey is required');
+        }
+        this.operatorKey = operatorKey;
+        this.agentId = agentId;
+        this.baseUrl = baseUrl || getBackendUrl();
+    }
+    async mint(input = {}) {
+        return this.call('POST', '/introductions', input, 'mint');
+    }
+    async redeem(token) {
+        return this.call('POST', `/introductions/${encodeURIComponent(token)}/redeem`, {}, 'redeem');
+    }
+    async decline(token) {
+        return this.call('POST', `/introductions/${encodeURIComponent(token)}/decline`, {}, 'decline');
+    }
+    async revoke(token) {
+        return this.call('DELETE', `/introductions/${encodeURIComponent(token)}`, undefined, 'revoke');
+    }
+    async listMine(limit) {
+        const query = limit != null ? `?limit=${encodeURIComponent(String(limit))}` : '';
+        return this.call('GET', `/introductions${query}`, undefined, 'listMine');
+    }
+    async call(method, path, body, label) {
+        const res = await fetch(`${this.baseUrl}${path}`, {
+            method,
+            headers: {
+                ...buildOperatorHeaders(this.operatorKey, this.agentId),
+                ...(body === undefined ? {} : { 'Content-Type': 'application/json' }),
+            },
+            ...(body === undefined ? {} : { body: JSON.stringify(body) }),
+        });
+        const text = await res.text().catch(() => '');
+        if (!res.ok) {
+            throwApiError(res, text, `IntroductionsClient.${label} failed: ${res.status}`);
+        }
+        return JSON.parse(text);
+    }
+}

package/dist/http/MarketplaceClient.d.ts

@@ -23,21 +23,6 @@ export interface PullOffersOptions {
     since?: string;
 }
 export declare function pullOffers(options: PullOffersOptions | undefined, creds: Creds): Promise<Agreement[]>;
-export interface PublishRequestPayload {
-    /** See PublishOfferPayload.billing. */
-    billing?: 'total' | 'per_task';
-    description: string;
-    chatId?: string;
-    payerId?: string;
-    price?: number;
-    lifecycle?: string;
-    expiresAt?: string;
-    maxExecutions?: number;
-    agreementDescription?: string;
-    /** Broadcast audience: 'everyone' (default, fully public) or 'org' (members of your active org only). */
-    audience?: BroadcastAudience;
-}
-export declare function publishRequest(payload: PublishRequestPayload, creds: Creds): Promise<Agreement>;
 export interface PullRequestsOptions {
     limit?: number;
     since?: string;
@@ -52,6 +37,5 @@ export declare class MarketplaceClient {
     constructor(operatorKey: string, agentId?: string);
     publishOffer(payload: PublishOfferPayload): Promise<Agreement>;
     pullOffers(options?: PullOffersOptions): Promise<Agreement[]>;
-    publishRequest(payload: PublishRequestPayload): Promise<Agreement>;
     pullRequests(options?: PullRequestsOptions): Promise<Agreement[]>;
 }

package/dist/http/MarketplaceClient.js

@@ -52,22 +52,6 @@ export async function pullOffers(options, creds) {
     const data = await res.json().catch(() => null);
     return data?.['offers'] ?? [];
 }
-export async function publishRequest(payload, creds) {
-    assertCreds(creds, 'request publish');
-    const res = await fetch(`${getMarketplaceBaseUrl()}/requests/publish`, {
-        method: 'POST',
-        headers: buildHeaders(creds),
-        body: JSON.stringify(payload || {}),
-    });
-    if (!res.ok) {
-        const body = await res.text().catch(() => '');
-        throwApiError(res, body, `Request publish failed: ${res.status}`);
-    }
-    const data = await res.json().catch(() => null);
-    if (!data?.['agreement'])
-        throw new Error('Request publish returned no agreement');
-    return shapeAgreement(data['agreement']);
-}
 export async function pullRequests(options, creds) {
     assertCreds(creds, 'request pull');
     const params = new URLSearchParams();
@@ -102,6 +86,5 @@ export class MarketplaceClient {
     }
     publishOffer(payload) { return publishOffer(payload, this.creds); }
     pullOffers(options) { return pullOffers(options, this.creds); }
-    publishRequest(payload) { return publishRequest(payload, this.creds); }
     pullRequests(options) { return pullRequests(options, this.creds); }
 }

package/dist/http/TaskClient.d.ts

@@ -13,6 +13,7 @@ export interface TaskWriteConfirm {
     structureChanged?: boolean;
     stepId?: string;
     stepStatus?: string;
+    patchedCount?: number;
     resultRecorded?: boolean;
     terminalState?: string;
     [key: string]: unknown;
@@ -23,6 +24,20 @@ export interface TaskWriteConfirm {
  * subcontract inputs rather than teaching those routes to keep one.
  */
 export type PlanReviewTiming = 'with_proposal' | 'before_execution';
+export interface CreateTaskGraphNodeData {
+    nodeId: string;
+    agreementId: string;
+    description: string;
+    title?: string;
+    assigneeId?: string;
+    waitsOn?: string[];
+    joinKind?: 'all' | 'any';
+}
+export interface CreateTaskGraphData {
+    nodes: CreateTaskGraphNodeData[];
+    inputArtifactIds?: string[];
+    review?: 'before_execution';
+}
 export interface CreateTaskData {
     description: string;
     /**
@@ -37,10 +52,26 @@ export interface CreateTaskData {
     planReviewTiming?: PlanReviewTiming;
     requireMidWorkPlanAck?: boolean;
     idempotencyKey?: string;
-    /** Explicit delegation target — must be a party to the agreement; validated server-side. */
+    /**
+     * Explicit delegation target — must hold a grant on the agreement, so work
+     * can only be handed to someone that contract already reaches; validated
+     * server-side.
+     */
     assigneeId?: string;
     /** prior-step artifact handles consumed as structured input links. */
     inputArtifactIds?: string[];
+    /**
+     * Tasks this one waits for. The task is created immediately, but its assignee
+     * is not woken and cannot start it until every task named here is terminal.
+     * Declaring an edge needs read reach on the task you name.
+     *
+     * Declared rather than enacted: state the join up front and the platform
+     * wakes the joiner once, instead of a live agent polling for it and holding
+     * the shape in its own control flow where nothing else can see it.
+     */
+    waitsOn?: string[];
+    /** Atomically declare a native work graph beneath the returned root task. */
+    graph?: CreateTaskGraphData;
 }
 export declare function createTask(taskData: CreateTaskData, creds: Creds): Promise<Task>;
 export declare function getTask(taskId: string, creds: Creds): Promise<Task>;
@@ -77,6 +108,13 @@ export interface PlanReplaceStep {
     result?: unknown;
 }
 export declare function replaceTaskPlan(taskId: string, steps: PlanReplaceStep[], creds: Creds): Promise<TaskWriteConfirm>;
+/** Named-step progress — only the listed steps change. */
+export type PlanStepPatch = {
+    stepId: string;
+    status: 'pending' | 'in_progress' | 'completed' | 'skipped';
+    result?: unknown;
+};
+export declare function updateTaskPlanSteps(taskId: string, patches: PlanStepPatch[], creds: Creds): Promise<TaskWriteConfirm>;
 export declare function updateTaskPlanStep(taskId: string, stepId: string, status: string, result: unknown, creds: Creds): Promise<TaskWriteConfirm>;
 export declare function reportTask(taskId: string, message: string | undefined, creds: Creds): Promise<TaskWriteConfirm>;
 export declare function setTaskSatisfaction(taskId: string, satisfaction: 'positive' | 'negative', creds: Creds): Promise<TaskWriteConfirm>;
@@ -121,6 +159,7 @@ export declare class TaskClient {
     getSubtasks(parentTaskId: string): Promise<Task[]>;
     replaceTaskPlan(taskId: string, steps: PlanReplaceStep[]): Promise<TaskWriteConfirm>;
     updateTaskPlanStep(taskId: string, stepId: string, status: string, result?: unknown): Promise<TaskWriteConfirm>;
+    updateTaskPlanSteps(taskId: string, patches: PlanStepPatch[]): Promise<TaskWriteConfirm>;
     reportTask(taskId: string, message?: string): Promise<TaskWriteConfirm>;
     setTaskSatisfaction(taskId: string, satisfaction: 'positive' | 'negative'): Promise<TaskWriteConfirm>;
     listTasks(options?: ListTasksOptions): Promise<ListTasksResult>;

package/dist/http/TaskClient.js

@@ -55,6 +55,7 @@ function extractWriteConfirm(data) {
                 : {}),
             ...(typeof d['stepId'] === 'string' ? { stepId: d['stepId'] } : {}),
             ...(typeof d['stepStatus'] === 'string' ? { stepStatus: d['stepStatus'] } : {}),
+            ...(typeof d['patchedCount'] === 'number' ? { patchedCount: d['patchedCount'] } : {}),
             ...(d['resultRecorded'] === true ? { resultRecorded: true } : {}),
             ...(typeof d['terminalState'] === 'string'
                 ? { terminalState: d['terminalState'] }
@@ -152,10 +153,29 @@ export async function getActiveTasksForAgent(agentId, creds) {
     const data = await res.json().catch(() => null);
     const fromAgent = Array.isArray(data?.['tasks']) ? data['tasks'] : [];
     if (fromAgent.length > 0)
-        return fromAgent;
+        return workable(fromAgent);
     // Fallback when /agents/:id/tasks is empty but party-agreement tasks exist.
     return getActiveTasksForAgentViaPartyAgreements(agentId, creds);
 }
+/**
+ * Drop the tasks the platform created but deliberately did not deliver.
+ *
+ * `heldByDeps` is a DELIVERY condition, not a task state: a task waiting on its
+ * `waitsOn` edges is genuinely `active`, so `?state=active` returns it and the
+ * assignee's own work list hands over a task nobody woke it for. Every caller of
+ * this function is asking "what can I act on now", and for a withheld row the
+ * answer is nothing — `updateTaskState` refuses it with `dependencies_unmet`.
+ * Two of AgentHost's three callers do worse than waste a wake: the needs gate
+ * and the unmet-access sweep both FAIL the tasks they find, so a withheld node
+ * was one missing grant away from being failed before its turn came.
+ *
+ * Filtered here rather than at `/agents/:id/tasks`, which is also the route the
+ * UI lists an agent's work with — a person looking at the graph should see the
+ * withheld node sitting there waiting, which is the whole point of a join.
+ */
+function workable(tasks) {
+    return tasks.filter((t) => t.heldByDeps !== true);
+}
 async function getActiveTasksForAgentViaPartyAgreements(agentId, creds) {
     const { listAgreements } = await import('./AgreementClient.js');
     const agreements = await listAgreements({ status: 'active' }, creds);
@@ -175,7 +195,7 @@ async function getActiveTasksForAgentViaPartyAgreements(agentId, creds) {
         return Array.isArray(data?.['tasks']) ? data['tasks'] : [];
     }));
     const merged = lists.flat();
-    return merged.filter((t) => !t.assigneeId || t.assigneeId === agentId);
+    return workable(merged.filter((t) => !t.assigneeId || t.assigneeId === agentId));
 }
 // Backend deliberately has no `/chats/:id/tasks` route — it's composable
 // from links → per-agreement tasks. We do the composition here so callers
@@ -263,6 +283,34 @@ export async function replaceTaskPlan(taskId, steps, creds) {
         throw new Error('Invalid response: task write confirm not found');
     return confirm;
 }
+export async function updateTaskPlanSteps(taskId, patches, creds) {
+    if (!taskId)
+        throw new Error('updateTaskPlanSteps: taskId is required');
+    if (!patches || !Array.isArray(patches) || patches.length === 0) {
+        throw new Error('updateTaskPlanSteps: patches must name at least one step');
+    }
+    for (const patch of patches) {
+        if (!patch?.stepId)
+            throw new Error('updateTaskPlanSteps: each patch needs a stepId');
+        if (!patch?.status)
+            throw new Error('updateTaskPlanSteps: each patch needs a status');
+    }
+    assertCreds(creds, 'plan step patch');
+    const res = await fetch(`${getTaskBaseUrl()}/${taskId}/plan`, {
+        method: 'PATCH',
+        headers: buildHeaders(creds),
+        body: JSON.stringify({ patches }),
+    });
+    if (!res.ok) {
+        const responseBody = await res.text().catch(() => '');
+        throwApiError(res, responseBody, `Plan step patch failed: ${res.status} ${res.statusText}`);
+    }
+    const data = await res.json().catch(() => null);
+    const confirm = extractWriteConfirm(data);
+    if (!confirm)
+        throw new Error('Invalid response: task write confirm not found');
+    return confirm;
+}
 export async function updateTaskPlanStep(taskId, stepId, status, result, creds) {
     if (!taskId)
         throw new Error('updateTaskPlanStep: taskId is required');
@@ -406,6 +454,7 @@ export class TaskClient {
     getSubtasks(parentTaskId) { return getSubtasks(parentTaskId, this.creds); }
     replaceTaskPlan(taskId, steps) { return replaceTaskPlan(taskId, steps, this.creds); }
     updateTaskPlanStep(taskId, stepId, status, result) { return updateTaskPlanStep(taskId, stepId, status, result, this.creds); }
+    updateTaskPlanSteps(taskId, patches) { return updateTaskPlanSteps(taskId, patches, this.creds); }
     reportTask(taskId, message) { return reportTask(taskId, message, this.creds); }
     setTaskSatisfaction(taskId, satisfaction) { return setTaskSatisfaction(taskId, satisfaction, this.creds); }
     listTasks(options) { return listTasks(options ?? {}, this.creds); }

package/dist/http/grants.d.ts

@@ -36,9 +36,15 @@ export type GrantBasisKind = 'creation' | 'publication' | 'membership' | 'accept
  * stopped showing a whole scope kind after `artifact` was added; anything that
  * means "every context scope" should read this.
  */
-export declare const CONTEXT_GRANT_SCOPE_KINDS: readonly ["chat", "agreement", "org", "artifact"];
-/** Every scope kind across every rail: context + connection + payment. */
-export declare const GRANT_SCOPE_KINDS: readonly ["chat", "agreement", "org", "artifact", "connection", "wallet"];
+export declare const CONTEXT_GRANT_SCOPE_KINDS: readonly ["chat", "agreement", "org", "artifact", "task"];
+/**
+ * Every scope kind across every rail: context + connection + payment + consent
+ * + carrier. Mirrors the server's `GRANT_SCOPE_KINDS` (grants/grant-view.ts),
+ * which is the list `GET /grants?scopeKind=` validates against — a kind missing
+ * here cannot be asked for at all, which is the failure the comment above
+ * describes.
+ */
+export declare const GRANT_SCOPE_KINDS: readonly ["chat", "agreement", "org", "artifact", "task", "connection", "wallet", "consent", "inbox"];
 export type GrantScopeKind = (typeof GRANT_SCOPE_KINDS)[number];
 export interface GrantScopeView {
     kind: GrantScopeKind;

package/dist/http/grants.js

@@ -12,12 +12,25 @@ export const CONTEXT_GRANT_SCOPE_KINDS = [
     'org',
     // narrowest context scope
     'artifact',
+    // a branch of a work graph: the named task and everything under it, now and
+    // in future. Holding one is what being in a job means.
+    'task',
 ];
-/** Every scope kind across every rail: context + connection + payment. */
+/**
+ * Every scope kind across every rail: context + connection + payment + consent
+ * + carrier. Mirrors the server's `GRANT_SCOPE_KINDS` (grants/grant-view.ts),
+ * which is the list `GET /grants?scopeKind=` validates against — a kind missing
+ * here cannot be asked for at all, which is the failure the comment above
+ * describes.
+ */
 export const GRANT_SCOPE_KINDS = [
     ...CONTEXT_GRANT_SCOPE_KINDS,
     'connection',
     'wallet',
+    // approval authority — who may answer a slot
+    'consent',
+    // carrier grants — who reads whose mailbox
+    'inbox',
 ];
 /** Value of the first caveat of `type` on a grant, or undefined. */
 export function grantCaveat(grant, type) {

package/dist/http/index.d.ts

@@ -11,6 +11,8 @@ export { ContextReadClient, CONTEXT_READ_TYPES, CONTEXT_READ_VIA, VIA_KINDS, par
 export type { ContextReadType, ContextReadQuery, ContextReadEnvelope, ContextSnapshotResult, ContextSnapshotParticipant, ViaKind, } from './ContextReadClient.js';
 export { ContextDiscoveryClient } from './ContextDiscoveryClient.js';
 export type { DiscoverableItem } from './ContextDiscoveryClient.js';
+export { IntroductionsClient } from './IntroductionsClient.js';
+export type { IntroductionView, IntroductionStatus, IntroductionOutcome, MintIntroductionInput, } from './IntroductionsClient.js';
 export { GrantsClient } from './GrantsClient.js';
 export type { ListGrantsQuery, ListGrantsResult, UnreadableRail } from './GrantsClient.js';
 export { ContextGrantsClient } from './ContextGrantsClient.js';

package/dist/http/index.js

@@ -9,6 +9,7 @@ export { ArtifactsClient,
 artifactScopeForSession, AGREEMENT_LANE_PREFIX, ARTIFACT_INLINE_TEXT_MAX_CHARS, ARTIFACT_INLINE_TEXT_OVER_LIMIT_HINT, } from './ArtifactsClient.js';
 export { ContextReadClient, CONTEXT_READ_TYPES, CONTEXT_READ_VIA, VIA_KINDS, parseVia, viaHint, } from './ContextReadClient.js';
 export { ContextDiscoveryClient } from './ContextDiscoveryClient.js';
+export { IntroductionsClient } from './IntroductionsClient.js';
 export { GrantsClient } from './GrantsClient.js';
 export { ContextGrantsClient } from './ContextGrantsClient.js';
 export { grantCaveat, CONTEXT_GRANT_SCOPE_KINDS, GRANT_SCOPE_KINDS, } from './grants.js';

package/dist/index.d.ts

@@ -1,6 +1,5 @@
 export * from './http/index.js';
 export * from './capabilities/index.js';
-export * from './relay/provisionRelayWorkers.js';
 export { ConnectionManager } from './ConnectionManager.js';
 export { EntryTypes, ContentTypes, OPEN_AGREEMENT_TARGET, ORG_AGREEMENT_TARGET, BROADCAST_TARGETS, isBroadcastTarget, isPersonaRef, isRoomPresentationRef, isOpaquePresentationRef, AGREEMENT_ENGAGEMENT_KIND, isValidContentType, partySideIds, partyActorIds, } from './types.js';
 export type { PrincipalPresentation } from './types.js';

package/dist/index.js

@@ -1,6 +1,5 @@
 export * from './http/index.js';
 export * from './capabilities/index.js';
-export * from './relay/provisionRelayWorkers.js';
 export { ConnectionManager } from './ConnectionManager.js';
 export { EntryTypes, ContentTypes, OPEN_AGREEMENT_TARGET, ORG_AGREEMENT_TARGET, BROADCAST_TARGETS, isBroadcastTarget, isPersonaRef, isRoomPresentationRef, isOpaquePresentationRef, AGREEMENT_ENGAGEMENT_KIND, isValidContentType, partySideIds, partyActorIds, } from './types.js';
 export { getBackendUrl } from './utils/urlUtils.js';

package/dist/types.d.ts

@@ -71,6 +71,24 @@ export interface Task {
     updatedAt?: string;
     parentTaskId?: string;
     rootTaskId?: string;
+    /** Tasks this one waits for before it may start. */
+    waitsOn?: string[];
+    /**
+     * True while {@link waitsOn} is unmet: the task exists but has not been
+     * delivered, and its assignee cannot take the processing lock yet. Distinct
+     * from "nobody has picked it up" — this one is waiting on purpose.
+     */
+    heldByDeps?: boolean;
+    joinKind?: 'all' | 'any';
+    graph?: {
+        nodes: Array<{
+            nodeId: string;
+            taskId: string;
+        }>;
+        review?: 'before_execution';
+    } | null;
+    graphNodeId?: string | null;
+    heldByGraphReview?: boolean;
     plan?: {
         steps?: PlanStep[];
     };
@@ -140,6 +158,8 @@ export interface AgreementApprovalEntry {
     role?: string;
     status?: string;
     respondedAt?: string | null;
+    /** Why a pending slot is held (e.g. 'formation-gate', 'contact-basis'), when the server said. */
+    heldReason?: string | null;
 }
 export interface Agreement {
     agreementId: string;
@@ -361,6 +381,15 @@ export interface InboxProposalRef {
     agreementId: string;
     title: string;
     proposedAt: string | null;
+    /**
+     * The agent designated to wake for this proposal, or null when it is
+     * ambient/human work in this reader's merged inbox.
+     *
+     * Optional for rolling deploys. When an older server omits it, clients must
+     * only use an explicit agent-keyed approval/responder slot as a safe fallback;
+     * org visibility alone is never assignment.
+     */
+    assignedAgentId?: string | null;
     /**
      * party ids still owing a decision, and the named responder slot.
      * The inbox lists proposals awaiting the agent OR its human, and only the

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ziggs-ai/api-client",
-  "version": "0.12.0",
+  "version": "0.14.0",
   "description": "HTTP and WebSocket client for the Ziggs backend API",
   "type": "module",
   "main": "dist/index.js",

package/dist/relay/provisionRelayWorkers.d.ts

@@ -1,53 +0,0 @@
-import type { Agreement, Creds } from '../types.js';
-import { claimOpenAgreement, delegateAgreement, getMyAgreements, pullOffers } from '../http/index.js';
-/** Minimal relay step shape — keep field names aligned with agents/coordinators/relayTypes.ts */
-export interface RelayStepInput {
-    stepId: string;
-    order: number;
-    assigneeId: string;
-    description: string;
-    /** Standing offer agreementId to claim for this worker (optional). */
-    offerAgreementId?: string;
-}
-export interface RelayPayloadShape {
-    inputArtifactIds?: string[];
-    steps: Array<{
-        stepId: string;
-        order: number;
-        agreementId: string;
-        assigneeId: string;
-        description: string;
-    }>;
-}
-export type ProvisionMethod = 'existing' | 'claim' | 'delegate';
-export type StepProvisionStatus = 'active' | 'pending_approval';
-export type ProvisionedRelayStep = RelayPayloadShape['steps'][number] & {
-    provisionMethod: ProvisionMethod;
-    status: StepProvisionStatus;
-};
-export interface RelayProvisionDeps {
-    getMyAgreements: typeof getMyAgreements;
-    pullOffers: typeof pullOffers;
-    claimOpenAgreement: typeof claimOpenAgreement;
-    delegateAgreement: typeof delegateAgreement;
-}
-export interface ProvisionRelayWorkersInput {
-    creds: Creds;
-    hireAgreementId: string;
-    chatId?: string;
-    steps: RelayStepInput[];
-    inputArtifactIds?: string[];
-}
-export interface ProvisionRelayWorkersResult {
-    payload: RelayPayloadShape;
-    steps: ProvisionedRelayStep[];
-    pendingApprovals: string[];
-    readyForKickoff: boolean;
-}
-type AgreementWithParent = Agreement & {
-    parentAgreementId?: string;
-};
-export declare function findExistingWorkerDelegation(hireAgreementId: string, assigneeId: string, agreements: AgreementWithParent[]): AgreementWithParent | null;
-export declare function findOpenOfferForAgent(assigneeId: string, offers: Agreement[]): Agreement | null;
-export declare function provisionRelayWorkers(input: ProvisionRelayWorkersInput, deps?: RelayProvisionDeps): Promise<ProvisionRelayWorkersResult>;
-export {};