effect-agent 0.1.0-beta.9 → 0.1.0-beta.91

package/dist/SubagentHost-CJUBQlcc.d.mts

@@ -0,0 +1,140 @@
+import { c as SettlementId, r as DelegationId, s as RunId, u as ThreadId } from "./Identifiers-CN2s30fF.mjs";
+import { i as SubagentBudgetReservation } from "./SubagentContract-DdT7Cqe6.mjs";
+import { a as Receipt, n as JoinedToHost, t as IdempotencyKey } from "./Receipt-BAHyigAF.mjs";
+import { t as AgentPolicy } from "./AgentPolicy-CetmQrf3.mjs";
+import { r as AnyDefinition } from "./Agent-CN0EWRsR.mjs";
+import { a as WorkerError, c as WorkerRef, d as WorkerStarted, f as WorkerSummary, i as WorkerContext, n as WorkerBudgetScope, o as WorkerHistoryEntry, r as WorkerCompletion, s as WorkerPage, u as WorkerSource } from "./Worker-CaPYykpe.mjs";
+import { Context, Effect, Option, Schema, Stream } from "effect";
+declare namespace SubagentHost_d_exports {
+  export { BackgroundReporting, FollowUpWorkerRequest, StartWorkerRequest, SubagentHost, WorkerObservation, WorkerReceiptRequest, WorkerReportPreparationFailure, WorkerReporting, WorkerRunReport };
+}
+/** Prepared values cross this port only to be Schema-decoded before durable storage. */
+interface StartWorkerRequest {
+  readonly delegationId: DelegationId;
+  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;
+}
+interface FollowUpWorkerRequest {
+  readonly worker: WorkerRef;
+  readonly target: AnyDefinition;
+  readonly idempotencyKey: IdempotencyKey;
+  readonly encodedInput: unknown;
+  readonly encodedParameters: unknown;
+}
+interface WorkerReceiptRequest {
+  readonly worker: WorkerRef;
+  readonly target: AnyDefinition;
+  readonly receipt: Receipt;
+}
+/**
+ * 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;
+  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 projection discovered from background tools or supplied by a custom registration.
+ * 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;
+  /** Standard messages retain the parent's original application input. */
+  readonly mode?: "standard";
+  readonly input?: Schema.Top;
+  /** Required for custom mapping when the receiving coordinator is itself an established worker. */
+  readonly destination?: {
+    readonly delegationId: DelegationId;
+    readonly target: AnyDefinition;
+  };
+  readonly prepare: (report: WorkerRunReport) => Effect.Effect<{
+    readonly encodedInput: Schema.Json;
+    readonly encodedParameters?: Schema.Json;
+    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 target: AnyDefinition;
+    readonly encodedInput: unknown;
+  }) => Effect.Effect<Option.Option<AgentPolicy>, WorkerError>;
+  readonly start: (request: StartWorkerRequest) => Effect.Effect<WorkerStarted, WorkerError>;
+  readonly followUp: (request: FollowUpWorkerRequest) => Effect.Effect<Receipt, WorkerError>;
+  readonly inspect: (request: WorkerReceiptRequest) => Effect.Effect<WorkerObservation, 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>;
+  /** 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 { SubagentHost_d_exports as a, WorkerReportPreparationFailure as c, SubagentHost as i, WorkerReporting as l, FollowUpWorkerRequest as n, WorkerObservation as o, StartWorkerRequest as r, WorkerReceiptRequest as s, BackgroundReporting as t, WorkerRunReport as u };
+//# sourceMappingURL=SubagentHost-CJUBQlcc.d.mts.map