@ziggs-ai/agent-sdk 0.1.10 → 0.1.11

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