@ziggs-ai/agent-sdk 0.37.0 → 0.38.1

package/CHANGELOG.md

@@ -14,6 +14,9 @@
 
 ### 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.
 

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,6 +11,8 @@ 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 { EventQueue } from './platform/EventQueue.js';
@@ -39,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() {
@@ -201,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. */
@@ -227,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,
@@ -347,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 = {

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

package/dist/brain/claudeSdkProtocol.js

@@ -27,7 +27,7 @@ Your prose and final summary are private host notes, not messages to the people
 - Closing a task closes the TASK, and only the task. It stores your result where the next agent reads it, queues a wake for whoever the platform addresses, and on an agreement that bills per completed task it meters that one execution. It does not end the hire — a standing agreement stays active for the next task — it does not prove anyone has read you, and it does not prove you were paid. The reply tells you which of those actually happened: report that and nothing beyond it. A completion whose reply you never saw is recovered by READING the task back, never by completing it a second time; your retry carries the same write key, so a redelivered completion no-ops instead of doubling the result, the wake and the charge.
 - Enumerate open work with \`task_list\` (use assignedToMe for your own active tasks).
 - Chat is where you talk to whoever you are working with, and where a human reads what you delivered — sending it to them there is delivery, not duplication. It is not where another AGENT collects a deliverable: that one reads the task result, so a chat message never stands in for closing the task. Deliver into the working conversation the hire already has; do not repeat it into every room you can reach.
-- Use any room you can write in, or open one (newChat for a separate subject). The server refuses what you are not allowed to do, and the refusal says why.
+- For replies and follow-ups, send into the original conversation (its chatId). Sending to a person without a chatId selects the main pair room, which may be a different conversation. Missing access is a reason to request the scoped permission, not to silently move the exchange. Use another writable room, or open one with newChat, only for a separate subject. The server refuses what you are not allowed to do, and the refusal says why.
 - When a store listing of yours is claimed (\`resource_changed\` with reason \`proposal_approved\`), call \`chat_open\` with the buyer (actorId / Sender) AND the claimed agreementId. That returns the hire's room, which the server usually made at claim, or opens one when there is none. Greet them only when the agreement accepts messages, then serve the agreement terms. A task-only agreement needs no chat or greeting: wait for assigned tasks and deliver results through tasks. Do not \`chat_send\` to an \`agrn-*\` session id — open a real chat first.
 - When a task you hold carries a deadline or a reminder rule, they are part of the job, not decoration. Never remind the same person sooner than the stated interval or more times than the budget; use \`wake_at\` to come back rather than waiting in place, and re-arm it each time you wake. When the budget is spent, stop asking and say what you have. At the deadline, post what you got and where you are stuck in the room where the question was asked, close the task, and stop — whether or not you got the answer. Nothing stops you from breaking this, which is exactly why it is on you: over-reminding is a breach of the task, not diligence, and every reminder costs a wake.
 - Hand off by completing your task — the platform notifies the next agent.

package/dist/brain/claudeSdkTools.js

@@ -74,7 +74,7 @@ export const chatSendTool = defineTool('chat_send', {
     underAgreementId: { type: 'string', description: 'Your run authority, defaulting to the current run in every destination room.' },
     chatId: { type: 'string', description: 'Omit this to send in the chat you were woken in — that is the usual case. Only pass a chatId to send in a DIFFERENT chat, such as one you just opened with chat_open. When chatId is set it wins over `to`.' },
     to: { type: 'string', description: 'User or agent id of someone you already have a conversation with. Sends in that pair room. Naming the person whose message woke you sends in the room that woke you instead, addressed to them. Does not open contact — first contact still needs chat_open. Ignored when chatId is set (chatId wins; `to` is used as receiverId if receiverId is omitted).' },
-    receiverId: { type: 'string', description: 'Name someone only when you mean them. Leave it out to write back in this room: one other participant is the recipient, and with several Jev may select one. Otherwise the message stays in the room with no specific wake. To name a masked party, pass its rpb_ ref as it came. Pass human to address the people in the room.' },
+    receiverId: { type: 'string', description: 'Name someone only when you mean them. Leave it out to write back in this room: one other participant is the recipient, and with several Jev may select one. Otherwise the message stays in the room with no specific wake. To name a masked party, pass its rpb_ ref as it came. Pass human only for a broadcast to the people in the room; it does not wake assistants or stand-ins. For a reply from a person or their assistant, name that person\'s returned participant id. This does not grant their assistant access or guarantee a reply.' },
     text: { type: 'string', required: true },
     idempotencyKey: { type: 'string', description: 'Reuse for retry-safe resend of the same logical message.' },
 }, async (args, ctx) => {

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';

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

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.37.0",
+  "version": "0.38.1",
   "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.36.0",
+    "@ziggs-ai/api-client": "0.37.1",
     "ajv": "^8.17.1",
     "dotenv": "^17.2.3",
     "openai": "^4.0.0",