@ziggs-ai/agent-sdk 0.1.11 → 0.2.0

package/dist/index.js

@@ -0,0 +1,66 @@
+/**
+ * @ziggs-ai/agent-sdk public surface.
+ *
+ * Foundation:
+ *   • Outcome union — discriminated, hybrid (closed core + extension)
+ *   • Workflow shape — explicit kind: 'parked' | 'thinking' | 'mechanical'
+ *   • Visible defaults — thinkingDefaults({ initial }) spread by author
+ *   • Validation at load — defineAgent throws on hard problems, warns on soft
+ */
+export { defineAgent } from './defineAgent.js';
+export { createMcpAgent, resolveZiggsGatewayTarget, wrapGatewayFetch, ZiggsGatewayError } from './adapters/McpAdapter.js';
+export { AgentHost, createAgent, createAgentPool, DEFAULT_MODEL } from './AgentHost.js';
+export { Agent } from './agent/Agent.js';
+export { ClaudeSdkAgent } from './agent/ClaudeSdkAgent.js';
+export { ziggsBrain, claudeBrain, isBrainSelection, isClaudeCognition } from './brain/index.js';
+export { createZiggsEffectHandler } from './server/ZiggsEffectHandler.js';
+export { EventQueue } from './server/EventQueue.js';
+export { StateTimers } from './server/StateTimers.js';
+export { OutboxBuffer } from './server/OutboxBuffer.js';
+export { normalizeIncomingEvent } from './ingress/normalizeIncoming.js';
+// Runtime primitives
+export { AgentMachine } from './runtime/AgentMachine.js';
+export { runTurn } from './runtime/runTurn.js';
+export { runMechanical } from './runtime/runMechanical.js';
+export { PromptBuilder } from './runtime/PromptBuilder.js';
+export { thinkingDefaults, defineThinkingState, defineMechanicalState, DEFAULT_WAIT_PROMPT } from './runtime/defaults.js';
+export { KICKOFF_STATE, injectKickoffDefault, buildKickoffState } from './runtime/kickoff.js';
+export { validateWorkflow, WorkflowValidationError } from './runtime/validateWorkflow.js';
+export { deriveRespondsToProposals, statesRespondToProposals, } from './runtime/deriveRespondsToProposals.js';
+export { outcomeFromEvent, outcomeFromActionResult, applyOutcomeToCtx } from './runtime/buildOutcome.js';
+export { default } from './AgentHost.js';
+// ── Supporting modules ──────────────────────────────────────────────────────
+export { validateContext, ContextWarning } from './cognition/validateContext.js';
+export { runLauncher } from './server/runLauncher.js';
+export { ConnectionPool } from './server/ConnectionPool.js';
+export { createHealthServer } from './server/createHealthServer.js';
+export { TaskService } from './server/tasks/TaskService.js';
+export { AgreementService } from './server/agreements/AgreementService.js';
+export { ToolManager } from './tools/ToolManager.js';
+export { ToolProvider } from './tools/ToolProvider.js';
+export { defineTool } from './tools/defineTool.js';
+export { recordReport } from './tools/recordReport.js';
+export { OpenAIAdapter } from './adapters/OpenAIAdapter.js';
+export { extractJSON, safeParseJSON } from './utils/jsonExtractor.js';
+export { HistoryFormatter, historyFormatter, AgreementFormatter, agreementFormatter } from './formatters/index.js';
+export { ProactiveTrigger } from './server/proactive/ProactiveTrigger.js';
+export { ZiggsPayClient, createZiggsPayClient } from './server/ziggspay/ZiggsPayClient.js';
+export { ZiggsConnectClient, createZiggsConnectClient } from './server/ziggsconnect/ZiggsConnectClient.js';
+export { ZiggsContextClient } from './server/ziggscontext/ZiggsContextClient.js';
+// All agent tool bundles live under server/tools/ (tier1 = protocol grammar,
+// tier2 = opt-in HTTP capability bundles). Single home: server/tools/index.ts.
+export { 
+// Tier 1 — protocol grammar (framework-managed via taskTools).
+PROTOCOL_TOOLS, agreementProposeTool, agreementSubcontractTool, agreementRespondTool, agreementCounterProposalTool, agreementCheckProposalTool, taskSpawnTool, taskUpdateTool, taskUpdatePlanStepTool, dispatchProtocolOp, 
+// Tier 2 — opt-in capability bundles (spread into `tools:`).
+PAYMENT_TOOLS, paymentBalanceTool, paymentTransferTool, paymentHoldTool, paymentReleaseTool, paymentResolveWalletTool, CONNECTION_TOOLS, connectionProxyTool, connectionListGrantsTool, DISCOVERY_TOOLS, agentSearchTool, agentGetTool, MARKETPLACE_TOOLS, marketplaceViewTool, } from './server/tools/index.js';
+export { PROTOCOL_TOOL_NAMES, PROTOCOL_TOOL_TO_OPERATION, mapProtocolToolToOperation, isProtocolToolName } from './tasks/protocolRegistry.js';
+export { InMemoryStore, FileMemoryStore } from './memory/MemoryStore.js';
+export { classifyIncomingEvent } from './context/classifyEnvelope.js';
+export { buildContextUpdates, CONTEXT_RESET } from './context/applyEffects.js';
+export { getBatchEvents, isTaskResultRelevantToAgent } from './context/batch.js';
+export { classifyWorkflowEvent, findTaskResult, unwrapBatchEvent, findIncomingTaskResult } from './context/routingLabels.js';
+export { WebSocketClient, MessagesClient, ArtifactsClient, AgentSearchClient, getBackendUrl, getWebSocketUrl, } from '@ziggs-ai/api-client';
+export { runInboxCatchUp } from './server/InboxCatchUp.js';
+export { SeenMessages } from './server/SeenMessages.js';
+export { runtimeLog, resetRuntimeLogLevelCache } from './shared/runtimeLog.js';

package/dist/ingress/normalizeIncoming.d.ts

@@ -0,0 +1,65 @@
+export interface NormalizedEvent {
+    chatId: string | null;
+    event: {
+        senderId?: string;
+        senderType?: string;
+        receiverId?: string;
+        timestamp: number;
+        type: 'task_result' | 'message' | 'agreement_lifecycle';
+        operation?: string;
+        agreementId?: string;
+        result?: unknown;
+        text?: string;
+    };
+    shouldProcess: boolean;
+    reason: string | null;
+}
+interface WireParties {
+    creator?: string;
+    provider?: string;
+    payer?: string;
+    proposedTo?: string;
+}
+interface WireTask {
+    taskId?: string;
+    agentId?: string;
+    executorId?: string;
+    payerId?: string;
+    proposedTo?: string;
+    createdBy?: string;
+    parentTaskId?: string;
+    state?: string;
+    proposal?: unknown;
+    agreement?: {
+        parties?: WireParties;
+    };
+}
+interface WireMetadata {
+    chatId?: string;
+    chat_id?: string;
+    entryType?: string;
+    content_type?: string;
+    contentType?: string;
+    receiverId?: string;
+    operation?: string;
+    agreementId?: string;
+    sender?: {
+        id?: string;
+        type?: string;
+    };
+    receiver?: {
+        id?: string;
+    };
+    to?: {
+        id?: string;
+    };
+    task?: WireTask;
+    [key: string]: unknown;
+}
+interface NormalizeArgs {
+    text: string;
+    metadata?: WireMetadata;
+    ownAgentId?: string | null;
+}
+export declare function normalizeIncomingEvent({ text, metadata, ownAgentId }: NormalizeArgs): NormalizedEvent;
+export {};

package/dist/ingress/normalizeIncoming.js

@@ -0,0 +1,88 @@
+import { OPEN_AGREEMENT_TARGET } from '@ziggs-ai/api-client';
+/** Backend wire operations that map to FSM `proposal-resolved`. */
+const PROPOSAL_RESOLVED_OPERATIONS = new Set([
+    'proposal_approved',
+    'proposal_rejected',
+    'proposal_approved_execute',
+]);
+function normalizeChatId(metadata) {
+    return metadata.chatId || metadata.chat_id || null;
+}
+function normalizeReceiverId(metadata, taskData) {
+    return metadata.receiver?.id || metadata.receiverId || metadata.to?.id || taskData?.executorId || taskData?.proposedTo || null;
+}
+function isTaskRelated(metadata, taskData) {
+    if (!taskData?.taskId)
+        return false;
+    const entryType = metadata.entryType || 'message';
+    const contentType = metadata.content_type || metadata.contentType || 'text';
+    return (entryType === 'notification' || entryType === 'task_history'
+        || contentType === 'task' || contentType === 'task_update'
+        || Boolean(taskData.state || taskData.proposal || taskData.parentTaskId || taskData.executorId || taskData.agentId || taskData.payerId || taskData.createdBy));
+}
+function isRelevantForAgent(ids, ownAgentId) {
+    if (!ownAgentId)
+        return true;
+    return ids.includes(ownAgentId) || ids.includes(OPEN_AGREEMENT_TARGET);
+}
+function isAgreementLifecycleNotification(metadata) {
+    const entryType = metadata.entryType || 'message';
+    const operation = metadata.operation;
+    return (entryType === 'notification' &&
+        typeof operation === 'string' &&
+        PROPOSAL_RESOLVED_OPERATIONS.has(operation));
+}
+export function normalizeIncomingEvent({ text, metadata = {}, ownAgentId = null }) {
+    const taskData = metadata.task || null;
+    const chatId = normalizeChatId(metadata);
+    const receiverId = normalizeReceiverId(metadata, taskData);
+    const senderType = metadata.sender?.type ? String(metadata.sender.type).toUpperCase() : undefined;
+    const base = {
+        senderId: metadata.sender?.id,
+        senderType,
+        receiverId: receiverId || undefined,
+        timestamp: Date.now(),
+    };
+    if (isAgreementLifecycleNotification(metadata)) {
+        const relevant = !ownAgentId ||
+            !receiverId ||
+            receiverId === ownAgentId ||
+            receiverId === OPEN_AGREEMENT_TARGET;
+        const agreementId = typeof metadata.agreementId === 'string' ? metadata.agreementId : '';
+        return {
+            chatId,
+            event: {
+                ...base,
+                type: 'agreement_lifecycle',
+                operation: metadata.operation,
+                agreementId,
+                text,
+            },
+            shouldProcess: relevant,
+            reason: relevant ? null : 'message_not_targeted_to_agent',
+        };
+    }
+    if (isTaskRelated(metadata, taskData)) {
+        const receiverFromMeta = metadata.receiver?.id || metadata.receiverId || null;
+        const parties = taskData.agreement?.parties ?? {};
+        const candidateIds = [
+            parties.creator, parties.provider, parties.payer, parties.proposedTo,
+            taskData.agentId, taskData.executorId, taskData.payerId, taskData.proposedTo, taskData.createdBy,
+            receiverFromMeta,
+        ].filter(Boolean);
+        const relevant = isRelevantForAgent(candidateIds, ownAgentId);
+        return {
+            chatId,
+            event: { ...base, type: 'task_result', result: taskData, text },
+            shouldProcess: relevant,
+            reason: relevant ? null : 'task_not_targeted_to_agent',
+        };
+    }
+    const relevant = !ownAgentId || !receiverId || receiverId === ownAgentId || receiverId === OPEN_AGREEMENT_TARGET;
+    return {
+        chatId,
+        event: { ...base, type: 'message', text },
+        shouldProcess: relevant,
+        reason: relevant ? null : 'message_not_targeted_to_agent',
+    };
+}

package/dist/memory/MemoryStore.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Agent-private long-term memory.
+ *
+ * This is the SDK's contract; the *storage* is operator-provided. The agent
+ * picks the key shape (often `counterparty:<id>`, sometimes `agreement:<id>:notes`,
+ * etc.) — the SDK does not enforce one.
+ *
+ * Reference implementations: `InMemoryStore` (default; non-durable) and
+ * `FileMemoryStore` (single JSON file; useful for local dev). Anything
+ * production-grade (sqlite, redis, postgres, …) is operator-owned.
+ *
+ * Aligns with the project's "agents are third-party" framing: an agent's
+ * private notes are its own concern, not the backend's.
+ */
+export interface MemoryStore {
+    get(key: string): Promise<unknown | undefined>;
+    put(key: string, value: unknown): Promise<void>;
+    list(prefix: string): Promise<{
+        key: string;
+        value: unknown;
+    }[]>;
+    delete?(key: string): Promise<void>;
+}
+/** Non-durable reference impl. Per-process; lost on restart. */
+export declare class InMemoryStore implements MemoryStore {
+    private readonly store;
+    get(key: string): Promise<unknown | undefined>;
+    put(key: string, value: unknown): Promise<void>;
+    list(prefix: string): Promise<{
+        key: string;
+        value: unknown;
+    }[]>;
+    delete(key: string): Promise<void>;
+}
+/**
+ * Single-file JSON store. Reads on startup, writes on every put — fine for
+ * local dev and example agents; not for production (no concurrency control,
+ * no atomicity). Operators with serious durability needs ship their own
+ * `MemoryStore` (sqlite, redis, …) and pass it via `defineAgent({ memory })`.
+ */
+export declare class FileMemoryStore implements MemoryStore {
+    private readonly path;
+    private cache;
+    private loading;
+    constructor(path: string);
+    private _ensureLoaded;
+    private _flush;
+    get(key: string): Promise<unknown | undefined>;
+    put(key: string, value: unknown): Promise<void>;
+    list(prefix: string): Promise<{
+        key: string;
+        value: unknown;
+    }[]>;
+    delete(key: string): Promise<void>;
+}

package/dist/memory/MemoryStore.js

@@ -0,0 +1,78 @@
+/** Non-durable reference impl. Per-process; lost on restart. */
+export class InMemoryStore {
+    store = new Map();
+    async get(key) {
+        return this.store.get(key);
+    }
+    async put(key, value) {
+        this.store.set(key, value);
+    }
+    async list(prefix) {
+        const out = [];
+        for (const [k, v] of this.store) {
+            if (k.startsWith(prefix))
+                out.push({ key: k, value: v });
+        }
+        return out;
+    }
+    async delete(key) {
+        this.store.delete(key);
+    }
+}
+/**
+ * Single-file JSON store. Reads on startup, writes on every put — fine for
+ * local dev and example agents; not for production (no concurrency control,
+ * no atomicity). Operators with serious durability needs ship their own
+ * `MemoryStore` (sqlite, redis, …) and pass it via `defineAgent({ memory })`.
+ */
+export class FileMemoryStore {
+    path;
+    cache = null;
+    loading = null;
+    constructor(path) {
+        this.path = path;
+    }
+    async _ensureLoaded() {
+        if (this.cache)
+            return;
+        if (!this.loading) {
+            this.loading = (async () => {
+                try {
+                    const fs = await import('fs/promises');
+                    const txt = await fs.readFile(this.path, 'utf-8');
+                    this.cache = JSON.parse(txt);
+                }
+                catch {
+                    this.cache = {};
+                }
+            })();
+        }
+        await this.loading;
+    }
+    async _flush() {
+        if (!this.cache)
+            return;
+        const fs = await import('fs/promises');
+        await fs.writeFile(this.path, JSON.stringify(this.cache, null, 2), 'utf-8');
+    }
+    async get(key) {
+        await this._ensureLoaded();
+        return this.cache[key];
+    }
+    async put(key, value) {
+        await this._ensureLoaded();
+        this.cache[key] = value;
+        await this._flush();
+    }
+    async list(prefix) {
+        await this._ensureLoaded();
+        return Object.entries(this.cache)
+            .filter(([k]) => k.startsWith(prefix))
+            .map(([key, value]) => ({ key, value }));
+    }
+    async delete(key) {
+        await this._ensureLoaded();
+        delete this.cache[key];
+        await this._flush();
+    }
+}

package/dist/pricing/fleetDefaults.d.ts

@@ -0,0 +1,46 @@
+/**
+ * ZIG-368 — default paid pricing for Ziggs-operated (first-party) agents.
+ * Prices are in wallet cents (1 ZIG = 100 cents).
+ */
+import { type FleetPricingTier } from './fleetTierByAgentId.gen.js';
+export declare const ZIGGS_OPERATOR_CUT_BPS = 1000;
+export declare const TIER_PRICE_CENTS: Record<FleetPricingTier, number>;
+export declare function resolveFleetTier(agentId: string): FleetPricingTier | null;
+export declare function isFirstPartyFleetAgent(agentId: string): boolean;
+export declare function tierPriceCents(tier: FleetPricingTier): number;
+export declare function isZiggsOrchestrator(agentId: string): boolean;
+export declare function isFreeAllowlistedExecutor(executorId: string, description?: string | null): boolean;
+export declare function resolveDefaultPriceCentsForExecutor(executorId: string, description?: string | null): number | null;
+export interface ProtocolPricingPayload {
+    price?: number | null;
+    description?: string;
+    agreementDescription?: string;
+    proposedTo?: string;
+    providerId?: string;
+    executorId?: string;
+    parentAgreementId?: string;
+    parentTaskId?: string;
+    [key: string]: unknown;
+}
+/**
+ * Apply ZIG-368 defaults when `price` is omitted (null/undefined).
+ * Explicit `price: 0` is kept (free-on-purpose).
+ */
+export declare function applyFleetAgreementPricing(operation: 'agreement-propose' | 'agreement-subcontract', payload: ProtocolPricingPayload, actingAgentId: string): ProtocolPricingPayload;
+/**
+ * Default tier price when a fleet agent counters without an explicit `price`.
+ *
+ * Generic over the payload shape so the precise field types of the caller's
+ * payload survive the round-trip — this helper only ever sets `price`, so a
+ * richer input type (e.g. protocolRunner's `ProtocolPayload`) must come back
+ * out unwidened by `ProtocolPricingPayload`'s `[key: string]: unknown` index.
+ */
+export declare function applyFleetCounterPricing<T extends ProtocolPricingPayload>(payload: T, actingAgentId: string): T;
+/** User or agent direct-create / marketplace: default from provider specialist. */
+export declare function resolveDefaultPriceForProvider(providerId: string, description?: string | null, explicitPrice?: number | null): number | null;
+/**
+ * Infer fleet actor when tool context omits agentId (ZIG-368 safety net).
+ */
+export declare function inferFleetPricingActorId(payload: ProtocolPricingPayload): string | null;
+/** Apply fleet defaults with optional acting agent (falls back to payload inference). */
+export declare function applyFleetPricingForProtocol(operation: 'agreement-propose' | 'agreement-subcontract', payload: ProtocolPricingPayload, actingAgentId: string | null): ProtocolPricingPayload;

package/dist/pricing/fleetDefaults.js

@@ -0,0 +1,168 @@
+/**
+ * ZIG-368 — default paid pricing for Ziggs-operated (first-party) agents.
+ * Prices are in wallet cents (1 ZIG = 100 cents).
+ */
+import { FLEET_TIER_BY_AGENT_ID } from './fleetTierByAgentId.gen.js';
+import { FREE_TIER_A_AGENT_IDS } from './fleetFreeTierA.gen.js';
+import { isEvalFreeExecutor } from './fleetEvalFree.js';
+export const ZIGGS_OPERATOR_CUT_BPS = 1000; // 10%
+export const TIER_PRICE_CENTS = {
+    A: 200, // 2 ZIG / call
+    B: 500, // 5 ZIG / call
+    C: 1500, // 15 ZIG / job (orchestrator, charged once at top)
+    D: 100, // 1 ZIG / call (hand-written demo agents)
+};
+const ZIGGS_ORCHESTRATOR_IDS = new Set(['ziggs-agent']);
+const PING_DESCRIPTION_PATTERN = /\b(ping|health\s*check|healthcheck|liveness|readiness|heartbeat)\b/i;
+const TRIVIAL_LOOKUP_DESCRIPTION_PATTERN = /\b(what\s+time|current\s+time|local\s+time|world\s+clock|timezone|time\s+zone|weather|forecast|temperature|uv\s+index)\b/i;
+export function resolveFleetTier(agentId) {
+    if (!agentId || typeof agentId !== 'string')
+        return null;
+    return FLEET_TIER_BY_AGENT_ID[agentId] ?? null;
+}
+export function isFirstPartyFleetAgent(agentId) {
+    return resolveFleetTier(agentId) != null;
+}
+export function tierPriceCents(tier) {
+    return TIER_PRICE_CENTS[tier];
+}
+export function isZiggsOrchestrator(agentId) {
+    return ZIGGS_ORCHESTRATOR_IDS.has(agentId);
+}
+export function isFreeAllowlistedExecutor(executorId, description) {
+    if (!executorId)
+        return false;
+    if (isEvalFreeExecutor(executorId))
+        return true;
+    if (FREE_TIER_A_AGENT_IDS.has(executorId))
+        return true;
+    if (description && PING_DESCRIPTION_PATTERN.test(description))
+        return true;
+    if (description &&
+        TRIVIAL_LOOKUP_DESCRIPTION_PATTERN.test(description) &&
+        FREE_TIER_A_AGENT_IDS.has(executorId)) {
+        return true;
+    }
+    return false;
+}
+export function resolveDefaultPriceCentsForExecutor(executorId, description) {
+    if (isFreeAllowlistedExecutor(executorId, description))
+        return 0;
+    const tier = resolveFleetTier(executorId);
+    if (!tier)
+        return null;
+    return tierPriceCents(tier);
+}
+/**
+ * Apply ZIG-368 defaults when `price` is omitted (null/undefined).
+ * Explicit `price: 0` is kept (free-on-purpose).
+ */
+export function applyFleetAgreementPricing(operation, payload, actingAgentId) {
+    if (payload.price != null && payload.price !== undefined) {
+        return payload;
+    }
+    const next = { ...payload };
+    const scopeDescription = next.description ?? next.agreementDescription;
+    if (operation === 'agreement-subcontract') {
+        const executorId = String(next.executorId ?? '');
+        if (next.parentAgreementId) {
+            // Paid parent scope: no second user hold — allocate from parent budget (recordAllocation).
+            const cents = resolveDefaultPriceCentsForExecutor(executorId, scopeDescription);
+            next.price = cents ?? 0;
+            return next;
+        }
+        const cents = resolveDefaultPriceCentsForExecutor(executorId, scopeDescription);
+        if (cents != null)
+            next.price = cents;
+        return next;
+    }
+    // agreement-propose
+    if (next.parentAgreementId) {
+        return next;
+    }
+    const proposedTo = next.proposedTo != null ? String(next.proposedTo) : '';
+    const providerId = next.providerId != null ? String(next.providerId) : '';
+    // Ziggs scope proposal to human user — 15 ZIG once at top.
+    if (isZiggsOrchestrator(actingAgentId) &&
+        proposedTo &&
+        !isFirstPartyFleetAgent(proposedTo)) {
+        next.price = TIER_PRICE_CENTS.C;
+        return next;
+    }
+    // Tier C orchestrator proposing scope to a user (non-ziggs fleet orchestrators).
+    const actingTier = resolveFleetTier(actingAgentId);
+    if (actingTier === 'C' && proposedTo && !isFirstPartyFleetAgent(proposedTo)) {
+        next.price = TIER_PRICE_CENTS.C;
+        return next;
+    }
+    // Matchmaking: propose directly to a fleet specialist with tier list price.
+    const specialistId = providerId || (isFirstPartyFleetAgent(proposedTo) ? proposedTo : '');
+    if (specialistId) {
+        const cents = resolveDefaultPriceCentsForExecutor(specialistId, scopeDescription);
+        if (cents != null)
+            next.price = cents;
+    }
+    return next;
+}
+/**
+ * Default tier price when a fleet agent counters without an explicit `price`.
+ *
+ * Generic over the payload shape so the precise field types of the caller's
+ * payload survive the round-trip — this helper only ever sets `price`, so a
+ * richer input type (e.g. protocolRunner's `ProtocolPayload`) must come back
+ * out unwidened by `ProtocolPricingPayload`'s `[key: string]: unknown` index.
+ */
+export function applyFleetCounterPricing(payload, actingAgentId) {
+    if (payload.price != null && payload.price !== undefined) {
+        return payload;
+    }
+    const cents = resolveDefaultPriceCentsForExecutor(actingAgentId, payload.description ?? payload.agreementDescription);
+    if (cents == null)
+        return payload;
+    return { ...payload, price: cents };
+}
+/** User or agent direct-create / marketplace: default from provider specialist. */
+export function resolveDefaultPriceForProvider(providerId, description, explicitPrice) {
+    if (typeof explicitPrice === 'number')
+        return explicitPrice;
+    return resolveDefaultPriceCentsForExecutor(providerId, description);
+}
+/**
+ * Infer fleet actor when tool context omits agentId (ZIG-368 safety net).
+ */
+export function inferFleetPricingActorId(payload) {
+    const executor = payload.executorId != null ? String(payload.executorId) : '';
+    if (executor && isFirstPartyFleetAgent(executor))
+        return executor;
+    const provider = payload.providerId != null ? String(payload.providerId) : '';
+    if (provider && isFirstPartyFleetAgent(provider))
+        return provider;
+    const proposed = payload.proposedTo != null ? String(payload.proposedTo) : '';
+    if (proposed && isFirstPartyFleetAgent(proposed))
+        return proposed;
+    return null;
+}
+/** Apply fleet defaults with optional acting agent (falls back to payload inference). */
+export function applyFleetPricingForProtocol(operation, payload, actingAgentId) {
+    const actor = actingAgentId?.trim() || inferFleetPricingActorId(payload);
+    if (!actor) {
+        if (operation === 'agreement-propose') {
+            const specialist = (payload.providerId != null ? String(payload.providerId) : '') ||
+                (payload.proposedTo != null && isFirstPartyFleetAgent(String(payload.proposedTo))
+                    ? String(payload.proposedTo)
+                    : '');
+            if (specialist) {
+                const cents = resolveDefaultPriceCentsForExecutor(specialist, payload.description ?? payload.agreementDescription);
+                if (cents != null)
+                    return { ...payload, price: cents };
+            }
+        }
+        if (operation === 'agreement-subcontract' && payload.executorId) {
+            const cents = resolveDefaultPriceCentsForExecutor(String(payload.executorId), payload.description);
+            if (cents != null)
+                return { ...payload, price: cents };
+        }
+        return payload;
+    }
+    return applyFleetAgreementPricing(operation, payload, actor);
+}

package/dist/pricing/fleetEvalFree.d.ts

@@ -0,0 +1,7 @@
+/**
+ * ZIG-395 — eval/harness free pricing via env flag (no SANDBOX id-shape regex).
+ */
+/** Capability-probe + test harness agents (agents/test/). */
+export declare const EVAL_HARNESS_AGENT_IDS: Set<string>;
+export declare function isEvalFreePricingEnabled(): boolean;
+export declare function isEvalFreeExecutor(agentId: string): boolean;

package/dist/pricing/fleetEvalFree.js

@@ -0,0 +1,24 @@
+/**
+ * ZIG-395 — eval/harness free pricing via env flag (no SANDBOX id-shape regex).
+ */
+/** Capability-probe + test harness agents (agents/test/). */
+export const EVAL_HARNESS_AGENT_IDS = new Set([
+    'minimal-context-agent',
+    'forwarding-agent',
+    'failing-agent',
+    'messaging-only-agent',
+    'principal-agent',
+    'capability-probe-agent',
+]);
+export function isEvalFreePricingEnabled() {
+    return process.env.FLEET_EVAL_FREE_PRICING === 'true';
+}
+export function isEvalFreeExecutor(agentId) {
+    if (!isEvalFreePricingEnabled() || !agentId)
+        return false;
+    if (agentId === 'eval-user')
+        return true;
+    if (agentId.endsWith('--eval'))
+        return true;
+    return EVAL_HARNESS_AGENT_IDS.has(agentId);
+}

package/dist/pricing/fleetFreeTierA.gen.d.ts

@@ -0,0 +1,6 @@
+/**
+ * AUTO-GENERATED by scripts/build-fleet-tier-map.mjs — do not edit by hand.
+ * ZIG-368: Tier A trivial public lookups (free when price omitted).
+ */
+export declare const FREE_TIER_A_AGENT_IDS: Set<string>;
+export declare const FREE_TIER_A_COUNT = 4;

package/{src/pricing/fleetFreeTierA.gen.ts → dist/pricing/fleetFreeTierA.gen.js}

@@ -2,11 +2,10 @@
  * AUTO-GENERATED by scripts/build-fleet-tier-map.mjs — do not edit by hand.
  * ZIG-368: Tier A trivial public lookups (free when price omitted).
  */
-export const FREE_TIER_A_AGENT_IDS = new Set<string>([
-  "site-health-checker",
-  "timezone-expert",
-  "uv-index-advisor",
-  "weather-forecaster"
+export const FREE_TIER_A_AGENT_IDS = new Set([
+    "site-health-checker",
+    "timezone-expert",
+    "uv-index-advisor",
+    "weather-forecaster"
 ]);
-
 export const FREE_TIER_A_COUNT = 4;

package/dist/pricing/fleetTierByAgentId.gen.d.ts

@@ -0,0 +1,7 @@
+/**
+ * AUTO-GENERATED by scripts/build-fleet-tier-map.mjs — do not edit by hand.
+ * ZIG-368: agent-sdk local default pricing (backend uses agent.pricingTier — ZIG-395).
+ */
+export type FleetPricingTier = 'A' | 'B' | 'C' | 'D';
+export declare const FLEET_TIER_BY_AGENT_ID: Record<string, FleetPricingTier>;
+export declare const FLEET_TIER_MAP_SIZE = 765;