@ziggs-ai/agent-sdk 0.10.8 → 0.11.1

package/dist/AgentHost.js

@@ -16,7 +16,8 @@ import { PROTOCOL_TOOLS } from './server/tools/tier1/protocolTools.js';
 import { marketplaceViewTool } from './server/tools/tier2/marketplaceTools.js';
 import { OpenAIAdapter } from './adapters/OpenAIAdapter.js';
 import { AnthropicAdapter } from './adapters/AnthropicAdapter.js';
-import { ArtifactsClient, ContextReadClient, TelemetryClient, sendChatMessage, } from '@ziggs-ai/api-client';
+import { ArtifactsClient, ConnectionsClient, ContextReadClient, TelemetryClient, sendChatMessage, } from '@ziggs-ai/api-client';
+import { normalizeNeeds, unmetNeeds, unmetNeedsMessage, } from './tools/needs.js';
 import { TaskService } from './server/tasks/TaskService.js';
 import { AgreementService } from './server/agreements/AgreementService.js';
 import { runInboxLoop } from './server/inboxLoop.js';
@@ -40,13 +41,13 @@ async function loadConnectionPool() {
 }
 const DEFAULT_SESSION_RESOLVER = (normalized) => normalized.chatId;
 /**
- * ZIG-975: one lane key per unit of work, derived the same way as inbox wakes.
+ * one lane key per unit of work, derived the same way as inbox wakes.
  *
  * Inbox deliveries key on `chatId` (DEFAULT_SESSION_RESOLVER). Bootstrap used to
  * prefer bare `agreementId`, which opened a second lane for the same task and
  * made the snapshot read treat the agreement id as a chat (`chatMissing: true`,
  * empty context). Prefer the origin chat when present; otherwise the agreement's
- * notification chat (`agrn-<agreementId>`), which is always linked after ZIG-966.
+ * notification chat (`agrn-<agreementId>`), which is always linked after.
  */
 export function laneSessionIdForTask(task) {
     if (typeof task.originChatId === 'string' && task.originChatId) {
@@ -69,13 +70,13 @@ function createToolManager(options) {
         taskTools = PROTOCOL_TOOLS; // 'all' or undefined
     const claudeSdkTools = isClaudeCognition(options.cognition) ? CLAUDE_SDK_TOOLS : [];
     const ownTools = Array.isArray(userTools) ? userTools : [];
-    // ZIG-1280 — browse rides wherever claim rides. Posted-first engagements
+    // browse rides wherever claim rides. Posted-first engagements
     // START at marketplace_view (find the listing), so an agent that can
     // agreement_claim but cannot browse holds a default pathway it cannot begin.
     // Both directions: shedding claim (taskTools array without it) sheds browse.
     const canClaim = taskTools.some((t) => t.schema.function.name === 'agreement_claim');
     const browseTools = canClaim ? [marketplaceViewTool] : [];
-    // ZIG-1278 — chat_open is always-on so claim/provider kickoff (FSM) and the
+    // chat_open is always-on so claim/provider kickoff (FSM) and the
     // Claude always-on set can open the buyer chat after a store claim. CHAT_TOOLS
     // is also folded into CLAUDE_SDK_TOOLS; Map registration makes duplicates a no-op.
     const platformTools = [...taskTools, ...CHAT_TOOLS, ...browseTools, ...claudeSdkTools];
@@ -128,7 +129,7 @@ function createBackendServices(options) {
     const agentId = options.agentId;
     const artifactsClient = new ArtifactsClient(operatorKey, agentId);
     const contextReadClient = new ContextReadClient(operatorKey, agentId);
-    // ZIG-1080: the role text is the prompt when the author split the two; the
+    // the role text is the prompt when the author split the two; the
     // store-facing `description` is only the fallback for agents that never did.
     const promptBuilder = new PromptBuilder({
         description: options.systemPrompt || options.description,
@@ -153,7 +154,7 @@ function createBackendServices(options) {
  * a transport (Ziggs WebSocket), and the lane router (per-session FIFO queue
  * + in-memory session state).
  *
- *   transport (WS)  →  handleMessage  →  agent.tick(... , eff)  →  ...
+ *   transport (WS)  →  handleMessage  →  agent.tick(.. , eff)  →  ..
  */
 export class AgentHost {
     options;
@@ -177,6 +178,8 @@ export class AgentHost {
     /** The per-agent inbox long-poll loop — this agent's sole wake source. */
     inboxLoop = null;
     inboxLoopEnabled;
+    /** Short-lived grant-provider cache for the declared-needs gate. */
+    grantProviderCache = null;
     constructor(options = {}) {
         const resolved = applyBrainToHostOptions(options);
         this.options = {
@@ -190,6 +193,11 @@ export class AgentHost {
             systemPrompt: resolved.systemPrompt,
             specialization: resolved.specialization ?? null,
             tools: resolved.tools || [],
+            // Copied deliberately: this object is an allow-list, so a field left out
+            // here is silently dropped between the manifest and the runtime. That is
+            // exactly how `respondsToProposals` reached the store as null for 133
+            // agents — the declaration existed and nothing carried it.
+            needs: resolved.needs,
             taskTools: resolved.taskTools,
             states: resolved.states,
             initial: resolved.initial,
@@ -200,6 +208,7 @@ export class AgentHost {
             effectTap: resolved.effectTap,
             transitionTap: resolved.transitionTap,
             metricsTap: resolved.metricsTap,
+            wakeTap: resolved.wakeTap,
             inboxCatchUp: resolved.inboxCatchUp,
             brain: resolved.brain,
             cognition: resolved.cognition ?? 'fsm',
@@ -209,9 +218,9 @@ export class AgentHost {
         this.inboxLoopEnabled = options.inboxCatchUp !== false;
         this.sessionResolver = options.sessionResolver || DEFAULT_SESSION_RESOLVER;
         // A Claude-brain wake legitimately runs long (multi-turn query, prose
-        // deliverables) — 120s watchdogged real spec-writing wakes mid-flight,
-        // which then redelivered and re-ran (ZIG-924 dogfood, 2026-07-26). FSM
-        // turns stay on the tight default.
+        // deliverables). At 120s the watchdog cuts real spec-writing wakes
+        // mid-flight, which then redeliver and re-run. FSM turns stay on the tight
+        // default.
         this.tickTimeoutMs =
             options.tickTimeoutMs ??
                 (isClaudeCognition(options.cognition)
@@ -319,7 +328,7 @@ export class AgentHost {
                 agentId: this.options.agentId,
                 // No taskService/agreementService: Claude-brain tools execute through
                 // eff({ kind: 'tool-call' }) → the shared executor, which sources those
-                // services from the effect handler's deps like the FSM path (ZIG-775).
+                // services from the effect handler's deps like the FSM path.
                 maxTurns: this.options.claudeMaxTurns,
                 statelessPerWake: this.options.claudeStatelessPerWake,
             })
@@ -331,7 +340,7 @@ export class AgentHost {
         this.eventQueue = new EventQueue((event, laneKey) => this._processEvent(event, laneKey));
         // A timer frame is not a delivery: there is no watermark waiting on it and
         // nothing to redeliver, so its failure is logged and dropped here rather
-        // than left as an unhandled rejection (ZIG-1191 made enqueue reject).
+        // than left as an unhandled rejection (made enqueue reject).
         this.stateTimers = new StateTimers((ev, laneKey) => {
             void this.eventQueue.enqueue(ev, laneKey).catch((err) => {
                 runtimeLog.warn('AgentHost', `state-timer frame failed laneKey=${laneKey}: ${err?.message || err}`);
@@ -366,7 +375,7 @@ export class AgentHost {
             event: { type: 'message', timestamp: Date.now(), text: '' },
         };
         let sessionId = this.sessionResolver(fakeNormalized, ownAgentId);
-        // ZIG-1278 — store claims deliver agreement wakes with no chatId. Do not
+        // store claims deliver agreement wakes with no chatId. Do not
         // drop them; lane by agreement the same way task bootstrap does
         // (`agrn-<agreementId>`), never a bare agreement id.
         if (!sessionId) {
@@ -415,7 +424,7 @@ export class AgentHost {
         }
         let enrichedText = typeof text === 'string' ? text : '';
         if (!enrichedText.trim()) {
-            // ZIG-936: agreement rides under `service` on the inbox-pull wire; fall
+            // agreement rides under `service` on the inbox-pull wire; fall
             // back to top-level for hand-built metadata.
             const svc = metadata.service;
             const agreement = (svc?.agreement ?? metadata.agreement);
@@ -441,7 +450,7 @@ export class AgentHost {
         // routes the event onto its lane. No live-path watermark ack — there is no
         // separate live/push channel to reconcile against anymore.
         //
-        // ZIG-1191: a failure un-marks the messageId. The mark above is what stops
+        // a failure un-marks the messageId. The mark above is what stops
         // the same message being processed twice; leaving it set on a failed wake
         // would make the redelivery this rejection buys us a no-op.
         try {
@@ -454,7 +463,7 @@ export class AgentHost {
         }
     }
     /**
-     * ZIG-1144 part 3 — an agreement lane outlives the agreement.
+     * part 3 — an agreement lane outlives the agreement.
      *
      * A lane named `agrn-<agreementId>` keeps its Claude session for the whole
      * engagement, so a trailing event after the deal ends pays for all of it: on
@@ -486,11 +495,11 @@ export class AgentHost {
         }
     }
     /**
-     * ZIG-1153 — the trailing turn on work that is already reported.
+     * the trailing turn on work that is already reported.
      *
      * A lane session carries the whole engagement, so the LAST wake is the most
      * expensive one: on prod, the frame that followed a completed elicitation cost
-     * **158,733 tokens** with the session's input at 366,417 before ZIG-816 reset
+     * **158,733 tokens** with the session's input at 366,417 before reset
      * it, and produced nothing — the spec had been written and the task closed one
      * frame earlier.
      *
@@ -518,6 +527,90 @@ export class AgentHost {
         const reported = result.result;
         return reported !== undefined && reported !== null && reported !== '';
     }
+    /** Providers of this agent's live connection grants. Its own seam, so the gate below is testable without a backend. */
+    async _listGrantProviders(operatorKey, agentId) {
+        const groups = await new ConnectionsClient(operatorKey, agentId).listForHolder();
+        return groups.filter((g) => (g.grants ?? []).length > 0).map((g) => g.provider);
+    }
+    /**
+     * Short TTL on purpose: the gate runs on every wake, and a claim produces
+     * several in seconds — but hire comes before grant, so a grant arriving
+     * mid-engagement has to take effect without a restart.
+     */
+    async _grantProvidersCached(operatorKey, agentId) {
+        const now = Date.now();
+        if (this.grantProviderCache && now - this.grantProviderCache.at < 30_000) {
+            return this.grantProviderCache.providers;
+        }
+        const providers = await this._listGrantProviders(operatorKey, agentId);
+        this.grantProviderCache = { at: now, providers };
+        return providers;
+    }
+    /**
+     * Refuse work this agent has no way to do, before it costs a turn.
+     * Returns true when work was refused and the tick must not run.
+     *
+     * Enforced at wake for an agent holding assigned work, not at hire: hire comes
+     * first and the grant second, so a hire-time gate would refuse every honest
+     * one. Not limited to the task frame either — a store claim wakes the agent on
+     * the agreement first, and a task-only gate let the model take that turn and
+     * reason its own way to "I have no grant" (measured on linear-janitor: 8 calls,
+     * 114,025 tokens, for what one HTTP call answers).
+     *
+     * It fails the task rather than skipping quietly, which would leave it active
+     * with nothing working it — the same invisible stall from the buyer's side.
+     */
+    async _refuseIfNeedsUnmet(_event, _laneKey) {
+        const needs = normalizeNeeds(this.options.needs);
+        if (!needs.length)
+            return false;
+        const operatorKey = this.options.operatorKey;
+        const agentId = this.options.agentId;
+        if (!operatorKey || !agentId || !this.taskService)
+            return false;
+        let providers;
+        try {
+            providers = await this._grantProvidersCached(operatorKey, agentId);
+        }
+        catch (err) {
+            // A grants read that failed is not proof the grant is missing, and failing
+            // the task on our own outage would be worse than letting the agent try.
+            runtimeLog.warn(this.options.name || 'agent', `needs check skipped: ${err?.message ?? err}`);
+            return false;
+        }
+        const unmet = unmetNeeds(needs, providers);
+        if (!unmet.length)
+            return false;
+        // Only work already on this agent's plate is refused. A wake with no assigned
+        // task is someone talking to it — an agent that cannot reach Linear can still
+        // say so in a sentence, and muting it would be a worse silence.
+        let assigned;
+        try {
+            assigned = await this.taskService.getActiveTasksForAgent(agentId);
+        }
+        catch (err) {
+            runtimeLog.warn(this.options.name || 'agent', `needs check could not read assigned work: ${err?.message ?? err}`);
+            return false;
+        }
+        const mine = assigned.filter((t) => t.taskId && (!t.assigneeId || t.assigneeId === agentId));
+        if (!mine.length)
+            return false;
+        const message = unmetNeedsMessage(unmet);
+        for (const task of mine) {
+            const taskId = String(task.taskId);
+            runtimeLog.warn(this.options.name || 'agent', `refusing task ${taskId} — ${message}`);
+            try {
+                await this.taskService.updateState(taskId, 'failed', {
+                    summary: message,
+                    status: 'failed',
+                });
+            }
+            catch (err) {
+                runtimeLog.warn(this.options.name || 'agent', `could not fail task ${taskId} after refusing it: ${err?.message ?? err}`);
+            }
+        }
+        return true;
+    }
     async _processEvent(event, laneKey) {
         const session = this.sessions.get(laneKey);
         if (!session?.sessionId)
@@ -530,6 +623,10 @@ export class AgentHost {
             runtimeLog.info(this.options.name || 'agent', `skipping wake on ${session.sessionId} — its task already reported a result`);
             return;
         }
+        // Before the tick spends anything: work this agent declared it cannot do
+        // without access it does not hold.
+        if (await this._refuseIfNeedsUnmet(event, laneKey))
+            return;
         // Stale timer frames (superseded epoch) are dropped BEFORE touching the
         // live timer — a pure-stale frame must not reset a freshly armed countdown.
         const frame = this.stateTimers.stripStale(event, laneKey);
@@ -557,6 +654,24 @@ export class AgentHost {
             sessionId: session.sessionId,
             laneKey,
         };
+        // Recorded here rather than after the tick: this is the last point where the
+        // input is still exactly what the brain will see, and a wake that goes on to
+        // throw is the one most worth replaying.
+        if (this.options.wakeTap) {
+            try {
+                this.options.wakeTap({
+                    agentId: identity.agentId,
+                    sessionId: identity.sessionId,
+                    laneKey,
+                    event: frame,
+                    ctx: session.ctx,
+                    state: session.state,
+                });
+            }
+            catch (err) {
+                runtimeLog.warn('AgentHost', `wakeTap failed: ${err?.message || err}`);
+            }
+        }
         // The watchdog timer must be cleared once the tick settles — leaving it
         // armed pinned one live 2-minute timer per tick (and kept short-lived
         // processes/tests alive until it fired).
@@ -589,7 +704,7 @@ export class AgentHost {
                 runtimeLog.info('AgentHost', `wake agent=${identity.agentId} lane=${laneKey} llmCalls=${m.llmCalls} ` +
                     `tokens_in=${m.tokens.input} tokens_out=${m.tokens.output} total=${m.tokens.total}`);
             }
-            // Single source of truth for usage/cost (ZIG-813): emit the tick's
+            // Single source of truth for usage/cost: emit the tick's
             // authoritative token metrics once, for every cognition. Never let an
             // observability failure break the tick.
             if (this.options.metricsTap && result.metrics) {
@@ -624,7 +739,7 @@ export class AgentHost {
             // again unless a real event happens to arrive.
             this._armIfTimedParked(laneKey, session.state ?? this.agent.workflow.initial);
             // Best-effort: also notify the user so the conversation isn't silently
-            // stuck (ZIG-607). Complements the timer re-arm above — that recovers a
+            // stuck. Complements the timer re-arm above — that recovers a
             // parked lane; this tells a waiting human.
             const ev = event;
             const senderType = String(ev?.senderType ?? '').toUpperCase();
@@ -632,7 +747,7 @@ export class AgentHost {
             if (senderId && senderType === 'USER') {
                 this.eff({ kind: 'send-message', sessionId: session.sessionId, receiverId: senderId, text: 'Something went wrong. Please try again.' }).catch(() => { });
             }
-            // ZIG-1191: and then say so. Everything above is recovery for the lane —
+            // and then say so. Everything above is recovery for the lane —
             // it does not mean the event was handled, and the caller is about to
             // decide whether the delivery that carried it can be acked. Swallowing
             // here is what turned a failed wake into a lost one: two hand-off publish
@@ -644,6 +759,71 @@ export class AgentHost {
             clearTimeout(tickWatchdog);
         }
     }
+    /**
+     * Re-run one recorded wake against THIS host's agent, and nothing else.
+     *
+     * The dev loop for a prompt: record a wake off a live run, edit the agent, and
+     * see what it does differently in seconds instead of standing a world back up
+     * for one turn. The brain, tools and effect handler are the real ones, so the
+     * turn is real — its tool calls hit the backend this host is pointed at, which
+     * is why it belongs against a disposable world and not a shared one.
+     *
+     * Deliberately NOT routed through `_processEvent`: everything that method does
+     * around the tick is lane bookkeeping — session state, liveness timers, session
+     * persistence, ack decisions, failure re-arm — and a replay has no lane to keep.
+     * Borrowing that path would make a dev tool able to disturb a live one.
+     */
+    async replayWake(record) {
+        if (!record?.sessionId)
+            throw new Error('replayWake: record.sessionId is required');
+        const identity = {
+            agentId: record.agentId || this.options.agentId,
+            sessionId: record.sessionId,
+            laneKey: record.laneKey || record.sessionId,
+        };
+        // Same watchdog as a live wake, for the same reason: an unaborted Claude
+        // query outlives the promise that abandoned it and keeps spending.
+        const abort = new AbortController();
+        let watchdog;
+        try {
+            const result = await Promise.race([
+                this.agent.tick({
+                    event: record.event,
+                    ctx: record.ctx,
+                    state: record.state,
+                    identity,
+                    eff: this.eff,
+                    memory: this.memory,
+                    transitionTap: this.options.transitionTap,
+                    signal: abort.signal,
+                }),
+                new Promise((_, reject) => {
+                    watchdog = setTimeout(() => {
+                        abort.abort(new Error('tick timeout'));
+                        reject(new Error('tick timeout'));
+                    }, this.tickTimeoutMs);
+                }),
+            ]);
+            if (this.options.metricsTap && result.metrics) {
+                try {
+                    this.options.metricsTap({
+                        agentId: identity.agentId,
+                        sessionId: identity.sessionId,
+                        model: this.options.model ?? 'unknown',
+                        cognition: this.options.cognition ?? 'fsm',
+                        metrics: result.metrics,
+                    });
+                }
+                catch (err) {
+                    runtimeLog.warn('AgentHost', `metricsTap failed: ${err?.message || err}`);
+                }
+            }
+            return result;
+        }
+        finally {
+            clearTimeout(watchdog);
+        }
+    }
     /** Arms the lane's liveness timer iff stateName is a parked state declaring timeoutMs. */
     _armIfTimedParked(laneKey, stateName) {
         if (!stateName)
@@ -682,7 +862,7 @@ export class AgentHost {
                 onResourceEvent: (event) => {
                     return this.handleResourceEvent(event);
                 },
-                // ZIG-973: work delivered by the inbox's task channel, not by a chat
+                // work delivered by the inbox's task channel, not by a chat
                 // row — this is what reaches a task under a chat-less agreement or one
                 // the agent assigned to itself.
                 onTask: async (task) => {
@@ -693,7 +873,7 @@ export class AgentHost {
                         runtimeLog.warn(this.options.name || 'agent', `inbox task ${task.taskId} could not be woken: ${err.message}`);
                     }
                 },
-                // ZIG-1185: exact-match triage in code — miss acks with 0 tokens.
+                // exact-match triage in code — miss acks with 0 tokens.
                 onQuest: async (quest) => {
                     await this.triageQuestDelivery(quest);
                 },
@@ -702,7 +882,7 @@ export class AgentHost {
         return this;
     }
     /**
-     * ZIG-1185 — plain string compare against {@link AgentHostOptions.questMatchTags}
+     * plain string compare against {@link AgentHostOptions.questMatchTags}
      * and `specialization`. No match → return (caller acks). Match → normal wake.
      */
     async triageQuestDelivery(quest) {
@@ -768,7 +948,7 @@ export class AgentHost {
             }, laneKey);
         }
     }
-    /** ZIG-802: replay task-assigned for an existing active task (demo recovery). */
+    /** replay task-assigned for an existing active task (demo recovery). */
     async wakeTaskAssignment(taskId) {
         const agentId = this.options.agentId;
         if (!agentId || !this.taskService) {

package/dist/adapters/AnthropicAdapter.js

@@ -94,7 +94,7 @@ export class AnthropicAdapter {
         const final = await stream.finalMessage();
         const u = final.usage;
         // Fold cache read/creation into prompt tokens so the streamed reply is not
-        // undercounted (cache traffic was the bulk of the ZIG-759 drain).
+        // undercounted (cache traffic was the bulk of the drain).
         const usage = u
             ? {
                 prompt_tokens: (u.input_tokens ?? 0) + (u.cache_read_input_tokens ?? 0) + (u.cache_creation_input_tokens ?? 0),

package/dist/adapters/McpAdapter.d.ts

@@ -38,7 +38,7 @@ export type McpTransportConfig = {
     agentId?: string;
 } | {
     /**
-     * Per-user brokered connection (ZIG-771): the agent holds NO
+     * Per-user brokered connection: the agent holds NO
      * connectionId/grantId. It speaks StreamableHTTP to
      * `/connections/mcp/relay` and asserts the invoking end-user via
      * `x-on-behalf-of-user`; the gateway resolves that user's own connection
@@ -57,13 +57,13 @@ export type McpTransportConfig = {
      * The MCP server URL this agent fronts. Not used for gateway calls (the
      * gateway derives the server from the resolved connection), but needed to
      * open a connection request when the invoking user hasn't connected yet
-     * (ZIG-771). Without it, a NO_USER_CONNECTION surfaces as an error rather
+     *. Without it, a NO_USER_CONNECTION surfaces as an error rather
      * than an auto-created consent prompt.
      */
     serverUrl?: string;
 };
 /**
- * Typed failure from the Ziggs MCP gateway (ZIG-702). `code` is the stable
+ * Typed failure from the Ziggs MCP gateway. `code` is the stable
  * machine-readable reason — e.g. `GRANT_REVOKED`, `GRANT_EXPIRED`,
  * `GRANT_HOLDER_MISMATCH`, `GRANT_CONNECTION_MISMATCH` — so agent code can
  * branch ("revoked → tell the user and stop retrying" vs "network blip →
@@ -89,7 +89,7 @@ export declare function resolveZiggsGatewayTarget(config: Extract<McpTransportCo
     headers: Record<string, string>;
 };
 /**
- * Resolve the per-user gateway URL + headers (ZIG-771). No connectionId/grantId —
+ * Resolve the per-user gateway URL + headers. No connectionId/grantId —
  * the gateway resolves the invoking user's own connection + grant from
  * `x-on-behalf-of-user` + the impersonated agent.
  */
@@ -109,9 +109,9 @@ export interface CreateMcpAgentOptions extends Omit<AgentHostOptions, 'tools' |
     /**
      * Max tools to bind to the LLM per turn. LLM providers cap the `tools` array
      * (OpenAI: 128); an MCP server exposing more (e.g. PostHog: 146) makes every
-     * turn fail with `400 ... array too long`. When the server's tool count
+     * turn fail with `400 .. array too long`. When the server's tool count
      * exceeds this budget the list is truncated (and logged). Defaults to 128.
-     * See ZIG-759; Phase 2 will replace truncation with query-aware selection.
+     * See; Phase 2 will replace truncation with query-aware selection.
      */
     maxTools?: number;
     /**
@@ -120,12 +120,12 @@ export interface CreateMcpAgentOptions extends Omit<AgentHostOptions, 'tools' |
      * MCP server (e.g. PostHog's 146 tools) be narrowed to the handful this agent
      * actually needs — cutting per-turn cost and stopping the model from thrashing
      * across (or never binding) the tool it should call. Empty/undefined = bind
-     * all (unchanged behavior). ZIG-759 Phase 2 = name-based selection.
+     * all (unchanged behavior). Phase 2 = name-based selection.
      */
     allowedTools?: string[];
     /**
      * Pre-discovered MCP tool schemas. REQUIRED for `type: 'ziggs-per-user'`
-     * (ZIG-771) — there is no boot connection to call `tools/list` on, so the
+     * — there is no boot connection to call `tools/list` on, so the
      * schema is baked at provision time and passed here. Ignored for the other
      * transports, which discover tools live at boot.
      */
@@ -138,7 +138,7 @@ export interface CreateMcpAgentOptions extends Omit<AgentHostOptions, 'tools' |
 /**
  * How many MCP tools may be bound to the LLM, given the provider cap and the
  * number of extra (non-MCP) tools the agent also carries. Always >= 1 so a
- * pathological config still binds something rather than nothing. ZIG-759.
+ * pathological config still binds something rather than nothing.
  */
 export declare function mcpToolBudget(maxTools: number, extraToolCount: number): number;
 export interface McpAgentHandle {
@@ -158,7 +158,7 @@ export declare function buildTransport(config: McpTransportConfig, defaults?: {
  * that full block rides every turn. Keep the lead — what the tool does + how to
  * call it — and drop the embedded reference; agents fetch detail via dedicated
  * schema/help tools at call time. Tunable; big enough to preserve real guidance.
- * ZIG-759.
+ *.
  */
 export declare const MAX_TOOL_DESC_CHARS = 2000;
 /** Truncate one description at a sentence/newline boundary near the cap. */