@ziggs-ai/agent-sdk 0.42.2 → 0.43.0

package/dist/runtime/wakeEffects.js

@@ -1,5 +1,3 @@
-import { agreementIdFromLane } from '@ziggs-ai/api-client';
-import { isListing } from './agreementContext.js';
 const record = (value) => value && typeof value === 'object' && !Array.isArray(value) ? value : {};
 const id = (value) => typeof value === 'string' && value.trim() ? value : undefined;
 /** Never combine a task from one event with an agreement from another. */
@@ -26,9 +24,7 @@ export function workScopeFromWake(event, sessionId) {
     // A listing is never work, so it is never what a wake's sends and
     // tools are filed under.
     const listing = record(rec.agreementContext).listing === true;
-    const agreementId = listing ? undefined : id(rec.agreementId) ?? id(resource.agreementId) ?? id(task.agreementId)
-        ?? agreementIdFromLane(rec.chatId) ?? agreementIdFromLane(resource.chatId)
-        ?? agreementIdFromLane(sessionId) ?? undefined;
+    const agreementId = listing ? undefined : id(rec.agreementId) ?? id(resource.agreementId) ?? id(task.agreementId);
     const taskId = id(rec.taskId) ?? id(resource.taskId) ?? id(task.taskId) ?? (resource.kind === 'task' ? id(resource.resourceId) : undefined);
     return { ...(agreementId ? { agreementId } : {}), ...(taskId ? { taskId } : {}) };
 }
@@ -49,19 +45,15 @@ const TASK_WRITES = new Set(['task_create', 'task_set_result', 'task_update_plan
 /** Per-wake observation, including effects nested inside tools and cross-room sends. */
 export class WakeEffects {
     initialScope;
-    sessionId;
     inferScope;
     sentMessage = false;
     taskWrite = false;
     planVersions = new Set();
     sentMessageKeys = new Set();
-    /** Agreements the wake's OWN room reported, from its fenced snapshot. */
-    roomAgreementIds = [];
     /** Confirmed task writes: work this wake actually performed. */
     taskWrites = [];
-    constructor(initialScope, sessionId, inferScope = true) {
+    constructor(initialScope, inferScope = true) {
         this.initialScope = initialScope;
-        this.sessionId = sessionId;
         this.inferScope = inferScope;
     }
     static forWake(event, sessionId) {
@@ -70,47 +62,23 @@ export class WakeEffects {
         const conflictingBatch = frame.type === 'batch' && Array.isArray(frame.events)
             && !initialScope.agreementId && !initialScope.taskId
             && frame.events.some(item => Object.keys(workScopeFromWake(item, sessionId)).length > 0);
-        return new WakeEffects(initialScope, sessionId, !conflictingBatch);
+        return new WakeEffects(initialScope, !conflictingBatch);
     }
-    /**
-     * Structured wake fields first. Otherwise the room's one agreement is the
-     * scope — spend follows who the agent acts for, and in a room that is the
-     * room's agreement — and a confirmed task write names its task only when
-     * the server tied the write to that same agreement. A plan written for
-     * customer A from customer B's room stays billed to B and names no task; a
-     * write whose agreement the server did not report adds nothing but the room.
-     */
+    /** Structured work wins. A confirmed task write may identify work performed;
+     * reading a context snapshot never selects billing or execution authority. */
     get scope() {
         if (this.initialScope.agreementId || this.initialScope.taskId)
             return this.initialScope;
-        if (!this.inferScope)
-            return {};
-        const room = new Set(this.roomAgreementIds);
-        if (room.size > 1)
-            return {};
-        const agreementId = [...room][0];
-        if (!agreementId)
-            return uniqueWorkScope(this.taskWrites);
-        const tasks = new Set(this.taskWrites.filter(w => w.agreementId === agreementId).map(w => w.taskId));
-        return { agreementId, ...(tasks.size === 1 ? { taskId: [...tasks][0] } : {}) };
+        return this.inferScope ? uniqueWorkScope(this.taskWrites) : {};
     }
     observe(effect, response) {
         const outer = record(response);
-        if (effect.kind === 'send-message' && outer.ok === true)
-            this.sentMessage = true;
-        // This is the fenced snapshot of the wake's own chat, not an arbitrary
-        // agreement consulted while answering. A room with multiple agreements
-        // remains ambiguous, and cross-room reads cannot change the wake's scope.
-        if (effect.kind === 'read-context' && effect.sessionId === this.sessionId
-            && outer.chatMissing !== true && Array.isArray(outer.agreements)) {
-            for (const row of outer.agreements) {
-                // A stranger's room is linked to the agent's listing; the listing is
-                // every stranger's and never the room's work.
-                if (isListing(row))
-                    continue;
-                const agreementId = id(record(row).agreementId);
-                if (agreementId)
-                    this.roomAgreementIds.push(agreementId);
+        if (effect.kind === 'send-message' && outer.ok === true
+            && (outer.outcome === 'created' || outer.outcome === 'existing')) {
+            const messageId = id(record(outer.message).messageId);
+            if (messageId) {
+                this.sentMessage = true;
+                this.sentMessageKeys.add(messageId);
             }
         }
         if (effect.kind !== 'tool-call' || outer.ok !== true)
@@ -119,10 +87,11 @@ export class WakeEffects {
         if (result.ok === false || result.success === false || result.error)
             return;
         const name = effect.name.replace(/^(functions|tools|function|tool)\./, '');
-        if (name === 'chat_send') {
-            this.sentMessage = true;
-            if (id(result.chatId) && id(result.messageId)) {
-                this.sentMessageKeys.add(JSON.stringify([result.chatId, result.messageId]));
+        if (name === 'message_send') {
+            const messageId = id(record(result.message).messageId);
+            if ((result.outcome === 'created' || result.outcome === 'existing') && messageId) {
+                this.sentMessage = true;
+                this.sentMessageKeys.add(messageId);
             }
         }
         if (TASK_WRITES.has(name))

package/dist/runtime/wakeOutcome.js

@@ -71,7 +71,7 @@ export function classifyWakeOutcome(input) {
 export function buildWakeOutcomePayload(input) {
     return {
         source: 'agent',
-        chatId: input.sessionId,
+        addressId: input.sessionId,
         sessionId: input.sessionId,
         execution: {
             llmCallsTotal: input.llmCalls ?? 0,

package/dist/skills/createSkillAgent.js

@@ -1,10 +1,19 @@
 import { createAgent } from '../Agent.js';
 import { ARTIFACT_TOOLS } from '../platform/tools/tier2/artifactTools.js';
+import { accessRequestTool } from '../platform/tools/tier2/contextTools.js';
 import { toolName } from '../tools/defineTool.js';
 import { parseSkill, skillRolePrompt } from './parseSkill.js';
 /** The artifact tools that finish inside one call, so instructions can keep
  * their work as artifacts. The rest hand back a storage URL to upload to or
  * fetch from, and this agent has no web tool to do that with.
+ *
+ * The contribution pair is here because delegating needs it: task_delegate
+ * takes an instruction artifact, the destination may read it only once a
+ * person approves that exact input, and that approval is asked for with
+ * artifact_contribution_review from inside this agent's execution. Without
+ * it a hired helper could never be given work. The review only reports
+ * what is missing; access_request (with its release source) files the card
+ * the person approves, so both are offered.
  */
 const SKILL_ARTIFACT_TOOL_NAMES = new Set([
     'artifact_record',
@@ -12,6 +21,8 @@ const SKILL_ARTIFACT_TOOL_NAMES = new Set([
     'artifact_find',
     'artifact_share',
     'artifact_attach',
+    'artifact_contribution_review',
+    'artifact_contribute',
 ]);
 const SKILL_ARTIFACT_TOOLS = ARTIFACT_TOOLS.filter((tool) => SKILL_ARTIFACT_TOOL_NAMES.has(toolName(tool) ?? ''));
 /** The same instructions run on a host or on a person's machine. The trusted
@@ -30,7 +41,7 @@ export function createSkillAgent(options) {
             const skill = parseSkill([{ path: 'SKILL.md', bytes: Buffer.from(text, 'utf8') }]);
             return skillRolePrompt(skill);
         },
-        tools: [...SKILL_ARTIFACT_TOOLS],
+        tools: [...SKILL_ARTIFACT_TOOLS, accessRequestTool],
         taskTools: 'all',
         actsOnHireActivation: true,
         respondsToProposals: true,

package/dist/tools/capabilityAdapter.js

@@ -13,7 +13,7 @@ export function toolFromCapability(cap) {
         const operatorKey = ctx?.['operatorKey'];
         const agentId = ctx?.['agentId'];
         // The lane the wake is running in was already threaded to this exact
-        // point by the shared executor (`chatId: effect.sessionId` in
+        // point by the shared executor (`sessionId: effect.sessionId` in
         // executeToolWithSideEffects). `laneFromToolContext` is the one reader
         // for it, which makes the fence brain-agnostic by construction — the
         // Claude brain, the FSM brain and hand-written tools all claim the same

package/dist/tools/recordReport.d.ts

@@ -18,7 +18,7 @@ export interface RecordReportInput {
      * readable by the task's parties; a chat or agreement only widens where it also
      * shows up. Pass at most one; when both arrive, agreementId wins.
      */
-    chatId?: string;
+    addressId?: string;
     agreementId?: string;
     /**
      * Heavy deliverable text (document, diff, data).

package/dist/tools/recordReport.js

@@ -14,7 +14,7 @@ import { ArtifactsClient, updateTaskState, } from '@ziggs-ai/api-client';
  * Implements the B1 convention (Agents/REPORTING.md).
  */
 export async function recordReport(input) {
-    const { creds, taskId, report, chatId, agreementId, deliverable } = input;
+    const { creds, taskId, report, addressId, agreementId, deliverable } = input;
     // no container needed. The deliverable is bound to its task, which
     // is what makes it retrievable as `via=task:<taskId>` and readable by the
     // task's parties — a chat or agreement was never what made that work.
@@ -25,7 +25,7 @@ export async function recordReport(input) {
     // (the task's agreement and the chat it is running in), so there is no
     // mistake to surface and nobody to retry: refusing would fail a finished
     // task's delivery over a pair of ids it did not choose.
-    const scope = agreementId ? { agreementId } : chatId ? { chatId } : {};
+    const scope = agreementId ? { agreementId } : addressId ? { addressId } : {};
     // Deliverable FIRST, then close the task.
     //
     // The old order completed the task and then wrote the artifact with the
@@ -42,7 +42,7 @@ export async function recordReport(input) {
             contentType: 'result',
             taskId,
             ...scope,
-            visibility: 'chat',
+            visibility: 'address',
             // Deterministic, not random: one deliverable per task, so a replay of this
             // whole function reproduces the key and dedups server-side.
             idempotencyKey: `task-result:${taskId}`,

package/dist/tools/toolCreds.d.ts

@@ -4,7 +4,7 @@
  * A custom tool builds `{ operatorKey, agentId }` by hand and stops there, so
  * every call it makes runs on the narrowest reach fence there is: the agent's
  * own org. `Agent` already threads the wake's lane into the tool context
- * (as `chatId` / `sessionId`, which is what the capability adapter reads), and
+ * (as `addressId` / `sessionId`, which is what the capability adapter reads), and
  * the backend's fence is "own org ∪ the orgs of the parties to this lane" — so
  * a tool that does not pass it loses reach it is entitled to, and loses it
  * SILENTLY: enumerations come back short rather than refused.

package/dist/tools/toolCreds.js

@@ -4,7 +4,7 @@
  * A custom tool builds `{ operatorKey, agentId }` by hand and stops there, so
  * every call it makes runs on the narrowest reach fence there is: the agent's
  * own org. `Agent` already threads the wake's lane into the tool context
- * (as `chatId` / `sessionId`, which is what the capability adapter reads), and
+ * (as `addressId` / `sessionId`, which is what the capability adapter reads), and
  * the backend's fence is "own org ∪ the orgs of the parties to this lane" — so
  * a tool that does not pass it loses reach it is entitled to, and loses it
  * SILENTLY: enumerations come back short rather than refused.
@@ -35,7 +35,9 @@ const str = (ctx, key) => {
  * that agreement rather than inferring it from the room's mail.
  */
 export function laneFromToolContext(ctx) {
-    const lane = str(ctx, 'chatId') ?? str(ctx, 'sessionId');
+    // The executor names the lane `sessionId`; `addressId` is only the wake's
+    // explicit conversation, so it is the lane only where nothing else is.
+    const lane = str(ctx, 'sessionId') ?? str(ctx, 'addressId');
     return lane ? laneUnderAgreement(lane, str(ctx, 'wakeAgreementId')) : undefined;
 }
 /**

package/dist/types.d.ts

@@ -1,4 +1,4 @@
-import type { WriteSource } from '@ziggs-ai/api-client';
+import type { MessageCommand, MessageCommandResult } from '@ziggs-ai/contracts';
 /**
  * Foundation types for the agent SDK workflow runtime.
  *
@@ -19,7 +19,14 @@ export interface AgreementRef {
         paymentStatus?: string;
     };
 }
+/** Exact facts that prompted this attempt. References convey no read authority. */
+export interface TaskInputRef {
+    kind: import('@ziggs-ai/contracts').ResourceKind;
+    id: string;
+    eventId: string;
+}
 export interface TaskRef {
+    inputs?: TaskInputRef[];
     taskId: string;
     agreementId?: string;
     agreement?: AgreementRef;
@@ -130,7 +137,7 @@ export type Outcome = {
  * `{ sessionId, ctx, queue, parked }`. `Identity` is the Agent's view of
  * which session this tick belongs to. `sessionId` is opaque to the Agent —
  * it's a string the Server uses to route inbound events and outbound
- * effects. (Today, the Ziggs transport derives sessionId from `chatId` at
+ * effects. (Today, the Ziggs transport derives sessionId from `addressId` at
  * the wire boundary; non-chat surfaces will produce sessionIds of other
  * shapes.)
  */
@@ -360,19 +367,15 @@ export interface ContextSnapshot {
     timelineSummary?: string | null;
     latestSequence?: string | null;
     unavailable?: boolean;
-    /**
-     * The session's chat no longer resolves on the backend (messages read
-     * 404'd) — deleted or never visible to this agent. Message-triggered wakes
-     * check this and skip the LLM instead of reasoning over a fabricated empty
-     * history. Only gates message wakes. A bare agreementId as sessionId also
-     * trips it — that is a mis-keyed lane, not a legitimate task lane;
-     * task wakes should key on the agreement's origin/notification chat.
-     */
-    chatMissing?: boolean;
     /** Index signature so PromptBuilder's `ServerContext` can accept it directly. */
     [key: string]: unknown;
 }
 export interface ReadContextOpts {
+    /** Optional message history. Task/work initialization does not require it.
+     * An exact triggering message is always read when the wake names one. */
+    includeHistory?: boolean;
+    /** Explicit read entry point; distinct from the processing session. */
+    via?: string;
     workScopes?: Array<{
         agreementId?: string;
         taskId?: string;
@@ -434,7 +437,7 @@ export interface DeliveryWriteKeys {
     taskStateKey(taskId: string, state: string): string | undefined;
     /**
      * Default messageId for a chat-message send of this wake — the backend dedups
-     * on (chatId, messageId). Derived from the emission's content (text + chat +
+     * on (addressId, messageId). Derived from the emission's content (text + chat +
      * receiver), not a per-wake ordinal: a wake that says two things
      * gets two keys, and a redelivered wake that re-says the same text reuses the
      * same key, while a re-think with different text does not collide and drop.
@@ -523,13 +526,7 @@ export type Effect = {
  | {
     kind: 'send-message';
     sessionId: string;
-    receiverId?: string;
-    text: string;
-    messageId?: string;
-    conversationAgreementId?: string;
-    underAgreementId?: string;
-    taskId?: string;
-    sources?: WriteSource[];
+    command: MessageCommand;
 } | {
     kind: 'record-event';
     sessionId: string;
@@ -556,15 +553,8 @@ export interface EffectResultMap {
      * widened to the room's humans. The send's own report rides along when the
      * backend makes one: where it went. Routing is separate from acceptance.
      */
-    'send-message': {
+    'send-message': MessageCommandResult & {
         ok: true;
-        chatId?: string;
-        messageId?: string;
-        delivered?: string;
-        to?: {
-            id: string;
-            type: string;
-        };
     };
     'record-event': {
         ok: true;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ziggs-ai/agent-sdk",
-  "version": "0.42.2",
+  "version": "0.43.0",
   "description": "Agent framework SDK for building autonomous agents on the Ziggs platform",
   "homepage": "https://ziggsai.com/docs",
   "bugs": {
@@ -30,8 +30,8 @@
     "@anthropic-ai/claude-agent-sdk": "^0.3.284",
     "@anthropic-ai/sdk": "^0.110.0",
     "@modelcontextprotocol/sdk": "^1.29.0",
-    "@ziggs-ai/api-client": "0.38.2",
-    "@ziggs-ai/contracts": "^0.33.1",
+    "@ziggs-ai/api-client": "0.39.0",
+    "@ziggs-ai/contracts": "0.37.0",
     "ajv": "^8.17.1",
     "dotenv": "^17.2.3",
     "openai": "^4.0.0",

package/dist/platform/tools/tier2/chatTools.d.ts

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

package/dist/platform/tools/tier2/chatTools.js

@@ -1,7 +0,0 @@
-import { CHAT_CAPABILITIES, openConversationCapability } from '@ziggs-ai/api-client';
-import { toolFromCapability, toolsFromCapabilities } from '../../../tools/capabilityAdapter.js';
-// chat_open only (chat listing stays a
-// context-rail read, rule); defined once in api-client's shared
-// capability layer.
-export const openConversationTool = toolFromCapability(openConversationCapability);
-export const CHAT_TOOLS = toolsFromCapabilities(CHAT_CAPABILITIES);

package/dist/probeChat.d.ts

@@ -1,10 +0,0 @@
-/**
- * One classifier for store-publish probe rooms.
- *
- * The runner mints `probe_<agentId>_<ts>`. That prefix skips the wake gate
- * and the wake-rate breaker, so a store publish still hears a model reply.
- * It does not write a canned answer, and it is not capability evidence.
- * Capability versus liveness is decided by the store sync.
- */
-export declare const PROBE_CHAT_ID_PREFIX = "probe_";
-export declare function isPublishProbeChat(chatId: string | undefined | null): boolean;

package/dist/probeChat.js

@@ -1,12 +0,0 @@
-/**
- * One classifier for store-publish probe rooms.
- *
- * The runner mints `probe_<agentId>_<ts>`. That prefix skips the wake gate
- * and the wake-rate breaker, so a store publish still hears a model reply.
- * It does not write a canned answer, and it is not capability evidence.
- * Capability versus liveness is decided by the store sync.
- */
-export const PROBE_CHAT_ID_PREFIX = 'probe_';
-export function isPublishProbeChat(chatId) {
-    return typeof chatId === 'string' && chatId.startsWith(PROBE_CHAT_ID_PREFIX);
-}