@ziggs-ai/agent-sdk 0.14.0 → 0.16.1

package/dist/runtime/AgentMachine.d.ts

@@ -32,6 +32,10 @@ export type TransitionEvent = {
     kind: 'error-escape';
     fromState: string;
     toState: string;
+} | {
+    kind: 'unmatched-escape';
+    fromState: string;
+    toState: string;
 } | {
     kind: 'timeout-unhandled';
     state: string;
@@ -134,8 +138,31 @@ export declare class AgentMachine {
      */
     send(frame: IncomingFrame): Promise<void>;
     _handleFrame(frame: IncomingFrame): Promise<void>;
+    /**
+     * Give up on a wedged state and go back to listening.
+     *
+     * Both runaway guards used to just `return`, which left `this.state` AT the
+     * state that had run away. Parking inside a thinking state is not parking —
+     * it is a lane stuck in a room whose transitions were written for one
+     * occasion, so every later event is evaluated against the wrong state and
+     * anything that state does not route is swallowed. Measured: three lab
+     * workers tripped the depth guard inside the injected `claimKickingOff`
+     * greeting; `claimKickingOff` has no `task-assigned` route, so the task wake
+     * that arrived next was dropped and three graph nodes were never worked at
+     * all. The greeting is best-effort; the work is not.
+     *
+     * The initial state is the one the author wrote to receive anything, so it is
+     * the only safe place to land.
+     */
+    private _parkAtInitial;
     _step(outcome: Outcome, depth?: number): Promise<void>;
-    /** Error with no author-defined escape: park at workflow.initial if it is parked. */
+    /**
+     * Unmatched thinking outcome: go back to workflow.initial when that state is
+     * parked. Used to require an error outcome, so a tool-result /
+     * message-sent / wait with no route logged "parking" and left `this.state`
+     * on the thinking state. The next event then ran a turn against prompts
+     * written for the previous occasion.
+     */
     _escapeToInitialParked(outcome: Outcome, fromState: string): Promise<boolean>;
     /** Sends a short fallback to the last known human user when the machine parks unexpectedly. Best-effort — never throws. */
     _sendFallbackIfUserWaiting(text: string): Promise<void>;

package/dist/runtime/AgentMachine.js

@@ -144,6 +144,30 @@ export class AgentMachine {
         applyOutcomeToCtx(this.ctx, outcome);
         await this._step(outcome);
     }
+    /**
+     * Give up on a wedged state and go back to listening.
+     *
+     * Both runaway guards used to just `return`, which left `this.state` AT the
+     * state that had run away. Parking inside a thinking state is not parking —
+     * it is a lane stuck in a room whose transitions were written for one
+     * occasion, so every later event is evaluated against the wrong state and
+     * anything that state does not route is swallowed. Measured: three lab
+     * workers tripped the depth guard inside the injected `claimKickingOff`
+     * greeting; `claimKickingOff` has no `task-assigned` route, so the task wake
+     * that arrived next was dropped and three graph nodes were never worked at
+     * all. The greeting is best-effort; the work is not.
+     *
+     * The initial state is the one the author wrote to receive anything, so it is
+     * the only safe place to land.
+     */
+    _parkAtInitial() {
+        const initial = this.workflow.initial;
+        if (this.state !== initial) {
+            runtimeLog.warn('AgentMachine', `recovering wedged state=${this.state} → ${initial}`);
+            this.state = initial;
+        }
+        this._notify();
+    }
     async _step(outcome, depth = 0) {
         const fromState = this.state;
         const target = this._evaluateTransitions(outcome);
@@ -182,14 +206,14 @@ export class AgentMachine {
                 runtimeLog.warn('AgentMachine', `state=${this.state} runaway mechanical loop (depth=${depth}); parking`);
                 this._transitionTap?.({ kind: 'depth-guard', state: this.state, depth });
                 await this._sendFallbackIfUserWaiting('Something went wrong. Please try again.');
-                this._notify();
+                this._parkAtInitial();
                 return;
             }
             if (this._turnsSinceUserInput >= this._maxTurnsWithoutUserInput) {
                 runtimeLog.warn('AgentMachine', `state=${this.state} runaway loop: ${this._turnsSinceUserInput} turns without user input (cap ${this._maxTurnsWithoutUserInput}); parking`);
                 this._transitionTap?.({ kind: 'turn-budget-guard', state: this.state, turns: this._turnsSinceUserInput });
                 await this._sendFallbackIfUserWaiting('I got stuck in a loop and paused. Please send another message to continue.');
-                this._notify();
+                this._parkAtInitial();
                 return;
             }
             runtimeLog.debug('FSM', `_step mechanical state=${this.state} — run tool`);
@@ -238,16 +262,23 @@ export class AgentMachine {
             return;
         }
         // A thinking turn that yields an outcome no transition handles must not
-        // silently re-enter the same state and burn another LLM call.
-        // Explicit self-loops still match (target is non-null, even if target === state).
+        // silently re-enter the same state and burn another LLM call, and must
+        // not stay IN that thinking state — the next event would be judged by
+        // transitions written for a different occasion. Explicit
+        // self-loops still match (target is non-null, even if target === state).
         if (sd.kind === 'thinking' &&
             depth > 0 &&
             fromState === this.state &&
             !target) {
+            this._transitionTap?.({
+                kind: 'no-match',
+                state: fromState,
+                outcomeKind: outcome.kind,
+                depth,
+            });
             if (await this._escapeToInitialParked(outcome, fromState))
                 return;
             runtimeLog.warn('AgentMachine', `state=${fromState} outcome.kind=${outcome.kind} matched no transition; parking (depth=${depth})`);
-            this._transitionTap?.({ kind: 'no-match', state: fromState, outcomeKind: outcome.kind, depth });
             await this._sendFallbackIfUserWaiting('Something went wrong. Please try again.');
             this._notify();
             return;
@@ -265,7 +296,7 @@ export class AgentMachine {
             runtimeLog.warn('AgentMachine', `state=${this.state} runaway turn loop (depth=${depth}); parking`);
             this._transitionTap?.({ kind: 'depth-guard', state: this.state, depth });
             await this._sendFallbackIfUserWaiting('Something went wrong. Please try again.');
-            this._notify();
+            this._parkAtInitial();
             return;
         }
         // Cross-event runaway guard. The depth-guard above only bounds
@@ -278,7 +309,7 @@ export class AgentMachine {
             runtimeLog.warn('AgentMachine', `state=${this.state} runaway loop: ${this._turnsSinceUserInput} turns without user input (cap ${this._maxTurnsWithoutUserInput}); parking`);
             this._transitionTap?.({ kind: 'turn-budget-guard', state: this.state, turns: this._turnsSinceUserInput });
             await this._sendFallbackIfUserWaiting('I got stuck in a loop and paused. Please send another message to continue.');
-            this._notify();
+            this._parkAtInitial();
             return;
         }
         runtimeLog.debug('FSM', `_step thinking state=${this.state} — run turn`);
@@ -320,8 +351,8 @@ export class AgentMachine {
             applyOutcomeToCtx(this.ctx, errOutcome);
             this._running = false;
             this._notify();
-            // Try to fall through using current state's transitions; if none match
-            // the error outcome the machine just parks (next event will re-enter).
+            // Try to fall through using current state's transitions; if none match,
+            // recover to workflow.initial so the next event is not judged here.
             const fallback = this._evaluateTransitions(errOutcome);
             if (fallback && fallback !== this.state) {
                 this.state = fallback;
@@ -329,23 +360,31 @@ export class AgentMachine {
             }
             else {
                 await this._sendFallbackIfUserWaiting('Something went wrong. Please try again.');
+                this._parkAtInitial();
             }
         }
     }
-    /** Error with no author-defined escape: park at workflow.initial if it is parked. */
+    /**
+     * Unmatched thinking outcome: go back to workflow.initial when that state is
+     * parked. Used to require an error outcome, so a tool-result /
+     * message-sent / wait with no route logged "parking" and left `this.state`
+     * on the thinking state. The next event then ran a turn against prompts
+     * written for the previous occasion.
+     */
     async _escapeToInitialParked(outcome, fromState) {
-        if (outcome.kind !== 'error')
-            return false;
         const initial = this.workflow.initial;
         const initialSd = this.workflow.states[initial];
         if (!initialSd || initialSd.kind !== 'parked' || initial === fromState) {
             return false;
         }
-        runtimeLog.warn('AgentMachine', `state=${fromState} error outcome had no transition — escaped to parked initial "${initial}"`);
-        this._transitionTap?.({ kind: 'error-escape', fromState, toState: initial });
+        const kind = outcome.kind;
+        runtimeLog.warn('AgentMachine', `state=${fromState} unmatched ${String(kind)} — escaped to parked initial "${initial}"`);
+        this._transitionTap?.({
+            kind: kind === 'error' ? 'error-escape' : 'unmatched-escape',
+            fromState,
+            toState: initial,
+        });
         this.state = initial;
-        // The turn failed and no workflow transition handled it — a waiting human
-        // got nothing, so apologize before parking (same text as the other parks).
         await this._sendFallbackIfUserWaiting('Something went wrong. Please try again.');
         this._notify();
         return true;

package/dist/runtime/buildOutcome.d.ts

@@ -36,14 +36,6 @@ export interface EmittedEvent {
     senderId?: string;
     [key: string]: unknown;
 }
-/**
- * A chat message whose stated receiver is a DIFFERENT party. `receiverId` is
- * the sender's addressing decision, carried on every wire frame; the
- * human-broadcast sentinel counts as "elsewhere" for an agent (a broadcast is
- * addressed to the room's humans). A frame with NO receiver keeps the turn —
- * we cannot know it is not ours, and skipping on absence would deafen agents
- * to malformed or legacy frames.
- */
 export declare function isMessageAddressedElsewhere(ev: RawEvent | null | undefined, ownAgentId: string | null | undefined): boolean;
 /**
  * Converts a raw incoming event into the single Outcome that re-enters the

package/dist/runtime/buildOutcome.js

@@ -9,12 +9,26 @@ import { bookForDelegation, ensureTaskBook, findBookHoldingPending, removeTaskBo
  * we cannot know it is not ours, and skipping on absence would deafen agents
  * to malformed or legacy frames.
  */
+function isSyntheticOrgReceiver(id) {
+    if (/^([a-z0-9][a-z0-9-]*)\1@ziggs\.local$/i.test(id))
+        return true;
+    const sep = id.indexOf(':::');
+    if (sep > 0)
+        return /@ziggs\.local$/i.test(id.slice(sep + 3));
+    return false;
+}
 export function isMessageAddressedElsewhere(ev, ownAgentId) {
-    return Boolean(ev &&
-        ev.type === 'message' &&
-        ownAgentId &&
-        ev.receiverId &&
-        ev.receiverId !== ownAgentId);
+    if (!ev || ev.type !== 'message' || !ownAgentId || !ev.receiverId) {
+        return false;
+    }
+    if (ev.receiverId === ownAgentId)
+        return false;
+    // Fleet synthetic users are not a party that will answer. A hire room
+    // born with the org ghost as the other face used to address the human's
+    // message there, and the agent skipped the turn — claimed, acked, silence.
+    if (isSyntheticOrgReceiver(String(ev.receiverId)))
+        return false;
+    return true;
 }
 // ── outcomeFromEvent: incoming wire event → Outcome ──────────────────────────
 /**

package/dist/runtime/kickoff.d.ts

@@ -1,4 +1,4 @@
-import type { ThinkingState, Workflow } from '../types.js';
+import type { ThinkingState, Transition, Workflow } from '../types.js';
 /** Reserved state name for the injected agreement-kickoff default (proposer). */
 export declare const KICKOFF_STATE = "kickingOff";
 /**
@@ -8,6 +8,28 @@ export declare const KICKOFF_STATE = "kickingOff";
 export declare const CLAIM_KICKOFF_STATE = "claimKickingOff";
 export declare function buildKickoffState(initial: string): ThinkingState;
 /** provider side after a store/listing claim. */
+/**
+ * Declare that THIS state answers a store-claim wake itself, so the injected
+ * `claimKickingOff` greeting is not added to it.
+ *
+ * The opt-out has to fire on a claim wake and NOT on a bare counterparty
+ * approve — `stateHandlesClaimKickoff` uses that difference to tell a
+ * deliberate claim handler from a generic `proposal-resolved` route that
+ * happens to match. Writing that predicate by hand is easy to get subtly wrong,
+ * and getting it wrong is silent: the agent greets on every claim while its
+ * author believes it opted out. That cost one lab cast 100% of its token spend
+ * and three wedged workers before anyone noticed.
+ *
+ *   transitions: [
+ *     handlesClaimWake('idle'),   // a claim does not make this agent talk
+ *     { to: 'idle', when: (o) => o.kind === 'proposal-resolved' && o.action === 'approve' },
+ *   ]
+ *
+ * Note the second route is still worth keeping when you also want to sit out
+ * the PROPOSER-side kickoff: that one probes with a bare approve, which this
+ * helper deliberately does not match.
+ */
+export declare function handlesClaimWake(to: string): Transition;
 export declare function buildClaimKickoffState(initial: string): ThinkingState;
 /**
  * Agreement-kickoff defaults. For every state whose transitions do not already

package/dist/runtime/kickoff.js

@@ -143,6 +143,33 @@ export function buildKickoffState(initial) {
     };
 }
 /** provider side after a store/listing claim. */
+/**
+ * Declare that THIS state answers a store-claim wake itself, so the injected
+ * `claimKickingOff` greeting is not added to it.
+ *
+ * The opt-out has to fire on a claim wake and NOT on a bare counterparty
+ * approve — `stateHandlesClaimKickoff` uses that difference to tell a
+ * deliberate claim handler from a generic `proposal-resolved` route that
+ * happens to match. Writing that predicate by hand is easy to get subtly wrong,
+ * and getting it wrong is silent: the agent greets on every claim while its
+ * author believes it opted out. That cost one lab cast 100% of its token spend
+ * and three wedged workers before anyone noticed.
+ *
+ *   transitions: [
+ *     handlesClaimWake('idle'),   // a claim does not make this agent talk
+ *     { to: 'idle', when: (o) => o.kind === 'proposal-resolved' && o.action === 'approve' },
+ *   ]
+ *
+ * Note the second route is still worth keeping when you also want to sit out
+ * the PROPOSER-side kickoff: that one probes with a bare approve, which this
+ * helper deliberately does not match.
+ */
+export function handlesClaimWake(to) {
+    return {
+        to,
+        when: (o) => o.kind === 'proposal-resolved' && o.action === 'approve' && o.fromClaimWake === true,
+    };
+}
 export function buildClaimKickoffState(initial) {
     const dflt = thinkingDefaults({ initial });
     return {
@@ -158,15 +185,30 @@ export function buildClaimKickoffState(initial) {
                 prompt: {
                     when: 'There is not yet a real chat with the buyer (common on store claims).',
                     instruction: 'Open or reuse a chat with the buyer who claimed the listing.',
-                    format: '{"participantId": "<buyer actorId / Sender from the event>"}',
+                    format: '{"participantId": "<buyer actorId / Sender from the event>", "agreementId": "<the claimed agreement id>"}',
                 },
                 tool: 'chat_open',
                 produces: (result) => {
                     const r = result;
                     return r?.chatId ? 'tool-result' : 'error';
                 },
-                // Stay in this state so the next turn can greet in the opened chat.
-                terminatesLoop: true,
+                /**
+                 * Deliberately does NOT terminate the turn.
+                 *
+                 * It used to, with "stay in this state so the next turn can greet in the
+                 * opened chat" — but the next turn re-enters this state from scratch,
+                 * reads the same prompt ("there is not yet a real chat"), and opens the
+                 * chat again. Nothing in a re-entered state says a chat is already open:
+                 * `chat_open` is idempotent, so every retry succeeds, produces
+                 * `tool-result`, and re-enters. Measured: three lab workers called
+                 * `chat_open` twelve times each, sent zero messages, and tripped the
+                 * depth guard — the greeting never happened and the wake was spent.
+                 *
+                 * Letting the turn continue puts the chatId in front of the model as a
+                 * tool result, so `greetBuyer` runs in the SAME turn. `message_sent`
+                 * outranks `tool_result` when the outcome is picked, so the turn leaves
+                 * on `message-sent` → initial: one turn, one greeting, no re-entry.
+                 */
             },
             greetBuyer: {
                 prompt: {

package/dist/runtime/wakeOutcome.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Every claimed wake must leave a recorded outcome.
+ *
+ * Claim + ack with no externally visible effect used to exist: the host
+ * consumed the delivery, the agent stayed silent, and metering had no row.
+ * A wake ends in exactly one of: a reply, task progress, or an explicit
+ * no-op with a reason.
+ */
+export type WakeOutcomeKind = 'replied' | 'task-progress' | 'no-op';
+export interface WakeOutcome {
+    kind: WakeOutcomeKind;
+    reason?: string;
+}
+export declare function classifyWakeOutcome(input: {
+    skippedReason?: string;
+    lastOutcomeKind?: string | null;
+    llmCalls: number;
+    sentMessage?: boolean;
+    taskWrite?: boolean;
+}): WakeOutcome;
+export declare function buildWakeOutcomePayload(input: {
+    agentId: string;
+    sessionId: string;
+    laneKey: string;
+    outcome: WakeOutcome;
+    llmCalls?: number;
+}): Record<string, unknown>;

package/dist/runtime/wakeOutcome.js

@@ -0,0 +1,43 @@
+/**
+ * Every claimed wake must leave a recorded outcome.
+ *
+ * Claim + ack with no externally visible effect used to exist: the host
+ * consumed the delivery, the agent stayed silent, and metering had no row.
+ * A wake ends in exactly one of: a reply, task progress, or an explicit
+ * no-op with a reason.
+ */
+export function classifyWakeOutcome(input) {
+    if (input.skippedReason) {
+        return { kind: 'no-op', reason: input.skippedReason };
+    }
+    if (input.sentMessage || input.lastOutcomeKind === 'message-sent') {
+        return { kind: 'replied' };
+    }
+    if (input.taskWrite ||
+        input.lastOutcomeKind === 'task-delegated' ||
+        input.lastOutcomeKind === 'task-completed' ||
+        input.lastOutcomeKind === 'task-progress') {
+        return { kind: 'task-progress' };
+    }
+    if (input.llmCalls > 0) {
+        return { kind: 'no-op', reason: 'llm_no_visible_effect' };
+    }
+    return { kind: 'no-op', reason: 'no_llm' };
+}
+export function buildWakeOutcomePayload(input) {
+    return {
+        source: 'agent',
+        chatId: input.sessionId,
+        sessionId: input.sessionId,
+        execution: {
+            llmCallsTotal: input.llmCalls ?? 0,
+        },
+        meta: {
+            effect: 'wake-outcome',
+            kind: input.outcome.kind,
+            ...(input.outcome.reason ? { reason: input.outcome.reason } : {}),
+            laneKey: input.laneKey,
+            agentId: input.agentId,
+        },
+    };
+}

package/dist/server/ConnectionPool.js

@@ -104,9 +104,17 @@ export class ConnectionPool {
     async shutdown(timeoutMs = 30_000) {
         const hosts = [...this.hosts.values()];
         await this.manager.stopAll();
-        await Promise.all(hosts.map((host) => host.drain(timeoutMs).catch((err) => {
-            runtimeLog.warn('ConnectionPool', `drain did not finish: ${err.message}`);
-        })));
+        await Promise.all(hosts.map(async (host) => {
+            try {
+                const result = await host.drain(timeoutMs);
+                if (result?.timedOut) {
+                    runtimeLog.warn('ConnectionPool', `drain timed out after ${timeoutMs}ms: ${result.queuedEvents} event(s) queued, ${result.busyLanes.length} busy lane(s)`);
+                }
+            }
+            catch (err) {
+                runtimeLog.warn('ConnectionPool', `drain did not finish: ${err.message}`);
+            }
+        }));
     }
     /**
      * Deliver a message to the named agent and wait for its first outbound

package/dist/server/EventQueue.d.ts

@@ -2,6 +2,19 @@ export type ProcessEventFn = (event: unknown, laneKey: string) => Promise<void>;
 export interface EventQueueOptions {
     maxQueueLengthPerLane?: number;
 }
+export interface EventQueueBusyLane {
+    laneKey: string;
+    queued: number;
+    processing: boolean;
+}
+/** Outcome of `waitForIdle` / `AgentHost.drain`. Timeout is data, not a throw. */
+export interface WaitForIdleResult {
+    idle: boolean;
+    timedOut: boolean;
+    timeoutMs: number;
+    queuedEvents: number;
+    busyLanes: EventQueueBusyLane[];
+}
 /**
  * Serializes events per lane and coalesces multiple queued events into one
  * batch dispatch. The runtime sees at most one in-flight processEvent call
@@ -25,8 +38,16 @@ export declare class EventQueue {
     private _processLoop;
     private _trimQueueIfNeeded;
     get isIdle(): boolean;
-    /** Resolves when all lanes finish processing, or after timeoutMs. Best-effort — never throws. */
-    waitForIdle(timeoutMs?: number): Promise<void>;
+    /** Lanes still holding work — a turn in flight, queued events, or both. */
+    busyLanes(): EventQueueBusyLane[];
+    /**
+     * Resolves when every lane is idle, or when `timeoutMs` elapses.
+     *
+     * Never throws. A timeout is returned as data so the caller can name it
+     * (queued count, which lanes) instead of a stray log line the verdict never
+     * sees. `timeoutMs <= 0` checks once and returns immediately.
+     */
+    waitForIdle(timeoutMs?: number): Promise<WaitForIdleResult>;
     getMetrics(): {
         lanes: number;
         queuedEvents: number;

package/dist/server/EventQueue.js

@@ -93,15 +93,45 @@ export class EventQueue {
     get isIdle() {
         return [...this._state.values()].every(s => !s.processing && s.events.length === 0);
     }
-    /** Resolves when all lanes finish processing, or after timeoutMs. Best-effort — never throws. */
+    /** Lanes still holding work — a turn in flight, queued events, or both. */
+    busyLanes() {
+        const out = [];
+        for (const [laneKey, state] of this._state) {
+            if (!state.processing && state.events.length === 0)
+                continue;
+            out.push({ laneKey, queued: state.events.length, processing: state.processing });
+        }
+        return out;
+    }
+    /**
+     * Resolves when every lane is idle, or when `timeoutMs` elapses.
+     *
+     * Never throws. A timeout is returned as data so the caller can name it
+     * (queued count, which lanes) instead of a stray log line the verdict never
+     * sees. `timeoutMs <= 0` checks once and returns immediately.
+     */
     async waitForIdle(timeoutMs = 30_000) {
+        const snapshot = (timedOut) => {
+            const busy = this.busyLanes();
+            return {
+                idle: busy.length === 0,
+                timedOut,
+                timeoutMs,
+                queuedEvents: busy.reduce((n, lane) => n + lane.queued, 0),
+                busyLanes: busy,
+            };
+        };
+        if (this.isIdle)
+            return snapshot(false);
+        if (timeoutMs <= 0)
+            return snapshot(true);
         const deadline = Date.now() + timeoutMs;
         while (Date.now() < deadline) {
             if (this.isIdle)
-                return;
+                return snapshot(false);
             await new Promise(r => setTimeout(r, 50));
         }
-        runtimeLog.warn('EventQueue', `waitForIdle timed out after ${timeoutMs}ms`);
+        return snapshot(!this.isIdle);
     }
     getMetrics() {
         return {

package/dist/server/agreements/AgreementService.d.ts

@@ -1,4 +1,4 @@
-import { type Agreement, type ClaimedKind, type ClaimOptions, type ProposeAgreementData, type ProposeDirectInput, type ProposeBroadcastInput, type PublishOfferPayload, type DelegateAgreementData, type CounterAgreementData, type CreateLinkBody, type CreateLinkResult, type ListAgreementsFilters, type GetMyAgreementsFilters, type ChatLinkType, type ArtifactLinkType } from '@ziggs-ai/api-client';
+import { type Agreement, type ClaimedKind, type ClaimOptions, type ProposeAgreementData, type ProposeDirectInput, type ProposeBroadcastInput, type PublishOfferPayload, type UnifiedProposeInput, type ProposeShape, type DelegateAgreementData, type CounterAgreementData, type CreateLinkBody, type CreateLinkResult, type ListAgreementsFilters, type GetMyAgreementsFilters, type ChatLinkType, type ArtifactLinkType } from '@ziggs-ai/api-client';
 export declare class AgreementService {
     private creds;
     constructor(operatorKey: string, agentId: string);
@@ -12,6 +12,15 @@ export declare class AgreementService {
     proposeBroadcast(payload: ProposeBroadcastInput): Promise<Agreement>;
     /** @deprecated Alias for {@link proposeDirect}. */
     propose(payload: ProposeAgreementData): Promise<Agreement>;
+    /**
+     * One propose grammar (direct / request / standing offer). Fleet pricing
+     * and the wake idempotency key stay on the caller — this is the shared
+     * routing, not a second copy of it.
+     */
+    proposeUnified(input: UnifiedProposeInput): Promise<{
+        agreement: Agreement;
+        shape: ProposeShape;
+    }>;
     /**
      * Seller-broadcast marketplace offer. `payload.audience` sets the `payer`
      * sentinel: 'everyone' (default, public) or 'org' (your active org only).

package/dist/server/agreements/AgreementService.js

@@ -1,4 +1,4 @@
-import { proposeAgreement, proposeBroadcast as proposeBroadcastApi, delegateAgreement, respondToAgreement, counterAgreement, claimOpenAgreement, getAgreementStatus, listAgreements, getMyAgreements, getAgreement, publishOffer as publishOfferApi, createLink, revokeAgreement, fulfillAgreement, linkAgreementToChat, getChatsForAgreement, linkArtifactToAgreement, getArtifactsForAgreement, } from '@ziggs-ai/api-client';
+import { proposeAgreement, proposeBroadcast as proposeBroadcastApi, delegateAgreement, respondToAgreement, counterAgreement, claimOpenAgreement, proposeUnified, getAgreementStatus, listAgreements, getMyAgreements, getAgreement, publishOffer as publishOfferApi, createLink, revokeAgreement, fulfillAgreement, linkAgreementToChat, getChatsForAgreement, linkArtifactToAgreement, getArtifactsForAgreement, } from '@ziggs-ai/api-client';
 export class AgreementService {
     creds;
     constructor(operatorKey, agentId) {
@@ -24,6 +24,14 @@ export class AgreementService {
     propose(payload) {
         return proposeAgreement(payload, this.creds);
     }
+    /**
+     * One propose grammar (direct / request / standing offer). Fleet pricing
+     * and the wake idempotency key stay on the caller — this is the shared
+     * routing, not a second copy of it.
+     */
+    proposeUnified(input) {
+        return proposeUnified(input, this.creds);
+    }
     /**
      * Seller-broadcast marketplace offer. `payload.audience` sets the `payer`
      * sentinel: 'everyone' (default, public) or 'org' (your active org only).

package/dist/server/tools/index.d.ts

@@ -23,7 +23,9 @@ export { PAYMENT_TOOLS, paymentBalanceTool } from './tier2/paymentTools.js';
 export { CONNECTION_TOOLS, connectionProxyTool, connectionListGrantsTool, requestConnectionTool, } from './tier2/connectionTools.js';
 export { CONTEXT_TOOLS, contextReadTool, contextDelegateTool, contextExpandReachTool, contextDiscoverGrantableTool, } from './tier2/contextTools.js';
 export { GRANTS_TOOLS, listGrantsTool } from './tier2/grantsTools.js';
+export { TASK_TOOLS, listTasksTool } from './tier2/taskTools.js';
 export { LINK_TOOLS, linkProposeTool, linkListTool, } from './tier2/linkTools.js';
+export { INTRODUCTION_TOOLS, introductionMintTool, introductionRedeemTool, introductionListTool, introductionRevokeTool, } from './tier2/introductionTools.js';
 export { ARTIFACT_TOOLS, recordArtifactTool } from './tier2/artifactTools.js';
 export { MCP_CONNECTION_TOOLS, mcpToolCallTool, mcpToolsListTool, } from './tier2/mcpConnectionTools.js';
 export { CHAT_TOOLS, openConversationTool } from './tier2/chatTools.js';

package/dist/server/tools/index.js

@@ -27,10 +27,13 @@ export { CONTEXT_TOOLS, contextReadTool, contextDelegateTool, contextExpandReach
 // one grant lister across every rail (retires context_discover +
 // payment_list_grants). Always-available on the hosted agent — see CLAUDE_SDK_TOOLS.
 export { GRANTS_TOOLS, listGrantsTool } from './tier2/grantsTools.js';
+export { TASK_TOOLS, listTasksTool } from './tier2/taskTools.js';
 // links (agreements with engagementKind 'link') — cross-org reach.
 ///1022: the rail is two tools; propose/claim/revoke ride the
 // agreement grammar.
 export { LINK_TOOLS, linkProposeTool, linkListTool, } from './tier2/linkTools.js';
+// introduction tokens — a meeting somewhere else turned into a link here.
+export { INTRODUCTION_TOOLS, introductionMintTool, introductionRedeemTool, introductionListTool, introductionRevokeTool, } from './tier2/introductionTools.js';
 // deliberate artifact recording (the model decides "record this").
 export { ARTIFACT_TOOLS, recordArtifactTool } from './tier2/artifactTools.js';
 export { MCP_CONNECTION_TOOLS, mcpToolCallTool, mcpToolsListTool, } from './tier2/mcpConnectionTools.js';