effect-agent 0.1.0-beta.16 → 0.1.0-beta.160

package/dist/Worker-XEBYxRQv.d.mts

@@ -0,0 +1,472 @@
+import { l as SubagentGrant, p as WorkerOperationTool, s as SubagentExecutionFailure } from "./SubagentContract-tyN9v-Jv.mjs";
+import { a as Receipt } from "./Receipt-BAHyigAF.mjs";
+import { r as Update } from "./AgentUpdates-DMJ-_xow.mjs";
+import { a as FailureDiagnostic_d_exports, r as Diagnostic } from "./FailureDiagnostic-CaAkzGHL.mjs";
+import { t as AgentPolicy } from "./AgentPolicy-B4oH8TbG.mjs";
+import { Schema } from "effect";
+declare namespace Worker_d_exports {
+  export { AssignmentDisposition, AssignmentTerminal, FrameworkMessage, WorkerAppliedInput, WorkerBudgetScope, WorkerCompletion, WorkerContext, WorkerError, WorkerHistoryEntry, WorkerInput, WorkerOperationTool, WorkerPage, WorkerRef, WorkerReport, WorkerRun, WorkerSource, WorkerStarted, WorkerStop, WorkerStopped, WorkerSummary, WorkerUpdate };
+}
+/** Assignment output selected through the Definition's runDisposition declaration. */
+declare const AssignmentDisposition: Schema.Literals<readonly ["completed", "waiting"]>;
+type AssignmentDisposition = typeof AssignmentDisposition.Type;
+/** A permanent destination outcome; an ordinary Run completion does not imply this. */
+declare const AssignmentTerminal: Schema.Literals<readonly ["completed", "failed", "cancelled"]>;
+type AssignmentTerminal = typeof AssignmentTerminal.Type;
+/** A reusable child Thread, correlated with its declaration. This value grants no authority. */
+declare const WorkerRef: Schema.Struct<{
+  readonly schemaVersion: Schema.Literal<1>;
+  readonly delegationId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/DelegationId">;
+  readonly targetAgentId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/AgentId">;
+  readonly threadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+}>;
+type WorkerRef = typeof WorkerRef.Type;
+/** A continuing worker identity and retained first delivery, never an execution handle. */
+declare const WorkerStarted: Schema.Struct<{
+  readonly worker: Schema.Struct<{
+    readonly schemaVersion: Schema.Literal<1>;
+    readonly delegationId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/DelegationId">;
+    readonly targetAgentId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/AgentId">;
+    readonly threadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+  }>;
+  readonly delivery: Schema.Union<readonly [Schema.Struct<{
+    readonly message: Schema.Struct<{
+      readonly ownerThreadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+      readonly messageId: Schema.brand<Schema.NonEmptyString, "@effect-agent/thread/IdempotencyKey">;
+    }>;
+    readonly status: Schema.Literal<"pending">;
+    readonly receipt: Schema.Null;
+    readonly settlement: Schema.Null;
+    readonly reason: Schema.NullOr<Schema.NonEmptyString>;
+  }>, Schema.Struct<{
+    readonly message: Schema.Struct<{
+      readonly ownerThreadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+      readonly messageId: Schema.brand<Schema.NonEmptyString, "@effect-agent/thread/IdempotencyKey">;
+    }>;
+    readonly status: Schema.Literal<"accepted">;
+    readonly receipt: typeof Receipt;
+    readonly settlement: Schema.Null;
+    readonly reason: Schema.NullOr<Schema.NonEmptyString>;
+  }>, Schema.Struct<{
+    readonly message: Schema.Struct<{
+      readonly ownerThreadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+      readonly messageId: Schema.brand<Schema.NonEmptyString, "@effect-agent/thread/IdempotencyKey">;
+    }>;
+    readonly status: Schema.Literal<"processed">;
+    readonly receipt: typeof Receipt;
+    readonly settlement: Schema.Struct<{
+      readonly settlementId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/SettlementId">;
+      readonly outcome: Schema.Literals<readonly ["completed", "failed", "aborted"]>;
+    }>;
+    readonly reason: Schema.Null;
+  }>, Schema.Struct<{
+    readonly message: Schema.Struct<{
+      readonly ownerThreadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+      readonly messageId: Schema.brand<Schema.NonEmptyString, "@effect-agent/thread/IdempotencyKey">;
+    }>;
+    readonly status: Schema.Literal<"refused">;
+    readonly receipt: Schema.Null;
+    readonly settlement: Schema.Null;
+    readonly reason: Schema.NonEmptyString;
+  }>, Schema.Struct<{
+    readonly message: Schema.Struct<{
+      readonly ownerThreadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+      readonly messageId: Schema.brand<Schema.NonEmptyString, "@effect-agent/thread/IdempotencyKey">;
+    }>;
+    readonly status: Schema.Literal<"parked">;
+    readonly receipt: Schema.NullOr<typeof Receipt>;
+    readonly settlement: Schema.Null;
+    readonly reason: Schema.NonEmptyString;
+  }>]>;
+}>;
+type WorkerStarted = typeof WorkerStarted.Type;
+/** Stable owner command. Reusing its key for a different worker conflicts. */
+declare const WorkerStop: Schema.Struct<{
+  readonly worker: Schema.Struct<{
+    readonly schemaVersion: Schema.Literal<1>;
+    readonly delegationId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/DelegationId">;
+    readonly targetAgentId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/AgentId">;
+    readonly threadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+  }>;
+  readonly idempotencyKey: Schema.brand<Schema.NonEmptyString, "@effect-agent/thread/IdempotencyKey">;
+}>;
+type WorkerStop = typeof WorkerStop.Type;
+/** The inbox is sealed and active execution has released ownership. External actions are not undone. */
+declare const WorkerStopped: Schema.Struct<{
+  readonly worker: Schema.Struct<{
+    readonly schemaVersion: Schema.Literal<1>;
+    readonly delegationId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/DelegationId">;
+    readonly targetAgentId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/AgentId">;
+    readonly threadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+  }>;
+  readonly idempotencyKey: Schema.brand<Schema.NonEmptyString, "@effect-agent/thread/IdempotencyKey">;
+}>;
+type WorkerStopped = typeof WorkerStopped.Type;
+/** A host-authorized Run allowance is independent of the immutable delegation lineage. */
+declare const WorkerBudgetScope: Schema.Literals<readonly ["source-subtree", "worker-run"]>;
+type WorkerBudgetScope = typeof WorkerBudgetScope.Type;
+/** Host-bound caller metadata. Programmatic calls never fabricate Run or Tool Call identities. */
+declare const WorkerSource: Schema.Union<readonly [Schema.Struct<{
+  readonly _tag: Schema.Literal<"tool">;
+  readonly agentId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/AgentId">;
+  readonly threadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+  readonly runId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/RunId">;
+  readonly toolCallId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ToolCallId">;
+}>, Schema.Struct<{
+  readonly _tag: Schema.Literal<"programmatic">;
+  readonly agentId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/AgentId">;
+  readonly threadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+}>]>;
+type WorkerSource = typeof WorkerSource.Type;
+/** The caller's effective policy and root-relative depth, resolved by its host. */
+declare const WorkerContext: Schema.Struct<{
+  readonly source: Schema.Union<readonly [Schema.Struct<{
+    readonly _tag: Schema.Literal<"tool">;
+    readonly agentId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/AgentId">;
+    readonly threadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+    readonly runId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/RunId">;
+    readonly toolCallId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ToolCallId">;
+  }>, Schema.Struct<{
+    readonly _tag: Schema.Literal<"programmatic">;
+    readonly agentId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/AgentId">;
+    readonly threadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+  }>]>;
+  readonly policy: typeof AgentPolicy;
+  readonly depth: Schema.Natural;
+  readonly grant: Schema.optionalKey<typeof SubagentGrant>;
+}>;
+type WorkerContext = typeof WorkerContext.Type;
+/** Admission identity is distinct from canonical input application. */
+declare const WorkerInput: Schema.Struct<{
+  readonly receipt: typeof Receipt;
+  readonly messageId: Schema.brand<Schema.NonEmptyString, "@effect-agent/thread/IdempotencyKey">;
+}>;
+type WorkerInput = typeof WorkerInput.Type;
+declare const WorkerAppliedInput: Schema.Struct<{
+  readonly receipt: typeof Receipt;
+  readonly messageId: Schema.brand<Schema.NonEmptyString, "@effect-agent/thread/IdempotencyKey">;
+  readonly runId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/RunId">;
+  readonly sequence: Schema.Natural;
+}>;
+/** A Run outcome is not assignment completion. Interpret only a Definition's disposition. */
+declare const WorkerRun: Schema.Struct<{
+  readonly runId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/RunId">;
+  readonly hostReceipt: typeof Receipt;
+  readonly outcome: Schema.NullOr<Schema.Literals<readonly ["completed", "failed", "aborted"]>>;
+  readonly disposition: Schema.NullOr<Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+}>;
+/** Bounded durable listing data; a latest Receipt never substitutes for a requested Receipt. */
+declare const WorkerSummary: Schema.Struct<{
+  readonly worker: Schema.Struct<{
+    readonly schemaVersion: Schema.Literal<1>;
+    readonly delegationId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/DelegationId">;
+    readonly targetAgentId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/AgentId">;
+    readonly threadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+  }>;
+  readonly latestReceipt: Schema.NullOr<typeof Receipt>;
+  /** stopping/stopped identify an owner-issued worker stop, never an ordinary Receipt abort. */
+  readonly state: Schema.Literals<readonly ["starting", "active", "idle", "stopping", "stopped", "completed", "failed", "cancelled"]>;
+  readonly acceptedInput: Schema.NullOr<Schema.Struct<{
+    readonly receipt: typeof Receipt;
+    readonly messageId: Schema.brand<Schema.NonEmptyString, "@effect-agent/thread/IdempotencyKey">;
+  }>>;
+  readonly appliedInput: Schema.NullOr<Schema.Struct<{
+    readonly receipt: typeof Receipt;
+    readonly messageId: Schema.brand<Schema.NonEmptyString, "@effect-agent/thread/IdempotencyKey">;
+    readonly runId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/RunId">;
+    readonly sequence: Schema.Natural;
+  }>>;
+  readonly run: Schema.NullOr<Schema.Struct<{
+    readonly runId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/RunId">;
+    readonly hostReceipt: typeof Receipt;
+    readonly outcome: Schema.NullOr<Schema.Literals<readonly ["completed", "failed", "aborted"]>>;
+    readonly disposition: Schema.NullOr<Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+  }>>;
+  /** One retained unadmitted input, if any; its state is independent of destination execution. */
+  readonly pendingDelivery: Schema.NullOr<Schema.Union<readonly [Schema.Struct<{
+    readonly message: Schema.Struct<{
+      readonly ownerThreadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+      readonly messageId: Schema.brand<Schema.NonEmptyString, "@effect-agent/thread/IdempotencyKey">;
+    }>;
+    readonly status: Schema.Literal<"pending">;
+    readonly receipt: Schema.Null;
+    readonly settlement: Schema.Null;
+    readonly reason: Schema.NullOr<Schema.NonEmptyString>;
+  }>, Schema.Struct<{
+    readonly message: Schema.Struct<{
+      readonly ownerThreadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+      readonly messageId: Schema.brand<Schema.NonEmptyString, "@effect-agent/thread/IdempotencyKey">;
+    }>;
+    readonly status: Schema.Literal<"accepted">;
+    readonly receipt: typeof Receipt;
+    readonly settlement: Schema.Null;
+    readonly reason: Schema.NullOr<Schema.NonEmptyString>;
+  }>, Schema.Struct<{
+    readonly message: Schema.Struct<{
+      readonly ownerThreadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+      readonly messageId: Schema.brand<Schema.NonEmptyString, "@effect-agent/thread/IdempotencyKey">;
+    }>;
+    readonly status: Schema.Literal<"processed">;
+    readonly receipt: typeof Receipt;
+    readonly settlement: Schema.Struct<{
+      readonly settlementId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/SettlementId">;
+      readonly outcome: Schema.Literals<readonly ["completed", "failed", "aborted"]>;
+    }>;
+    readonly reason: Schema.Null;
+  }>, Schema.Struct<{
+    readonly message: Schema.Struct<{
+      readonly ownerThreadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+      readonly messageId: Schema.brand<Schema.NonEmptyString, "@effect-agent/thread/IdempotencyKey">;
+    }>;
+    readonly status: Schema.Literal<"refused">;
+    readonly receipt: Schema.Null;
+    readonly settlement: Schema.Null;
+    readonly reason: Schema.NonEmptyString;
+  }>, Schema.Struct<{
+    readonly message: Schema.Struct<{
+      readonly ownerThreadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+      readonly messageId: Schema.brand<Schema.NonEmptyString, "@effect-agent/thread/IdempotencyKey">;
+    }>;
+    readonly status: Schema.Literal<"parked">;
+    readonly receipt: Schema.NullOr<typeof Receipt>;
+    readonly settlement: Schema.Null;
+    readonly reason: Schema.NonEmptyString;
+  }>]>>;
+  /** Consistent destination facts; pending delivery has its own source-owned version. */
+  readonly watermark: Schema.Struct<{
+    readonly canonicalSequence: Schema.Natural;
+    readonly acceptedQueueSequence: Schema.Natural;
+    readonly pendingDeliveryVersion: Schema.NullOr<Schema.Natural>;
+  }>;
+}>;
+type WorkerSummary = typeof WorkerSummary.Type;
+declare const WorkerPage: Schema.Struct<{
+  readonly items: Schema.$Array<Schema.Struct<{
+    readonly worker: Schema.Struct<{
+      readonly schemaVersion: Schema.Literal<1>;
+      readonly delegationId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/DelegationId">;
+      readonly targetAgentId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/AgentId">;
+      readonly threadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+    }>;
+    readonly latestReceipt: Schema.NullOr<typeof Receipt>;
+    /** stopping/stopped identify an owner-issued worker stop, never an ordinary Receipt abort. */
+    readonly state: Schema.Literals<readonly ["starting", "active", "idle", "stopping", "stopped", "completed", "failed", "cancelled"]>;
+    readonly acceptedInput: Schema.NullOr<Schema.Struct<{
+      readonly receipt: typeof Receipt;
+      readonly messageId: Schema.brand<Schema.NonEmptyString, "@effect-agent/thread/IdempotencyKey">;
+    }>>;
+    readonly appliedInput: Schema.NullOr<Schema.Struct<{
+      readonly receipt: typeof Receipt;
+      readonly messageId: Schema.brand<Schema.NonEmptyString, "@effect-agent/thread/IdempotencyKey">;
+      readonly runId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/RunId">;
+      readonly sequence: Schema.Natural;
+    }>>;
+    readonly run: Schema.NullOr<Schema.Struct<{
+      readonly runId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/RunId">;
+      readonly hostReceipt: typeof Receipt;
+      readonly outcome: Schema.NullOr<Schema.Literals<readonly ["completed", "failed", "aborted"]>>;
+      readonly disposition: Schema.NullOr<Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+    }>>;
+    /** One retained unadmitted input, if any; its state is independent of destination execution. */
+    readonly pendingDelivery: Schema.NullOr<Schema.Union<readonly [Schema.Struct<{
+      readonly message: Schema.Struct<{
+        readonly ownerThreadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+        readonly messageId: Schema.brand<Schema.NonEmptyString, "@effect-agent/thread/IdempotencyKey">;
+      }>;
+      readonly status: Schema.Literal<"pending">;
+      readonly receipt: Schema.Null;
+      readonly settlement: Schema.Null;
+      readonly reason: Schema.NullOr<Schema.NonEmptyString>;
+    }>, Schema.Struct<{
+      readonly message: Schema.Struct<{
+        readonly ownerThreadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+        readonly messageId: Schema.brand<Schema.NonEmptyString, "@effect-agent/thread/IdempotencyKey">;
+      }>;
+      readonly status: Schema.Literal<"accepted">;
+      readonly receipt: typeof Receipt;
+      readonly settlement: Schema.Null;
+      readonly reason: Schema.NullOr<Schema.NonEmptyString>;
+    }>, Schema.Struct<{
+      readonly message: Schema.Struct<{
+        readonly ownerThreadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+        readonly messageId: Schema.brand<Schema.NonEmptyString, "@effect-agent/thread/IdempotencyKey">;
+      }>;
+      readonly status: Schema.Literal<"processed">;
+      readonly receipt: typeof Receipt;
+      readonly settlement: Schema.Struct<{
+        readonly settlementId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/SettlementId">;
+        readonly outcome: Schema.Literals<readonly ["completed", "failed", "aborted"]>;
+      }>;
+      readonly reason: Schema.Null;
+    }>, Schema.Struct<{
+      readonly message: Schema.Struct<{
+        readonly ownerThreadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+        readonly messageId: Schema.brand<Schema.NonEmptyString, "@effect-agent/thread/IdempotencyKey">;
+      }>;
+      readonly status: Schema.Literal<"refused">;
+      readonly receipt: Schema.Null;
+      readonly settlement: Schema.Null;
+      readonly reason: Schema.NonEmptyString;
+    }>, Schema.Struct<{
+      readonly message: Schema.Struct<{
+        readonly ownerThreadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+        readonly messageId: Schema.brand<Schema.NonEmptyString, "@effect-agent/thread/IdempotencyKey">;
+      }>;
+      readonly status: Schema.Literal<"parked">;
+      readonly receipt: Schema.NullOr<typeof Receipt>;
+      readonly settlement: Schema.Null;
+      readonly reason: Schema.NonEmptyString;
+    }>]>>;
+    /** Consistent destination facts; pending delivery has its own source-owned version. */
+    readonly watermark: Schema.Struct<{
+      readonly canonicalSequence: Schema.Natural;
+      readonly acceptedQueueSequence: Schema.Natural;
+      readonly pendingDeliveryVersion: Schema.NullOr<Schema.Natural>;
+    }>;
+  }>>;
+  readonly next: Schema.NullOr<Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">>;
+}>;
+type WorkerPage = typeof WorkerPage.Type;
+/** Authorized canonical history, encoded independently of storage-adapter representations. */
+declare const WorkerHistoryEntry: Schema.Struct<{
+  readonly sequence: Schema.Natural;
+  readonly recordId: Schema.NonEmptyString;
+  readonly record: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+}>;
+type WorkerHistoryEntry = typeof WorkerHistoryEntry.Type;
+declare const WorkerError_base: Schema.Class<WorkerError, Schema.TaggedStruct<"WorkerError", {
+  readonly cause: Schema.optionalKey<Schema.decodeTo<Schema.Unknown, Schema.Codec<Diagnostic, Diagnostic, never, never>, never, never>>;
+  readonly stack: Schema.optionalKey<Schema.String>;
+  /** Concurrency pressure may clear without changing the request. */
+  readonly retryable: Schema.optionalKey<Schema.Literal<true>>;
+  readonly operation: Schema.Literals<readonly ["context", "start", "followUp", "inspect", "observe", "await", "list", "cancel", "stop"]>;
+  readonly reason: Schema.Literals<readonly ["denied", "declaration-unavailable", "worker-mismatch", "receipt-mismatch", "message-mismatch", "idempotency-conflict", "capacity", "not-found", "delivery-pending", "storage", "corrupt", "unavailable"]>;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * Closed host-boundary failures. Original causes stay private and survive diagnostic transport.
+ * Retained delivery states are successful MessageStatus values, including pending and refused.
+ * After a storage failure, keep the same idempotency key and parameters when reconciling.
+ */
+declare class WorkerError extends WorkerError_base {}
+/** One projected canonical Run outcome. Joined receipts share this identity. */
+declare const WorkerReport: <Success extends Schema.Top>(success: Success) => Schema.Union<readonly [Schema.Struct<{
+  readonly _tag: Schema.Literal<"Settled">;
+  readonly worker: Schema.Struct<{
+    readonly schemaVersion: Schema.Literal<1>;
+    readonly delegationId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/DelegationId">;
+    readonly targetAgentId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/AgentId">;
+    readonly threadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+  }>;
+  readonly receipt: typeof Receipt;
+  readonly runId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/RunId">;
+  readonly settlementId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/SettlementId">;
+  readonly outcome: Schema.Literal<"completed">;
+  readonly result: Schema.Union<readonly [Success]>;
+}>, Schema.Struct<{
+  readonly _tag: Schema.Literal<"Settled">;
+  readonly worker: Schema.Struct<{
+    readonly schemaVersion: Schema.Literal<1>;
+    readonly delegationId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/DelegationId">;
+    readonly targetAgentId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/AgentId">;
+    readonly threadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+  }>;
+  readonly receipt: typeof Receipt;
+  readonly runId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/RunId">;
+  readonly settlementId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/SettlementId">;
+  readonly outcome: Schema.Literals<readonly ["failed", "aborted"]>;
+  readonly failure: typeof SubagentExecutionFailure;
+}>]>;
+type WorkerReport<Success extends Schema.Top> = ReturnType<typeof WorkerReport<Success>>["Type"];
+/** Framework message stored separately from the parent's application input. */
+declare const WorkerCompletion: Schema.Struct<{
+  readonly _tag: Schema.Literal<"WorkerCompletion">;
+  readonly budgetExhausted: Schema.Boolean;
+  readonly schemaVersion: Schema.Literal<1>;
+  readonly report: Schema.Union<readonly [Schema.Struct<{
+    readonly _tag: Schema.Literal<"Settled">;
+    readonly worker: Schema.Struct<{
+      readonly schemaVersion: Schema.Literal<1>;
+      readonly delegationId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/DelegationId">;
+      readonly targetAgentId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/AgentId">;
+      readonly threadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+    }>;
+    readonly receipt: typeof Receipt;
+    readonly runId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/RunId">;
+    readonly settlementId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/SettlementId">;
+    readonly outcome: Schema.Literal<"completed">;
+    readonly result: Schema.Union<readonly [Schema.Codec<Schema.Json, Schema.Json, never, never>]>;
+  }>, Schema.Struct<{
+    readonly _tag: Schema.Literal<"Settled">;
+    readonly worker: Schema.Struct<{
+      readonly schemaVersion: Schema.Literal<1>;
+      readonly delegationId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/DelegationId">;
+      readonly targetAgentId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/AgentId">;
+      readonly threadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+    }>;
+    readonly receipt: typeof Receipt;
+    readonly runId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/RunId">;
+    readonly settlementId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/SettlementId">;
+    readonly outcome: Schema.Literals<readonly ["failed", "aborted"]>;
+    readonly failure: typeof SubagentExecutionFailure;
+  }>]>;
+}>;
+type WorkerCompletion = typeof WorkerCompletion.Type;
+/** Source-worker intermediate output, kept separate from application input. */
+declare const WorkerUpdate: Schema.Struct<{
+  readonly _tag: Schema.Literal<"WorkerUpdate">;
+  readonly schemaVersion: Schema.Literal<1>;
+  readonly worker: Schema.Struct<{
+    readonly schemaVersion: Schema.Literal<1>;
+    readonly delegationId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/DelegationId">;
+    readonly targetAgentId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/AgentId">;
+    readonly threadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+  }>;
+  readonly update: typeof Update;
+}>;
+type WorkerUpdate = typeof WorkerUpdate.Type;
+declare const FrameworkMessage: Schema.Union<readonly [Schema.Struct<{
+  readonly _tag: Schema.Literal<"WorkerCompletion">;
+  readonly budgetExhausted: Schema.Boolean;
+  readonly schemaVersion: Schema.Literal<1>;
+  readonly report: Schema.Union<readonly [Schema.Struct<{
+    readonly _tag: Schema.Literal<"Settled">;
+    readonly worker: Schema.Struct<{
+      readonly schemaVersion: Schema.Literal<1>;
+      readonly delegationId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/DelegationId">;
+      readonly targetAgentId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/AgentId">;
+      readonly threadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+    }>;
+    readonly receipt: typeof Receipt;
+    readonly runId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/RunId">;
+    readonly settlementId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/SettlementId">;
+    readonly outcome: Schema.Literal<"completed">;
+    readonly result: Schema.Union<readonly [Schema.Codec<Schema.Json, Schema.Json, never, never>]>;
+  }>, Schema.Struct<{
+    readonly _tag: Schema.Literal<"Settled">;
+    readonly worker: Schema.Struct<{
+      readonly schemaVersion: Schema.Literal<1>;
+      readonly delegationId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/DelegationId">;
+      readonly targetAgentId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/AgentId">;
+      readonly threadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+    }>;
+    readonly receipt: typeof Receipt;
+    readonly runId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/RunId">;
+    readonly settlementId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/SettlementId">;
+    readonly outcome: Schema.Literals<readonly ["failed", "aborted"]>;
+    readonly failure: typeof SubagentExecutionFailure;
+  }>]>;
+}>, Schema.Struct<{
+  readonly _tag: Schema.Literal<"WorkerUpdate">;
+  readonly schemaVersion: Schema.Literal<1>;
+  readonly worker: Schema.Struct<{
+    readonly schemaVersion: Schema.Literal<1>;
+    readonly delegationId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/DelegationId">;
+    readonly targetAgentId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/AgentId">;
+    readonly threadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+  }>;
+  readonly update: typeof Update;
+}>]>;
+type FrameworkMessage = typeof FrameworkMessage.Type;
+//#endregion
+export { WorkerStop as _, WorkerBudgetScope as a, WorkerUpdate as b, WorkerError as c, WorkerPage as d, WorkerRef as f, WorkerStarted as g, WorkerSource as h, WorkerAppliedInput as i, WorkerHistoryEntry as l, WorkerRun as m, AssignmentTerminal as n, WorkerCompletion as o, WorkerReport as p, FrameworkMessage as r, WorkerContext as s, AssignmentDisposition as t, WorkerInput as u, WorkerStopped as v, Worker_d_exports as x, WorkerSummary as y };
+//# sourceMappingURL=Worker-XEBYxRQv.d.mts.map

package/dist/WorkerAdmission-Cmcxd6nS.mjs

@@ -0,0 +1,171 @@
+import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
+import { c as WorkerError } from "./Worker-CfwzMZEK.mjs";
+import { BatchId, CanonicalBatch, ProducerEpoch, ProducerId, RecordEnvelope, RecordId, ThreadCreated, WorkerAdmission, WorkerOrigin, WorkerOriginRecorded } from "./durable/Records.mjs";
+import { AdmissionConflict, AdmissionPolicyError, AdmissionRequest, LedgerError, MarkReadyRequest, SubmissionLedger } from "./durable/SubmissionLedger.mjs";
+import { o as definitionDigestsEqual } from "./agent-registration-BIOzAej4.mjs";
+import { $ as workerOriginRecordId } from "./RunJournal-CA2bsvHn.mjs";
+import { AppendConflict, FenceRejected, FencedAppendRequest, ThreadIdentityRequest, ThreadMaterialization, ThreadNotMaterialized, ThreadStore, ThreadStoreError, ThreadTailRequest } from "./durable/ThreadStore.mjs";
+import { DurableRuntimeFailpoint, DurableRuntimeFailpointError } from "./durable/DurableFailpoint.mjs";
+import { WakeScheduler } from "./durable/WakeScheduler.mjs";
+import { Context, DateTime, Effect, Schema } from "effect";
+//#region src/durable/internal/thread-initialization.ts
+/** Stable identities retained across admission retries and recovery. */
+const threadCreatedBatchId = (threadId) => Schema.decodeSync(BatchId)(`thread-created:${threadId}`);
+const threadCreatedRecordId = (threadId) => Schema.decodeSync(RecordId)(`thread-created:${threadId}`);
+/**
+* Coordinator invariant: every Thread's first canonical record is `ThreadCreated`,
+* so `tailSequence >= 1` is the deterministic already-created check. A lost race (conflict or
+* fence) is verified against that invariant instead of being trusted blindly. An admitted
+* child can be claimed before it is runnable; that advances the shared storage fence without
+* appending anything. Re-read and retry that initialization race with the current fence.
+*/
+const ensureThreadCreated = Effect.fn("DurableAgentRuntime.ensureThreadCreated")(function* (config, threadId, agentId, definitions) {
+	const store = yield* ThreadStore;
+	const wake = yield* WakeScheduler;
+	const tail = yield* store.inspectTail(ThreadTailRequest.make({ threadId }));
+	if (tail.tailSequence > 0) return;
+	const record = yield* Effect.map(DateTime.now, (createdAt) => RecordEnvelope.make({
+		recordId: threadCreatedRecordId(threadId),
+		family: "thread",
+		schemaVersion: 1,
+		createdAt,
+		deploymentId: config.deploymentId,
+		payload: ThreadCreated.make({
+			agentId,
+			definitions
+		})
+	}));
+	yield* store.append(FencedAppendRequest.make({
+		threadId,
+		batch: CanonicalBatch.make({
+			batchId: threadCreatedBatchId(threadId),
+			producerId: config.producerId,
+			records: [record]
+		}),
+		expectedTailSequence: tail.tailSequence,
+		expectedTailDigest: tail.tailDigest,
+		producerEpoch: tail.producerEpoch
+	})).pipe(Effect.catchTag(["AppendConflict", "FenceRejected"], (error) => store.inspectTail(ThreadTailRequest.make({ threadId })).pipe(Effect.flatMap((current) => current.tailSequence > 0 ? Effect.void : Effect.fail(error)))), Effect.andThen(wake.notify(threadId)), Effect.asVoid);
+}, (effect) => effect.pipe(Effect.retry({
+	times: 7,
+	while: (error) => error._tag === "AppendConflict" || error._tag === "FenceRejected"
+})));
+const sameOrigin = Schema.toEquivalence(WorkerOrigin);
+const ensureWorkerOrigin = Effect.fn("WorkerHost.ensureOrigin")(function* (config, origin) {
+	const store = yield* ThreadStore;
+	const failpoint = yield* DurableRuntimeFailpoint;
+	for (let attempt = 0; attempt < 16; attempt++) {
+		const current = yield* store.readIdentity(ThreadIdentityRequest.make({ threadId: origin.worker.threadId }));
+		const existing = current.records.find(({ record }) => record.payload._tag === "WorkerOriginRecorded")?.record.payload;
+		if (existing?._tag === "WorkerOriginRecorded") {
+			if (!sameOrigin(existing.origin, origin)) return yield* WorkerError.make({
+				operation: "start",
+				reason: "worker-mismatch"
+			});
+			return;
+		}
+		const first = current.records[0]?.record.payload;
+		if (first?._tag !== "ThreadCreated" || first.agentId !== origin.worker.targetAgentId || !definitionDigestsEqual(first.definitions, origin.targetDigests) || current.records.some(({ record }) => record.payload._tag === "SubagentLineageRecorded")) return yield* WorkerError.make({
+			operation: "start",
+			reason: "worker-mismatch"
+		});
+		const id = workerOriginRecordId(origin.worker.threadId);
+		yield* failpoint.hit("worker:before-origin-append");
+		if (yield* store.append(FencedAppendRequest.make({
+			threadId: origin.worker.threadId,
+			producerEpoch: current.producerEpoch,
+			expectedTailSequence: current.tailSequence,
+			expectedTailDigest: current.tailDigest,
+			batch: CanonicalBatch.make({
+				batchId: Schema.decodeSync(BatchId)(id),
+				producerId: config.producerId,
+				records: [RecordEnvelope.make({
+					recordId: id,
+					family: "thread",
+					schemaVersion: 1,
+					createdAt: DateTime.makeUnsafe(origin.createdAtMillis),
+					deploymentId: config.deploymentId,
+					payload: WorkerOriginRecorded.make({ origin })
+				})]
+			})
+		})).pipe(Effect.as(true), Effect.catchTag(["AppendConflict", "FenceRejected"], () => Effect.succeed(false)))) {
+			yield* failpoint.hit("worker:after-origin-append");
+			return;
+		}
+	}
+	return yield* WorkerError.make({
+		operation: "start",
+		reason: "storage"
+	});
+}, Effect.mapError((cause) => cause._tag === "WorkerError" ? cause : WorkerError.make({
+	operation: "start",
+	reason: "storage",
+	cause
+})));
+//#endregion
+//#region src/durable/WorkerAdmission.ts
+var WorkerAdmission_exports = /* @__PURE__ */ __exportAll({
+	WorkerAdmissionFailure: () => WorkerAdmissionFailure,
+	WorkerAdmissionPort: () => WorkerAdmissionPort,
+	WorkerAdmissionRequest: () => WorkerAdmissionRequest,
+	admitWorker: () => admitWorker
+});
+/**
+* Storage admission after source authorization, input validation and capacity reservation.
+* This is an internal host port, not an authorization entrypoint. Hosts route the whole
+* operation to the destination owner and enroll recovery before executing it.
+*/
+var WorkerAdmissionRequest = class extends Schema.Class("@effect-agent/thread/WorkerAdmissionRequest")({
+	...AdmissionRequest.fields,
+	workerAdmission: WorkerAdmission,
+	producerId: ProducerId
+}) {};
+const WorkerAdmissionFailure = Schema.Union([
+	AdmissionConflict,
+	AdmissionPolicyError,
+	LedgerError,
+	ThreadStoreError,
+	ThreadNotMaterialized,
+	AppendConflict,
+	FenceRejected,
+	DurableRuntimeFailpointError
+]);
+/** Local implementation shared by every host; retries finish the same admitted row. */
+const admitWorker = Effect.fn("WorkerAdmission.admitWorker")(function* (request) {
+	const origin = request.workerAdmission.origin;
+	if (origin.worker.threadId !== request.threadId || origin.worker.targetAgentId !== request.agentId || request.parentLinkage !== void 0) return yield* LedgerError.make({
+		operation: "admit worker",
+		message: "Worker admission does not belong to the destination Thread"
+	});
+	const ledger = yield* SubmissionLedger;
+	const store = yield* ThreadStore;
+	const wake = yield* WakeScheduler;
+	const failpoint = yield* DurableRuntimeFailpoint;
+	const admitted = yield* ledger.admit(AdmissionRequest.make(request));
+	yield* failpoint.hit("submit:after-admit");
+	if (admitted.replayed && admitted.state !== "admitted") return admitted;
+	yield* store.materialize(ThreadMaterialization.make({
+		threadId: request.threadId,
+		producerEpoch: Schema.decodeSync(ProducerEpoch)(0)
+	})).pipe(Effect.catchTag("FenceRejected", () => Effect.void));
+	const config = {
+		producerId: request.producerId,
+		deploymentId: request.deploymentId
+	};
+	yield* ensureThreadCreated(config, request.threadId, request.agentId, request.agentDigests);
+	yield* ensureWorkerOrigin(config, origin).pipe(Effect.mapError((cause) => LedgerError.make({
+		operation: "worker-origin",
+		message: cause.reason,
+		cause
+	})));
+	yield* failpoint.hit("submit:after-materialize");
+	yield* ledger.markReady(MarkReadyRequest.make({ submissionId: admitted.submissionId }));
+	yield* wake.notify(request.threadId);
+	return admitted;
+});
+/** Placement adapter for the composite operation; local hosts use the same implementation. */
+const WorkerAdmissionPort = Context.Reference("@effect-agent/thread/WorkerAdmissionPort", { defaultValue: () => ({ admit: admitWorker }) });
+//#endregion
+export { admitWorker as a, threadCreatedBatchId as c, WorkerAdmission_exports as i, threadCreatedRecordId as l, WorkerAdmissionPort as n, ensureThreadCreated as o, WorkerAdmissionRequest as r, ensureWorkerOrigin as s, WorkerAdmissionFailure as t };
+
+//# sourceMappingURL=WorkerAdmission-Cmcxd6nS.mjs.map