tardie 0.22.2 → 0.22.3-rc.265

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tardie",
-  "version": "0.22.2",
+  "version": "0.22.3-rc.265",
   "license": "MIT",
   "author": "Clavia, Inc.",
   "description": "A durable agent harness. State is a pure function of the log.",
@@ -16,7 +16,7 @@
     "access": "public"
   },
   "tardigrade": {
-    "sourceTree": "51defd3cb83af555260546ac69a04a069a47c68f"
+    "sourceTree": "c77212bc7abbcc6391e5c56d162d2f27830f71c8"
   },
   "files": [
     "src",

package/src/agent/packages/agents.ts

@@ -256,7 +256,7 @@ const childClaimOf = (
         ...(recorded.placement === undefined ? {} : { placement: recorded.placement })
       }
   const target = recorded?.address ?? (yield* allocateChildThread({
-    parent: source, child: childKeyOf(JSON.stringify([parentRunId, callId]))
+    parent: source, child: childKeyOf("unnamed"), key: JSON.stringify([parentRunId, callId])
   }))
   // clash rejects a derived address already claimed by another recorded child (agents.test.ts, "a derived address that names another child dies rather than delivering").
   if (recorded === undefined) {

package/src/bun/host.ts

@@ -295,7 +295,7 @@ export const createBunHost = async <R = never>(options: BunHostOptions<R>): Prom
     `.pipe(
       Effect.map((rows) => ({
         cursor: Number(rows.at(-1)?.seq ?? 0),
-        threads: actorThreadsOf(rows.map((row) => JSON.parse(row.event) as Event)).filter((record) => record.state !== "allocated")
+        threads: actorThreadsOf(rows.map((row) => JSON.parse(row.event) as Event))
       })),
       Effect.orDie
     ))
@@ -342,7 +342,7 @@ export const createBunHost = async <R = never>(options: BunHostOptions<R>): Prom
       }),
       at
     } satisfies ThreadRequested)
-    await appendActorEvent({ type: "ThreadRegistered", thread, at } satisfies ThreadRegistered)
+    await appendActorEvent({ type: "ThreadRegistered", thread, ...(lineage?.placement === undefined ? {} : { placement: lineage.placement }), at } satisfies ThreadRegistered)
   }
   const threads = (): Promise<ReadonlyArray<string>> => directoryRuntime.runPromise(
     directorySql<{ thread: string }>`SELECT thread FROM thread_directory ORDER BY thread`.pipe(Effect.map((rows) => rows.map((row) => row.thread)), Effect.orDie)

package/src/cloudflare/actor.ts

@@ -44,17 +44,18 @@ const actorSupervisorOf = (
         key: registeredKeyOf(event.thread),
         input: event,
         act: (request) => Effect.gen(function* () {
-          yield* Effect.promise(async () => {
+          const registration = yield* Effect.promise(async () => {
             const stub = env.THREADS.getByName(threadObjectNameOf(identity.actor, identity.instance, request.thread))
             if (request.parentThread === undefined) {
-              if (!(await stub.exists(identity.actor, identity.instance, request.thread))) {
-                throw new Error(`root thread ${JSON.stringify(request.thread)} has no durable host`)
-              }
-            } else {
-              await stub.commitCreation()
+              await stub.init(identity.actor, identity.instance, request.thread)
+              await stub.initializeRoot()
+              return {}
             }
+            const created = await stub.commitCreation()
+            return created === undefined ? undefined : created.placement === undefined ? {} : { placement: created.placement }
           })
-          return [{ type: "ThreadRegistered", thread: request.thread, at: yield* Clock.currentTimeMillis }]
+          if (registration === undefined) return []
+          return [{ type: "ThreadRegistered", thread: request.thread, ...registration, at: yield* Clock.currentTimeMillis }]
         })
       })]
     })
@@ -220,12 +221,15 @@ export class ActorDO extends DurableObject<Env> {
         WHERE json_extract(event, '$.type') = 'ThreadRequested' AND json_extract(event, '$.thread') = ${target.thread}`.pipe(
         Effect.map((rows) => rows.length > 0 && (!existingRoot || rows.some((row) => row.parent !== null))), Effect.orDie
       ))
-    return Effect.runPromise(allocateThread(request).pipe(Effect.provideService(
+    const target = await Effect.runPromise(allocateThread(request).pipe(Effect.provideService(
       ThreadAllocator, mountedActor?.threadAllocator ?? registeredThreadAllocator({
         get: (key) => Effect.promise(() => this.database.runPromise(store.get(key))),
         claim: (key, target, existingRoot, request) => Effect.promise(() => this.database.runPromise(store.claim(key, target, existingRoot, request)))
       }, mountedActor?.allocation)
     )))
+    const at = armAt(await this.ctx.storage.getAlarm(), Date.now(), this.alarmPolicy.recoveryDelayMillis)
+    if (at !== null) await this.ctx.storage.setAlarm(at)
+    return target
   }
 
   async initializeRootThread(thread: string): Promise<void> {
@@ -261,7 +265,7 @@ export class ActorDO extends DurableObject<Env> {
     if (existing !== undefined && (
       existing.parentThread !== lineage.parent.thread ||
       Number(existing.depth) !== lineage.depth ||
-      (existing.state !== "allocated" && existing.placement !== placement)
+      ((existing.state === "registered" || existing.placement !== undefined) && (existing.placement ?? null) !== placement)
     )) {
       throw new Error("a child thread already has different lineage")
     }

package/src/cloudflare/thread.ts

@@ -1,3 +1,4 @@
+import { threadCreatedOf, type ThreadCreated } from "tardie/core/interaction/relations"
 import { cloudflareRpcTransport } from "./transport/rpc"
 import { DurableObject } from "cloudflare:workers"
 import { Effect, Layer, Schema } from "effect"
@@ -313,12 +314,16 @@ export class ThreadDO extends DurableObject<Env> {
     await this.ctx.storage.sync()
   }
 
-  async commitCreation(): Promise<void> {
+  async commitCreation(): Promise<ThreadCreated | undefined> {
+    if (!this.initialized()) return undefined
     const host = await this.host()
+    const created = threadCreatedOf(await host.read())
+    if (created === undefined) return undefined
     await this.arm()
     await this.commitTurn()
     host.publishStaged()
     this.kick(host)
+    return created
   }
 
   async deliver(envelope: ActorEnvelope): Promise<void> {

package/src/core/actor/events.ts

@@ -3,6 +3,7 @@ import type { ChildPlacement } from "../interaction/relations"
 
 export interface ThreadRequested extends Event {
   readonly type: "ThreadRequested"
+  readonly allocationKey?: string
   readonly thread: string
   readonly parentThread?: string
   readonly depth: number
@@ -10,22 +11,14 @@ export interface ThreadRequested extends Event {
   readonly at: number
 }
 
-export interface ThreadAllocated extends Event {
-  readonly type: "ThreadAllocated"
-  readonly thread: string
-  readonly allocationKey: string
-  readonly parentThread?: string
-  readonly depth: number
-  readonly at: number
-}
-
 export interface ThreadRegistered extends Event {
   readonly type: "ThreadRegistered"
+  readonly placement?: ChildPlacement
   readonly thread: string
   readonly at: number
 }
 
-export type ActorEvent = ThreadAllocated | ThreadRequested | ThreadRegistered
+export type ActorEvent = ThreadRequested | ThreadRegistered
 
 export interface ActorThreadRecord {
   readonly allocationKey?: string
@@ -33,37 +26,28 @@ export interface ActorThreadRecord {
   readonly parentThread?: string
   readonly depth: number
   readonly placement?: ChildPlacement
-  readonly state: "allocated" | "requested" | "registered"
+  readonly state: "requested" | "registered"
 }
 
 export const actorEventKeyOf = (event: Event): string | undefined => {
-  if (event.type === "ThreadAllocated" && typeof event.thread === "string") return `thread:allocated:${event.thread}`
   if (event.type === "ThreadRequested" && typeof event.thread === "string") return `thread:requested:${event.thread}`
   if (event.type === "ThreadRegistered" && typeof event.thread === "string") return `thread:registered:${event.thread}`
   return undefined
 }
 
 export const actorEventsOf = (events: ReadonlyArray<Event>): ReadonlyArray<ActorEvent> =>
-  events.filter((event): event is ActorEvent => {
-    if (typeof event.thread !== "string") return false
-    return event.type === "ThreadAllocated" || event.type === "ThreadRequested" || event.type === "ThreadRegistered"
+  events.flatMap((event): ReadonlyArray<ActorEvent> => {
+    if (typeof event.thread !== "string") return []
+    return event.type === "ThreadRequested" || event.type === "ThreadRegistered" ? [event as ActorEvent] : []
   })
 
 export const actorThreadsOf = (events: ReadonlyArray<Event>): ReadonlyArray<ActorThreadRecord> => {
   const entries = new Map<string, ActorThreadRecord>()
   for (const event of actorEventsOf(events)) {
     const current = entries.get(event.thread)
-    if (event.type === "ThreadAllocated") {
-      entries.set(event.thread, current === undefined ? {
-        thread: event.thread, allocationKey: event.allocationKey, depth: event.depth,
-        ...(event.parentThread === undefined ? {} : { parentThread: event.parentThread }),
-        state: "allocated"
-      } : { ...current, allocationKey: event.allocationKey })
-      continue
-    }
     if (event.type === "ThreadRequested") {
       entries.set(event.thread, {
-        ...(current?.allocationKey === undefined ? {} : { allocationKey: current.allocationKey }),
+        ...(event.allocationKey === undefined ? {} : { allocationKey: event.allocationKey }),
         thread: event.thread,
         ...(event.parentThread === undefined ? {} : { parentThread: event.parentThread }),
         depth: event.depth,
@@ -73,7 +57,7 @@ export const actorThreadsOf = (events: ReadonlyArray<Event>): ReadonlyArray<Acto
       continue
     }
     if (current === undefined) throw new Error(`thread ${JSON.stringify(event.thread)} has no request`)
-    entries.set(event.thread, { ...current, state: "registered" })
+    entries.set(event.thread, { ...current, ...(event.placement === undefined ? {} : { placement: event.placement }), state: "registered" })
   }
   return [...entries.values()]
 }

package/src/host/allocation-sql.ts

@@ -12,7 +12,7 @@ export const sqlThreadDirectory = (
   occupied: (target: ThreadCoordinate, existingRoot: boolean) => Effect.Effect<boolean>
 ): ThreadAllocationStore => {
   const get = (key: string) => sql<{ thread: string }>`SELECT json_extract(event, '$.thread') AS thread
-    FROM ${sql(table)} WHERE json_extract(event, '$.type') = 'ThreadAllocated'
+    FROM ${sql(table)} WHERE json_extract(event, '$.type') = 'ThreadRequested'
     AND json_extract(event, '$.allocationKey') = ${key}`.pipe(
     Effect.map((rows) => rows[0]?.thread), Effect.orDie
   )

package/src/host/allocation.ts

@@ -1,7 +1,7 @@
 import { Clock, Effect, Schema } from "effect"
 import { ThreadCoordinate, threadIdOf } from "tardie/core/actor/coordinate"
 import { allocateThread, ThreadAllocator, type ThreadAllocation } from "tardie/core/actor/allocation"
-import { actorThreadsOf, type ThreadAllocated } from "tardie/core/actor/events"
+import { actorThreadsOf, type ThreadRequested } from "tardie/core/actor/events"
 import type { Event } from "tardie/core/event"
 
 // instanceThreadAllocator rejects assignments outside the owning actor instance.
@@ -68,16 +68,17 @@ export interface ThreadAllocationStore {
 // threadAllocationRecord keeps allocation identity in the actor's thread record (allocation.test.ts).
 export const threadAllocationRecord = (
   events: ReadonlyArray<Event>, request: ThreadAllocation, target: ThreadCoordinate, existingRoot: boolean, at: number
-): { readonly thread: string; readonly event?: ThreadAllocated } | undefined => {
+): { readonly thread: string; readonly event?: ThreadRequested } | undefined => {
   const key = threadAllocationKey(request)
   const records = actorThreadsOf(events)
   const assigned = records.find((record) => record.allocationKey === key)
   if (assigned !== undefined) return { thread: assigned.thread }
   const current = records.find((record) => record.thread === target.thread)
   if (current !== undefined && (current.allocationKey !== undefined || !existingRoot || current.parentThread !== undefined)) return undefined
+  if (current !== undefined) return { thread: current.thread }
   const parent = request.kind === "child" ? request.parent.thread : undefined
   return { thread: target.thread, event: {
-    type: "ThreadAllocated", thread: target.thread, allocationKey: key,
+    type: "ThreadRequested", thread: target.thread, allocationKey: key,
     ...(parent === undefined ? {} : { parentThread: parent }),
     depth: parent === undefined ? 0 : (records.find((record) => record.thread === parent)?.depth ?? 0) + 1,
     at
@@ -103,13 +104,19 @@ export const registeredThreadAllocator = (
     const key = threadAllocationKey(request)
     const recorded = yield* store.get(key)
     if (recorded !== undefined) return { ...parent, thread: recorded }
+    if (request.key === undefined) {
+      const name = threadIdOf(request.kind === "root" ? parent.thread : request.child)
+      const thread = request.kind === "child" && name === parent.thread ? undefined
+        : yield* store.claim(key, { ...parent, thread: name }, request.kind === "root", request)
+      if (thread !== undefined) return { ...parent, thread }
+      return yield* Effect.die(new Error(`thread name ${JSON.stringify(name)} is already taken in actor instance ${JSON.stringify([parent.actor, parent.instance])}`))
+    }
     const attempts = policy.maxAttempts ?? DEFAULT_THREAD_ALLOCATION_ATTEMPTS
     if (!Number.isSafeInteger(attempts) || attempts < 1) throw new Error("allocation attempts must be a positive integer")
-    const namedRoot = request.kind === "root" && request.key === undefined
     for (let attempt = 0; attempt < attempts; attempt++) {
-      const candidate = threadIdOf(namedRoot && attempt === 0 ? parent.thread : (policy.generate ?? (() => threadSlug(policy)))())
+      const candidate = threadIdOf((policy.generate ?? (() => threadSlug(policy)))())
       if (request.kind === "child" && candidate === parent.thread) continue
-      const thread = yield* store.claim(key, { ...parent, thread: candidate }, namedRoot && candidate === parent.thread, request)
+      const thread = yield* store.claim(key, { ...parent, thread: candidate }, false, request)
       if (thread !== undefined) return { ...parent, thread }
     }
     return yield* Effect.die(new Error(`thread allocation exhausted ${attempts} collision attempts`))