@ziggs-ai/agent-sdk 0.36.0 → 0.38.0

package/CHANGELOG.md

@@ -12,6 +12,14 @@
 
 ## Unreleased
 
+### Changed (breaking)
+
+- The SDK log level follows `configureApiClient({ logLevel })`. `DEBUG_AGENTPLUS` / `LOG_LEVEL` still apply when the process runs `env-init`, which is what copies them into that config. Setting only the environment, without `configureApiClient`, no longer changes SDK logs.
+- `decodeOperatorKeyClaims` is api-client's decoder. A non-string `boundAgentId` is ignored, and `issuedVia` is kept.
+- The fleet model is `resolveFleetModel`: a per-agent pin, then `LLM_MODEL`, then Sonnet 5.5 (`DEFAULT_MODEL`).
+- Hosted Claude agents load Ziggs tools on demand. Everyday and own tools load up front; every other platform tool is offered by its own name and loaded by the Agent SDK's tool search when the model looks for it. The `tools` / `tool_read` / `tool_write` catalog is gone from the hosted brain.
+- `isHostedCatalogOnly` is now `isHostedDeferred`; `hostedModelTools(all)` takes no executor and returns every tool; `HostedToolExecute` is removed.
+
 ### Fixed
 
 - Hosted Claude agents can discover and invoke the access explanation tool named by their recovery instructions.

package/dist/Agent.d.ts

@@ -4,6 +4,7 @@ import type { AgentConfig, Ctx, Workflow } from './types.js';
 import { ZiggsBrain, type TickOutput } from './brain/ZiggsBrain.js';
 import { ClaudeBrain, type CognitionKind } from './brain/ClaudeBrain.js';
 import { type BrainSelection } from './brain/index.js';
+export { DEFAULT_MODEL, resolveFleetModel } from './shared/fleetModel.js';
 export type { CognitionKind };
 import { type WaitForIdleResult } from './platform/EventQueue.js';
 import { type NormalizedEvent } from './ingress/normalizeIncoming.js';
@@ -29,14 +30,6 @@ import { ToolManager } from './tools/ToolManager.js';
 import { type ToolDefinition } from './tools/defineTool.js';
 import { OpenAIAdapter } from './adapters/OpenAIAdapter.js';
 import { type AgentNeed } from './tools/needs.js';
-/**
- * The single fleet-wide default model — the one place the fallback lives.
- * Change this (or set `LLM_MODEL`) to move the whole fleet; nothing hardcodes a
- * model anywhere else. The id also picks the provider: a `claude-*` value routes
- * to AnthropicAdapter (+ ANTHROPIC_API_KEY), anything else to OpenAIAdapter — see
- * the `model?.startsWith('claude')` branch in createBackendServices below.
- */
-export declare const DEFAULT_MODEL = "claude-haiku-4-5";
 /**
  * Given a normalized event, return the sessionId for this agent. Return
  * `null` to skip processing. Lets each Agent define what "session" means —
@@ -251,7 +244,6 @@ export declare class Agent {
     private taskService;
     private agreementService;
     private telemetryClient?;
-    private messageSender;
     private seenMessages;
     private stateTimers;
     /** The per-agent inbox long-poll loop — this agent's sole wake source. */

package/dist/Agent.js

@@ -11,9 +11,10 @@ import { backendWakeGate } from './brain/wakeGate.js';
 import { applyBrainToAgentOptions, isClaudeCognition, } from './brain/index.js';
 import { CLAUDE_SDK_TOOLS } from './brain/claudeSdkTools.js';
 import { resolveClaudeModel } from './brain/claudeCognition.js';
+import { resolveFleetModel } from './shared/fleetModel.js';
+export { DEFAULT_MODEL, resolveFleetModel } from './shared/fleetModel.js';
 import { CHAT_TOOLS } from './platform/tools/tier2/chatTools.js';
 import { contextReadTool, openTool, accessExplainTool } from './platform/tools/tier2/contextTools.js';
-import { hostedModelTools } from './brain/hostedToolSurface.js';
 import { EventQueue } from './platform/EventQueue.js';
 import { StateTimers } from './platform/StateTimers.js';
 import { laneKeyFor } from './platform/laneKey.js';
@@ -40,14 +41,6 @@ import { runtimeLog } from './shared/runtimeLog.js';
 import { isTelemetryIngestEnabled, sendTelemetry, } from './platform/telemetryIngest.js';
 import { buildWakeOutcomePayload, classifyWakeOutcome, wakeWasAsked, } from './runtime/wakeOutcome.js';
 import { agreementIdFromWake, formedByFromWake, isHireActivationNotice, shouldSkipAgentFormedHireActivation, } from './brain/hireActivationNotice.js';
-/**
- * The single fleet-wide default model — the one place the fallback lives.
- * Change this (or set `LLM_MODEL`) to move the whole fleet; nothing hardcodes a
- * model anywhere else. The id also picks the provider: a `claude-*` value routes
- * to AnthropicAdapter (+ ANTHROPIC_API_KEY), anything else to OpenAIAdapter — see
- * the `model?.startsWith('claude')` branch in createBackendServices below.
- */
-export const DEFAULT_MODEL = 'claude-haiku-4-5';
 // ConnectionPool lives in a separate module; resolved via a computed-path
 // dynamic import to avoid a circular import with Agent.
 async function loadConnectionPool() {
@@ -95,8 +88,8 @@ function createToolManager(options) {
     // 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.
-    // wake_at stays registered for the FSM and for the hosted catalog. The Claude
-    // model reaches it through tool_write; an agent that can be handed a task
+    // wake_at stays registered for the FSM and for the hosted model, where it is
+    // deferred behind tool search; an agent that can be handed a task
     // with a check-back rule but cannot arm a wake would have to busy-wait, and
     // there is nothing to busy-wait with.
     // open / context_read are the hosted twins of the MCP everyday set.
@@ -110,18 +103,6 @@ function createToolManager(options) {
     const platformTools = [...taskTools, ...CHAT_TOOLS, ...browseTools, ...claudeSdkTools, ...everydayContext, ...WAKE_TOOLS];
     warnOnShadowedPlatformTools(platformTools, ownTools, options.agentId);
     toolManager.registerAll([...platformTools, ...ownTools]);
-    // The Claude bridge executes every mounted name through the tool manager,
-    // including the catalog. Register those three here or a wake that calls
-    // `tools` dies with "Tool not found" before the dispatcher runs.
-    if (isClaudeCognition(options.cognition)) {
-        const catalog = hostedModelTools([...platformTools, ...ownTools], (name, args, ctx) => toolManager.executeTool(name, args, ctx));
-        for (const tool of catalog) {
-            const name = toolName(tool);
-            if ((name === 'tools' || name === 'tool_read' || name === 'tool_write') && !toolManager.getTool(name)) {
-                toolManager.register(tool);
-            }
-        }
-    }
     return toolManager;
 }
 /**
@@ -214,7 +195,6 @@ export class Agent {
     taskService;
     agreementService;
     telemetryClient;
-    messageSender;
     seenMessages = new SeenMessages();
     stateTimers;
     /** The per-agent inbox long-poll loop — this agent's sole wake source. */
@@ -240,7 +220,8 @@ export class Agent {
         this.options = {
             openaiKey: resolved.openaiKey || process.env.OPENAI_API_KEY,
             anthropicKey: resolved.anthropicKey || process.env.ANTHROPIC_API_KEY,
-            model: resolved.model || (!isLlmAdapter(resolved.services?.llm) ? resolved.services?.llm?.model : undefined) || DEFAULT_MODEL,
+            model: resolveFleetModel(resolved.model ||
+                (!isLlmAdapter(resolved.services?.llm) ? resolved.services?.llm?.model : undefined)),
             operatorKey: resolved.operatorKey || process.env.ZIGGS_OPERATOR_KEY || undefined,
             agentId: resolved.agentId || '',
             name: resolved.name || null,
@@ -360,7 +341,6 @@ export class Agent {
         this.taskService = services.taskService;
         this.agreementService = services.agreementService;
         this.telemetryClient = services.telemetryClient;
-        this.messageSender = messageSender;
         let workflow = this.options.workflow;
         if (!workflow && this.options.states) {
             workflow = {
@@ -1162,13 +1142,6 @@ export class Agent {
             const args = effect.args;
             if (typeof args.taskId === 'string')
                 return args.taskId;
-            const nested = args.args;
-            if ((effect.name === 'tool_read' || effect.name === 'tool_write')
-                && nested && typeof nested === 'object' && !Array.isArray(nested)) {
-                const inner = nested.taskId;
-                if (typeof inner === 'string')
-                    return inner;
-            }
             return undefined;
         };
         const eff = async (effect) => {

package/dist/brain/ClaudeBrain.js

@@ -7,7 +7,7 @@ import { bootstrapCtx } from '../runtime/bootstrapCtx.js';
 import { createDeliveryWriteKeys } from '../runtime/deliveryWriteKeys.js';
 import { CLAUDE_SDK_PROTOCOL } from './claudeSdkProtocol.js';
 import { hireIdsFromEvent, memorySectionForWake } from '../memory/MemoryStore.js';
-import { hostedModelTools } from './hostedToolSurface.js';
+import { hostedModelTools, isHostedDeferred } from './hostedToolSurface.js';
 import { buildZiggsSdkMcpServer } from './toolManagerToSdkMcp.js';
 import { claudeQueryOptions, buildClaudeEventPrompt, summarizeContext, extractAssistantText, } from './claudeCognition.js';
 import { assertHostedAgentZiggsTools } from './hostedAgentConnection.js';
@@ -418,7 +418,7 @@ export class ClaudeBrain {
         let sdkMcpServer = this.sdkMcpByLane.get(lane);
         if (!sdkMcpServer) {
             const availableTools = await this.toolManager.getAvailableTools();
-            const mounted = hostedModelTools(availableTools, (name, args, ctx) => this.toolManager.executeTool(name, args, ctx));
+            const mounted = hostedModelTools(availableTools);
             sdkMcpServer = buildZiggsSdkMcpServer(mounted, () => {
                 const ctx = this.toolContextByLane.get(lane);
                 if (!ctx) {
@@ -427,7 +427,8 @@ export class ClaudeBrain {
                 return ctx;
             }, {
                 name: 'ziggs',
-                instructions: 'In-process Ziggs tools. Everyday tools and your own tools are loaded by name. tools lists the rest; tool_read and tool_write call them. agreement_revoke is called by name only.',
+                instructions: 'In-process Ziggs tools. Everyday tools and your own tools are loaded; every other Ziggs tool loads when you search for it.',
+                alwaysLoad: (name) => !isHostedDeferred(name),
             });
             this.sdkMcpByLane.set(lane, sdkMcpServer);
         }

package/dist/brain/claudeCognition.d.ts

@@ -44,7 +44,7 @@ export interface ClaudeQueryOptionsParams {
  * Pick the Claude model for a Claude-brain wake. The brain must run a `claude-*`
  * model, but the host's default model is provider-agnostic (an OpenAI id today),
  * so this prefers an explicit `claude-*` id (direct or via `services.llm`) and
- * otherwise falls back to a safe Claude default — never an OpenAI id.
+ * otherwise falls back to {@link DEFAULT_MODEL} — never an OpenAI id.
  */
 export declare function resolveClaudeModel(preferred?: string, servicesModel?: string): string;
 /**

package/dist/brain/claudeCognition.js

@@ -14,19 +14,19 @@
 import { SYSTEM_PROMPT_DYNAMIC_BOUNDARY, } from '@anthropic-ai/claude-agent-sdk';
 import { decisionWords } from '@ziggs-ai/api-client';
 import { getBatchEvents } from '../context/batch.js';
-const DEFAULT_CLAUDE_MODEL = 'claude-sonnet-5-5';
+import { DEFAULT_MODEL } from '../shared/fleetModel.js';
 /**
  * Pick the Claude model for a Claude-brain wake. The brain must run a `claude-*`
  * model, but the host's default model is provider-agnostic (an OpenAI id today),
  * so this prefers an explicit `claude-*` id (direct or via `services.llm`) and
- * otherwise falls back to a safe Claude default — never an OpenAI id.
+ * otherwise falls back to {@link DEFAULT_MODEL} — never an OpenAI id.
  */
 export function resolveClaudeModel(preferred, servicesModel) {
     if (preferred?.startsWith('claude'))
         return preferred;
     if (servicesModel?.startsWith('claude'))
         return servicesModel;
-    return DEFAULT_CLAUDE_MODEL;
+    return DEFAULT_MODEL;
 }
 /**
  * Build the `query()` options for a Claude-brain wake. The lockdown fields are
@@ -58,7 +58,10 @@ export function claudeQueryOptions(params) {
         mcpServers: params.mcpServers,
         // The agent's ONLY capabilities are its MCP tools — no built-in file/bash/web
         // tools, no project/user/plugin MCP config, no local settings / CLAUDE.md.
-        tools: [],
+        // ToolSearch is the one built-in: it loads a deferred Ziggs tool's schema
+        // when the model looks for it. Without it the SDK ignores deferral and
+        // sends every schema on every wake.
+        tools: ['ToolSearch'],
         strictMcpConfig: true,
         settingSources: [],
         permissionMode: 'bypassPermissions',

package/dist/brain/claudeSdkProtocol.js

@@ -16,7 +16,7 @@ export const CLAUDE_SDK_PROTOCOL = `You are an autonomous agent on a Ziggs team,
 
 Each wake hands you ONE event (or a small batch). Read workBrief for current work and audience. Resource open/access_explain returns the same scoped actions: use tool, args and required inputs; recovery names a suggested next call. Available is checked at read time, needs_decision names missing authority, unavailable names a known blocker, and not_evaluated requires further inputs or execution checks. It is backend-resolved context, not a permission token. Use normal tools for actions marked not_evaluated; that state alone does not require human approval. Never infer authority from role names or combine customers’ permissions. actingFor.state ambiguous means several customers are present and only your own account authority applies; relationship.side is the agreement side you hold and authorizes nothing by itself. A chat_send refused with WORK_SELECTION_REQUIRED lists the eligible agreements in choices: set conversationAgreementId to one of them and send again; never guess which one. Handle the event, then stop.
 
-Ziggs tools loaded with their full schemas are ${loadedByName}, plus any tools that belong to you specifically. Every other Ziggs tool is one call away: \`tools\` lists each one (name and one line); pass \`describe\` to \`tools\` for the schema before you call a tool you have not used. A read goes through \`tool_read\` { tool, args }; a change goes through \`tool_write\` { tool, args }. \`agreement_revoke\` is irreversible, so call it by its own name — the dispatchers refuse it. When the lines below name \`context_snapshot\`, \`wake_at\`, \`task_list\`, \`task_update_plan_step\`, \`grant_list\`, or an agreement verb, that is how you reach it.
+Ziggs tools loaded with their full schemas are ${loadedByName}, plus any tools that belong to you specifically. Every other Ziggs tool exists too and is called by its own name; its schema loads when you look it up with ToolSearch, by name or by what you need done. When the lines below name \`context_snapshot\`, \`wake_at\`, \`task_list\`, \`task_update_plan_step\`, \`grant_list\`, or an agreement verb, look it up that way and call it.
 
 Your prose and final summary are private host notes, not messages to the people or agents you work with. To answer an incoming question, including a simple status question, call \`chat_send\` in the requesting conversation. Reading the answer and writing it in your final summary does not deliver it. Do not finish a question wake until the reply tool confirms delivery, or you have surfaced a concrete blocker through the appropriate channel.
 

package/dist/brain/hostedToolSurface.d.ts

@@ -1,14 +1,15 @@
 import { type ToolDefinition } from '../tools/defineTool.js';
-export type HostedToolExecute = (name: string, args: Record<string, unknown>, context: Record<string, unknown>) => Promise<unknown>;
 type Lane = 'read-only' | 'write' | 'destructive';
 export declare function hostedToolLane(name: string): Lane;
-/** A Ziggs platform tool the model reaches through the catalog, not by schema. */
-export declare function isHostedCatalogOnly(name: string): boolean;
 /**
- * The tool block the hosted model is shown.
- *
- * `execute` runs a catalog call through the ToolManager. Omit it when only
- * the schemas are being priced — the dispatchers then refuse to run.
+ * A Ziggs platform tool whose schema loads when the model searches for it,
+ * rather than on every wake. Everyday tools and the agent's own tools are
+ * never deferred.
  */
-export declare function hostedModelTools(all: ToolDefinition[], execute?: HostedToolExecute): ToolDefinition[];
+export declare function isHostedDeferred(name: string): boolean;
+/**
+ * The tools the hosted model is offered: every registered tool, each by its
+ * own name and schema. Which of them load up front is `isHostedDeferred`.
+ */
+export declare function hostedModelTools(all: ToolDefinition[]): ToolDefinition[];
 export {};

package/dist/brain/hostedToolSurface.js

@@ -1,20 +1,18 @@
 /**
  * What the hosted Claude brain mounts into the model.
  *
- * The MCP door already lists only the everyday set plus a catalog. This is
- * that same cut for the in-process brain: everyday SDK tools stay loaded by
- * name, agent-owned tools stay loaded by name, and every other Ziggs platform
- * tool is named by `tools` and called through `tool_read` or `tool_write`.
- * The tools stay registered on the ToolManager — the FSM brain and the
- * dispatcher both call them — they just stop riding every wake as schemas.
+ * Every tool the agent has is mounted with its own schema. Everyday SDK tools
+ * and the agent's own tools load on every wake; every other Ziggs platform
+ * tool is deferred, and the Agent SDK's tool search loads its schema when the
+ * model looks for it. The model sees each tool by its own name and calls it
+ * directly — there is no catalog to read and no dispatcher in between, so the
+ * host's per-tool permission and the trace name the real tool.
  */
-import { EVERYDAY_SDK_TOOLS, annotationForSdkTool, backendToolPick } from '@ziggs-ai/api-client';
-import { credsFromToolContext } from '../tools/toolCreds.js';
-import { defineTool, toolName } from '../tools/defineTool.js';
+import { EVERYDAY_SDK_TOOLS, annotationForSdkTool } from '@ziggs-ai/api-client';
+import { toolName } from '../tools/defineTool.js';
 /**
- * Platform tools written by hand, not as a shared capability. Their lane is
- * what the dispatcher uses; a name here is also a platform name, so it leaves
- * the model block unless it is in the everyday set.
+ * Platform tools written by hand, not as a shared capability. A name here is
+ * a platform name, so it is deferred unless it is in the everyday set.
  */
 const HAND_LANE = {
     context_snapshot: 'read-only',
@@ -38,8 +36,6 @@ const HAND_LANE = {
     connection_list_grants: 'read-only',
 };
 const EVERYDAY = new Set(EVERYDAY_SDK_TOOLS);
-const CATALOG_NAMES = ['tools', 'tool_read', 'tool_write'];
-const CATALOG = new Set(CATALOG_NAMES);
 export function hostedToolLane(name) {
     const hand = HAND_LANE[name];
     if (hand)
@@ -52,166 +48,27 @@ export function hostedToolLane(name) {
 function isPlatform(name) {
     return name in HAND_LANE || annotationForSdkTool(name) !== undefined;
 }
-/** A Ziggs platform tool the model reaches through the catalog, not by schema. */
-export function isHostedCatalogOnly(name) {
-    return isPlatform(name) && !EVERYDAY.has(name);
-}
-function oneLine(description, name) {
-    const text = String(description ?? name).replace(/\s+/g, ' ').trim();
-    const sentence = text.split(/(?<=\.)\s/)[0] ?? text;
-    return sentence.length > 180 ? `${sentence.slice(0, 177)}...` : sentence;
-}
-function callLine(name, lane, native) {
-    const dispatcher = lane === 'read-only' ? 'tool_read' : 'tool_write';
-    if (native) {
-        return `call it by name: ${name}; ${dispatcher} { tool: "${name}", args } also works`;
-    }
-    return `call via ${dispatcher} { tool, args }`;
-}
-function rowFor(tool) {
-    const name = toolName(tool) ?? '';
-    const lane = hostedToolLane(name);
-    const native = !isHostedCatalogOnly(name);
-    return {
-        name,
-        line: oneLine(tool.schema.function['description'], name),
-        readOnly: lane === 'read-only',
-        native,
-        call: callLine(name, lane, native),
-    };
-}
-function refuseWrongLane(name, lane, via) {
-    const readOnly = lane === 'read-only';
-    const askedRead = via === 'tool_read';
-    if (readOnly === askedRead)
-        return;
-    throw new Error(readOnly
-        ? `${name} is read-only: call it with tool_read { tool, args }, not tool_write.`
-        : `${name} changes state: call it with tool_write { tool, args }, not tool_read.`);
-}
 /**
- * The Claude bridge does not call a tool's handler. It emits `tool-call`, and
- * the effect handler looks the name up on the ToolManager. A catalog call has
- * to go back through that same effect so the target still gets the timeline,
- * the write keys, and the wake scope. A direct executor is only for a caller
- * that has no effect handler (a schema probe, a unit test).
+ * A Ziggs platform tool whose schema loads when the model searches for it,
+ * rather than on every wake. Everyday tools and the agent's own tools are
+ * never deferred.
  */
-async function callCatalogTarget(name, payload, ctx, execute) {
-    const eff = ctx.eff;
-    const sessionId = typeof ctx.chatId === 'string' ? ctx.chatId
-        : typeof ctx.sessionId === 'string' ? ctx.sessionId
-            : undefined;
-    if (typeof eff === 'function' && sessionId) {
-        const result = await eff({
-            kind: 'tool-call',
-            sessionId,
-            name,
-            args: payload,
-            senderId: typeof ctx.senderId === 'string' ? ctx.senderId : undefined,
-            senderType: typeof ctx.senderType === 'string' ? ctx.senderType : undefined,
-            onBehalfOfAgreementId: typeof ctx.onBehalfOfAgreementId === 'string' ? ctx.onBehalfOfAgreementId : undefined,
-            serviceAgreementId: typeof ctx.serviceAgreementId === 'string' ? ctx.serviceAgreementId : undefined,
-            runId: typeof ctx.runId === 'string' ? ctx.runId : undefined,
-            writeKeys: ctx.writeKeys,
-            memory: ctx.memory,
-        });
-        const settled = result;
-        if (settled && settled.ok === false)
-            throw new Error(settled.error ?? `${name} failed`);
-        if (settled && 'ok' in settled)
-            return settled.result;
-        return result;
-    }
-    if (!execute)
-        throw new Error('hosted catalog has no executor');
-    return execute(name, payload, ctx);
-}
-function catalogTools(present, execute) {
-    const list = () => [...present.values()].map(rowFor).sort((a, b) => a.name.localeCompare(b.name));
-    const toolsTool = defineTool('tools', {
-        need: { type: 'string', description: 'Describe what you need to do. Suggests a tool and its schema; falls back to the catalog when unsure.' },
-        search: {
-            type: 'string',
-            description: 'Filter by name or the one-line description. Omit to list every tool.',
-        },
-        describe: {
-            type: 'array',
-            items: { type: 'string' },
-            description: 'Tool names whose full schema you want before calling them.',
-        },
-    }, async (args, ctx) => {
-        const describe = Array.isArray(args.describe) ? args.describe.map(String) : [];
-        if (describe.length > 0) {
-            return describe.map((name) => {
-                const tool = present.get(name);
-                if (!tool) {
-                    return { name, error: `No such tool: ${name}. Call tools for the full list of names.` };
-                }
-                return { ...rowFor(tool), schema: tool.schema.function };
-            });
-        }
-        const need = typeof args.need === 'string' ? args.need.trim() : '';
-        if (need) {
-            const rows = list();
-            try {
-                const pick = await backendToolPick(credsFromToolContext(ctx, 'tools'))(need, rows.map(({ name, line }) => ({ name, line })));
-                const tool = pick?.how === 'pick' && pick.tool ? present.get(pick.tool) : undefined;
-                if (tool)
-                    return { suggestion: { ...rowFor(tool), schema: tool.schema.function }, confidence: pick?.confidence };
-            }
-            catch { /* Missing credentials or picker failure still leaves every tool available. */ }
-            return { tools: rows, note: 'No confident suggestion. Choose from the catalog; no action was taken.' };
-        }
-        const q = typeof args.search === 'string' ? args.search.toLowerCase() : '';
-        return list().filter((row) => !q || row.name.includes(q) || row.line.toLowerCase().includes(q));
-    }, {
-        description: 'Every Ziggs tool that exists: name plus one line. A handful are already loaded by name; the rest are called through tool_read or tool_write. Pass need for a plain-language tool suggestion with its schema, or describe with exact names. Suggestions never execute tools. Nothing is hidden.',
-    });
-    const dispatch = (via) => async (args, ctx) => {
-        const name = typeof args.tool === 'string' ? args.tool : '';
-        if (!name || !present.has(name)) {
-            throw new Error(`No such tool: ${name || '(missing)'}. Call tools for the full list of names.`);
-        }
-        refuseWrongLane(name, hostedToolLane(name), via);
-        const payload = args.args && typeof args.args === 'object' && !Array.isArray(args.args)
-            ? args.args
-            : {};
-        return callCatalogTarget(name, payload, ctx, execute);
-    };
-    const toolRead = defineTool('tool_read', {
-        tool: { type: 'string', required: true, description: 'Read-only tool name from tools.' },
-        args: { type: 'object', description: 'Arguments for that tool, as its schema defines them.' },
-    }, dispatch('tool_read'), {
-        description: 'Call a read-only Ziggs tool by name. A tool that writes is refused here and pointed at tool_write. Look it up with tools describe=[name] first when you do not already know its parameters. The result is exactly what the tool itself returns.',
-    });
-    const toolWrite = defineTool('tool_write', {
-        tool: { type: 'string', required: true, description: 'Writing tool name from tools.' },
-        args: { type: 'object', description: 'Arguments for that tool, as its schema defines them.' },
-    }, dispatch('tool_write'), {
-        description: 'Call a Ziggs tool that creates or changes something, by name. Read-only tools are refused here and pointed at tool_read. Irreversible tools (agreement_revoke) are called by their own name only — this dispatcher refuses them. Look the tool up with tools describe=[name] first when you do not already know its parameters.',
-    });
-    return [toolsTool, toolRead, toolWrite];
+export function isHostedDeferred(name) {
+    return isPlatform(name) && !EVERYDAY.has(name);
 }
 /**
- * The tool block the hosted model is shown.
- *
- * `execute` runs a catalog call through the ToolManager. Omit it when only
- * the schemas are being priced — the dispatchers then refuse to run.
+ * The tools the hosted model is offered: every registered tool, each by its
+ * own name and schema. Which of them load up front is `isHostedDeferred`.
  */
-export function hostedModelTools(all, execute) {
-    const present = new Map();
+export function hostedModelTools(all) {
+    const seen = new Set();
+    const out = [];
     for (const tool of all) {
         const name = toolName(tool);
-        if (!name || CATALOG.has(name))
-            continue;
-        present.set(name, tool);
-    }
-    const visible = [];
-    for (const [name, tool] of present) {
-        if (isHostedCatalogOnly(name))
+        if (!name || seen.has(name))
             continue;
-        visible.push(tool);
+        seen.add(name);
+        out.push(tool);
     }
-    visible.push(...catalogTools(present, execute));
-    return visible;
+    return out;
 }

package/dist/brain/toolManagerToSdkMcp.d.ts

@@ -5,8 +5,12 @@ import type { ClaudeSdkToolContext } from './claudeSdkTools.js';
  * Map Ziggs `ToolDefinition`s to Claude Agent SDK MCP tools. Each handler routes
  * execution through `eff({ kind: 'tool-call' })` — the shared executor.
  */
-export declare function buildSdkToolDefs(toolDefs: ToolDefinition[], getContext: () => ClaudeSdkToolContext): Array<SdkMcpToolDefinition>;
+export declare function buildSdkToolDefs(toolDefs: ToolDefinition[], getContext: () => ClaudeSdkToolContext, 
+/** Which tools load on every wake; the rest wait for tool search. Default: all. */
+alwaysLoad?: (name: string) => boolean): Array<SdkMcpToolDefinition>;
 export declare function buildZiggsSdkMcpServer(toolDefs: ToolDefinition[], getContext: () => ClaudeSdkToolContext, options?: {
     name?: string;
     instructions?: string;
+    /** Per tool; a tool it returns false for is deferred behind tool search. */
+    alwaysLoad?: (name: string) => boolean;
 }): import("@anthropic-ai/claude-agent-sdk").McpSdkServerConfigWithInstance;

package/dist/brain/toolManagerToSdkMcp.js

@@ -85,7 +85,9 @@ function toCallToolError(err) {
  * Map Ziggs `ToolDefinition`s to Claude Agent SDK MCP tools. Each handler routes
  * execution through `eff({ kind: 'tool-call' })` — the shared executor.
  */
-export function buildSdkToolDefs(toolDefs, getContext) {
+export function buildSdkToolDefs(toolDefs, getContext, 
+/** Which tools load on every wake; the rest wait for tool search. Default: all. */
+alwaysLoad = () => true) {
     return toolDefs.map((def) => {
         const fn = def.schema.function;
         const name = String(fn['name'] ?? '');
@@ -99,7 +101,7 @@ export function buildSdkToolDefs(toolDefs, getContext) {
             name,
             description,
             inputSchema,
-            _meta: { 'anthropic/alwaysLoad': true },
+            _meta: { 'anthropic/alwaysLoad': alwaysLoad(name) },
             handler: async (args) => {
                 try {
                     const ctx = getContext();
@@ -147,7 +149,6 @@ export function buildZiggsSdkMcpServer(toolDefs, getContext, options = {}) {
         name: options.name ?? 'ziggs',
         version: '1.0.0',
         instructions: options.instructions,
-        tools: buildSdkToolDefs(toolDefs, getContext),
-        alwaysLoad: true,
+        tools: buildSdkToolDefs(toolDefs, getContext, options.alwaysLoad),
     });
 }

package/dist/defineAgent.js

@@ -2,7 +2,7 @@ import { validateWorkflow } from './runtime/validateWorkflow.js';
 import { injectKickoffDefault } from './runtime/kickoff.js';
 import { injectTaskIntakeDefault } from './runtime/taskIntake.js';
 import { runtimeLog } from './shared/runtimeLog.js';
-import { DEFAULT_MODEL } from './Agent.js';
+import { resolveFleetModel } from './shared/fleetModel.js';
 import { normalizeNeeds, toolsForNeeds } from './tools/needs.js';
 import { toolName } from './tools/defineTool.js';
 /**
@@ -74,13 +74,8 @@ export function defineAgent(input) {
             tools[at] = tool;
         }
     }
-    // Model resolution, most-specific-first: a per-agent pin, then the
-    // fleet-wide `LLM_MODEL` lever, then the single `DEFAULT_MODEL` fallback (the
-    // ONE place the default lives — see Agent). The id also picks the provider
-    // (claude-* → Anthropic). No agent hardcodes its own fallback.
-    const model = input.services?.llm?.model ||
-        process.env.LLM_MODEL ||
-        DEFAULT_MODEL;
+    // One resolution for every agent: a pin, then LLM_MODEL, then DEFAULT_MODEL.
+    const model = resolveFleetModel(input.services?.llm?.model);
     // Strip the structural fields we already consumed; pass through everything
     // else (operatorKey, taskTools, custom keys consumed by Agent).
     const { agentId, description, specialization, services: _services, initial: _initial, states: _states, tools: _tools, operatorKey, taskTools, ...rest } = input;

package/dist/formatters/AgreementFormatter.js

@@ -53,7 +53,7 @@ export class AgreementFormatter {
             lines.push(`${indent}  Proposal: ${proposal['status']}${proposal['respondedBy'] ? ` (by ${proposal['respondedBy']})` : ''}`);
         const money = ag['money'];
         if (typeof money?.['price'] === 'number' && money['price'] > 0) {
-            const parts = [`${money['price']} cents`];
+            const parts = [`${money['price']} hundredths of a point`];
             if (money['paymentStatus'] && money['paymentStatus'] !== 'none')
                 parts.push(money['paymentStatus']);
             lines.push(`${indent}  Money: ${parts.join(', ')}`);

package/dist/index.d.ts

@@ -14,7 +14,7 @@ export { parseSkill, skillHash, skillRolePrompt, skillReferenceName, skillRefere
 export type { ParsedSkill, SkillFile, SkillReference } from './skills/parseSkill.js';
 export { loadSkill, readSkillFiles, assertSkillHash } from './skills/loadSkill.js';
 export { skillReadReferenceTool } from './skills/skillReadReference.js';
-export { Agent, createAgent, createAgentPool, DEFAULT_MODEL } from './Agent.js';
+export { Agent, createAgent, createAgentPool, DEFAULT_MODEL, resolveFleetModel } from './Agent.js';
 export { ZiggsBrain } from './brain/ZiggsBrain.js';
 export { ClaudeBrain } from './brain/ClaudeBrain.js';
 export type { CognitionKind, ClaudeBrainOptions } from './brain/ClaudeBrain.js';
@@ -69,8 +69,7 @@ export { PollRegistry, declaredPolls, type PollBinding, type PollContext, type P
 export { PollRunner, type PollRunnerOptions, type WakeTarget } from './platform/polls/PollRunner.js';
 export { PROTOCOL_TOOLS, agreementProposeTool, agreementSubcontractTool, agreementRespondTool, agreementClaimTool, agreementCounterTool, agreementGetTool, agreementRevokeTool, agreementFulfillTool, taskCreateTool, taskSetResultTool, taskUpdatePlanStepTool, dispatchProtocolOp, PAYMENT_TOOLS, paymentBalanceTool, CONNECTION_TOOLS, connectionProxyTool, connectionListGrantsTool, requestConnectionTool, MCP_CONNECTION_TOOLS, mcpToolCallTool, mcpToolsListTool, DISCOVERY_TOOLS, agentSearchTool, agentGetTool, MARKETPLACE_TOOLS, marketplaceViewTool, CONTEXT_TOOLS, contextReadTool, contextRequestTool, accessRequestTool, contextDelegateTool, contextExpandReachTool, contextDiscoverGrantableTool, GRANTS_TOOLS, listGrantsTool, PLAN_TOOLS, taskReplacePlanTool, LINK_TOOLS, linkProposeTool, linkListTool, INTRODUCTION_TOOLS, introductionMintTool, introductionRedeemTool, introductionListTool, introductionRevokeTool, ARTIFACT_TOOLS, recordArtifactTool, CHAT_TOOLS, openConversationTool, LISTING_TOOLS, } from './platform/tools/index.js';
 export { CLAUDE_SDK_TOOLS } from './brain/claudeSdkTools.js';
-export { hostedModelTools, isHostedCatalogOnly, hostedToolLane } from './brain/hostedToolSurface.js';
-export type { HostedToolExecute } from './brain/hostedToolSurface.js';
+export { hostedModelTools, isHostedDeferred, hostedToolLane } from './brain/hostedToolSurface.js';
 export { PROTOCOL_TOOL_NAMES, PROTOCOL_TOOL_TO_OPERATION, mapProtocolToolToOperation, isProtocolToolName } from './tasks/protocolRegistry.js';
 export { InMemoryStore, FileMemoryStore } from './memory/MemoryStore.js';
 export type { MemoryStore } from './memory/MemoryStore.js';

package/dist/index.js

@@ -16,7 +16,7 @@ export { createMcpAgent, resolveZiggsGatewayTarget, wrapGatewayFetch, ZiggsGatew
 export { parseSkill, skillHash, skillRolePrompt, skillReferenceName, skillReferenceOneLine, splitFrontmatter, SkillValidationError, SKILL_MAX_CHARS, } from './skills/parseSkill.js';
 export { loadSkill, readSkillFiles, assertSkillHash } from './skills/loadSkill.js';
 export { skillReadReferenceTool } from './skills/skillReadReference.js';
-export { Agent, createAgent, createAgentPool, DEFAULT_MODEL } from './Agent.js';
+export { Agent, createAgent, createAgentPool, DEFAULT_MODEL, resolveFleetModel } from './Agent.js';
 export { ZiggsBrain } from './brain/ZiggsBrain.js';
 export { ClaudeBrain } from './brain/ClaudeBrain.js';
 // The exact strings a Claude-brain wake sends: the shared protocol block, the
@@ -83,7 +83,7 @@ PAYMENT_TOOLS, paymentBalanceTool, CONNECTION_TOOLS, connectionProxyTool, connec
 // The always-on toolset for the hosted Claude cognition (parity guard
 // reads this as part of the real SDK registry).
 export { CLAUDE_SDK_TOOLS } from './brain/claudeSdkTools.js';
-export { hostedModelTools, isHostedCatalogOnly, hostedToolLane } from './brain/hostedToolSurface.js';
+export { hostedModelTools, isHostedDeferred, hostedToolLane } from './brain/hostedToolSurface.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';

package/dist/platform/inboxLoop.js

@@ -7,7 +7,12 @@ function log(label, msg) {
     runtimeLog.info(label, msg);
 }
 function inboxClient(deps) {
-    return new InboxClient(deps.creds.operatorKey, deps.creds.agentId, deps.baseUrl, deps.creds.instanceId);
+    return new InboxClient(deps.creds.operatorKey, deps.creds.agentId, deps.baseUrl, deps.creds.instanceId, {
+        clientSessionId: deps.creds.clientSessionId,
+        workspaceIds: deps.creds.workspaceIds,
+        app: deps.creds.app,
+        sessionName: deps.creds.sessionName,
+    });
 }
 async function releaseInboxHostBestEffort(deps) {
     try {

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

@@ -255,6 +255,12 @@ async function proposeAgreement(services, payload, chatId, writeKeys = null) {
     // propose resolves to the already-created agreement server-side instead of
     // minting a duplicate proposal. Keyed on what the proposal writes, so
     // multiple proposals in one wake stay distinct.
+    // A standing listing is published by a person or the deploy.
+    // A broadcast with a provider is that listing. A request omits providerId.
+    // A named counterparty is a direct proposal and stays.
+    if (isBroadcastTarget(payload.proposedTo) && payload.providerId) {
+        throw new Error('A standing listing is published by a person or the deploy. Broadcast without providerId to post a request, or name a counterparty to propose terms inside a deal.');
+    }
     const idempotencyKey = writeKeys?.agreementProposeKey({
         proposedTo: payload.proposedTo,
         providerId: payload.providerId,

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

@@ -60,7 +60,7 @@ function handlerFor(toolName) {
         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. For a bilateral trust link, use link_propose.' }, parentAgreementId: 'string', providerId: { type: 'string', description: AGREEMENT_PROPOSE_PROVIDER_ID_DESCRIPTION }, price: { type: 'number', description: 'Price in POINTS, as an integer of hundredths — 500 means ϟ5.00. Convert both ways: a human asking for "ϟ2 per task" means 200, not 2. ϟ is the points symbol, not a hundredth.' }, lifecycle: lifecycleParam, expiresAt: 'string', maxExecutions: 'integer', conversationAllowance: { type: 'number', description: 'Incoming-message limit shared across covered rooms; omitted on new agreements means unlimited.' }, billing: { type: 'string', enum: ['total', 'per_task'], description: "How price reads: 'total' (default, escrowed and paid at the end) or 'per_task' (a rate settled as each task completes — standing agreements only, and the default for a hire)." }, agreementDescription: 'string' }, handlerFor('agreement_propose'), { description: 'Propose an agreement — direct, broadcast, or link; there are no separate publish tools. Engagement precedence (posted-first): 1) REUSE an active agreement on matching terms, 2) CLAIM the counterparty\'s listing (marketplace_view → agreement_claim; never counter a listing), 3) POST a request broadcast here when nothing listed fits, 4) direct-propose ONLY for bespoke terms, renegotiation, or commissioning a named counterparty with no listing — most published agents are claim-only and refuse direct proposals with a pointer at their listing. Direction is stated, never guessed: providerId = your own id ("I work, you pay") or providerId = proposedTo ("you work, I pay") on direct proposals. Broadcast with proposedTo="everyone" (fully public) or "org" (your org only): no providerId publishes a REQUEST any agent may claim; providerId = your own id publishes a STANDING OFFER (claiming is agreement_claim; browsing is marketplace_view). For a bilateral trust link, use link_propose: it takes an email or an agent id, or neither for a share link. engagementKind defaults to service. Agreements are STANDING by default (no expiry, unlimited tasks under one agreement); set expiresAt or maxExecutions only when the engagement should end on its own.', isAgreementCreation: true });
+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. For a bilateral trust link, use link_propose.' }, parentAgreementId: 'string', providerId: { type: 'string', description: AGREEMENT_PROPOSE_PROVIDER_ID_DESCRIPTION }, price: { type: 'number', description: 'Price in POINTS, as an integer of hundredths — 500 means ϟ5.00. Convert both ways: a human asking for "ϟ2 per task" means 200, not 2. ϟ is the points symbol, not a hundredth.' }, lifecycle: lifecycleParam, expiresAt: 'string', maxExecutions: 'integer', conversationAllowance: { type: 'number', description: 'Incoming-message limit shared across covered rooms; omitted on new agreements means unlimited.' }, billing: { type: 'string', enum: ['total', 'per_task'], description: "How price reads: 'total' (default, escrowed and paid at the end) or 'per_task' (a rate settled as each task completes — standing agreements only, and the default for a hire)." }, agreementDescription: 'string' }, handlerFor('agreement_propose'), { description: 'Propose an agreement — direct, broadcast, or link; there are no separate publish tools. Engagement precedence (posted-first): 1) REUSE an active agreement on matching terms, 2) CLAIM the counterparty\'s listing (marketplace_view → agreement_claim; never counter a listing), 3) POST a request broadcast here when nothing listed fits, 4) direct-propose ONLY for bespoke terms, renegotiation, or commissioning a named counterparty with no listing — most published agents are claim-only and refuse direct proposals with a pointer at their listing. Direction is stated, never guessed: providerId = your own id ("I work, you pay") or providerId = proposedTo ("you work, I pay") on direct proposals. Broadcast with proposedTo="everyone" (fully public) or "org" (your org only) and no providerId posts a REQUEST any agent may claim. A person or the deploy publishes a standing listing; this agent does not. For a bilateral trust link, use link_propose: it takes an email or an agent id, or neither for a share link. engagementKind defaults to service. Agreements are STANDING by default (no expiry, unlimited tasks under one agreement); set expiresAt or maxExecutions only when the engagement should end on its own.', isAgreementCreation: true });
 export const agreementSubcontractTool = defineTool('agreement_subcontract', agreementSubcontractCapability.params, handlerFor('agreement_subcontract'), { description: agreementSubcontractCapability.descriptions.sdk, 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 DIRECT agreement proposal addressed to you. Open broadcasts (requests, standing offers, link invites) have no personal approval slot — claim those with agreement_claim instead, or ignore them to pass. ONE exception: a hand-off that pins YOU as provider carries your pending approval even as an open broadcast — approving consents to serving whoever claims it (the row stays open for claims); rejecting cancels the hand-off. Ignoring it leaves the hand-off unclaimable, so always respond.' });
 export const agreementClaimTool = defineTool('agreement_claim', agreementClaimCapability.params, handlerFor('agreement_claim'), { description: agreementClaimCapability.descriptions.sdk });

package/dist/runtime/PromptBuilder.js

@@ -206,7 +206,7 @@ ${this._renderDecisionSchemaFromActions(actions, senderMeta, ctxObj, omitMessage
             }
             const money = ag.money;
             if (typeof money?.price === 'number' && money.price > 0) {
-                lines.push(`  Price: ${money.price} cents (${money.paymentStatus})`);
+                lines.push(`  Price: ${money.price} hundredths of a point (${money.paymentStatus})`);
             }
         }
         lines.push('');

package/dist/runtime/runTurn.js

@@ -493,27 +493,6 @@ export async function runTurn(input) {
     return { outcome, toolResults, llmCalls: llmCallsTotal, tokens: { total: tokensTotal, input: tokensInput, output: tokensOutput } };
 }
 // ─────────────────────────────────────────────────────────────────────────────
-function extractIncomingMessageText(event) {
-    if (!event)
-        return '';
-    const parts = [];
-    const push = (v) => {
-        if (typeof v === 'string' && v.trim())
-            parts.push(v.trim());
-    };
-    push(event.text);
-    push(event.message);
-    const agreement = event.agreement;
-    if (agreement) {
-        const terms = agreement.terms;
-        push(terms?.description);
-        push(JSON.stringify(agreement));
-    }
-    const task = event.task;
-    if (task)
-        push(JSON.stringify(task));
-    return parts.join('\n');
-}
 function normalizeContextSnapshot(raw) {
     if (!raw || typeof raw !== 'object') {
         return { history: [], agreements: [], agents: [], users: [] };

package/dist/shared/fleetModel.d.ts

@@ -0,0 +1,8 @@
+/**
+ * The one model table. Sonnet 5.5 is the default.
+ * A per-agent pin wins, then `LLM_MODEL`, then {@link DEFAULT_MODEL}.
+ * The id also picks the provider: `claude-*` routes to Anthropic.
+ */
+export declare const DEFAULT_MODEL = "claude-sonnet-5-5";
+/** Pin, then `LLM_MODEL`, then {@link DEFAULT_MODEL}. */
+export declare function resolveFleetModel(pinned?: string): string;

package/dist/shared/fleetModel.js

@@ -0,0 +1,16 @@
+/**
+ * The one model table. Sonnet 5.5 is the default.
+ * A per-agent pin wins, then `LLM_MODEL`, then {@link DEFAULT_MODEL}.
+ * The id also picks the provider: `claude-*` routes to Anthropic.
+ */
+export const DEFAULT_MODEL = 'claude-sonnet-5-5';
+/** Pin, then `LLM_MODEL`, then {@link DEFAULT_MODEL}. */
+export function resolveFleetModel(pinned) {
+    const pin = pinned?.trim();
+    if (pin)
+        return pin;
+    const fromEnv = process.env.LLM_MODEL?.trim();
+    if (fromEnv)
+        return fromEnv;
+    return DEFAULT_MODEL;
+}

package/dist/shared/operatorKeyClaims.d.ts

@@ -1,18 +1,11 @@
 /**
- * Client-side peek at an operator key's JWT payload (signature NOT verified —
- * identity hint only, the backend remains the authority). Used by the fleet
- * launcher to warn when the key is agent-bound: a bound key
- * collapses the operator multiplex to its one agent and 403s every other
- * per-agent loop, so a large fleet quietly watches a single agent.
+ * Client-side peek at an operator key. The decoder lives in api-client (it
+ * keeps `issuedVia` and ignores a non-string `boundAgentId`, and it does not
+ * use Node's Buffer). This file re-exports it and keeps the fleet warning.
  */
-export interface OperatorKeyClaims {
-    type?: string;
-    keyId?: string;
-    ownerId?: string;
-    boundAgentId?: string | null;
-    exp?: number;
-}
-export declare function decodeOperatorKeyClaims(token: string): OperatorKeyClaims | null;
+import { decodeOperatorKeyClaims } from '@ziggs-ai/api-client';
+export { decodeOperatorKeyClaims };
+export type { OperatorKeyClaims } from '@ziggs-ai/api-client';
 /**
  * The startup check: warn (never refuse — a one-agent launcher on a
  * bound key is legitimate) when the fleet's control key is bound to a single

package/dist/shared/operatorKeyClaims.js

@@ -1,22 +1,10 @@
-export function decodeOperatorKeyClaims(token) {
-    const parts = token.trim().split('.');
-    if (parts.length !== 3)
-        return null;
-    try {
-        const json = Buffer.from(parts[1], 'base64url').toString('utf8');
-        const payload = JSON.parse(json);
-        return {
-            type: payload.type,
-            keyId: payload.keyId,
-            ownerId: payload.ownerId,
-            boundAgentId: payload.boundAgentId ?? null,
-            exp: payload.exp,
-        };
-    }
-    catch {
-        return null;
-    }
-}
+/**
+ * Client-side peek at an operator key. The decoder lives in api-client (it
+ * keeps `issuedVia` and ignores a non-string `boundAgentId`, and it does not
+ * use Node's Buffer). This file re-exports it and keeps the fleet warning.
+ */
+import { decodeOperatorKeyClaims } from '@ziggs-ai/api-client';
+export { decodeOperatorKeyClaims };
 /**
  * The startup check: warn (never refuse — a one-agent launcher on a
  * bound key is legitimate) when the fleet's control key is bound to a single

package/dist/shared/runtimeLog.d.ts

@@ -1,18 +1,6 @@
 /**
- * Process-wide log levels for agentplus runtimes. Default is `info` so FSM /
- * socket chatter stays quiet unless operators opt in.
- *
- * Env (first match wins for the debug shortcut):
- * - `DEBUG_AGENTPLUS=1` or `AGENTPLUS_DEBUG=1` → threshold `debug`
- * - `LOG_LEVEL` or `AGENTPLUS_LOG_LEVEL` → `debug` | `info` | `warn` | `error` | `silent`
- *   (`silent` keeps only `error` output)
+ * The SDK follows `configureApiClient({ logLevel })`. The level table lives in
+ * api-client; this file only re-exports it so existing imports keep working.
  */
-export type RuntimeLogLevel = 'debug' | 'info' | 'warn' | 'error';
-/** Test hook: re-read env after `process.env` mutations. */
-export declare function resetRuntimeLogLevelCache(): void;
-export declare const runtimeLog: {
-    debug(scope: string, msg: string, ...rest: unknown[]): void;
-    info(scope: string, msg: string, ...rest: unknown[]): void;
-    warn(scope: string, msg: string, ...rest: unknown[]): void;
-    error(scope: string, msg: string, ...rest: unknown[]): void;
-};
+export { runtimeLog, resetRuntimeLogLevelCache, } from '@ziggs-ai/api-client';
+export type { RuntimeLogLevel } from '@ziggs-ai/api-client';

package/dist/shared/runtimeLog.js

@@ -1,68 +1,5 @@
 /**
- * Process-wide log levels for agentplus runtimes. Default is `info` so FSM /
- * socket chatter stays quiet unless operators opt in.
- *
- * Env (first match wins for the debug shortcut):
- * - `DEBUG_AGENTPLUS=1` or `AGENTPLUS_DEBUG=1` → threshold `debug`
- * - `LOG_LEVEL` or `AGENTPLUS_LOG_LEVEL` → `debug` | `info` | `warn` | `error` | `silent`
- *   (`silent` keeps only `error` output)
+ * The SDK follows `configureApiClient({ logLevel })`. The level table lives in
+ * api-client; this file only re-exports it so existing imports keep working.
  */
-const SEVERITY = {
-    debug: 0,
-    info: 1,
-    warn: 2,
-    error: 3,
-};
-function parseThreshold() {
-    if (process.env.DEBUG_AGENTPLUS === '1' || process.env.AGENTPLUS_DEBUG === '1') {
-        return SEVERITY.debug;
-    }
-    const raw = (process.env.LOG_LEVEL ||
-        process.env.AGENTPLUS_LOG_LEVEL ||
-        'info').toLowerCase();
-    if (raw === 'silent' || raw === 'none')
-        return SEVERITY.error;
-    if (raw === 'debug' || raw === 'trace')
-        return SEVERITY.debug;
-    if (raw === 'warn')
-        return SEVERITY.warn;
-    if (raw === 'error')
-        return SEVERITY.error;
-    return SEVERITY.info;
-}
-let cachedThreshold = null;
-function threshold() {
-    if (cachedThreshold === null)
-        cachedThreshold = parseThreshold();
-    return cachedThreshold;
-}
-/** Test hook: re-read env after `process.env` mutations. */
-export function resetRuntimeLogLevelCache() {
-    cachedThreshold = null;
-}
-function shouldEmit(level) {
-    return SEVERITY[level] >= threshold();
-}
-function fmt(scope, msg) {
-    return `[${scope}] ${msg}`;
-}
-export const runtimeLog = {
-    debug(scope, msg, ...rest) {
-        if (!shouldEmit('debug'))
-            return;
-        console.log(fmt(scope, msg), ...rest);
-    },
-    info(scope, msg, ...rest) {
-        if (!shouldEmit('info'))
-            return;
-        console.log(fmt(scope, msg), ...rest);
-    },
-    warn(scope, msg, ...rest) {
-        if (!shouldEmit('warn'))
-            return;
-        console.warn(fmt(scope, msg), ...rest);
-    },
-    error(scope, msg, ...rest) {
-        console.error(fmt(scope, msg), ...rest);
-    },
-};
+export { runtimeLog, resetRuntimeLogLevelCache, } from '@ziggs-ai/api-client';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ziggs-ai/agent-sdk",
-  "version": "0.36.0",
+  "version": "0.38.0",
   "description": "Agent framework SDK for building autonomous agents on the Ziggs platform",
   "type": "module",
   "main": "dist/index.js",
@@ -26,7 +26,7 @@
     "@anthropic-ai/claude-agent-sdk": "^0.3.284",
     "@anthropic-ai/sdk": "^0.110.0",
     "@modelcontextprotocol/sdk": "^1.29.0",
-    "@ziggs-ai/api-client": "0.35.0",
+    "@ziggs-ai/api-client": "0.37.0",
     "ajv": "^8.17.1",
     "dotenv": "^17.2.3",
     "openai": "^4.0.0",