@ziggs-ai/agent-sdk 0.1.9 → 0.1.11

package/src/server/tools/tier1/protocolRunner.ts

@@ -32,6 +32,7 @@ interface ProtocolPayload {
   parentAgreementId?: string;
   parentTaskId?: string;
   taskId?: string;
+  stepId?: string;
   assigneeId?: string;
   status?: string;
   result?: unknown;
@@ -97,12 +98,20 @@ export async function dispatchProtocolOp(
         planReviewTiming: payload.planReviewTiming,
         requireMidWorkPlanAck: payload.requireMidWorkPlanAck,
         assigneeId: payload.assigneeId,
+        inputArtifactIds: Array.isArray(payload.inputArtifactIds)
+          ? (payload.inputArtifactIds as string[])
+          : undefined,
       });
     case 'task-update':
       if (!payload.taskId || !payload.status) return null;
       return taskService.updateState(payload.taskId, normalizeState(payload.status) as Parameters<typeof taskService.updateState>[1], payload.result);
+    case 'task-update-plan-step':
+      if (!payload.taskId) throw new Error('task-update-plan-step requires `taskId`');
+      if (!payload.stepId) throw new Error('task-update-plan-step requires `stepId`');
+      if (!payload.status) throw new Error('task-update-plan-step requires `status`');
+      return taskService.updatePlanStep(payload.taskId, payload.stepId, payload.status, payload.result);
     default:
-      return null;
+      throw new Error(`Unknown protocol operation: ${operation}`);
   }
 }
 

package/src/server/tools/tier1/protocolTools.ts

@@ -87,7 +87,7 @@ export const taskUpdatePlanStepTool: ToolDefinition = defineTool(
 
 export const taskSpawnTool: ToolDefinition = defineTool(
   'task_spawn',
-  { agreementId: { type: 'string', required: true }, description: { type: 'string', required: true }, parentTaskId: 'string', assigneeId: { type: 'string', description: 'Explicitly hand this task to one specific agent (e.g. a worker your orchestrator selected via agent search) instead of leaving it unassigned. Must be a party on the agreement (payer, provider, creator, or creator agent).' }, plan: { type: 'object' }, planReviewTiming: 'string', requireMidWorkPlanAck: 'boolean' },
+  { agreementId: { type: 'string', required: true }, description: { type: 'string', required: true }, parentTaskId: 'string', assigneeId: { type: 'string', description: 'Explicitly hand this task to one specific agent (e.g. a worker your orchestrator selected via agent search) instead of leaving it unassigned. Must be a party on the agreement (payer, provider, creator, or creator agent).' }, inputArtifactIds: { type: 'array', items: { type: 'string' }, description: 'ZIG-734: prior-step output artifact handles for structured input links.' }, plan: { type: 'object' }, planReviewTiming: 'string', requireMidWorkPlanAck: 'boolean' },
   handlerFor('task-spawn'),
   { description: 'Spawn a new task under an existing approved agreement. Use when the contract is already in place. Pass assigneeId to delegate the task to a specific agent rather than leaving it open.' },
 );

package/src/server/tools/tier2/paymentTools.ts

@@ -121,14 +121,8 @@ export const paymentIssueGrantTool: ToolDefinition = defineTool('payment_issue_g
   issueGrantHandler,
 );
 
-/** @deprecated Use payment_issue_grant */
-export const paymentIssueTokenTool: ToolDefinition = defineTool('payment_issue_token',
-  { holderId: { type: 'string', required: true }, maxAmount: 'number', dailyBudget: 'number', allowedRecipients: ['string'], expiresInSeconds: 'number' },
-  issueGrantHandler,
-);
-
 const attenuateGrantHandler = async (args: AnyObj, ctx: Ctx) => {
-  const grantId = (args['grantId'] || args['tokenId']) as string;
+  const grantId = args['grantId'] as string;
   if (!grantId) throw new Error('grantId is required');
   if (!args['holderId']) throw new Error('holderId is required');
   try {
@@ -144,14 +138,8 @@ export const paymentAttenuateGrantTool: ToolDefinition = defineTool('payment_att
   attenuateGrantHandler,
 );
 
-/** @deprecated Use payment_attenuate_grant */
-export const paymentAttenuateTokenTool: ToolDefinition = defineTool('payment_attenuate_token',
-  { tokenId: { type: 'string', required: true }, holderId: { type: 'string', required: true }, maxAmount: 'number', dailyBudget: 'number', allowedRecipients: ['string'], expiresInSeconds: 'number' },
-  attenuateGrantHandler,
-);
-
 const revokeGrantHandler = async (args: AnyObj, ctx: Ctx) => {
-  const grantId = (args['grantId'] || args['tokenId']) as string;
+  const grantId = args['grantId'] as string;
   if (!grantId) throw new Error('grantId is required');
   try {
     const result = await clientFor(ctx).revokeGrant(grantId) as AnyObj;
@@ -164,12 +152,6 @@ export const paymentRevokeGrantTool: ToolDefinition = defineTool('payment_revoke
   revokeGrantHandler,
 );
 
-/** @deprecated Use payment_revoke_grant */
-export const paymentRevokeTokenTool: ToolDefinition = defineTool('payment_revoke_token',
-  { tokenId: { type: 'string', required: true } },
-  revokeGrantHandler,
-);
-
 const listGrantsHandler = async (_args: AnyObj, ctx: Ctx) => {
   try {
     const result = await clientFor(ctx).listGrants();
@@ -181,11 +163,6 @@ export const paymentListGrantsTool: ToolDefinition = defineTool('payment_list_gr
   listGrantsHandler,
 );
 
-/** @deprecated Use payment_list_grants */
-export const paymentListTokensTool: ToolDefinition = defineTool('payment_list_tokens', {},
-  listGrantsHandler,
-);
-
 export const PAYMENT_TOOLS: ToolDefinition[] = [
   paymentBalanceTool, paymentTransferTool, paymentWaitForApprovalTool,
   paymentHoldTool, paymentReleaseTool, paymentResolveWalletTool,

package/src/types.ts

@@ -26,6 +26,10 @@ export interface TaskRef {
   state?: string;
   description?: string;
   parentTaskId?: string;
+  executorId?: string;
+  assigneeId?: string | null;
+  /** Work product set by task_update (safeJsonStringify'd string on the wire). */
+  result?: unknown;
   proposal?: { status?: 'pending' | 'approved' | 'rejected' | 'cancelled' };
   proposedToIsYou?: boolean;
   providerIsYou?: boolean;
@@ -43,7 +47,7 @@ export interface ProposalRef {
 export type OutcomeKind =
   | 'enter'
   | 'wait'
-  | 'timeout'
+  | 'state-timeout'
   | 'message-sent'
   | 'message-received'
   | 'task-assigned'
@@ -59,7 +63,7 @@ export type OutcomeKind =
 export type Outcome =
   | { kind: 'enter' }
   | { kind: 'wait' }
-  | { kind: 'timeout' }
+  | { kind: 'state-timeout'; state: string; waitedMs: number }
   | { kind: 'message-sent'; text?: string; receiverId?: string }
   | { kind: 'message-received'; text?: string; senderId?: string; senderType?: string }
   | { kind: 'task-assigned'; task: TaskRef }
@@ -67,7 +71,20 @@ export type Outcome =
   | { kind: 'task-closed'; status: 'completed' | 'failed'; result?: unknown }
   | { kind: 'subtask-finished'; status: 'completed' | 'failed'; task: TaskRef; result?: unknown }
   | { kind: 'proposal-made'; proposal: ProposalRef }
-  | { kind: 'proposal-resolved'; action: 'approve' | 'reject'; proposal: ProposalRef }
+  | {
+      kind: 'proposal-resolved';
+      action: 'approve' | 'reject';
+      proposal: ProposalRef;
+      /**
+       * True when THIS agent made the proposal being resolved. Computed in
+       * AgentMachine._handleFrame by matching proposal.agreementId against
+       * ctx.pendingProposalAgreementId BEFORE applyOutcomeToCtx clears it —
+       * wire frames carry no trustworthy proposer field (agreement_lifecycle
+       * drops `parties` at ingress, and parties.creator is a principal id,
+       * not an agentId). Drives the injected agreement-kickoff default.
+       */
+      proposedByMe: boolean;
+    }
   | { kind: 'tool-result'; tool: string; result: unknown }
   | {
       kind: 'error';
@@ -109,11 +126,26 @@ export interface ToolResultEntry {
   error?: string;
 }
 
+export interface PendingSubtask {
+  /** Executor the task was placed with; null only when the spawn result carried
+   * no executor identity (open/broadcast agreement task not yet claimed). */
+  agentId: string | null;
+  spawnedAt: number;
+}
+
+export interface CollectedSubtaskResult {
+  taskId: string;
+  agentId: string | null;
+  status: 'completed' | 'failed';
+  /** task.result from the finishing event; null when the event carried none. */
+  result: unknown;
+}
+
 /**
  * Per-lane runtime state. Outcome is "what just happened"; Ctx is "what I know."
  *
  * Persistent identifiers (activeAgreementId, pendingProposalAgreementId,
- * delegatedTaskIds) survive across outcomes — they're the memory of which
+ * pendingSubtasks) survive across outcomes — they're the memory of which
  * agreement the agent is currently bound to and which subtasks it's awaiting.
  */
 export interface Ctx {
@@ -124,7 +156,10 @@ export interface Ctx {
   activeTaskId: string | null;
   pendingProposalAgreementId: string | null;
   delegatedAgreementIds: string[];
-  delegatedTaskIds: string[];
+  /** Durable barrier for orchestration: every spawned-but-unfinished subtask, keyed by taskId. */
+  pendingSubtasks: Record<string, PendingSubtask>;
+  /** Every finished subtask of the current engagement, arrival order. Synthesis prompts render ALL of these. */
+  collectedResults: CollectedSubtaskResult[];
 
   // Per-turn working memory
   toolResults: ToolResultEntry[];
@@ -182,6 +217,17 @@ export interface Transition {
 
 export interface ParkedState {
   kind: 'parked';
+  /**
+   * Liveness timer. When the machine settles in this state and no event
+   * arrives on the lane within timeoutMs, the host wakes the lane with a
+   * { kind: 'state-timeout', state, waitedMs } outcome so a transition can
+   * route to a recovery/nudge state. If no transition matches, the machine
+   * parks loudly (runtimeLog.error) and the timer is NOT re-armed. Countdown
+   * starts when the tick settles and resets on any event for the lane.
+   * In-memory only: lost on process restart; re-armed by the next real event
+   * that ticks the lane.
+   */
+  timeoutMs?: number;
   transitions: Transition[];
 }
 
@@ -389,11 +435,14 @@ export interface DefineAgentInput {
 
 /**
  * Frozen output of defineAgent. Consumed directly by AgentHost / createAgent.
- * No mutation — defineAgent validates and returns; injection of defaults is
- * the workflow author's responsibility (visible spread of `thinkingDefaults`).
+ * defineAgent injects ONE default: the agreement-kickoff state `kickingOff`
+ * plus a last-position transition into it, added to states that don't already
+ * handle a proposer-side proposal-resolved/approve outcome (runtime/kickoff.ts).
+ * `wait` defaults remain the author's visible spread of `thinkingDefaults`.
  */
 export interface AgentConfig {
   openaiKey: string | undefined;
+  anthropicKey: string | undefined;
   operatorKey?: string;
   agentId: string;
   description: string;