@ziggs-ai/agent-sdk 0.42.2 → 0.43.1

package/CHANGELOG.md

@@ -1,5 +1,33 @@
 # Changelog
 
+## Unreleased
+
+## 0.43.1
+
+- Task progress updates use the shared non-cancellation state type. Cancellation remains a separate command.
+
+- Explicit message answer requests assigned to an agent bypass the context-only wake classifier. Short greetings and acknowledgments can no longer leave a requested answer pending because their wording looks like an FYI.
+- An MCP agent can work an assigned task before closing it. The task intake now offers the MCP server's tools beside `task_set_result`; before, the only tool there was `task_set_result`, so the agent could close or fail the task but never search, fetch or call anything for it.
+- An agent closing an assigned task through the injected intake now gets its `task_set_result` call carried out. The intake bound two actions (complete and fail) to that one tool, so a native tool call matched both and was dropped. It is one action now, and its format passes `result` as an object (`{ summary }`), as the tool requires.
+- An agent made with `createSkillAgent` also has `access_request`, so it can file the release request (`releaseSource`) the person approves before an input can be delegated to a hired helper.
+- An agent made with `createSkillAgent` can delegate to a helper it hired. It now has `artifact_contribution_review` and `artifact_contribute`, so it can ask for the person's approval of the instruction input that `task_delegate` takes, and then deliver it.
+- A message that arrives inside a task or agreement no longer makes the wake read as unavailable. The context read selects the work, and the triggering message is read on its own; before, both went into one snapshot request, which refuses a message beside other resources.
+- An MCP agent answers an assigned task with its result. `createMcpAgent` workflows now get the same assigned-task intake `defineAgent` gives every other agent, so a task wake goes to `task_set_result` instead of a reply that has no recipient and is refused.
+- A lane name is never an address. Sends, context reads, breadcrumbs and tool contexts use the wake's explicit destination: the incoming message's address, or the room a lane's own messages came from (kept with saved check-backs). With none, a send fails asking to name the conversation, and a read says nothing is selected. Tool contexts carry the lane as `sessionId` and `addressId` only for an explicit destination; the FSM prompt shows the lane as `lane`.
+- Later wakes of a direct request (check-backs, restored wakes, events on its execution) still answer it: they read it by its message and reply to its sender, in its room when it arrived in one.
+- Coalesced messages from one shared room under agreement work are answered in that room. From several rooms, a send must name the conversation.
+- A work-conversation reply names its recipient and selected work; a causal reply reference never changes either.
+- A matching marketplace request wakes the agent with the request's agreement only, no made-up message or address. A request wake that fails is logged and no longer holds the rest of the inbox pass.
+
+- Work execution remains stable across navigation changes and retains exact message sources in batches. Both cognition engines refuse missing required inputs without acknowledging the responsibility; optional history can fail independently.
+
+- Work execution and inbox message reads use the shared messaging API. Task initialization no longer needs conversation history; `includeHistory` requests optional history while exact triggering messages and execution revocation remain enforced.
+
+- Task recovery uses its agreement or restored execution; historical origin links never choose its delivery destination. Missing shared conversations cannot silently become agreement conversations. Structured work events and restored timer execution replace session-name parsing.
+
+- Resolve agreement/shared-conversation destinations from selected executions, including task-first, scheduled and replayed work. Never select or create rooms from lane names. Explicit shared conversation addresses remain exact.
+- Keep mixed work from borrowing a previous destination; stop deriving artifact and memory scopes from lane names. `context_snapshot` accepts explicit agreement/task scopes.
+
 ## 0.39.0
 
 - A manifest may declare `needs: [{ checkout: 'git' }]`. The host provides a throwaway box per wake (`checkout` option, a `CheckoutProvider`); the task names the repository as owner/name and may name a base branch; the brain gets `checkout_read`, `checkout_write`, `checkout_run` and `checkout_push`; the change is pushed to `agent/<task id>` for a pull request. Without a GitHub connection grant on the hire the task is refused by name, like a connection need. The box holds no credential: its git traffic is relayed by the host through the backend git door under the hire's grant. The box server ships as `dist/checkout/box/server.js` (`checkoutBoxServerPath()`).
@@ -32,6 +60,18 @@
 
 ## Unreleased
 
+- A store claim no longer makes the agent open a room and greet the buyer. `claimKickingOff`, `CLAIM_KICKOFF_STATE` and `buildClaimKickoffState` are removed; the buyer's first message or task wakes the provider, and the protocol says so. `handlesClaimWake` still routes a claim for an author who wants to act on it.
+
+- Consume roomless message assignments under their execution contexts; keep retained lanes separate and route replies without creating chats.
+
+- Only a lane that a message with no room reached sends to, and reads history from, that agreement's conversation. A task or claim wake on an `agrn-` lane, including any hire made with a room, sends into the lane as before, and the server routes it to the agreement's live room.
+
+- On a roomless lane, a `human` recipient answers the message that woke the lane; with no such message the send is refused and points to `conversation_read` for recipients. A send that names a different agreement is refused, never dropped or moved.
+
+- A message with no room that the host cannot route (a custom `sessionResolver` returned no lane, or the agent id is missing) now fails its handover and stays pending instead of being acknowledged.
+
+- Roomless sends and history reads use the runner's backend URL. Proposals and subcontracts made from an agreement lane name no chat.
+
 - Expose the shared `task_delegate` capability on the hosted agent surface for recursive task assignments and approved artifact returns.
 
 ## 0.41.2

package/README.md

@@ -150,7 +150,7 @@ who want them.
 
 ## External wake sources
 
-Declare `polls: [{ kind, chatId, ...sourceOptions }]` and their implementations in
+Declare `polls: [{ kind, addressId, ...sourceOptions }]` and their implementations in
 `pollKinds`. Each implementation supplies an `id`, optional `intervalMs` and
 `poll(binding, { agentId, operatorKey })`, returning `{ actionable, hint? }`.
 

package/dist/Agent.d.ts

@@ -35,18 +35,17 @@ import type { CheckoutProvider } from './checkout/types.js';
 /**
  * Given a normalized event, return the sessionId for this agent. Return
  * `null` to skip processing. Lets each Agent define what "session" means —
- * chat-scoped agents bucket by chatId (the default), task-scoped agents
+ * the default groups by addressId or by agreement when there is no room, task-scoped agents
  * could bucket by taskId, cron agents by schedule id, etc.
  */
 export type SessionResolver = (normalized: NormalizedEvent, ownAgentId: string) => string | null;
 /**
  * one lane key per unit of work, derived the same way as inbox wakes.
  *
- * Inbox deliveries key on `chatId` (DEFAULT_SESSION_RESOLVER). Bootstrap used to
+ * Inbox deliveries use their room when present. Bootstrap used to
  * prefer bare `agreementId`, which opened a second lane for the same task and
- * made the snapshot read treat the agreement id as a chat (`chatMissing: true`,
- * empty context). Prefer the origin chat when present; otherwise the agreement's
- * notification chat (`agrn-<agreementId>`), which is always linked after.
+ * misdirected the snapshot read. Use the agreement's local processing key. An origin link is
+ * navigation, not a delivery destination. This key creates no chat or grant.
  */
 export declare function laneSessionIdForTask(task: {
     originChatId?: string | null;
@@ -140,7 +139,7 @@ export interface AgentOptions {
     states?: Workflow['states'];
     initial?: string;
     tickTimeoutMs?: number;
-    /** Per-agent session keying. Defaults to `(n) => n.chatId`. */
+    /** Per-agent session keying. Defaults to `(n) => n.addressId`. */
     sessionResolver?: SessionResolver;
     /**
      * Agent-private long-term memory. With an operator key and agent id, the
@@ -277,6 +276,11 @@ export declare class Agent {
     /** Tasks left active by the asking turn, failed right after it (per lane). */
     private unmetTasksPendingAsk;
     private readonly wakeEffects;
+    /**
+     * The roomless lane a live wake runs on. A tool's send or read reaches the
+     * host without the wake's effect wrapper, so both look the lane up here.
+     */
+    private readonly wakeDestination;
     private readonly outboundMessages;
     private readonly confirmedPlanVersions;
     private grantProviderCache;
@@ -347,7 +351,7 @@ export declare class Agent {
      * wake keys on the live room / hire.
      */
     private dropStaleCancelledAgreementSession;
-    private laneAgreementIsTerminal;
+    private agreementIsTerminal;
     /**
      * Whether the host answers this wake without spending a model turn.
      *
@@ -372,7 +376,7 @@ export declare class Agent {
      *
      * A task frame that carries a terminal state AND a result is an echo of work
      * this agent has already finished: there is no decision left in it. Dropping it
-     * is not the same suppression as {@link laneAgreementIsTerminal}, which waits
+     * is not the same suppression as {@link agreementIsTerminal}, which waits
      * for the agreement to end — this fires while the engagement is still live,
      * which is where the cost actually was.
      *
@@ -418,6 +422,14 @@ export declare class Agent {
      * need". Without it the extra turn buys nothing, so it is not spent.
      */
     private canAskForAccess;
+    /**
+     * The work destination comes from the selected execution first, then the
+     * structured wake. It does not depend on an earlier message being delivered
+     * to this host, so task-first and restarted/scheduled runs work identically.
+     * A reply defaults to the message that woke it, and to the wake's task.
+     * A lane name is never an address: a conversation comes from a message.
+     */
+    private wakeDestinationFor;
     private _processEvent;
     private _processEventInContext;
     /**
@@ -467,6 +479,7 @@ export declare class Agent {
     /** replay task-assigned for an existing active task (demo recovery). */
     wakeTaskAssignment(taskId: string, options?: {
         fromInbox?: boolean;
+        inputs?: import('./types.js').TaskInputRef[];
     }): Promise<void>;
     /**
      * Stop taking work. Timers and polls stop at once; the inbox loop cancels