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

package/src/capabilities/internal/subagent-contract.ts

@@ -0,0 +1,142 @@
+import { Duration, Schema } from "effect";
+
+import { AgentId, DelegationId } from "../../core/Identifiers.ts";
+import { SubagentDelegationCaps, SubagentReservationAmounts } from "../../core/SubagentContract.ts";
+
+const PositiveInt = Schema.Int.check(Schema.isGreaterThan(0));
+const Natural = Schema.Natural;
+
+const FinitePositiveDuration = Schema.Duration.pipe(
+  Schema.refine(
+    (duration): duration is Duration.Duration =>
+      Duration.isFinite(duration) && Duration.isPositive(duration),
+    { expected: "a finite positive duration" },
+  ),
+);
+
+const SubagentPolicyFields = Schema.Struct({
+  /** Total invocation slots, including reserved descendants, available through this delegation budget. */
+  maxChildren: PositiveInt,
+  /** Concurrently executing children per parent Run. */
+  maxConcurrency: PositiveInt,
+  /** Invocation slots held for the entire descendant subtree; omitted reserves zero. */
+  descendantInvocations: Schema.optionalKey(Natural),
+  /** Model turns reserved for each child invocation. */
+  maxTurns: PositiveInt,
+  /** Tool Calls reserved for each child invocation. */
+  maxToolCalls: PositiveInt,
+  /** Wall-clock duration reserved for each child invocation. */
+  maxDuration: FinitePositiveDuration,
+  maxInputTokens: Schema.optionalKey(PositiveInt),
+  maxOutputTokens: Schema.optionalKey(PositiveInt),
+  maxCostMicrousd: Schema.optionalKey(Natural),
+  maxResultBytes: Schema.optionalKey(PositiveInt),
+});
+
+type SubagentPolicyFields = typeof SubagentPolicyFields.Type;
+
+/** Inputs normalized and validated by `SubagentPolicy.make`. */
+export type SubagentPolicyInput = Readonly<
+  Omit<SubagentPolicyFields, "maxDuration"> & {
+    /** Finite, positive wall-clock duration accepted in any Effect Duration input form. */
+    readonly maxDuration: Duration.Input;
+  }
+>;
+
+/**
+ * Finite delegation bounds declared by one Subagent capability.
+ * Structural limits are hard limits; token
+ * and cost caps are optional and enforced only as honestly as provider
+ * reporting allows.
+ */
+export class SubagentPolicy extends Schema.Class<SubagentPolicy>(
+  "@effect-agent/capabilities/SubagentPolicy",
+)(SubagentPolicyFields) {
+  /** Normalize and validate finite delegation bounds, throwing on invalid input. */
+  static override make(input: SubagentPolicyInput): SubagentPolicy {
+    return super.make({
+      ...input,
+      maxDuration: Duration.fromInputUnsafe(input.maxDuration),
+    });
+  }
+}
+
+const BoundedFailureText = Schema.String.check(Schema.isMaxLength(4 * 1024));
+
+/**
+ * Delegation preflight denied before any child started.
+ * No reservation, identity, or event exists for the
+ * denied invocation; retry requires a new authorized parent Tool Call.
+ */
+export class SubagentPrestartDenied extends Schema.TaggedError<SubagentPrestartDenied>()(
+  "SubagentPrestartDenied",
+  {
+    delegationId: DelegationId,
+    targetAgentId: AgentId,
+    reason: Schema.Literals(["nested-delegation", "grant-violation", "budget-conflict"]),
+    message: BoundedFailureText,
+  },
+) {}
+
+/**
+ * Input or result projection failed its Schema or bounds.
+ * Fail closed: the message is a fixed description and
+ * never carries the raw child value.
+ */
+export class SubagentProjectionFailure extends Schema.TaggedError<SubagentProjectionFailure>()(
+  "SubagentProjectionFailure",
+  {
+    delegationId: DelegationId,
+    stage: Schema.Literals(["input", "result"]),
+    message: BoundedFailureText,
+  },
+) {}
+
+export {
+  SubagentExecutionFailureClassification,
+  SubagentExecutionFailure,
+  maxErrorTagLength,
+} from "../../core/SubagentContract.ts";
+
+const millisOfMaxDuration = (policy: SubagentPolicy): number =>
+  Math.max(1, Math.ceil(Duration.toMillis(policy.maxDuration)));
+
+/**
+ * Derive the parent-Run delegation caps registered with
+ * `SubagentReservations` from one delegation policy: the per-invocation
+ * bounds scaled by `maxChildren` plus the invocation and concurrency limits.
+ */
+export const delegationCapsFromPolicy = (policy: SubagentPolicy): SubagentDelegationCaps =>
+  SubagentDelegationCaps.make({
+    maxTotalChildInvocations: policy.maxChildren,
+    maxConcurrentChildren: policy.maxConcurrency,
+    maxTurns: policy.maxChildren * policy.maxTurns,
+    maxToolCalls: policy.maxChildren * policy.maxToolCalls,
+    maxDurationMillis: policy.maxChildren * millisOfMaxDuration(policy),
+    ...(policy.maxInputTokens === undefined
+      ? {}
+      : { maxInputTokens: policy.maxChildren * policy.maxInputTokens }),
+    ...(policy.maxOutputTokens === undefined
+      ? {}
+      : { maxOutputTokens: policy.maxChildren * policy.maxOutputTokens }),
+    ...(policy.maxCostMicrousd === undefined
+      ? {}
+      : { maxCostMicrousd: policy.maxChildren * policy.maxCostMicrousd }),
+    ...(policy.maxResultBytes === undefined
+      ? {}
+      : { maxResultBytes: policy.maxChildren * policy.maxResultBytes }),
+  });
+
+/** Derive the all-or-nothing per-invocation reservation from one delegation policy. */
+export const delegationAllocationFromPolicy = (
+  policy: SubagentPolicy,
+): SubagentReservationAmounts =>
+  SubagentReservationAmounts.make({
+    turns: policy.maxTurns,
+    toolCalls: policy.maxToolCalls,
+    durationMillis: millisOfMaxDuration(policy),
+    inputTokens: policy.maxInputTokens ?? 0,
+    outputTokens: policy.maxOutputTokens ?? 0,
+    costMicrousd: policy.maxCostMicrousd ?? 0,
+    resultBytes: policy.maxResultBytes ?? 0,
+  });

package/src/capabilities/internal/subagent-policy.ts

@@ -0,0 +1,235 @@
+import { Duration } from "effect";
+
+import type { AnyDefinition } from "../../core/Agent.ts";
+import { AgentPolicy } from "../../core/AgentPolicy.ts";
+import {
+  SubagentDelegationCaps,
+  type SubagentBudgetReservation,
+} from "../../core/SubagentContract.ts";
+import {
+  SubagentPolicy,
+  delegationCapsFromPolicy,
+  delegationAllocationFromPolicy,
+} from "./subagent-contract.ts";
+
+export const resolveSubagentPolicy = (
+  delegation: {
+    readonly target: Pick<AnyDefinition, "policy" | "policyOverrides">;
+    readonly policy?: SubagentPolicy | undefined;
+  },
+  parent: AgentPolicy,
+  parentCaps?: SubagentDelegationCaps,
+  mode: "root-attached" | "conserved" = "conserved",
+  resolvedTarget?: AgentPolicy,
+) => {
+  // A root attached declaration has its own explicit pool. Child overrides retain
+  // that established behavior; background and inherited subtree launches also obey
+  // the source's own ceilings, before their shared reservation checks the residual.
+  const parentCeiling = mode === "conserved" ? parent : undefined;
+
+  const inherited =
+    resolvedTarget ??
+    AgentPolicy.resolve(delegation.target.policyOverrides ?? delegation.target.policy, parent);
+
+  const policy =
+    delegation.policy ??
+    SubagentPolicy.make({
+      maxChildren: parent.maxToolCalls,
+      maxConcurrency: parent.toolConcurrency,
+      maxTurns: Math.min(inherited.maxTurns, parent.maxTurns),
+      maxToolCalls: Math.min(inherited.maxToolCalls, parent.maxToolCalls),
+      maxDuration: Duration.min(inherited.maxDuration, parent.maxDuration),
+      ...(parent.tokenBudget === undefined
+        ? {}
+        : { maxInputTokens: parent.tokenBudget, maxOutputTokens: parent.tokenBudget }),
+      ...(parent.costBudgetMicrousd === undefined
+        ? {}
+        : { maxCostMicrousd: parent.costBudgetMicrousd }),
+      maxResultBytes: parent.toolResultBounds.maxBytes,
+    });
+
+  const tokenCeiling =
+    policy.maxInputTokens === undefined || policy.maxOutputTokens === undefined
+      ? Math.min(inherited.tokenBudget ?? Infinity, parentCeiling?.tokenBudget ?? Infinity)
+      : Math.min(
+          inherited.tokenBudget ?? Infinity,
+          parentCeiling?.tokenBudget ?? Infinity,
+          policy.maxInputTokens + policy.maxOutputTokens,
+        );
+
+  const childPolicy = AgentPolicy.make({
+    ...inherited,
+    maxTurns: Math.min(inherited.maxTurns, policy.maxTurns, parentCeiling?.maxTurns ?? Infinity),
+    maxToolCalls: Math.min(
+      inherited.maxToolCalls,
+      policy.maxToolCalls,
+      parentCeiling?.maxToolCalls ?? Infinity,
+    ),
+    maxDuration: Duration.min(
+      Duration.min(inherited.maxDuration, policy.maxDuration),
+      parentCeiling?.maxDuration ?? Duration.infinity,
+    ),
+    toolConcurrency: Math.min(
+      inherited.toolConcurrency,
+      parentCeiling?.toolConcurrency ?? Infinity,
+    ),
+    ...(parentCeiling === undefined
+      ? {}
+      : {
+          toolResultBounds: {
+            maxBytes: Math.min(
+              inherited.toolResultBounds.maxBytes,
+              parentCeiling.toolResultBounds.maxBytes,
+              Math.max(256, policy.maxResultBytes ?? Infinity),
+            ),
+          },
+        }),
+    ...(tokenCeiling === Infinity
+      ? {}
+      : {
+          tokenBudget: tokenCeiling,
+          completionReserveTokens: Math.min(inherited.completionReserveTokens, tokenCeiling),
+        }),
+    ...(Math.min(
+      inherited.costBudgetMicrousd ?? Infinity,
+      parentCeiling?.costBudgetMicrousd ?? Infinity,
+      policy.maxCostMicrousd ?? Infinity,
+    ) === Infinity
+      ? {}
+      : {
+          costBudgetMicrousd: Math.min(
+            inherited.costBudgetMicrousd ?? Infinity,
+            parentCeiling?.costBudgetMicrousd ?? Infinity,
+            policy.maxCostMicrousd ?? Infinity,
+          ),
+        }),
+  });
+
+  const caps =
+    parentCaps ??
+    (delegation.policy === undefined
+      ? SubagentDelegationCaps.make({
+          maxTotalChildInvocations: parent.maxToolCalls,
+          maxConcurrentChildren: parent.toolConcurrency,
+          maxTurns: parent.maxTurns,
+          maxToolCalls: parent.maxToolCalls,
+          maxDurationMillis: Math.ceil(Duration.toMillis(parent.maxDuration)),
+          ...(parent.tokenBudget === undefined
+            ? {}
+            : { maxInputTokens: parent.tokenBudget, maxOutputTokens: parent.tokenBudget }),
+          ...(parent.costBudgetMicrousd === undefined
+            ? {}
+            : { maxCostMicrousd: parent.costBudgetMicrousd }),
+        })
+      : delegationCapsFromPolicy(policy));
+
+  return { policy, childPolicy, allocation: delegationAllocationFromPolicy(policy), caps };
+};
+
+export const resolveToolCallAllowance = <Parameters>(
+  option:
+    | {
+        readonly default: number;
+        readonly fromParameters?: (parameters: Parameters) => number | undefined;
+      }
+    | undefined,
+  parameters: Parameters,
+  policy: SubagentPolicy,
+  childPolicy: AgentPolicy,
+): number => {
+  if (option === undefined) return childPolicy.maxToolCalls;
+  const extracted = option.fromParameters?.(parameters);
+
+  // A non-finite parameter falls back to the author default, then the reservation.
+  const requested =
+    extracted !== undefined && Number.isFinite(extracted)
+      ? extracted
+      : Number.isFinite(option.default)
+        ? option.default
+        : policy.maxToolCalls;
+
+  return Math.min(
+    Math.max(1, Math.floor(requested)),
+    policy.maxToolCalls,
+    childPolicy.maxToolCalls,
+  );
+};
+
+/** Conservative subtree remainder after reserving this Run's own full execution ceiling. */
+export const residualSubagentCaps = (
+  declared: SubagentDelegationCaps,
+  parent: AgentPolicy,
+  inherited: SubagentBudgetReservation,
+  independentRun = false,
+): SubagentDelegationCaps => {
+  const allocation = inherited.allocation;
+
+  const remaining = (allocated: number, own: number, cap: number | undefined) =>
+    Math.min(cap ?? Infinity, Math.max(0, allocated - own));
+
+  return SubagentDelegationCaps.make({
+    maxTotalChildInvocations: Math.min(
+      declared.maxTotalChildInvocations ?? Infinity,
+      inherited.descendantInvocations ?? 0,
+    ),
+    maxConcurrentChildren: Math.min(
+      declared.maxConcurrentChildren ?? Infinity,
+      parent.toolConcurrency,
+      inherited.descendantInvocations ?? 0,
+    ),
+    maxTurns: remaining(allocation.turns, parent.maxTurns, declared.maxTurns),
+    maxToolCalls: remaining(allocation.toolCalls, parent.maxToolCalls, declared.maxToolCalls),
+    maxDurationMillis: remaining(
+      allocation.durationMillis,
+      Math.ceil(Duration.toMillis(parent.maxDuration)),
+      declared.maxDurationMillis,
+    ),
+    ...(independentRun &&
+    inherited.caps.maxInputTokens === undefined &&
+    allocation.inputTokens === 0 &&
+    parent.tokenBudget === undefined
+      ? declared.maxInputTokens === undefined
+        ? {}
+        : { maxInputTokens: declared.maxInputTokens }
+      : {
+          maxInputTokens: remaining(
+            allocation.inputTokens,
+            parent.tokenBudget ?? allocation.inputTokens,
+            declared.maxInputTokens,
+          ),
+        }),
+    ...(independentRun &&
+    inherited.caps.maxOutputTokens === undefined &&
+    allocation.outputTokens === 0 &&
+    parent.tokenBudget === undefined
+      ? declared.maxOutputTokens === undefined
+        ? {}
+        : { maxOutputTokens: declared.maxOutputTokens }
+      : {
+          maxOutputTokens: remaining(
+            allocation.outputTokens,
+            parent.tokenBudget ?? allocation.outputTokens,
+            declared.maxOutputTokens,
+          ),
+        }),
+    ...(independentRun &&
+    inherited.caps.maxCostMicrousd === undefined &&
+    allocation.costMicrousd === 0 &&
+    parent.costBudgetMicrousd === undefined
+      ? declared.maxCostMicrousd === undefined
+        ? {}
+        : { maxCostMicrousd: declared.maxCostMicrousd }
+      : {
+          maxCostMicrousd: remaining(
+            allocation.costMicrousd,
+            parent.costBudgetMicrousd ?? allocation.costMicrousd,
+            declared.maxCostMicrousd,
+          ),
+        }),
+    maxResultBytes: remaining(
+      allocation.resultBytes,
+      parent.toolResultBounds.maxBytes,
+      declared.maxResultBytes,
+    ),
+  });
+};

package/src/capabilities/internal/subagent-reporting.ts

@@ -0,0 +1,261 @@
+import { Effect, Schema } from "effect";
+
+import { utf8ByteLength } from "../../core/internal/utf8.ts";
+import { Receipt } from "../../core/Receipt.ts";
+import { type WorkerReport, WorkerCompletion } from "../../core/Worker.ts";
+import {
+  WorkerReportPreparationFailure,
+  type WorkerReporting,
+  type WorkerRunReport,
+} from "../../engine/SubagentHost.ts";
+import { type Declaration } from "./subagent-background.ts";
+import { SubagentExecutionFailure } from "./subagent-contract.ts";
+
+export { WorkerReport } from "../../core/Worker.ts";
+
+const projectReport = <
+  const Name extends string,
+  Input extends Schema.Top,
+  Output extends Schema.Top,
+  Parameters extends Schema.Top,
+  Success extends Schema.Top,
+  Failure extends Schema.Top,
+  Prepare,
+  Project,
+>(
+  declaration: Declaration<Name, Input, Output, Parameters, Success, Failure, Prepare, Project>,
+) =>
+  Effect.fn("Subagent.projectReport")(function* (report: WorkerRunReport) {
+    const { worker, observation } = report;
+    const invalid = () => WorkerReportPreparationFailure.make({ stage: "projection" });
+
+    if (
+      worker.delegationId !== declaration.delegationId ||
+      worker.targetAgentId !== declaration.target.id ||
+      observation.receipt.threadId !== worker.threadId
+    )
+      return yield* invalid();
+
+    const base = {
+      _tag: "Settled" as const,
+      worker,
+      receipt: yield* Schema.decodeEffect(Receipt)(observation.receipt).pipe(
+        Effect.mapError(invalid),
+      ),
+      runId: observation.runId,
+      settlementId: observation.settlementId,
+    };
+
+    let projected: WorkerReport<Success>;
+    let encodedResult: Schema.Json = null;
+
+    if (observation.outcome === "completed") {
+      const parameters = yield* Schema.decodeUnknownEffect(declaration.parameters)(
+        observation.encodedParameters,
+      ).pipe(Effect.mapError(invalid));
+
+      const output = yield* Schema.decodeUnknownEffect(declaration.target.output)(
+        observation.encodedResult,
+      ).pipe(Effect.mapError(invalid));
+
+      const result = yield* declaration.projectResult(
+        output,
+        { budgetExhausted: observation.budgetExhausted },
+        parameters,
+      );
+
+      const encoded = yield* Schema.encodeEffect(declaration.success)(result).pipe(
+        Effect.mapError(invalid),
+      );
+
+      const json = yield* Schema.decodeUnknownEffect(Schema.Json)(encoded).pipe(
+        Effect.mapError(invalid),
+      );
+
+      if (
+        utf8ByteLength(JSON.stringify(json)) >
+        (declaration.policy?.maxResultBytes ?? declaration.target.policy.toolResultBounds.maxBytes)
+      )
+        return yield* invalid();
+      projected = { ...base, outcome: "completed", result };
+      encodedResult = json;
+    } else {
+      projected = {
+        ...base,
+        outcome: observation.outcome,
+        failure: SubagentExecutionFailure.make({
+          delegationId: declaration.delegationId,
+          targetAgentId: declaration.target.id,
+          classification: observation.outcome === "failed" ? "child-failed" : "child-aborted",
+          childThreadId: worker.threadId,
+          childSubmissionId: observation.receipt.submissionId,
+          childRunId: observation.runId,
+          errorTag: observation.outcome === "failed" ? "WorkerFailed" : "WorkerAborted",
+          message:
+            observation.outcome === "failed" ? "Worker input failed" : "Worker input was aborted",
+        }),
+      };
+    }
+
+    return { projected, encodedResult };
+  });
+
+/** Framework reporting shares the same bounded declaration projection as custom mapping. */
+export const automaticReporting = <
+  const Name extends string,
+  Input extends Schema.Top,
+  Output extends Schema.Top,
+  Parameters extends Schema.Top,
+  Success extends Schema.Top,
+  Failure extends Schema.Top,
+  Prepare,
+  Project,
+>(
+  declaration: Declaration<Name, Input, Output, Parameters, Success, Failure, Prepare, Project>,
+) => ({
+  delegationId: declaration.delegationId,
+  target: declaration.target,
+  mode: "standard" as const,
+  prepare: Effect.fn("Subagent.automaticReport")(function* (report: WorkerRunReport) {
+    const { projected, encodedResult } = yield* projectReport(declaration)(report);
+
+    const encoded =
+      projected.outcome === "completed"
+        ? { ...projected, result: encodedResult }
+        : {
+            ...projected,
+            failure: yield* Schema.encodeEffect(SubagentExecutionFailure)(projected.failure).pipe(
+              Effect.mapError(() => WorkerReportPreparationFailure.make({ stage: "projection" })),
+            ),
+          };
+
+    const message = yield* Schema.decodeEffect(WorkerCompletion)({
+      _tag: "WorkerCompletion",
+      schemaVersion: 1,
+      report: encoded,
+      budgetExhausted: report.observation.budgetExhausted,
+    }).pipe(Effect.mapError(() => WorkerReportPreparationFailure.make({ stage: "projection" })));
+
+    return { encodedInput: null, message };
+  }),
+});
+
+/**
+ * Define an optional application-specific conversion for `background({ reportToParent: report })`.
+ * Existing Agent Registration `reporting` arrays remain supported. The input Schema must be the coordinator Definition's exact input Schema.
+ * Preparation is bounded by the durable host; a retained prepared envelope is never reprojected
+ * during delivery retries. The callback should be deterministic and have no external side effects.
+ */
+export const reporting = <
+  const Name extends string,
+  Input extends Schema.Top,
+  Output extends Schema.Top,
+  Parameters extends Schema.Top,
+  Success extends Schema.Top,
+  Failure extends Schema.Top,
+  Prepare,
+  Project,
+  CoordinatorInput extends Schema.Top,
+  ReportFailure extends Schema.Top = typeof Schema.Never,
+  ReportRequirements = never,
+>(
+  declaration: Declaration<Name, Input, Output, Parameters, Success, Failure, Prepare, Project>,
+  options: {
+    readonly input: CoordinatorInput;
+    readonly failure?: ReportFailure;
+    readonly prepare: (
+      report: WorkerReport<Success>,
+    ) => Effect.Effect<CoordinatorInput["Type"], ReportFailure["Type"], ReportRequirements>;
+  },
+): WorkerReporting<
+  Failure["Type"] | ReportFailure["Type"],
+  | Parameters["DecodingServices"]
+  | Output["DecodingServices"]
+  | Success["EncodingServices"]
+  | CoordinatorInput["EncodingServices"]
+  | Project
+  | ReportRequirements
+> => {
+  const prepare = Effect.fn("Subagent.reporting.prepare")(function* (report: WorkerRunReport) {
+    const { projected } = yield* projectReport(declaration)(report);
+    const input = yield* options.prepare(projected);
+
+    const encoded = yield* Schema.encodeEffect(options.input)(input).pipe(
+      Effect.mapError(() => WorkerReportPreparationFailure.make({ stage: "input" })),
+    );
+
+    const encodedInput = yield* Schema.decodeUnknownEffect(Schema.Json)(encoded).pipe(
+      Effect.mapError(() => WorkerReportPreparationFailure.make({ stage: "input" })),
+    );
+
+    return { encodedInput };
+  });
+
+  return Object.freeze({
+    delegationId: declaration.delegationId,
+    target: declaration.target,
+    input: options.input,
+    prepare,
+  });
+};
+
+/**
+ * Adapt a report expressed in a receiving worker declaration's Parameters to its Agent input.
+ * Use this on that worker's registration when it can itself launch reporting workers. This
+ * explicit conversion preserves custom Parameters and charges the next input to its ancestor.
+ */
+export const reportingToWorker = <
+  E,
+  R,
+  const Name extends string,
+  Input extends Schema.Top,
+  Output extends Schema.Top,
+  Parameters extends Schema.Top,
+  Success extends Schema.Top,
+  Failure extends Schema.Top,
+  Prepare,
+  Project,
+>(
+  report: WorkerReporting<E, R>,
+  destination: Declaration<Name, Input, Output, Parameters, Success, Failure, Prepare, Project>,
+): WorkerReporting<
+  E | Failure["Type"],
+  R | Prepare | Parameters["DecodingServices"] | Input["EncodingServices"]
+> => {
+  if (report.input !== destination.parameters) {
+    throw new TypeError(
+      "Worker reporting must use the destination declaration's Parameters Schema",
+    );
+  }
+
+  return Object.freeze({
+    delegationId: report.delegationId,
+    target: report.target,
+    input: destination.target.input,
+    destination: { delegationId: destination.delegationId, target: destination.target },
+    prepare: Effect.fn("Subagent.reportingToWorker.prepare")(function* (run: WorkerRunReport) {
+      const encodedParameters = (yield* report.prepare(run)).encodedInput;
+      const invalid = () => WorkerReportPreparationFailure.make({ stage: "input" });
+
+      const parameters = yield* Schema.decodeEffect(destination.parameters)(encodedParameters).pipe(
+        Effect.mapError(invalid),
+      );
+
+      const input = yield* destination.prepareInput(parameters, {
+        source: "programmatic",
+        delegationId: destination.delegationId,
+        parent: { agentId: run.context.source.agentId, threadId: run.context.source.threadId },
+      });
+
+      const encoded = yield* Schema.encodeEffect(destination.target.input)(input).pipe(
+        Effect.mapError(invalid),
+      );
+
+      const encodedInput = yield* Schema.decodeUnknownEffect(Schema.Json)(encoded).pipe(
+        Effect.mapError(invalid),
+      );
+
+      return { encodedInput, encodedParameters };
+    }),
+  });
+};

package/src/capabilities/internal/utf8.ts

@@ -0,0 +1,10 @@
+import { Encoding } from "effect";
+
+/** Encode through Effect without requiring browser or Node ambient types in consumers. */
+export const utf8Bytes = (value: string): Uint8Array => {
+  const hex = Encoding.encodeHex(value);
+
+  return Uint8Array.from({ length: hex.length / 2 }, (_, index) =>
+    Number.parseInt(hex.slice(index * 2, index * 2 + 2), 16),
+  );
+};