effect-agent 0.1.0-beta.85 → 0.1.0-beta.87

package/dist/SubagentContract-DdT7Cqe6.d.mts

@@ -0,0 +1,116 @@
+import { Context, Schema } from "effect";
+declare namespace SubagentContract_d_exports {
+  export { BackgroundSpawnTool, DelegationDepth, DelegationTool, SubagentBudgetReservation, SubagentDelegationCaps, SubagentExecutionFailure, SubagentExecutionFailureClassification, SubagentGrant, SubagentParentLink, SubagentReservationAmounts, ToolExecutionKind, WorkerOperationTool, delegationToolPrefix, getToolExecutionKind, isDelegationToolName, isSubagentToolAllowed, maxErrorTagLength, narrowSubagentGrant };
+}
+declare const SubagentGrant_base: Schema.Class<SubagentGrant, Schema.Struct<{
+  readonly allowedToolNames: Schema.$Array<Schema.NonEmptyString>;
+  readonly maxDepth: Schema.Int;
+  /** Omitted permits either lifetime within the depth and reserved subtree budgets. */
+  readonly childLifetimes: Schema.optionalKey<Schema.$Array<Schema.Literals<readonly ["attached", "background"]>>>;
+}>, {}>;
+/** Tree authority ceiling. Each child exposes only its own Toolkit's permitted names. */
+declare class SubagentGrant extends SubagentGrant_base {}
+/** Intersect inherited authority; another delegation can never restore a removed capability. */
+declare const narrowSubagentGrant: (declared: SubagentGrant, inherited?: SubagentGrant) => SubagentGrant;
+declare const SubagentDelegationCaps_base: Schema.Class<SubagentDelegationCaps, Schema.Struct<{
+  readonly maxTotalChildInvocations: Schema.optionalKey<Schema.Natural>;
+  readonly maxConcurrentChildren: Schema.optionalKey<Schema.Natural>;
+  readonly maxTurns: Schema.optionalKey<Schema.Natural>;
+  readonly maxToolCalls: Schema.optionalKey<Schema.Natural>;
+  readonly maxDurationMillis: Schema.optionalKey<Schema.Natural>;
+  readonly maxInputTokens: Schema.optionalKey<Schema.Natural>;
+  readonly maxOutputTokens: Schema.optionalKey<Schema.Natural>;
+  readonly maxCostMicrousd: Schema.optionalKey<Schema.Natural>;
+  readonly maxResultBytes: Schema.optionalKey<Schema.Natural>;
+}>, {}>;
+/** Finite delegable caps for one parent Run. Absent means not configured; present values are finite. */
+declare class SubagentDelegationCaps extends SubagentDelegationCaps_base {}
+declare const SubagentReservationAmounts_base: Schema.Class<SubagentReservationAmounts, Schema.Struct<{
+  readonly turns: Schema.Natural;
+  readonly toolCalls: Schema.Natural;
+  readonly durationMillis: Schema.Natural;
+  readonly inputTokens: Schema.Natural;
+  readonly outputTokens: Schema.Natural;
+  readonly costMicrousd: Schema.Natural;
+  readonly resultBytes: Schema.Natural;
+}>, {}>;
+/** Exact amounts across every reservable delegation dimension. */
+declare class SubagentReservationAmounts extends SubagentReservationAmounts_base {}
+/** One child reservation against the parent Run's shared delegation pool. */
+declare const SubagentBudgetReservation: Schema.Struct<{
+  readonly caps: typeof SubagentDelegationCaps;
+  readonly allocation: typeof SubagentReservationAmounts;
+  /** Slots reserved for every descendant input beneath this input; absent reserves none. */
+  readonly descendantInvocations: Schema.optionalKey<Schema.Natural>;
+}>;
+type SubagentBudgetReservation = typeof SubagentBudgetReservation.Type;
+/** Root-relative delegation depth; the direct child of a top-level run has depth 1. */
+declare const DelegationDepth: Schema.Int;
+type DelegationDepth = typeof DelegationDepth.Type;
+/** @deprecated Names are application-owned; use DelegationTool metadata for classification. */
+declare const delegationToolPrefix = "delegate_";
+/** @deprecated Checks a legacy spelling only, never execution, nesting or recovery semantics. */
+declare const isDelegationToolName: (toolName: string) => boolean;
+/** Marks a Tool implementing the idempotent Subagent establishment protocol. */
+declare const DelegationTool: Context.Reference<boolean>;
+/** Marks a host-managed idempotent worker operation, independently of its Tool name. */
+declare const WorkerOperationTool: Context.Reference<boolean>;
+/** Identifies the background launch operation within a generated management Toolkit. */
+declare const BackgroundSpawnTool: Context.Reference<boolean>;
+/** Declaration metadata and inherited authority determine the effective visible Tool set. */
+declare const isSubagentToolAllowed: (grant: SubagentGrant | undefined, depth: number, name: string, annotations: Context.Context<never>) => boolean;
+/** Persisted preparation classification, checked against the resolved Tool before replay. */
+declare const ToolExecutionKind: Schema.Literals<readonly ["ordinary", "delegation", "orchestration"]>;
+type ToolExecutionKind = typeof ToolExecutionKind.Type;
+/** Resolve only trusted declaration metadata; names never authorize automatic replay. */
+declare const getToolExecutionKind: (annotations: Context.Context<never>) => ToolExecutionKind;
+declare const SubagentParentLink_base: Schema.Class<SubagentParentLink, Schema.Struct<{
+  readonly delegationId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/DelegationId">;
+  readonly parentAgentId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/AgentId">;
+  readonly parentThreadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+  readonly parentRunId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/RunId">;
+  readonly parentToolCallId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ToolCallId">;
+  readonly depth: Schema.Int;
+}>, {}>;
+/** Immutable lineage from a child Thread to the parent identity that established it. */
+declare class SubagentParentLink extends SubagentParentLink_base {}
+/**
+ * Classification of one bounded durable delegation failure.
+ * `"child-failed"` and `"child-aborted"` project the
+ * child's canonical failed/aborted Settlement; `"child-compatibility"`
+ * projects the framework's `ChildCompatibilityFailure` child Settlement (the
+ * stored child Binding digest was unavailable — recovery never substituted
+ * current code); `"establishment-denied"` is a fail-closed coordinator
+ * refusal (lineage/digest verification, divergent replay); and
+ * `"declaration-unavailable"` is retained for decoding failures recorded by
+ * versions that required an explicit durable digest declaration.
+ */
+declare const SubagentExecutionFailureClassification: Schema.Literals<readonly ["child-failed", "child-aborted", "child-compatibility", "establishment-denied", "declaration-unavailable"]>;
+type SubagentExecutionFailureClassification = typeof SubagentExecutionFailureClassification.Type;
+declare const maxErrorTagLength = 256;
+declare const SubagentExecutionFailure_base: Schema.Class<SubagentExecutionFailure, Schema.TaggedStruct<"SubagentExecutionFailure", {
+  readonly delegationId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/DelegationId">;
+  readonly targetAgentId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/AgentId">;
+  readonly classification: Schema.Literals<readonly ["child-failed", "child-aborted", "child-compatibility", "establishment-denied", "declaration-unavailable"]>;
+  /** Child references, present once establishment reached a child identity. */
+  readonly childThreadId: Schema.optionalKey<Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">>;
+  readonly childSubmissionId: Schema.optionalKey<Schema.brand<Schema.NonEmptyString, "@effect-agent/core/SubmissionId">>;
+  readonly childRunId: Schema.optionalKey<Schema.brand<Schema.NonEmptyString, "@effect-agent/core/RunId">>;
+  readonly errorTag: Schema.NonEmptyString;
+  readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * Bounded framework projection of a durable child failure, shared by attached joins and reports.
+ * A failed or aborted durable child
+ * joins its parent Tool Call as exactly this typed failure: a classification,
+ * the child references, and the coordinator's bounded `{errorTag, message}`
+ * projection — never a raw Cause, stack, provider response, secret, or child
+ * payload. The typed child failure union does not survive a durable
+ * Settlement, so `mapChildFailure` remains the ephemeral-path contract;
+ * Schema-declared durable domain-failure mapping is a recorded later
+ * extension.
+ */
+declare class SubagentExecutionFailure extends SubagentExecutionFailure_base {}
+//#endregion
+export { isSubagentToolAllowed as _, SubagentContract_d_exports as a, SubagentExecutionFailureClassification as c, SubagentReservationAmounts as d, ToolExecutionKind as f, isDelegationToolName as g, getToolExecutionKind as h, SubagentBudgetReservation as i, SubagentGrant as l, delegationToolPrefix as m, DelegationDepth as n, SubagentDelegationCaps as o, WorkerOperationTool as p, DelegationTool as r, SubagentExecutionFailure as s, BackgroundSpawnTool as t, SubagentParentLink as u, maxErrorTagLength as v, narrowSubagentGrant as y };
+//# sourceMappingURL=SubagentContract-DdT7Cqe6.d.mts.map

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