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

package/dist/SubagentHost-VTyf_wEF.d.mts

@@ -0,0 +1,172 @@
+import { c as SettlementId, r as DelegationId, s as RunId, u as ThreadId } from "./Identifiers-CN2s30fF.mjs";
+import { i as SubagentBudgetReservation } from "./SubagentContract-tyN9v-Jv.mjs";
+import { a as Receipt, n as JoinedToHost, t as IdempotencyKey } from "./Receipt-BAHyigAF.mjs";
+import { r as Update } from "./AgentUpdates-DMJ-_xow.mjs";
+import { a as FailureDiagnostic_d_exports, i as Failure } from "./FailureDiagnostic-CaAkzGHL.mjs";
+import { t as AgentPolicy } from "./AgentPolicy-B4oH8TbG.mjs";
+import { r as AnyDefinition, t as Agent_d_exports } from "./Agent-ZfnNCQXs.mjs";
+import { _ as WorkerStop, a as WorkerBudgetScope, c as WorkerError, d as WorkerPage, f as WorkerRef, g as WorkerStarted, h as WorkerSource, l as WorkerHistoryEntry, o as WorkerCompletion, s as WorkerContext, v as WorkerStopped, y as WorkerSummary } from "./Worker-XEBYxRQv.mjs";
+import { c as MessageRef, l as MessageStatus } from "./Messaging-7VXQnWI3.mjs";
+import { Context, Effect, Option, Schema, Stream } from "effect";
+declare namespace SubagentHost_d_exports {
+  export { BackgroundReporting, DeferredFollowUpWorkerRequest, DeferredStartWorkerRequest, FollowUpWorkerRequest, StartWorkerRequest, SubagentHost, WorkerMessageRequest, WorkerObservation, WorkerReceiptRequest, WorkerReportPreparationFailure, WorkerReporting, WorkerRunReport };
+}
+/** Prepared values cross this port only to be Schema-decoded before durable storage. */
+interface StartWorkerRequest {
+  readonly delegationId: DelegationId;
+  /** Start a distinct assignment using verified completed predecessor authority. */
+  readonly continuationOf?: WorkerRef;
+  readonly target: AnyDefinition;
+  readonly idempotencyKey: IdempotencyKey;
+  readonly encodedInput: unknown;
+  readonly encodedParameters: unknown;
+  readonly policy: AgentPolicy;
+  readonly budget: SubagentBudgetReservation;
+  readonly encodedGrant: unknown;
+  readonly toolCallAllowance?: number;
+  /** Author-owned request; the durable host must separately authorize worker-run funding. */
+  readonly budgetScope?: WorkerBudgetScope;
+}
+/**
+ * First-admission preparation stays lazy until the owner authorizes the caller and checks the
+ * retained command. Replays compare declared parameters/options and reuse the original capture.
+ * Prepared policy, budget, and allowance are frozen first-admission configuration, not replay
+ * arguments; changing them requires a new command key. Current caller authorization still applies.
+ * Preparation must be free of external effects: concurrent first admissions can prepare before
+ * the retained delivery chooses its first writer.
+ */
+interface DeferredStartWorkerRequest<E = never, R = never> extends Pick<StartWorkerRequest, "delegationId" | "continuationOf" | "target" | "idempotencyKey" | "encodedParameters" | "encodedGrant" | "budgetScope"> {
+  readonly prepare: Effect.Effect<Pick<StartWorkerRequest, "encodedInput" | "policy" | "budget" | "toolCallAllowance">, E, R>;
+}
+interface FollowUpWorkerRequest {
+  readonly worker: WorkerRef;
+  readonly target: AnyDefinition;
+  readonly idempotencyKey: IdempotencyKey;
+  readonly encodedInput: unknown;
+  readonly encodedParameters: unknown;
+}
+/**
+ * Like deferred starts, follow-ups prepare only after current authorization and retained-command
+ * lookup. Replays compare declared parameters and reuse the original input and worker authority.
+ * Preparation must be free of external effects because concurrent first admissions can prepare.
+ */
+interface DeferredFollowUpWorkerRequest<E = never, R = never> extends Omit<FollowUpWorkerRequest, "encodedInput"> {
+  readonly prepare: Effect.Effect<Pick<FollowUpWorkerRequest, "encodedInput">, E, R>;
+}
+interface WorkerReceiptRequest {
+  readonly worker: WorkerRef;
+  readonly target: AnyDefinition;
+  readonly receipt: Receipt;
+}
+interface WorkerMessageRequest {
+  readonly worker: WorkerRef;
+  readonly target: AnyDefinition;
+  readonly message: MessageRef;
+}
+/**
+ * Canonical terminal values remain encoded until the capability decodes the saved parameters
+ * and target output and applies its declared result projection. Child E does not survive settlement.
+ */
+type WorkerObservation = {
+  readonly _tag: "Pending";
+  readonly receipt: Receipt;
+} | {
+  readonly _tag: "Settled";
+  readonly receipt: Receipt;
+  /** Absent when an input failed or was cancelled before any Run started. */
+  readonly runId?: RunId;
+  readonly settlementId: SettlementId;
+  readonly outcome: "completed" | "failed" | "aborted";
+  readonly encodedParameters: unknown;
+  readonly encodedResult: unknown;
+  /** Operator-private failed-settlement evidence; never part of a model Tool result. */
+  readonly diagnostic?: Failure;
+  readonly budgetExhausted: boolean;
+};
+/** One actual canonical Run, independent of how many input Receipts joined it. */
+interface WorkerRunReport {
+  readonly worker: WorkerRef;
+  readonly context: WorkerContext;
+  readonly observation: Extract<WorkerObservation, {
+    readonly _tag: "Settled";
+  }> & {
+    readonly runId: RunId;
+  };
+}
+declare const WorkerReportPreparationFailure_base: Schema.Class<WorkerReportPreparationFailure, Schema.TaggedStruct<"WorkerReportPreparationFailure", {
+  readonly stage: Schema.Literals<readonly ["projection", "input", "preparation"]>;
+}>, import("effect/Cause").YieldableError>;
+/** A bounded projection failure; raw application errors never enter durable report records. */
+declare class WorkerReportPreparationFailure extends WorkerReportPreparationFailure_base {}
+/**
+ * Source-owned standard projection discovered from background tools.
+ * The concrete descriptor retains its E/R; durable registration captures R and records
+ * bounded preparation failure rather than serializing arbitrary application errors.
+ */
+interface WorkerReporting<E = never, R = never> {
+  readonly delegationId: DelegationId;
+  readonly target: AnyDefinition;
+  /** Pure first-emission selection. False retains the canonical update without parent delivery. */
+  readonly reportUpdate?: (update: Update) => boolean;
+  /** False retains a filtered report receipt without waking the parent. */
+  readonly reportCompletion?: (report: WorkerRunReport) => boolean;
+  readonly prepare: (report: WorkerRunReport) => Effect.Effect<{
+    readonly message: WorkerCompletion;
+  }, E | WorkerReportPreparationFailure, R>;
+}
+/** Descriptor carried by background tools; registration discovers it without an app handoff. */
+declare const BackgroundReporting: Context.Reference<WorkerReporting<WorkerReportPreparationFailure, never> | undefined>;
+declare const SubagentHost_base: Context.ServiceClass<SubagentHost, "@effect-agent/engine/SubagentHost", {
+  readonly context: Effect.Effect<WorkerContext, WorkerError>;
+  /** Resolve prepared input through host authority; None retains legacy target inheritance. */
+  readonly resolveTargetPolicy: (request: {
+    readonly continuationOf?: WorkerRef;
+    readonly target: AnyDefinition;
+    readonly encodedInput: unknown;
+  }) => Effect.Effect<Option.Option<AgentPolicy>, WorkerError>;
+  /** Prepared callers retain strict input/policy conflicts; deferred callers replay the saved capture. */
+  readonly start: <E = never, R = never>(request: StartWorkerRequest | DeferredStartWorkerRequest<E, R>) => Effect.Effect<WorkerStarted, WorkerError | E, R>;
+  /** Prepared callers retain strict input conflicts; deferred callers replay the saved capture. */
+  readonly followUp: <E = never, R = never>(request: FollowUpWorkerRequest | DeferredFollowUpWorkerRequest<E, R>) => Effect.Effect<MessageStatus, WorkerError | E, R>;
+  readonly inspect: (request: WorkerReceiptRequest | WorkerMessageRequest) => Effect.Effect<WorkerObservation | MessageStatus, WorkerError>;
+  /** Inspect the continuing worker using the same summary contract as discovery. */
+  readonly summary: (request: {
+    readonly worker: WorkerRef;
+    readonly target: AnyDefinition;
+  }) => Effect.Effect<WorkerSummary, WorkerError>;
+  /** A finite snapshot through the captured tail; resume with the last sequence as `after`. */
+  readonly observe: (request: {
+    readonly worker: WorkerRef;
+    readonly target: AnyDefinition;
+    readonly after?: number;
+  }) => Stream.Stream<WorkerHistoryEntry, WorkerError>;
+  /** Interrupting this wait never requests cancellation of accepted work. */
+  readonly await: (request: WorkerReceiptRequest) => Effect.Effect<WorkerObservation, WorkerError>;
+  readonly list: (request: {
+    readonly delegationId: DelegationId;
+    readonly target: AnyDefinition;
+    readonly limit: number;
+    readonly after?: ThreadId;
+  }) => Effect.Effect<WorkerPage, WorkerError>;
+  /** Seal the whole worker; retries reconcile the same command, including a lost acknowledgement. */
+  readonly stop: (request: WorkerStop & {
+    readonly target: AnyDefinition;
+  }) => Effect.Effect<WorkerStopped, WorkerError>;
+  /** Cancel exactly this Receipt; preserve JoinedToHost without broadening its target. */
+  readonly cancel: (request: WorkerReceiptRequest) => Effect.Effect<void, WorkerError | JoinedToHost>;
+}>;
+/**
+ * Trusted, caller-bound host port. The interpreter supplies a fresh facet for each Tool Call;
+ * programmatic callers acquire a separately authorized Thread facet. Request values cannot
+ * choose the source identity, replace worker provenance or expand its authority and budgets.
+ */
+declare class SubagentHost extends SubagentHost_base {
+  static readonly unavailable: SubagentHost["Service"];
+  /** Runtime-owned per-call binding. Unconfigured Runs deny background operations. */
+  static readonly forTool: Context.Reference<(source: Extract<WorkerSource, {
+    readonly _tag: "tool";
+  }>) => SubagentHost["Service"]>;
+}
+//#endregion
+export { StartWorkerRequest as a, WorkerMessageRequest as c, WorkerReportPreparationFailure as d, WorkerReporting as f, FollowUpWorkerRequest as i, WorkerObservation as l, DeferredFollowUpWorkerRequest as n, SubagentHost as o, WorkerRunReport as p, DeferredStartWorkerRequest as r, SubagentHost_d_exports as s, BackgroundReporting as t, WorkerReceiptRequest as u };
+//# sourceMappingURL=SubagentHost-VTyf_wEF.d.mts.map