@ziggs-ai/agent-sdk 0.1.11 → 0.2.0

package/dist/server/tools/tier1/protocolRunner.js

@@ -0,0 +1,288 @@
+import { applyFleetCounterPricing, applyFleetPricingForProtocol, } from '../../../pricing/fleetDefaults.js';
+// Map legacy task-state aliases onto the canonical set.
+function normalizeState(state) {
+    if (state === 'done')
+        return 'completed';
+    if (state === 'error')
+        return 'failed';
+    return state;
+}
+// ZIG-793: the `plan` tool-schema is underspecified (`plan: {type:'object'}`,
+// `planReviewTiming: 'string'`), so the LLM emits steps missing stepId/order and an
+// out-of-enum planReviewTiming, which the backend DTO rejects. Normalize in-place here
+// so every op (propose / subcontract / counter / task-spawn) sends a valid plan.
+function normalizePlanInPlace(payload) {
+    const plan = payload.plan;
+    if (plan && Array.isArray(plan.steps)) {
+        plan.steps = plan.steps.map((s, i) => {
+            const step = s && typeof s === 'object'
+                ? s
+                : { description: String(s) };
+            return {
+                ...step,
+                stepId: typeof step.stepId === 'string' && step.stepId ? step.stepId : `step-${i + 1}`,
+                order: typeof step.order === 'number' ? step.order : i,
+                description: typeof step.description === 'string'
+                    ? step.description
+                    : String(step.description ?? ''),
+            };
+        });
+    }
+    if (payload.planReviewTiming !== undefined &&
+        payload.planReviewTiming !== 'with_proposal' &&
+        payload.planReviewTiming !== 'before_execution') {
+        payload.planReviewTiming = 'with_proposal';
+    }
+}
+export async function dispatchProtocolOp(services, payload, chatId, agents = [], actingAgentId = null) {
+    if (!payload?.operation)
+        return null;
+    normalizePlanInPlace(payload);
+    const { operation } = payload;
+    const { agreementService, taskService } = services;
+    const actorId = actingAgentId?.trim() || null;
+    switch (operation) {
+        case 'agreement-propose':
+            return proposeAgreement(services, payload, chatId, agents, actorId);
+        case 'agreement-subcontract':
+            return subcontractAgreement(services, payload, chatId, agents, actorId);
+        case 'agreement-respond':
+            if (!payload.agreementId || !payload.action)
+                return null;
+            return agreementService.respond(payload.agreementId, payload.action);
+        case 'agreement-counter-proposal':
+            if (!payload.agreementId)
+                return null;
+            {
+                const counterPayload = actorId != null
+                    ? applyFleetCounterPricing(payload, actorId)
+                    : payload;
+                return agreementService.counter(payload.agreementId, {
+                    price: counterPayload.price,
+                    agreementDescription: counterPayload.agreementDescription,
+                    expiresAt: counterPayload.expiresAt,
+                    lifecycle: counterPayload.lifecycle,
+                    maxExecutions: counterPayload.maxExecutions,
+                    description: counterPayload.description,
+                    plan: counterPayload.plan,
+                    planReviewTiming: counterPayload.planReviewTiming,
+                    requireMidWorkPlanAck: counterPayload.requireMidWorkPlanAck,
+                });
+            }
+        case 'agreement-check-proposal':
+            if (!payload.agreementId)
+                return null;
+            return agreementService.getStatus(payload.agreementId);
+        case 'agreement-revoke':
+            if (!payload.agreementId)
+                return null;
+            return agreementService.revoke(payload.agreementId);
+        case 'agreement-fulfill':
+            if (!payload.agreementId)
+                return null;
+            return agreementService.fulfill(payload.agreementId);
+        case 'task-spawn': {
+            if (!payload.agreementId || !payload.description)
+                return null;
+            let spawnAgreementId = payload.agreementId;
+            const ags = await agreementsInChat(services, chatId);
+            // b2 (ZIG-832): if the assignee is not a party on the cited agreement,
+            // redirect the spawn to the ACTIVE sub-agreement (same root) where the
+            // assignee IS the provider — the orchestrator often cites the top-level
+            // hire, which the backend rejects with "assignee not a party".
+            // ZIG-858: also redirect when the cited agreement is no longer active —
+            // a count-bound sub fulfills after its quota (default 1), and the LLM
+            // keeps citing that now-terminal sub for the next spawn even when a
+            // fresh active sub for the same executor exists.
+            if (payload.assigneeId) {
+                const cited = ags.find((a) => a.agreementId === payload.agreementId);
+                if (cited && (!agIsParty(cited, payload.assigneeId) || !agIsActiveStatus(cited))) {
+                    const root = cited.rootAgreementId || payload.agreementId;
+                    const sub = ags.find((a) => agIsActiveStatus(a) && agIsProvider(a, payload.assigneeId) &&
+                        (a.rootAgreementId === root || a.parentAgreementId === payload.agreementId ||
+                            a.parentAgreementId === root));
+                    if (sub?.agreementId)
+                        spawnAgreementId = sub.agreementId;
+                }
+            }
+            // Safety guard (ZIG-832, B): a spawn against an agreement that is not active,
+            // or whose assignee is not a party on it, hard-400s at the backend AND makes
+            // the worker invent a "connection needed" message. That happens when the
+            // orchestrator spawns before its sub-agreement is subcontracted/approved.
+            // Skip GRACEFULLY instead — the sub-agreement's activation event will wake
+            // the orchestrator to spawn correctly on a later turn, no 400, no cascade.
+            const target = ags.find((a) => a.agreementId === spawnAgreementId);
+            // ZIG-858: a TERMINAL target is not the same as a not-yet-active one — no
+            // activation event will ever arrive, so the "wait for a later turn" skip
+            // below would stall the run. Tell the caller the actionable next step:
+            // subcontract a fresh sub for this executor, then spawn under it.
+            if (target && TERMINAL_STATUS.has(String(target.status))) {
+                return {
+                    ok: false,
+                    skipped: 'spawn-target-terminal',
+                    reason: `agreement ${spawnAgreementId} is ${target.status} (terminal — its quota or term is exhausted). Subcontract a new sub-agreement to ${payload.assigneeId ?? 'the executor'}, then spawn this task under that new agreement.`,
+                    agreementId: spawnAgreementId,
+                };
+            }
+            const notReady = (target && !agIsActiveStatus(target)) ||
+                (!!payload.assigneeId && target && !agIsParty(target, payload.assigneeId));
+            if (notReady) {
+                return {
+                    ok: false,
+                    skipped: 'spawn-target-not-ready',
+                    reason: target && !agIsActiveStatus(target)
+                        ? `agreement ${spawnAgreementId} is ${target?.status ?? 'unknown'} (not active yet)`
+                        : `assignee is not a party on ${spawnAgreementId} yet — subcontract to it first`,
+                    agreementId: spawnAgreementId,
+                };
+            }
+            return taskService.spawnUnderAgreement(spawnAgreementId, {
+                description: payload.description,
+                parentTaskId: payload.parentTaskId,
+                plan: payload.plan,
+                planReviewTiming: payload.planReviewTiming,
+                requireMidWorkPlanAck: payload.requireMidWorkPlanAck,
+                assigneeId: payload.assigneeId,
+                inputArtifactIds: Array.isArray(payload.inputArtifactIds)
+                    ? payload.inputArtifactIds
+                    : undefined,
+            });
+        }
+        case 'task-update':
+            if (!payload.taskId || !payload.status)
+                return null;
+            return taskService.updateState(payload.taskId, normalizeState(payload.status), payload.result);
+        case 'task-update-plan-step':
+            if (!payload.taskId)
+                throw new Error('task-update-plan-step requires `taskId`');
+            if (!payload.stepId)
+                throw new Error('task-update-plan-step requires `stepId`');
+            if (!payload.status)
+                throw new Error('task-update-plan-step requires `status`');
+            // ZIG-793: a plan-step tick is cosmetic progress. Worker subtasks usually
+            // have NO plan (only the orchestrator's job task does), and the LLM may tick
+            // a stepId that isn't in the plan — the backend 400s on both. That must never
+            // hard-fail the tool → fail the task → wake-loop. Make it best-effort.
+            try {
+                return await taskService.updatePlanStep(payload.taskId, payload.stepId, payload.status, payload.result);
+            }
+            catch {
+                return { ok: false, skipped: 'plan-step-not-updatable', stepId: payload.stepId };
+            }
+        default:
+            throw new Error(`Unknown protocol operation: ${operation}`);
+    }
+}
+async function proposeAgreement(services, payload, chatId, _agents, actingAgentId) {
+    if (!payload.description)
+        throw new Error('agreement-propose requires `description`');
+    if (!payload.proposedTo)
+        throw new Error('agreement-propose requires `proposedTo` (userId or agentId). To spawn a task under an existing agreement, use `task_spawn` instead.');
+    const isBroadcast = payload.proposedTo === 'everyone' || payload.proposedTo === 'org';
+    if (!isBroadcast && !payload.providerId) {
+        throw new Error('agreement-propose requires `providerId` — name who does the work: your own id (you are offering to work) or the proposedTo id (you are commissioning the recipient).');
+    }
+    if (isBroadcast && payload.providerId) {
+        throw new Error('agreement-propose forbids `providerId` on a broadcast — the claiming agent fills the open side.');
+    }
+    const priced = applyFleetPricingForProtocol('agreement-propose', payload, actingAgentId);
+    const { operation: _op, ...fields } = priced;
+    return services.agreementService.propose({ ...fields, chatId });
+}
+// ── ZIG-832: deterministic sub-agreement resolution ─────────────────────────
+// The orchestrator delegates one task per worker, but the LLM inconsistently
+// (a) re-subcontracts the same worker (duplicate sub-agreements) and (b)
+// task_spawns a worker under the TOP-LEVEL hire — where the worker is not a
+// party — instead of under that worker's sub-agreement, which the backend
+// rejects with 400 "assignee is not a party". Both are made deterministic here
+// using the chat's existing agreements.
+const TERMINAL_STATUS = new Set(['fulfilled', 'cancelled', 'refunded', 'rejected']);
+async function agreementsInChat(services, chatId) {
+    if (!chatId)
+        return [];
+    try {
+        const snap = await services.contextReadClient.snapshot(chatId, { maxMessages: 1 });
+        const ags = snap.agreements;
+        return Array.isArray(ags) ? ags : [];
+    }
+    catch {
+        return [];
+    }
+}
+function agIsProvider(a, agentId) {
+    const p = a.parties ?? {};
+    return p['provider'] === agentId || p['providerAgent'] === agentId || a['providerId'] === agentId;
+}
+function agIsParty(a, agentId) {
+    const p = a.parties ?? {};
+    return ['provider', 'providerAgent', 'payer', 'proposedTo', 'creator', 'creatorAgent']
+        .some((k) => p[k] === agentId);
+}
+function agActive(a) {
+    return !a.status || !TERMINAL_STATUS.has(String(a.status));
+}
+// Spawnable = actually ACTIVE. A freshly-subcontracted sub is `draft` until its
+// counterparty auto-approves; spawning under a draft (or citing an agreement the
+// assignee isn't a party on) 400s and cascades into a bogus worker "connection
+// needed" message. We treat only 'active' as spawnable (ZIG-832).
+function agIsActiveStatus(a) {
+    return String(a.status ?? '') === 'active';
+}
+async function subcontractAgreement(services, payload, chatId, _agents, actingAgentId) {
+    if (!payload.description || !payload.executorId)
+        return null;
+    // b1 (ZIG-832): idempotent subcontract — if a non-terminal sub-agreement for
+    // this executor already exists under the same parent, reuse it instead of
+    // creating a duplicate (which bloats the chain and blocks the fulfill cascade).
+    if (chatId) {
+        const parent = payload.parentAgreementId;
+        const existing = (await agreementsInChat(services, chatId)).find((a) => agActive(a) && agIsProvider(a, payload.executorId) &&
+            (!parent || a.parentAgreementId === parent || a.rootAgreementId === parent));
+        if (existing?.agreementId)
+            return existing;
+    }
+    const priced = applyFleetPricingForProtocol('agreement-subcontract', payload, actingAgentId);
+    const { operation: _op, ...fields } = priced;
+    // ZIG-832: a subcontract must carry a working close condition, or it hangs
+    // 'active' forever — and because the backend only auto-fulfills a parent hire
+    // once every child sub-agreement is terminal (the fulfill cascade), one
+    // never-closing child leaves the whole engagement open. Deciding lifecycle is
+    // left to the model, which under load (context bloat, competing wakes) emits
+    // incomplete terms — e.g. time-bound with no expiresAt and no maxExecutions —
+    // that never reach fulfillment. Make the common single-delegated-task case
+    // deterministic: if the caller gave neither a real quota nor a real deadline,
+    // treat it as one count-bound execution so completing that task closes the
+    // sub — which then cascades the parent closed. A genuinely durable subcontract
+    // still opts out by setting maxExecutions>1 or a time-bound expiresAt.
+    const f = fields;
+    // ZIG-858: repair incomplete terms instead of clobbering them. The model
+    // often emits a real quota or deadline but gets the envelope wrong — a
+    // numeric-string maxExecutions, or a quota/deadline with the lifecycle field
+    // missing or mismatched. The old check treated all of those as "no close
+    // condition" and forced count-bound/1, silently discarding the stated intent
+    // (e.g. maxExecutions=2 → 1, so the sub fulfills one task early and the next
+    // spawn under it fails).
+    if (typeof f.maxExecutions === 'string' && f.maxExecutions.trim() !== '' && Number.isFinite(Number(f.maxExecutions))) {
+        f.maxExecutions = Number(f.maxExecutions);
+    }
+    const hasQuota = typeof f.maxExecutions === 'number' && f.maxExecutions > 0;
+    const hasDeadline = typeof f.expiresAt === 'string' && f.expiresAt.length > 0;
+    if (f.lifecycle === 'count-bound' && hasQuota) {
+        // coherent as stated
+    }
+    else if (f.lifecycle === 'time-bound' && hasDeadline) {
+        // coherent as stated
+    }
+    else if (hasQuota) {
+        f.lifecycle = 'count-bound'; // quota given, lifecycle missing/mismatched — keep the quota
+    }
+    else if (hasDeadline) {
+        f.lifecycle = 'time-bound'; // deadline given, lifecycle missing/mismatched — keep the deadline
+    }
+    else {
+        // no usable close condition at all — the deterministic single-task default
+        f.lifecycle = 'count-bound';
+        f.maxExecutions = 1;
+    }
+    return services.agreementService.delegate({ ...fields, chatId });
+}

package/dist/server/tools/tier1/protocolTools.d.ts

@@ -0,0 +1,12 @@
+import { type ToolDefinition } from '../../../tools/defineTool.js';
+export declare const agreementProposeTool: ToolDefinition;
+export declare const agreementSubcontractTool: ToolDefinition;
+export declare const agreementRespondTool: ToolDefinition;
+export declare const taskUpdateTool: ToolDefinition;
+export declare const agreementCounterProposalTool: ToolDefinition;
+export declare const agreementCheckProposalTool: ToolDefinition;
+export declare const agreementRevokeTool: ToolDefinition;
+export declare const agreementFulfillTool: ToolDefinition;
+export declare const taskUpdatePlanStepTool: ToolDefinition;
+export declare const taskSpawnTool: ToolDefinition;
+export declare const PROTOCOL_TOOLS: ToolDefinition[];

package/dist/server/tools/tier1/protocolTools.js

@@ -0,0 +1,37 @@
+import { defineTool } from '../../../tools/defineTool.js';
+import { dispatchProtocolOp } from './protocolRunner.js';
+function handlerFor(operation) {
+    return async (args, ctx) => {
+        const c = ctx;
+        if (!c.taskService)
+            throw new Error('taskService missing from tool context (expected when running under Agent)');
+        if (!c.agreementService)
+            throw new Error('agreementService missing from tool context (expected when running under Agent)');
+        if (!c.contextReadClient)
+            throw new Error('contextReadClient missing from tool context (expected when running under Agent)');
+        const result = await dispatchProtocolOp({
+            taskService: c.taskService,
+            agreementService: c.agreementService,
+            contextReadClient: c.contextReadClient,
+        }, { operation, ...args }, c.chatId ?? null, c.agents ?? [], typeof c.agentId === 'string' ? c.agentId : null);
+        if (result == null)
+            throw new Error(`Operation ${operation} returned no result`);
+        return result;
+    };
+}
+export const agreementProposeTool = defineTool('agreement_propose', { description: { type: 'string', required: true }, proposedTo: { type: 'string', required: true }, engagementKind: { type: 'string', enum: ['hire', 'service'], description: 'Contract type. Defaults to service when omitted.' }, parentAgreementId: 'string', parentTaskId: 'string', providerId: { type: 'string', description: 'Who does the work — required on direct proposals, forbidden on broadcasts (the claiming agent fills the open side). Pass your own id when YOU are offering to do the work, or the proposedTo id when you are commissioning the RECIPIENT. Naming any other third party requires that party to have a matching published offer. The payer is always derived as the non-providing side.' }, price: 'number', lifecycle: 'string', expiresAt: 'string', maxExecutions: 'number', agreementDescription: 'string', plan: { type: 'object' }, planReviewTiming: 'string', requireMidWorkPlanAck: 'boolean' }, handlerFor('agreement-propose'), { description: 'Propose a contract to a user, agent, or as an open broadcast. Direction is stated, never guessed: providerId = your own id ("I work, you pay") or providerId = proposedTo ("you work, I pay"). Required on direct proposals; omit it only for a broadcast — proposedTo="everyone" (fully public — any agent may claim) or proposedTo="org" (scoped to your org). engagementKind defaults to service.', isAgreementCreation: true });
+export const agreementSubcontractTool = defineTool('agreement_subcontract', { description: { type: 'string', required: true }, executorId: { type: 'string', required: true }, parentAgreementId: { type: 'string', required: true }, parentTaskId: 'string', payerId: 'string', price: 'number', lifecycle: 'string', expiresAt: 'string', maxExecutions: 'number', agreementDescription: 'string', plan: { type: 'object' }, planReviewTiming: 'string', requireMidWorkPlanAck: 'boolean' }, handlerFor('agreement-subcontract'), { description: 'Delegate work to another agent under an existing parent agreement. Requires parentAgreementId.', isAgreementCreation: true });
+export const agreementRespondTool = defineTool('agreement_respond', { agreementId: { type: 'string', required: true }, action: { type: 'string', required: true, enum: ['approve', 'reject'] } }, handlerFor('agreement-respond'), { description: 'Approve or reject a pending agreement proposal.' });
+export const taskUpdateTool = defineTool('task_update', { taskId: { type: 'string', required: true }, status: { type: 'string', required: true, enum: ['completed', 'failed', 'cancelled'] }, result: 'string' }, handlerFor('task-update'), { description: 'Transition a task to completed, failed, or cancelled. Include a result string for completed tasks.' });
+export const agreementCounterProposalTool = defineTool('agreement_counter_proposal', { agreementId: { type: 'string', required: true }, price: 'number', agreementDescription: 'string', expiresAt: 'string', lifecycle: 'string', maxExecutions: 'number', description: 'string', plan: { type: 'object' }, planReviewTiming: 'string', requireMidWorkPlanAck: 'boolean' }, handlerFor('agreement-counter-proposal'), { description: 'Counter a pending proposal with revised terms instead of approving or rejecting. Check status first with agreement_check_proposal.' });
+export const agreementCheckProposalTool = defineTool('agreement_check_proposal', { agreementId: { type: 'string', required: true } }, handlerFor('agreement-check-proposal'), { description: 'Read the current proposal status for an agreement (pending, approved, rejected, countered, expired).' });
+export const agreementRevokeTool = defineTool('agreement_revoke', { agreementId: { type: 'string', required: true } }, handlerFor('agreement-revoke'), { description: 'Revoke a pending proposal you created so it can no longer be approved. Use when the user has clearly moved on to a different request before responding to the previous proposal card.' });
+export const agreementFulfillTool = defineTool('agreement_fulfill', { agreementId: { type: 'string', required: true } }, handlerFor('agreement-fulfill'), { description: 'Mark an agreement you provide as fulfilled (complete) once its work is delivered — closes the engagement so it no longer reads as in-progress. Use on your hire after the final deliverable is done and delivered to the human.' });
+export const taskUpdatePlanStepTool = defineTool('task_update_plan_step', { taskId: { type: 'string', required: true }, stepId: { type: 'string', required: true }, status: { type: 'string', required: true }, result: 'string' }, handlerFor('task-update-plan-step'), { description: "Update the status of a single step within a task's plan." });
+export const taskSpawnTool = defineTool('task_spawn', { agreementId: { type: 'string', required: true }, description: { type: 'string', required: true }, parentTaskId: 'string', assigneeId: { type: 'string', description: 'Explicitly hand this task to one specific agent (e.g. a worker your orchestrator selected via agent search) instead of leaving it unassigned. Must be a party on the agreement (payer, provider, creator, or creator agent).' }, inputArtifactIds: { type: 'array', items: { type: 'string' }, description: 'ZIG-734: prior-step output artifact handles for structured input links.' }, plan: { type: 'object' }, planReviewTiming: 'string', requireMidWorkPlanAck: 'boolean' }, handlerFor('task-spawn'), { description: 'Spawn a new task under an existing approved agreement. Use when the contract is already in place. Pass assigneeId to delegate the task to a specific agent rather than leaving it open.' });
+export const PROTOCOL_TOOLS = [
+    agreementProposeTool, agreementSubcontractTool,
+    agreementRespondTool, agreementCounterProposalTool, agreementCheckProposalTool, agreementRevokeTool,
+    agreementFulfillTool,
+    taskSpawnTool, taskUpdateTool, taskUpdatePlanStepTool,
+];

package/dist/server/tools/tier2/connectionTools.d.ts

@@ -0,0 +1,4 @@
+import { type ToolDefinition } from '../../../tools/defineTool.js';
+export declare const connectionProxyTool: ToolDefinition;
+export declare const connectionListGrantsTool: ToolDefinition;
+export declare const CONNECTION_TOOLS: ToolDefinition[];

package/dist/server/tools/tier2/connectionTools.js

@@ -0,0 +1,63 @@
+import { defineTool } from '../../../tools/defineTool.js';
+import { ZiggsConnectClient } from '../../ziggsconnect/ZiggsConnectClient.js';
+function clientFor(ctx) {
+    const operatorKey = ctx?.['operatorKey'];
+    if (!operatorKey)
+        throw new Error('operatorKey missing from tool context');
+    return new ZiggsConnectClient({
+        operatorKey,
+        actAsAgentId: ctx?.['agentId'] || undefined,
+    });
+}
+function rethrowWithContext(error, prefix) {
+    const e = error;
+    const wrapped = new Error(`${prefix}: ${e.message}`);
+    if (e.status !== undefined)
+        wrapped.status = e.status;
+    if (e.body !== undefined)
+        wrapped.body = e.body;
+    wrapped['cause'] = error;
+    throw wrapped;
+}
+export const connectionProxyTool = defineTool('connection_proxy', {
+    connectionId: { type: 'string', required: true },
+    grantId: { type: 'string', required: true },
+    action: { type: 'string', required: true },
+    payload: { type: 'object' },
+}, async (args, ctx) => {
+    if (!args['connectionId'])
+        throw new Error('connectionId is required');
+    if (!args['grantId'])
+        throw new Error('grantId is required');
+    if (!args['action'])
+        throw new Error('action is required');
+    try {
+        const result = await clientFor(ctx).proxy({
+            connectionId: args['connectionId'],
+            grantId: args['grantId'],
+            action: args['action'],
+            payload: args['payload'],
+        });
+        return { status: 'ok', result };
+    }
+    catch (e) {
+        rethrowWithContext(e, 'Connection proxy failed');
+    }
+});
+export const connectionListGrantsTool = defineTool('connection_list_grants', { connectionId: { type: 'string', required: true } }, async (args, ctx) => {
+    if (!args['connectionId'])
+        throw new Error('connectionId is required');
+    try {
+        const grants = await clientFor(ctx).listGrants({
+            connectionId: args['connectionId'],
+        });
+        return { grants: grants || [] };
+    }
+    catch (e) {
+        rethrowWithContext(e, 'Failed to list connection grants');
+    }
+});
+export const CONNECTION_TOOLS = [
+    connectionProxyTool,
+    connectionListGrantsTool,
+];

package/dist/server/tools/tier2/contextTools.d.ts

@@ -0,0 +1,4 @@
+import { type ToolDefinition } from '../../../tools/defineTool.js';
+export declare const contextDiscoverTool: ToolDefinition;
+export declare const contextDelegateTool: ToolDefinition;
+export declare const CONTEXT_TOOLS: readonly [ToolDefinition, ToolDefinition];

package/dist/server/tools/tier2/contextTools.js

@@ -0,0 +1,46 @@
+import { defineTool } from '../../../tools/defineTool.js';
+import { ZiggsContextClient } from '../../ziggscontext/ZiggsContextClient.js';
+function clientFor(ctx) {
+    const operatorKey = ctx?.['operatorKey'];
+    if (!operatorKey)
+        throw new Error('operatorKey missing from tool context');
+    return new ZiggsContextClient({
+        operatorKey,
+        actAsAgentId: ctx?.['agentId'] || undefined,
+    });
+}
+export const contextDiscoverTool = defineTool('context_discover', {}, async (_args, ctx) => clientFor(ctx).discover(), {
+    description: 'List every context grant this agent holds, as scope descriptors — grantId, scope, temporal, watermarkAt, expiresAt (no message or artifact content).',
+});
+export const contextDelegateTool = defineTool('context_delegate', {
+    parentGrantId: { type: 'string', required: true },
+    holderId: { type: 'string', required: true },
+    scopeKind: { type: 'string', required: true },
+    scopeId: { type: 'string', required: true },
+    temporal: { type: 'string', required: true },
+    expiresAt: 'string',
+    watermarkAt: 'string',
+}, async (args, ctx) => {
+    const temporal = args['temporal'];
+    if (temporal !== 'from-now' && temporal !== 'from-start') {
+        throw new Error('temporal must be from-now or from-start');
+    }
+    const scopeKind = args['scopeKind'];
+    if (scopeKind !== 'chat' && scopeKind !== 'agreement' && scopeKind !== 'org') {
+        throw new Error('scopeKind must be chat, agreement, or org');
+    }
+    return clientFor(ctx).delegate({
+        parentGrantId: args['parentGrantId'],
+        holderId: args['holderId'],
+        scope: { kind: scopeKind, id: args['scopeId'] },
+        temporal,
+        expiresAt: args['expiresAt'] ?? undefined,
+        watermarkAt: args['watermarkAt'],
+    });
+}, {
+    description: 'Delegate a narrower child context grant (tighter scope, shorter expiry, or from-now). Holder-only.',
+});
+export const CONTEXT_TOOLS = [
+    contextDiscoverTool,
+    contextDelegateTool,
+];

package/dist/server/tools/tier2/discoveryTools.d.ts

@@ -0,0 +1,4 @@
+import { type ToolDefinition } from '../../../tools/defineTool.js';
+export declare const agentSearchTool: ToolDefinition;
+export declare const agentGetTool: ToolDefinition;
+export declare const DISCOVERY_TOOLS: ToolDefinition[];

package/dist/server/tools/tier2/discoveryTools.js

@@ -0,0 +1,25 @@
+import { defineTool } from '../../../tools/defineTool.js';
+import { AgentSearchClient } from '@ziggs-ai/api-client';
+function clientFor(ctx) {
+    const operatorKey = ctx?.['operatorKey'];
+    const agentId = ctx?.['agentId'];
+    if (!operatorKey)
+        throw new Error('operatorKey missing from tool context');
+    if (!agentId)
+        throw new Error('agentId missing from tool context');
+    return new AgentSearchClient(operatorKey, agentId);
+}
+export const agentSearchTool = defineTool('agent_search', { query: { type: 'string', required: true }, limit: 'number' }, async (args, ctx) => {
+    if (!args['query'])
+        throw new Error('query is required');
+    const options = {};
+    if (typeof args['limit'] === 'number')
+        options.limit = args['limit'];
+    return clientFor(ctx).searchAgents(args['query'], options);
+}, { description: 'Search for agents by capability, name, or description. Returns ranked results with relevance scores. Use before agreement_propose or agreement_subcontract to discover the right agent for a job.', isGenericFallback: true });
+export const agentGetTool = defineTool('agent_get', { agentId: { type: 'string', required: true } }, async (args, ctx) => {
+    if (!args['agentId'])
+        throw new Error('agentId is required');
+    return clientFor(ctx).getAgentById(args['agentId']);
+}, { description: 'Fetch the full profile of a specific agent by ID. Use to confirm capabilities and terms before proposing an agreement.' });
+export const DISCOVERY_TOOLS = [agentSearchTool, agentGetTool];

package/dist/server/tools/tier2/marketplaceTools.d.ts

@@ -0,0 +1,3 @@
+import { type ToolDefinition } from '../../../tools/defineTool.js';
+export declare const marketplaceViewTool: ToolDefinition;
+export declare const MARKETPLACE_TOOLS: ToolDefinition[];

package/dist/server/tools/tier2/marketplaceTools.js

@@ -0,0 +1,22 @@
+import { defineTool } from '../../../tools/defineTool.js';
+import { pullQuests } from '@ziggs-ai/api-client';
+// Read-only marketplace access. Publishing an open quest is NOT here: it is the
+// tier-1 protocol verb agreement_propose({ proposedTo: "everyone" | "org" }).
+// This feed already returns only quests the caller may see — org-scoped quests
+// appear here only for members of the quest's org (filtered server-side).
+export const marketplaceViewTool = defineTool('marketplace_view', { limit: 'number', since: 'string' }, async (args, ctx) => {
+    const operatorKey = ctx?.['operatorKey'];
+    const agentId = ctx?.['agentId'];
+    if (!operatorKey)
+        throw new Error('operatorKey missing from tool context');
+    if (!agentId)
+        throw new Error('agentId missing from tool context');
+    const options = {
+        limit: typeof args['limit'] === 'number' ? args['limit'] : 20,
+    };
+    if (args['since'])
+        options.since = args['since'];
+    const quests = await pullQuests(options, { operatorKey, agentId });
+    return { quests, count: quests.length };
+}, { description: 'Browse open quests on the marketplace — work buyers have broadcast to willing agents. Returns public quests plus any org-scoped quests in your org. To claim a quest, use agreement_respond on the returned agreementId. To publish your own, use agreement_propose({ proposedTo: "everyone" }) for a public quest or proposedTo: "org" to keep it inside your org.' });
+export const MARKETPLACE_TOOLS = [marketplaceViewTool];

package/dist/server/tools/tier2/paymentTools.d.ts

@@ -0,0 +1,12 @@
+import { type ToolDefinition } from '../../../tools/defineTool.js';
+export declare const paymentBalanceTool: ToolDefinition;
+export declare const paymentTransferTool: ToolDefinition;
+export declare const paymentWaitForApprovalTool: ToolDefinition;
+export declare const paymentResolveWalletTool: ToolDefinition;
+export declare const paymentHoldTool: ToolDefinition;
+export declare const paymentReleaseTool: ToolDefinition;
+export declare const paymentIssueGrantTool: ToolDefinition;
+export declare const paymentAttenuateGrantTool: ToolDefinition;
+export declare const paymentRevokeGrantTool: ToolDefinition;
+export declare const paymentListGrantsTool: ToolDefinition;
+export declare const PAYMENT_TOOLS: ToolDefinition[];