@electric-ax/agents 0.2.3 → 0.2.4

package/docs/usage/overview.md

@@ -1,6 +1,6 @@
 ---
 title: Overview
-titleTemplate: '... - Electric Agents'
+titleTemplate: "... - Electric Agents"
 description: >-
   High level overview of the Electric Agents system and developer APIs.
 outline: [2, 3]
@@ -31,7 +31,7 @@ The context API passed into the handler:
 
 | Property/Method                     | Purpose                                                               |
 | ----------------------------------- | --------------------------------------------------------------------- |
-| `ctx.firstWake`                     | Boolean -- is this the entity's first activation?                     |
+| `ctx.firstWake`                     | Boolean -- initial setup pass while no manifest entries exist         |
 | `ctx.entityUrl`                     | Identity -- `/type/id`                                                |
 | `ctx.entityType`                    | Type name string                                                      |
 | `ctx.args`                          | Readonly spawn arguments                                              |
@@ -44,13 +44,15 @@ The context API passed into the handler:
 | `ctx.timelineMessages()`            | Project the entity timeline into LLM messages                         |
 | `ctx.insertContext(id, entry)`      | Insert a durable context entry                                        |
 | `ctx.agent.run()`                   | Execute the agent loop                                                |
-| `ctx.electricTools`                 | Runtime-provided tools to spread into agent config                    |
+| `ctx.electricTools`                    | Runtime-provided tools to spread into agent config                    |
 | `ctx.spawn(type, id, args, opts)`   | Create child entity                                                   |
 | `ctx.observe(source, opts)`         | Subscribe to a source via `entity()`, `cron()`, `entities()`, `db()`  |
 | `ctx.send(url, payload, opts)`      | Send message to an entity                                             |
 | `ctx.sleep()`                       | Return to idle                                                        |
 | `ctx.mkdb(id, schema)`              | Create cross-entity shared state                                      |
 | `ctx.observe(db(id, schema), opts)` | Join existing shared state                                            |
+| `ctx.useCodingAgent(sessionId, opts)` | Spawn or attach to a built-in `coder` session                       |
+| `ctx.recordRun()`                   | Record non-LLM work as a run for `runFinished` observers              |
 | `ctx.setTag(key, value)`            | Set a tag on this entity                                              |
 | `ctx.removeTag(key)`                | Remove a tag from this entity                                         |
 
@@ -65,7 +67,9 @@ ctx.useAgent({
   provider?: KnownProvider,   // defaults to 'anthropic' for string models
   tools: AgentTool[],      // [...ctx.electricTools, ...custom]
   streamFn?: StreamFn,     // optional streaming callback
-  testResponses?: string[] // for testing without LLM
+  getApiKey?: (provider: string) => string | Promise<string> | undefined,
+  onPayload?: SimpleStreamOptions["onPayload"],
+  testResponses?: string[] | TestResponseFn // for testing without LLM
 })
 await ctx.agent.run()      // blocks until agent finishes
 ```
@@ -78,15 +82,15 @@ See [Configuring the agent](/docs/agents/usage/configuring-the-agent) and [Agent
 
 ```ts
 const myTool: AgentTool = {
-  name: 'calculator',
-  label: 'Calculator',
-  description: 'Evaluate a mathematical expression.',
+  name: "calculator",
+  label: "Calculator",
+  description: "Evaluate a mathematical expression.",
   parameters: Type.Object({ expression: Type.String() }), // TypeBox
   execute: async (_toolCallId, params) => {
     const { expression } = params as { expression: string }
     const result = evaluate(expression)
     return {
-      content: [{ type: 'text', text: String(result) }],
+      content: [{ type: "text", text: String(result) }],
       details: {},
     }
   },
@@ -98,9 +102,9 @@ const myTool: AgentTool = {
 ```ts
 function createMemoryTool(ctx: HandlerContext): AgentTool {
   return {
-    name: 'memory_store',
-    label: 'Memory Store',
-    description: 'Persist a key-value memory row.',
+    name: "memory_store",
+    label: "Memory Store",
+    description: "Persist a key-value memory row.",
     parameters: Type.Object({
       key: Type.String(),
       value: Type.String(),
@@ -108,7 +112,7 @@ function createMemoryTool(ctx: HandlerContext): AgentTool {
     execute: async (_, params) => {
       const { key, value } = params as { key: string; value: string }
       ctx.db.actions.memory_insert({ row: { key, value } }) // writes to entity state
-      return { content: [{ type: 'text', text: 'Stored.' }], details: {} }
+      return { content: [{ type: "text", text: "Stored." }], details: {} }
     },
   }
 }
@@ -119,9 +123,9 @@ function createMemoryTool(ctx: HandlerContext): AgentTool {
 ```ts
 function createDispatchTool(ctx: HandlerContext): AgentTool {
   return {
-    name: 'dispatch',
-    label: 'Dispatch',
-    description: 'Spawn a worker and return its text output.',
+    name: "dispatch",
+    label: "Dispatch",
+    description: "Spawn a worker and return its text output.",
     parameters: Type.Object({
       id: Type.String(),
       systemPrompt: Type.String(),
@@ -134,13 +138,13 @@ function createDispatchTool(ctx: HandlerContext): AgentTool {
         task: string
       }
       const child = await ctx.spawn(
-        'worker',
+        "worker",
         id,
-        { systemPrompt, tools: ['read'] },
-        { initialMessage: task, wake: 'runFinished' }
+        { systemPrompt, tools: ["read"] },
+        { initialMessage: task, wake: "runFinished" }
       )
-      const text = (await child.text()).join('\n\n')
-      return { content: [{ type: 'text', text }], details: {} }
+      const text = (await child.text()).join("\n\n")
+      return { content: [{ type: "text", text }], details: {} }
     },
   }
 }
@@ -172,6 +176,8 @@ See [Managing state](/docs/agents/usage/managing-state).
   - `opts.wake` -- `'runFinished'`, `{ on: 'runFinished', includeResponse? }`, or `{ on: 'change', collections?, debounceMs?, timeoutMs? }`
 - **`observe(source, opts)`** -> `EntityHandle | ObservationHandle` -- subscribe via `entity()`, `cron()`, `entities()`, `db()`
 - **`send(url, payload, opts)`** -- fire-and-forget message
+- **`useCodingAgent(sessionId, opts)`** -> `CodingSessionHandle` -- spawn or attach to a built-in Claude Code/Codex session
+- **`recordRun()`** -> `RunHandle` -- publish run lifecycle for external work
 - **`sleep()`** -- go idle
 
 **EntityHandle** returned from spawn/observe:
@@ -192,15 +198,15 @@ Define a schema map, then create/connect:
 const schema = {
   findings: {
     schema: z.object({ key: z.string(), text: z.string() }),
-    type: 'shared:finding',
-    primaryKey: 'key',
+    type: "shared:finding",
+    primaryKey: "key",
   },
 }
 // Parent creates:
-ctx.mkdb('research-123', schema)
+ctx.mkdb("research-123", schema)
 // Children connect:
-const shared = await ctx.observe(db('research-123', schema))
-shared.findings.insert({ key: 'f1', text: '...' })
+const shared = await ctx.observe(db("research-123", schema))
+shared.findings.insert({ key: "f1", text: "..." })
 ```
 
 See [Shared state](/docs/agents/usage/shared-state) and [SharedStateHandle reference](/docs/agents/reference/shared-state-handle).
@@ -235,20 +241,21 @@ See [Built-in collections](/docs/agents/reference/built-in-collections).
 
 Interact with the system using the Electric Agents CLI:
 
-| Command                                         | Purpose                          |
-| ----------------------------------------------- | -------------------------------- |
-| `electric agents types`                         | List registered entity types     |
-| `electric agents types inspect <name>`          | Show type schema                 |
-| `electric agents spawn /type/id --args '{...}'` | Create entity                    |
-| `electric agents send /type/id 'message'`       | Send message                     |
-| `electric agents observe /type/id`              | Stream entity events             |
-| `electric agents inspect /type/id`              | Show entity state                |
-| `electric agents ps [--type --status --parent]` | List entities                    |
-| `electric agents kill /type/id`                 | Delete entity                    |
-| `electric agents start`                         | Start local dev environment      |
-| `electric agents start-builtin`                 | Start built-in Horton runtime    |
-| `electric agents quickstart`                    | Start local server and built-ins |
-| `electric agents stop`                          | Stop local dev environment       |
+| Command                                      | Purpose                      |
+| -------------------------------------------- | ---------------------------- |
+| `electric agents types`                       | List registered entity types |
+| `electric agents types inspect <name>`        | Show type schema             |
+| `electric agents spawn /type/id --args '{...}'` | Create entity                |
+| `electric agents send /type/id 'message'`     | Send message                 |
+| `electric agents observe /type/id`            | Stream entity events         |
+| `electric agents inspect /type/id`            | Show entity state            |
+| `electric agents ps [--type --status --parent]` | List entities                |
+| `electric agents kill /type/id`               | Delete entity                |
+| `electric agents start`                       | Start local dev environment  |
+| `electric agents start-builtin`               | Start built-in Horton runtime |
+| `electric agents quickstart`                  | Start local server and built-ins |
+| `electric agents stop`                        | Stop local dev environment   |
+| `electric agents init [project-name]`          | Scaffold a starter app       |
 
 See [CLI reference](/docs/agents/reference/cli).
 
@@ -274,11 +281,11 @@ See [App setup](/docs/agents/usage/app-setup) and [RuntimeHandler reference](/do
 
 Use the client and embedding APIs when you need to work with agents outside an entity handler:
 
-| API                           | Use case                                                          |
-| ----------------------------- | ----------------------------------------------------------------- |
-| `createAgentsClient()`        | Observe entity, membership, or shared-state streams from app code |
-| `useChat()`                   | Render an observed `EntityStreamDB` in React                      |
-| `createRuntimeServerClient()` | Spawn, message, delete, tag, and schedule entities from services  |
-| `BuiltinAgentsServer`         | Host Horton and worker in your own process                        |
+| API                               | Use case                                      |
+| --------------------------------- | --------------------------------------------- |
+| `createAgentsClient()`            | Observe entity, membership, or shared-state streams from app code |
+| `useChat()`                       | Render an observed `EntityStreamDB` in React  |
+| `createRuntimeServerClient()`     | Spawn, message, delete, tag, and schedule entities from services |
+| `BuiltinAgentsServer`             | Host Horton, worker, and coder in your own process |
 
 See [Clients & React](/docs/agents/usage/clients-and-react), [Programmatic runtime client](/docs/agents/usage/programmatic-runtime-client), and [Embedded built-ins](/docs/agents/usage/embedded-builtins).

package/docs/usage/programmatic-runtime-client.md

@@ -1,6 +1,6 @@
 ---
 title: Programmatic runtime client
-titleTemplate: '... - Electric Agents'
+titleTemplate: "... - Electric Agents"
 description: >-
   Use createRuntimeServerClient to spawn entities, send messages, register wakes,
   manage schedules, and connect shared state from application code.
@@ -12,10 +12,10 @@ outline: [2, 3]
 `createRuntimeServerClient()` is the lower-level HTTP client for the Electric Agents server. Handler code should usually use `ctx.spawn()`, `ctx.send()`, `ctx.observe()`, and `ctx.mkdb()` instead. Use this client from application services, tests, CLIs, and integration code that needs to manage entities from outside a handler.
 
 ```ts
-import { createRuntimeServerClient } from '@electric-ax/agents-runtime'
+import { createRuntimeServerClient } from "@electric-ax/agents-runtime"
 
 const client = createRuntimeServerClient({
-  baseUrl: 'http://localhost:4437',
+  baseUrl: "http://localhost:4437",
 })
 ```
 
@@ -41,11 +41,11 @@ interface RuntimeServerClientConfig {
 
 ```ts
 const info = await client.spawnEntity({
-  type: 'horton',
-  id: 'onboarding',
-  args: { timezone: 'Europe/London' },
-  initialMessage: 'Help me get started.',
-  tags: { project: 'docs' },
+  type: "horton",
+  id: "onboarding",
+  args: { timezone: "Europe/London" },
+  initialMessage: "Help me get started.",
+  tags: { project: "docs" },
 })
 
 console.log(info.entityUrl) // "/horton/onboarding"
@@ -64,11 +64,11 @@ interface SpawnEntityOptions {
   wake?: {
     subscriberUrl: string
     condition:
-      | 'runFinished'
+      | "runFinished"
       | {
-          on: 'change'
+          on: "change"
           collections?: string[]
-          ops?: Array<'insert' | 'update' | 'delete'>
+          ops?: Array<"insert" | "update" | "delete">
         }
     debounceMs?: number
     timeoutMs?: number
@@ -80,14 +80,14 @@ interface SpawnEntityOptions {
 ### getEntityInfo
 
 ```ts
-const info = await client.getEntityInfo('/horton/onboarding')
+const info = await client.getEntityInfo("/horton/onboarding")
 // { entityUrl, entityType, streamPath }
 ```
 
 ### deleteEntity
 
 ```ts
-await client.deleteEntity('/horton/onboarding')
+await client.deleteEntity("/horton/onboarding")
 ```
 
 Deleting an already-missing entity is treated as success.
@@ -96,10 +96,10 @@ Deleting an already-missing entity is treated as success.
 
 ```ts
 await client.sendEntityMessage({
-  targetUrl: '/horton/onboarding',
-  payload: 'What changed since last time?',
-  from: 'support-ui',
-  type: 'user_message',
+  targetUrl: "/horton/onboarding",
+  payload: "What changed since last time?",
+  from: "support-ui",
+  type: "user_message",
 })
 ```
 
@@ -118,10 +118,10 @@ interface SendEntityMessageOptions {
 ## Shared State
 
 ```ts
-const streamPath = await client.ensureSharedStateStream('research-123')
+const streamPath = await client.ensureSharedStateStream("research-123")
 // "/_electric/shared-state/research-123"
 
-const samePath = client.getSharedStateStreamPath('research-123')
+const samePath = client.getSharedStateStreamPath("research-123")
 ```
 
 Use `ensureSharedStateStream()` when app code needs to create a shared-state stream before entities connect to it.
@@ -134,9 +134,9 @@ Use `ensureSharedStateStream()` when app code needs to create a shared-state str
 
 ```ts
 await client.registerWake({
-  subscriberUrl: '/coordinator/research',
-  sourceUrl: '/worker/analyst/main',
-  condition: 'runFinished',
+  subscriberUrl: "/coordinator/research",
+  sourceUrl: "/worker/analyst/main",
+  condition: "runFinished",
   includeResponse: true,
 })
 ```
@@ -145,12 +145,12 @@ For change wakes:
 
 ```ts
 await client.registerWake({
-  subscriberUrl: '/monitor/main',
-  sourceUrl: '/horton/onboarding/main',
+  subscriberUrl: "/monitor/main",
+  sourceUrl: "/horton/onboarding/main",
   condition: {
-    on: 'change',
-    collections: ['runs', 'texts'],
-    ops: ['insert', 'update'],
+    on: "change",
+    collections: ["runs", "texts"],
+    ops: ["insert", "update"],
   },
   debounceMs: 250,
 })
@@ -159,13 +159,16 @@ await client.registerWake({
 ### registerCronSource
 
 ```ts
-const streamUrl = await client.registerCronSource('0 9 * * *', 'Europe/London')
+const streamUrl = await client.registerCronSource(
+  "0 9 * * *",
+  "Europe/London"
+)
 ```
 
 ### registerEntitiesSource
 
 ```ts
-const source = await client.registerEntitiesSource({ project: 'docs' })
+const source = await client.registerEntitiesSource({ project: "docs" })
 // { streamUrl, sourceRef }
 ```
 
@@ -177,23 +180,23 @@ Schedules are stored on an entity manifest and return the write transaction id.
 
 ```ts
 await client.upsertCronSchedule({
-  entityUrl: '/horton/onboarding',
-  id: 'daily-checkin',
-  expression: '0 9 * * *',
-  timezone: 'Europe/London',
-  payload: 'Run the daily check-in.',
+  entityUrl: "/horton/onboarding",
+  id: "daily-checkin",
+  expression: "0 9 * * *",
+  timezone: "Europe/London",
+  payload: "Run the daily check-in.",
 })
 
 await client.upsertFutureSendSchedule({
-  entityUrl: '/horton/onboarding',
-  id: 'follow-up',
+  entityUrl: "/horton/onboarding",
+  id: "follow-up",
   fireAt: new Date(Date.now() + 60_000).toISOString(),
-  payload: 'Follow up now.',
+  payload: "Follow up now.",
 })
 
 await client.deleteSchedule({
-  entityUrl: '/horton/onboarding',
-  id: 'follow-up',
+  entityUrl: "/horton/onboarding",
+  id: "follow-up",
 })
 ```
 
@@ -202,15 +205,15 @@ await client.deleteSchedule({
 `setTag()` and `removeTag()` require the entity write token. Handler code should prefer `ctx.setTag()` and `ctx.removeTag()` because the runtime already has the write token.
 
 ```ts
-await client.setTag('/horton/onboarding', 'title', 'Onboarding', writeToken)
-await client.removeTag('/horton/onboarding', 'title', writeToken)
+await client.setTag("/horton/onboarding", "title", "Onboarding", writeToken)
+await client.removeTag("/horton/onboarding", "title", writeToken)
 ```
 
 ## Choosing a Client
 
-| API                            | Use when                                                                     |
-| ------------------------------ | ---------------------------------------------------------------------------- |
-| `ctx.spawn/send/observe`       | You are inside an entity handler.                                            |
-| `createAgentsClient()`         | You need to observe streams and drive UI state.                              |
-| `createRuntimeServerClient()`  | You need to manage entities, messages, wakes, schedules, or tags externally. |
-| `electric-ax/entity-stream-db` | You need the CLI-style entity stream loader with `close()`.                  |
+| API                         | Use when                                                                 |
+| --------------------------- | ------------------------------------------------------------------------ |
+| `ctx.spawn/send/observe`    | You are inside an entity handler.                                        |
+| `createAgentsClient()`      | You need to observe streams and drive UI state.                          |
+| `createRuntimeServerClient()` | You need to manage entities, messages, wakes, schedules, or tags externally. |
+| `electric-ax/entity-stream-db` | You need the CLI-style entity stream loader with `close()`.           |

package/docs/usage/shared-state.md

@@ -1,6 +1,6 @@
 ---
 title: Shared state
-titleTemplate: '... - Electric Agents'
+titleTemplate: "... - Electric Agents"
 description: >-
   Coordinate across entities with shared state streams, schema definition, and cross-entity reads and writes.
 outline: [2, 3]
@@ -18,8 +18,8 @@ Define a `SharedStateSchemaMap` — a record of collection names to their schema
 const researchSchema = {
   findings: {
     schema: z.object({ key: z.string(), domain: z.string(), text: z.string() }),
-    type: 'shared:finding',
-    primaryKey: 'key',
+    type: "shared:finding",
+    primaryKey: "key",
   },
 }
 ```
@@ -32,9 +32,9 @@ The parent entity creates the shared DB stream, typically on `firstWake`:
 
 ```ts
 if (ctx.firstWake) {
-  ctx.mkdb('research-123', researchSchema)
+  ctx.mkdb("research-123", researchSchema)
 }
-const shared = await ctx.observe(db('research-123', researchSchema))
+const shared = await ctx.observe(db("research-123", researchSchema))
 ```
 
 `mkdb` creates the backing stream. It throws if the DB already exists — creation is always a one-time operation guarded by `firstWake` or your own state checks.
@@ -44,8 +44,8 @@ const shared = await ctx.observe(db('research-123', researchSchema))
 `observe` accepts an optional `wake` option to re-wake the entity when the shared state changes:
 
 ```ts
-const shared = await ctx.observe(db('research-123', researchSchema), {
-  wake: { on: 'change', debounceMs: 500 },
+const shared = await ctx.observe(db("research-123", researchSchema), {
+  wake: { on: "change", debounceMs: 500 },
 })
 ```
 
@@ -55,13 +55,13 @@ Pass the shared DB config to children via spawn args:
 
 ```ts
 const child = await ctx.spawn(
-  'worker',
-  'specialist-1',
+  "worker",
+  "specialist-1",
   {
-    systemPrompt: '...',
-    sharedDb: { id: 'research-123', schema: researchSchema },
+    systemPrompt: "...",
+    sharedDb: { id: "research-123", schema: researchSchema },
   },
-  { initialMessage: 'Research topic X', wake: 'runFinished' }
+  { initialMessage: "Research topic X", wake: "runFinished" }
 )
 ```
 
@@ -82,22 +82,22 @@ async handler(ctx) {
 ```ts
 // Insert
 shared.findings.insert({
-  key: 'f1',
-  domain: 'physics',
-  text: 'Finding text...',
+  key: "f1",
+  domain: "physics",
+  text: "Finding text...",
 })
 
 // Read
-shared.findings.get('f1')
+shared.findings.get("f1")
 shared.findings.toArray
 
 // Update
-shared.findings.update('f1', (draft) => {
-  draft.text = 'Updated'
+shared.findings.update("f1", (draft) => {
+  draft.text = "Updated"
 })
 
 // Delete
-shared.findings.delete('f1')
+shared.findings.delete("f1")
 ```
 
 ## SharedStateHandle type
@@ -119,18 +119,18 @@ const debateSchema = {
   arguments: {
     schema: z.object({
       key: z.string(),
-      side: z.enum(['pro', 'con']),
+      side: z.enum(["pro", "con"]),
       text: z.string(),
       round: z.number(),
     }),
-    type: 'shared:argument',
-    primaryKey: 'key',
+    type: "shared:argument",
+    primaryKey: "key",
   },
 }
 
-registry.define('debate', {
+registry.define("debate", {
   state: {
-    status: { primaryKey: 'key' },
+    status: { primaryKey: "key" },
   },
 
   async handler(ctx) {
@@ -143,23 +143,23 @@ registry.define('debate', {
 
     // Spawn pro and con workers with shared state access
     const pro = await ctx.spawn(
-      'worker',
-      'debate-pro',
+      "worker",
+      "debate-pro",
       {
-        systemPrompt: 'Argue FOR the topic.',
+        systemPrompt: "Argue FOR the topic.",
         sharedDb: { id: `debate-${ctx.entityUrl}`, schema: debateSchema },
       },
-      { initialMessage: 'The topic is: ...', wake: 'runFinished' }
+      { initialMessage: "The topic is: ...", wake: "runFinished" }
     )
 
     const con = await ctx.spawn(
-      'worker',
-      'debate-con',
+      "worker",
+      "debate-con",
       {
-        systemPrompt: 'Argue AGAINST the topic.',
+        systemPrompt: "Argue AGAINST the topic.",
         sharedDb: { id: `debate-${ctx.entityUrl}`, schema: debateSchema },
       },
-      { initialMessage: 'The topic is: ...', wake: 'runFinished' }
+      { initialMessage: "The topic is: ...", wake: "runFinished" }
     )
 
     // Read all arguments written by both workers

package/docs/usage/spawning-and-coordinating.md

@@ -1,6 +1,6 @@
 ---
 title: Spawning & coordinating
-titleTemplate: '... - Electric Agents'
+titleTemplate: "... - Electric Agents"
 description: >-
   Spawn child entities, observe existing ones, send messages, and use EntityHandle for coordination.
 outline: [2, 3]
@@ -63,7 +63,7 @@ Wait for a single child:
 
 ```ts
 await child.run
-const output = (await child.text()).join('\n\n')
+const output = (await child.text()).join("\n\n")
 ```
 
 Wait for multiple children in parallel:
@@ -71,7 +71,7 @@ Wait for multiple children in parallel:
 ```ts
 const results = await Promise.all(
   children.map(async ({ handle }) => ({
-    text: (await handle.text()).join('\n\n'),
+    text: (await handle.text()).join("\n\n"),
   }))
 )
 ```
@@ -82,7 +82,7 @@ Subscribe to an existing entity without spawning it:
 
 ```ts
 const handle = await ctx.observe(entity(entityUrl), {
-  wake: { on: 'change', collections: ['runs', 'childStatus'] },
+  wake: { on: "change", collections: ["runs", "childStatus"] },
 })
 ```
 
@@ -93,8 +93,8 @@ Returns an `EntityHandle`. Use `wake` to re-invoke the parent handler when the o
 Fire-and-forget message to another entity:
 
 ```ts
-ctx.send('/assistant/target-id', { text: 'Hello' })
-ctx.send('/assistant/target-id', payload, { type: 'custom_type' })
+ctx.send("/assistant/target-id", { text: "Hello" })
+ctx.send("/assistant/target-id", payload, { type: "custom_type" })
 ```
 
 Messages appear in the target entity's `inbox` collection.
@@ -152,12 +152,12 @@ const data = await response.json()
 
 // Pass data, not credentials, to the worker
 await ctx.spawn(
-  'worker',
+  "worker",
   id,
-  { systemPrompt: 'Summarise this data.', tools: ['read'] },
+  { systemPrompt: "Summarise this data.", tools: ["read"] },
   {
     initialMessage: JSON.stringify(data),
-    wake: 'runFinished',
+    wake: "runFinished",
   }
 )
 ```