digital-workers 2.1.1 → 2.3.0

package/CHANGELOG.md

@@ -1,5 +1,28 @@
 # digital-workers
 
+## 2.3.0
+
+### Patch Changes
+
+- Updated dependencies [9e2779a]
+  - ai-functions@2.3.0
+  - ai-workflows@2.3.0
+
+## 2.1.3
+
+### Patch Changes
+
+- Documentation and testing improvements
+
+  - Add deterministic AI testing suite with self-validating patterns
+  - Apply StoryBrand narrative to all package READMEs
+  - Update TESTING.md with four principles of deterministic AI testing
+  - Fix duplicate examples package name conflict
+
+- Updated dependencies
+  - ai-functions@2.1.3
+  - ai-workflows@2.1.3
+
 ## 2.1.1
 
 ### Patch Changes

package/README.md

@@ -1,73 +1,50 @@
 # digital-workers
 
-Abstract interface for organizing digital work, independent of whether AI or humans perform individual tasks.
+![Stability: Beta](https://img.shields.io/badge/stability-beta-yellow)
 
-## Overview
+**You're building AI-powered workflows. But who should actually do the work?**
 
-**Digital workers** provides the foundational abstraction for structuring and organizing work in the digital enterprise. It defines a unified interface that both AI agents and humans implement, enabling you to design workflows without coupling them to specific execution strategies.
+Sometimes it's an AI agent operating autonomously. Sometimes it requires human judgment. Often it's both working together. And as AI capabilities evolve, you need workflows that can adapt without rewriting everything.
 
-### Why This Abstraction Matters
+`digital-workers` gives you a single interface that works whether the worker is human or AI - so you can design once and swap implementations as your needs change.
 
-When building AI-powered systems, you face a fundamental question: *who should do this task?* Sometimes it's an AI agent operating autonomously. Sometimes it requires human judgment. Often it's a mix of both.
+## The Problem
 
-`digital-workers` lets you define work in terms of **what** needs to happen, not **who** does it:
+```typescript
+// Without digital-workers: You're locked into implementation details
+if (task.requiresHumanJudgment) {
+  await sendSlackToAlice(task.description)
+  const approval = await waitForSlackResponse()
+  // Different code path for humans...
+} else {
+  await callAIAgent(task.description)
+  // Completely different code path for AI...
+}
+```
+
+Your workflow logic becomes tangled with *who* does the work instead of *what* needs to happen.
+
+## The Solution
 
 ```typescript
-// This workflow doesn't care if alice is an AI agent or a human
+// With digital-workers: Define what, not who
 await worker$.approve('Deploy v2.0 to production', alice, { via: 'slack' })
 ```
 
-The same Worker interface works whether `alice` is:
+The same code works whether `alice` is:
 - A human product manager who gets a Slack notification
 - An AI agent that evaluates deployment criteria autonomously
 - A supervised AI that escalates to humans for high-risk decisions
 
-### Package Relationships
+## Quick Start
 
-```
-┌─────────────────────────────────────────────────────────┐
-│                    ai-workflows                         │
-│              (orchestrates work execution)              │
-└────────────────────────┬────────────────────────────────┘
-                         │
-                         ▼
-┌─────────────────────────────────────────────────────────┐
-│                  digital-workers                        │
-│         (abstract interface for work & workers)         │
-└────────────────────────┬────────────────────────────────┘
-                         │
-           ┌─────────────┴─────────────┐
-           ▼                           ▼
-┌─────────────────────┐   ┌─────────────────────────────┐
-│  autonomous-agents  │   │     human-in-the-loop       │
-│  (AI implementation)│   │   (human implementation)    │
-└─────────────────────┘   └─────────────────────────────┘
-```
-
-- **digital-workers**: Defines the abstract `Worker` interface, action types, and communication patterns
-- **autonomous-agents**: Implements `Worker` for AI agents with autonomous decision-making
-- **human-in-the-loop**: Implements `Worker` for humans with approval workflows and notifications
-
-## Installation
+### 1. Install
 
 ```bash
 pnpm add digital-workers
 ```
 
-## Core Concepts
-
-### The Worker Abstraction
-
-A **Worker** is the unified interface for any entity that can perform work—whether AI or human. This abstraction enables you to:
-
-1. **Design workflows once** - Define your business logic without hardcoding execution strategy
-2. **Swap implementations** - Start with humans, transition to AI agents as they prove reliable
-3. **Mix freely** - Teams can include both AI agents and humans working together
-4. **Route dynamically** - Assign tasks based on availability, capability, or risk level
-
-### Worker
-
-A **Worker** is the common interface for both AI agents and humans:
+### 2. Define Your Workers
 
 ```typescript
 import type { Worker } from 'digital-workers'
@@ -80,7 +57,6 @@ const alice: Worker = {
   contacts: {
     email: 'alice@company.com',
     slack: { workspace: 'acme', user: 'U123' },
-    phone: '+1-555-1234',
   },
 }
 
@@ -90,57 +66,12 @@ const codeReviewer: Worker = {
   type: 'agent',
   status: 'available',
   contacts: {
-    api: { endpoint: 'https://api.internal/reviewer', auth: 'bearer' },
-    webhook: { url: 'https://hooks.internal/reviewer' },
+    api: { endpoint: 'https://api.internal/reviewer' },
   },
 }
 ```
 
-### Contacts
-
-Workers have **contacts** that define how they can be reached:
-
-```typescript
-import type { Contacts } from 'digital-workers'
-
-const contacts: Contacts = {
-  email: 'team@company.com',                    // Simple string
-  slack: { workspace: 'acme', channel: '#eng' }, // Config object
-  phone: { number: '+1-555-0000', voice: 'en-US' },
-  sms: '+1-555-0001',
-  teams: { tenant: 'company', channel: 'Engineering' },
-  discord: { server: 'dev-community', channel: 'support' },
-  telegram: { chat: '@company_support' },
-  web: { url: 'https://dashboard.company.com', pushEnabled: true },
-  api: { endpoint: 'https://api.company.com', auth: 'bearer' },
-  webhook: { url: 'https://hooks.company.com/events' },
-}
-```
-
-### Team
-
-**Teams** group workers with shared contacts:
-
-```typescript
-import { Team } from 'digital-workers'
-
-const engineering = Team({
-  id: 'team_eng',
-  name: 'Engineering',
-  members: [alice, bob, codeReviewer],
-  contacts: {
-    slack: '#engineering',
-    email: 'eng@company.com',
-  },
-  lead: alice,
-})
-```
-
-## Worker Actions
-
-Worker actions are durable workflow actions with Actor/Object semantics that integrate with `ai-workflows`:
-
-### Using with Workflows (Recommended)
+### 3. Build Your Workflow
 
 ```typescript
 import { Workflow } from 'ai-workflows'
@@ -151,7 +82,7 @@ const workflow = Workflow($ => {
   const worker$ = withWorkers($)
 
   $.on.Expense.submitted(async (expense) => {
-    // Notify finance team
+    // Notify the finance team
     await worker$.notify(finance, `New expense: ${expense.amount}`)
 
     // Request approval from manager
@@ -168,58 +99,35 @@ const workflow = Workflow($ => {
 })
 ```
 
-### Direct Workflow Integration
+## What You Can Do
 
-```typescript
-// Using $.do for durable actions
-await $.do('Worker.notify', {
-  actor: 'system',
-  object: alice,
-  action: 'notify',
-  message: 'Deployment complete',
-  via: 'slack',
-})
-
-// Using $.send for fire-and-forget
-await $.send('Worker.notified', { ... })
-```
-
-### Action Types
-
-#### notify - Send notifications
+### Notify - Send Messages
 
 ```typescript
-await worker$.notify(target, 'Message content', {
-  via: 'slack',           // Channel to use
-  priority: 'urgent',     // 'low' | 'normal' | 'high' | 'urgent'
+await worker$.notify(target, 'Deployment complete', {
+  via: 'slack',
+  priority: 'urgent',
 })
 ```
 
-#### ask - Request information
+### Ask - Request Information
 
 ```typescript
-const result = await worker$.ask<Priority>(
+const result = await worker$.ask<{ priority: string }>(
   target,
   'What priority should this be?',
-  {
-    via: 'slack',
-    schema: { priority: 'low | normal | high' },
-  }
+  { schema: { priority: 'low | normal | high' } }
 )
-console.log(result.answer) // { priority: 'high' }
+console.log(result.answer.priority) // 'high'
 ```
 
-#### approve - Request approval
+### Approve - Get Sign-off
 
 ```typescript
 const result = await worker$.approve(
   'Deploy v2.0 to production',
   manager,
-  {
-    via: 'slack',
-    context: { version: '2.0', environment: 'production' },
-    timeout: 3600000, // 1 hour
-  }
+  { via: 'slack', timeout: 3600000 }
 )
 
 if (result.approved) {
@@ -227,12 +135,12 @@ if (result.approved) {
 }
 ```
 
-#### decide - AI-powered decisions
+### Decide - Make Choices
 
 ```typescript
 const result = await worker$.decide({
   options: ['React', 'Vue', 'Svelte'],
-  context: 'Choosing a frontend framework for our new project',
+  context: 'Choosing a frontend framework',
   criteria: ['DX', 'Performance', 'Ecosystem'],
 })
 
@@ -241,9 +149,31 @@ console.log(result.reasoning)  // 'React offers the best ecosystem...'
 console.log(result.confidence) // 0.85
 ```
 
-## Standalone Functions
+## Teams
 
-For use outside workflows:
+Group workers with shared contacts:
+
+```typescript
+import { Team } from 'digital-workers'
+
+const engineering = Team({
+  id: 'team_eng',
+  name: 'Engineering',
+  members: [alice, bob, codeReviewer],
+  contacts: {
+    slack: '#engineering',
+    email: 'eng@company.com',
+  },
+  lead: alice,
+})
+
+// Notify the whole team
+await worker$.notify(engineering, 'Sprint planning in 10 minutes')
+```
+
+## Standalone Usage
+
+Use outside of workflows:
 
 ```typescript
 import { notify, ask, approve, decide } from 'digital-workers'
@@ -251,87 +181,113 @@ import { notify, ask, approve, decide } from 'digital-workers'
 // Simple notification
 await notify(alice, 'Task completed', { via: 'slack' })
 
-// Ask with variants
+// Ask variants
 await ask(alice, 'What is the status?')
 await ask.ai('What is our refund policy?', { policies: [...] })
 await ask.yesNo(manager, 'Should we proceed?')
 
 // Approval variants
 await approve('Deploy to production', manager)
-await approve.all('Major change', [cto, vpe, securityLead])
-await approve.any('Urgent fix', oncallTeam)
+await approve.all('Major change', [cto, vpe, securityLead])  // All must approve
+await approve.any('Urgent fix', oncallTeam)                   // Any one can approve
 
-// Decision making
+// Decision variants
 await decide({ options: ['A', 'B', 'C'], criteria: ['cost', 'time'] })
 await decide.yesNo('Should we proceed?', context)
 await decide.prioritize(['Task 1', 'Task 2', 'Task 3'])
 ```
 
-## Additional Utilities
+## How It Fits Together
+
+```
+┌─────────────────────────────────────────────────────────┐
+│                    ai-workflows                         │
+│              (orchestrates work execution)              │
+└────────────────────────┬────────────────────────────────┘
+                         │
+                         ▼
+┌─────────────────────────────────────────────────────────┐
+│                  digital-workers                        │
+│         (abstract interface for work & workers)         │
+└────────────────────────┬────────────────────────────────┘
+                         │
+           ┌─────────────┴─────────────┐
+           ▼                           ▼
+┌─────────────────────┐   ┌─────────────────────────────┐
+│  autonomous-agents  │   │     human-in-the-loop       │
+│  (AI implementation)│   │   (human implementation)    │
+└─────────────────────┘   └─────────────────────────────┘
+```
+
+- **digital-workers**: The abstract `Worker` interface, action types, and communication patterns
+- **autonomous-agents**: Implements `Worker` for AI agents with autonomous decision-making
+- **human-in-the-loop**: Implements `Worker` for humans with approval workflows and notifications
+- **ai-workflows**: Orchestrates work execution with durable, event-driven workflows
+
+## Advanced Features
+
+### Capability Tiers
 
-### Role Definition
+Route work based on agent capabilities:
 
 ```typescript
-import { Role } from 'digital-workers'
+import { matchTierToComplexity, canExecuteAtTier } from 'digital-workers'
 
-const engineer = Role({
-  name: 'Software Engineer',
-  description: 'Builds and maintains software',
-  responsibilities: ['Write code', 'Review PRs', 'Fix bugs'],
-  skills: ['TypeScript', 'React', 'Node.js'],
-})
+const tier = matchTierToComplexity({ reasoning: 'high', toolUse: true })
+// Returns: { tier: 'agentic', confidence: 0.9 }
 ```
 
-### Goals & KPIs
+### Load Balancing
+
+Distribute work across available workers:
 
 ```typescript
-import { Goals, kpis, okrs } from 'digital-workers'
-
-const teamGoals = Goals({
-  shortTerm: ['Ship v2.0', 'Reduce tech debt'],
-  longTerm: ['100% test coverage'],
-  metrics: [
-    { name: 'Velocity', current: 42, target: 50, unit: 'points' },
-  ],
-})
+import { createLeastBusyBalancer, createCapabilityRouter } from 'digital-workers'
+
+const balancer = createLeastBusyBalancer(workers)
+const router = createCapabilityRouter(agents)
 ```
 
-### Content Generation
+### Error Escalation
+
+Automatic escalation when things go wrong:
 
 ```typescript
-import { generate } from 'digital-workers'
+import { createEscalationEngine, createEscalationPolicy } from 'digital-workers'
 
-const result = await generate('Write a product description', {
-  type: 'text',
-  instructions: 'Keep it under 100 words',
+const policy = createEscalationPolicy({
+  maxRetries: 3,
+  escalationPath: ['junior-agent', 'senior-agent', 'human'],
 })
+
+const engine = createEscalationEngine(policy)
 ```
 
-### Type Validation
+### Agent Communication
+
+Direct agent-to-agent messaging:
 
 ```typescript
-import { is } from 'digital-workers'
+import { sendToAgent, requestFromAgent, initiateHandoff } from 'digital-workers'
 
-const result = await is('hello@example.com', 'email')
-console.log(result.valid) // true
+await sendToAgent(targetAgent, { type: 'task', payload: data })
+const response = await requestFromAgent(agent, query, { timeout: 5000 })
+await initiateHandoff(fromAgent, toAgent, context)
 ```
 
 ## Type Reference
 
-Key types exported:
+Key exports:
 
-- `Worker` - Worker interface
-- `Team` - Team interface
-- `WorkerRef` - Lightweight worker reference
-- `Contacts` - Contact configuration
-- `ContactChannel` - Channel names
-- `WorkerAction` - Action types
-- `NotifyResult`, `AskResult`, `ApprovalResult`, `DecideResult`, `DoResult`
-- `WorkerContext` - Context extension for workflows
+- `Worker`, `Team`, `WorkerRef` - Core interfaces
+- `Contacts`, `ContactChannel` - Communication configuration
+- `NotifyResult`, `AskResult`, `ApprovalResult`, `DecideResult`, `DoResult` - Action results
+- `CapabilityTier`, `CapabilityProfile` - Agent capability levels
+- `LoadBalancer`, `EscalationEngine` - Advanced orchestration
 
 ## Related Packages
 
-- `autonomous-agents` - **Implements** `Worker` for AI agents with autonomous decision-making, goals, and metrics
-- `human-in-the-loop` - **Implements** `Worker` for humans with approval workflows, notifications, and escalation
-- `ai-workflows` - **Uses** `digital-workers` to orchestrate work execution with durable, event-driven workflows
-- `services-as-software` - External service integration (crosses company boundaries, unlike workers)
+- **autonomous-agents** - Implements `Worker` for AI agents with goals, metrics, and autonomous decision-making
+- **human-in-the-loop** - Implements `Worker` for humans with approval workflows, notifications, and escalation
+- **ai-workflows** - Uses `digital-workers` to orchestrate work execution with durable, event-driven workflows
+- **services-as-software** - External service integration (crosses company boundaries, unlike workers)

package/dist/actions.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"actions.d.ts","sourceRoot":"","sources":["../src/actions.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,cAAc,CAAA;AACnD,OAAO,KAAK,EAIV,YAAY,EAGZ,gBAAgB,EAChB,aAAa,EACb,iBAAiB,EACjB,gBAAgB,EAChB,YAAY,EACZ,YAAY,EACZ,SAAS,EACT,cAAc,EACd,YAAY,EACZ,QAAQ,EACR,aAAa,EACb,UAAU,EACV,cAAc,EACd,aAAa,EACb,aAAa,EACd,MAAM,YAAY,CAAA;AAMnB;;GAEG;AACH,wBAAsB,YAAY,CAChC,IAAI,EAAE,gBAAgB,EACtB,CAAC,EAAE,eAAe,GACjB,OAAO,CAAC,YAAY,CAAC,CAkDvB;AAED;;GAEG;AACH,wBAAsB,SAAS,CAAC,CAAC,GAAG,MAAM,EACxC,IAAI,EAAE,aAAa,EACnB,CAAC,EAAE,eAAe,GACjB,OAAO,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,CA4BvB;AAED;;GAEG;AACH,wBAAsB,aAAa,CACjC,IAAI,EAAE,iBAAiB,EACvB,CAAC,EAAE,eAAe,GACjB,OAAO,CAAC,cAAc,CAAC,CAiCzB;AAED;;GAEG;AACH,wBAAsB,YAAY,CAAC,CAAC,GAAG,MAAM,EAC3C,IAAI,EAAE,gBAAgB,EACtB,CAAC,EAAE,eAAe,GACjB,OAAO,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,CAU1B;AAED;;GAEG;AACH,wBAAsB,QAAQ,CAAC,CAAC,GAAG,OAAO,EACxC,IAAI,EAAE,YAAY,EAClB,CAAC,EAAE,eAAe,GACjB,OAAO,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,CAyDtB;AAMD;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,qBAAqB,CAAC,CAAC,EAAE,eAAe,GAAG,IAAI,CAY9D;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,WAAW,CAAC,CAAC,EAAE,eAAe,GAAG,eAAe,GAAG,aAAa,CAgE/E;AAMD;;GAEG;AACH,wBAAsB,MAAM,CAC1B,MAAM,EAAE,YAAY,EACpB,OAAO,EAAE,MAAM,EACf,OAAO,GAAE,aAAkB,GAC1B,OAAO,CAAC,YAAY,CAAC,CA2BvB;AAED;;GAEG;AACH,wBAAsB,GAAG,CAAC,CAAC,GAAG,MAAM,EAClC,MAAM,EAAE,YAAY,EACpB,QAAQ,EAAE,MAAM,EAChB,OAAO,GAAE,UAAe,GACvB,OAAO,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,CAgBvB;AAED;;GAEG;AACH,wBAAsB,OAAO,CAC3B,OAAO,EAAE,MAAM,EACf,MAAM,EAAE,YAAY,EACpB,OAAO,GAAE,cAAmB,GAC3B,OAAO,CAAC,cAAc,CAAC,CAiBzB;AAED;;GAEG;AACH,wBAAsB,MAAM,CAAC,CAAC,GAAG,MAAM,EACrC,OAAO,EAAE,aAAa,CAAC,CAAC,CAAC,GACxB,OAAO,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,CAE1B"}
+{"version":3,"file":"actions.d.ts","sourceRoot":"","sources":["../src/actions.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,cAAc,CAAA;AAEnD,OAAO,KAAK,EAIV,YAAY,EAGZ,gBAAgB,EAChB,aAAa,EACb,iBAAiB,EACjB,gBAAgB,EAChB,YAAY,EACZ,YAAY,EACZ,SAAS,EACT,cAAc,EACd,YAAY,EACZ,QAAQ,EACR,aAAa,EACb,UAAU,EACV,cAAc,EACd,aAAa,EACb,aAAa,EACd,MAAM,YAAY,CAAA;AAMnB;;GAEG;AACH,wBAAsB,YAAY,CAChC,IAAI,EAAE,gBAAgB,EACtB,CAAC,EAAE,eAAe,GACjB,OAAO,CAAC,YAAY,CAAC,CAkDvB;AAED;;GAEG;AACH,wBAAsB,SAAS,CAAC,CAAC,GAAG,MAAM,EACxC,IAAI,EAAE,aAAa,EACnB,CAAC,EAAE,eAAe,GACjB,OAAO,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,CA+BvB;AAED;;GAEG;AACH,wBAAsB,aAAa,CACjC,IAAI,EAAE,iBAAiB,EACvB,CAAC,EAAE,eAAe,GACjB,OAAO,CAAC,cAAc,CAAC,CAiCzB;AAED;;GAEG;AACH,wBAAsB,YAAY,CAAC,CAAC,GAAG,MAAM,EAC3C,IAAI,EAAE,gBAAgB,EACtB,CAAC,EAAE,eAAe,GACjB,OAAO,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,CAU1B;AAED;;GAEG;AACH,wBAAsB,QAAQ,CAAC,CAAC,GAAG,OAAO,EACxC,IAAI,EAAE,YAAY,EAClB,CAAC,EAAE,eAAe,GACjB,OAAO,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,CA2DtB;AAMD;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,qBAAqB,CAAC,CAAC,EAAE,eAAe,GAAG,IAAI,CAY9D;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,WAAW,CAAC,CAAC,EAAE,eAAe,GAAG,eAAe,GAAG,aAAa,CAoE/E;AAMD;;GAEG;AACH,wBAAsB,MAAM,CAC1B,MAAM,EAAE,YAAY,EACpB,OAAO,EAAE,MAAM,EACf,OAAO,GAAE,aAAkB,GAC1B,OAAO,CAAC,YAAY,CAAC,CA6BvB;AAED;;GAEG;AACH,wBAAsB,GAAG,CAAC,CAAC,GAAG,MAAM,EAClC,MAAM,EAAE,YAAY,EACpB,QAAQ,EAAE,MAAM,EAChB,OAAO,GAAE,UAAe,GACvB,OAAO,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,CAgBvB;AAED;;GAEG;AACH,wBAAsB,OAAO,CAC3B,OAAO,EAAE,MAAM,EACf,MAAM,EAAE,YAAY,EACpB,OAAO,GAAE,cAAmB,GAC3B,OAAO,CAAC,cAAc,CAAC,CAiBzB;AAED;;GAEG;AACH,wBAAsB,MAAM,CAAC,CAAC,GAAG,MAAM,EAAE,OAAO,EAAE,aAAa,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,CAE5F"}

package/dist/actions.js

@@ -10,6 +10,7 @@
  *
  * @packageDocumentation
  */
+import { generateRequestId } from './utils/id.js';
 // ============================================================================
 // Action Handlers
 // ============================================================================
@@ -73,10 +74,13 @@ export async function handleAsk(data, $) {
         throw new Error('No valid channel available for ask action');
     }
     // Send question and wait for response
-    const answer = await sendQuestion(channel, question, contacts, { schema, timeout });
+    const answer = await sendQuestion(channel, question, contacts, {
+        ...(schema !== undefined && { schema }),
+        ...(timeout !== undefined && { timeout }),
+    });
     const result = {
         answer,
-        answeredBy: recipient,
+        ...(recipient !== undefined && { answeredBy: recipient }),
         answeredAt: new Date(),
         via: channel,
     };
@@ -99,15 +103,15 @@ export async function handleApprove(data, $) {
     }
     // Send approval request and wait for response
     const response = await sendApprovalRequest(channel, request, contacts, {
-        context,
-        timeout,
-        escalate,
+        ...(context !== undefined && { context }),
+        ...(timeout !== undefined && { timeout }),
+        ...(escalate !== undefined && { escalate }),
     });
     const result = {
         approved: response.approved,
-        approvedBy: approver,
+        ...(approver !== undefined && { approvedBy: approver }),
         approvedAt: new Date(),
-        notes: response.notes,
+        ...(response.notes !== undefined && { notes: response.notes }),
         via: channel,
     };
     // Emit result event
@@ -143,7 +147,9 @@ export async function handleDo(data, $) {
                 timestamp: new Date(),
             });
             // Execute the task (this would integrate with agent execution)
-            result = await executeTask(target, instruction, { timeout });
+            result = await executeTask(target, instruction, {
+                ...(timeout !== undefined && { timeout }),
+            });
             steps.push({
                 action: 'complete',
                 result,
@@ -171,7 +177,7 @@ export async function handleDo(data, $) {
     const failResult = {
         result: undefined,
         success: false,
-        error: lastError?.message,
+        ...(lastError !== undefined && { error: lastError.message }),
         duration: Date.now() - startTime,
         steps,
     };
@@ -207,12 +213,12 @@ export function registerWorkerActions($) {
     // Register action handlers using the proxy pattern
     // The $ context provides event registration via $.on[Namespace][event]
     const on = $.on;
-    if (on.Worker) {
-        on.Worker.notify?.(handleNotify);
-        on.Worker.ask?.(handleAsk);
-        on.Worker.approve?.(handleApprove);
-        on.Worker.decide?.(handleDecide);
-        on.Worker.do?.(handleDo);
+    if (on['Worker']) {
+        on['Worker']['notify']?.(handleNotify);
+        on['Worker']['ask']?.(handleAsk);
+        on['Worker']['approve']?.(handleApprove);
+        on['Worker']['decide']?.(handleDecide);
+        on['Worker']['do']?.(handleDo);
     }
 }
 /**
@@ -238,6 +244,7 @@ export function registerWorkerActions($) {
 export function withWorkers($) {
     const workerContext = {
         async notify(target, message, options = {}) {
+            // Workflow handler returns NotifyResult; $.do passes through the result
             return $.do('Worker.notify', {
                 actor: 'system',
                 object: target,
@@ -260,7 +267,11 @@ export function withWorkers($) {
             const actor = typeof target === 'string'
                 ? target
                 : 'id' in target
-                    ? { id: target.id, type: 'type' in target ? target.type : undefined, name: 'name' in target ? target.name : undefined }
+                    ? {
+                        id: target.id,
+                        ...('type' in target && target.type !== undefined && { type: target.type }),
+                        ...('name' in target && target.name !== undefined && { name: target.name }),
+                    }
                     : 'system';
             return $.do('Worker.approve', {
                 actor,
@@ -295,7 +306,9 @@ export async function notify(target, message, options = {}) {
     }
     const delivery = await Promise.all(channels.map(async (channel) => {
         try {
-            await sendToChannel(channel, message, contacts, { priority: options.priority });
+            await sendToChannel(channel, message, contacts, {
+                ...(options.priority !== undefined && { priority: options.priority }),
+            });
             return { channel, status: 'sent' };
         }
         catch (error) {
@@ -323,7 +336,7 @@ export async function ask(target, question, options = {}) {
     const answer = await sendQuestion(channel, question, contacts, options);
     return {
         answer,
-        answeredBy: recipients[0],
+        ...(recipients[0] !== undefined && { answeredBy: recipients[0] }),
         answeredAt: new Date(),
         via: channel,
     };
@@ -340,9 +353,9 @@ export async function approve(request, target, options = {}) {
     const response = await sendApprovalRequest(channel, request, contacts, options);
     return {
         approved: response.approved,
-        approvedBy: recipients[0],
+        ...(recipients[0] !== undefined && { approvedBy: recipients[0] }),
         approvedAt: new Date(),
-        notes: response.notes,
+        ...(response.notes !== undefined && { notes: response.notes }),
         via: channel,
     };
 }
@@ -432,6 +445,6 @@ async function executeTask(target, instruction, options) {
     return { completed: true, instruction };
 }
 function generateId(prefix) {
-    return `${prefix}_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+    return generateRequestId(prefix);
 }
 //# sourceMappingURL=actions.js.map