effect-agent 0.1.0-beta.103 → 0.1.0-beta.106

package/src/core/FailureDiagnostic.ts

@@ -0,0 +1,343 @@
+import {
+  Cause as EffectCause,
+  Exit,
+  Predicate,
+  Redacted,
+  Schema,
+  SchemaTransformation,
+} from "effect";
+
+import { strictSchema } from "./internal/strict-schema.ts";
+
+const Text = Schema.String.check(Schema.isMaxLength(16 * 1024));
+const Name = Schema.String.check(Schema.isMaxLength(1_024));
+const Scalar = Schema.Union([Text, Schema.Finite, Schema.Boolean, Schema.Null]);
+
+/** Correlation only: never include inputs, tool parameters, request bodies, or credentials. */
+export const Context = Schema.Struct({
+  agentId: Schema.optionalKey(Name),
+  threadId: Schema.optionalKey(Name),
+  runId: Schema.optionalKey(Name),
+  submissionId: Schema.optionalKey(Name),
+  attemptId: Schema.optionalKey(Name),
+  turnId: Schema.optionalKey(Name),
+  toolCallId: Schema.optionalKey(Name),
+  toolName: Schema.optionalKey(Name),
+  callId: Schema.optionalKey(Name),
+  check: Schema.optionalKey(Name),
+  operation: Schema.optionalKey(Name),
+}).pipe(strictSchema);
+
+export type Context = typeof Context.Type;
+
+type CauseReason =
+  | { readonly _tag: "Fail"; readonly error: Diagnostic }
+  | { readonly _tag: "Die"; readonly defect: Diagnostic }
+  | { readonly _tag: "Interrupt"; readonly fiberId?: number };
+
+/** A private diagnostic projection, not a JavaScript error reconstruction or model response. */
+export type Diagnostic =
+  | {
+      readonly _tag: "Error";
+      readonly errorTag?: string;
+      readonly name?: string;
+      readonly message?: string;
+      readonly stack?: string;
+      readonly reason?: Diagnostic;
+      readonly code?: string | number;
+      readonly cause?: Diagnostic;
+      readonly errors?: ReadonlyArray<Diagnostic>;
+      readonly context?: Context;
+      readonly omittedFields?: ReadonlyArray<string>;
+      readonly truncated?: true;
+    }
+  | {
+      readonly _tag: "Cause";
+      readonly reasons: ReadonlyArray<CauseReason>;
+      readonly truncated?: true;
+    }
+  | { readonly _tag: "Value"; readonly value: string | number | boolean | null }
+  | { readonly _tag: "Omitted"; readonly reason: "redacted" | "cycle" | "limit" | "unsupported" };
+
+const diagnosticSchema = <Nested extends Schema.Top>(nested: Nested) =>
+  Schema.Union([
+    Schema.Struct({
+      _tag: Schema.Literal("Error"),
+      errorTag: Schema.optionalKey(Name),
+      name: Schema.optionalKey(Name),
+      message: Schema.optionalKey(Text),
+      stack: Schema.optionalKey(Text),
+      reason: Schema.optionalKey(nested),
+      code: Schema.optionalKey(Schema.Union([Name, Schema.Finite])),
+      cause: Schema.optionalKey(nested),
+      errors: Schema.optionalKey(Schema.Array(nested).check(Schema.isMaxLength(128))),
+      context: Schema.optionalKey(Context),
+      omittedFields: Schema.optionalKey(Schema.Array(Name).check(Schema.isMaxLength(32))),
+      truncated: Schema.optionalKey(Schema.Literal(true)),
+    }),
+    Schema.Struct({
+      _tag: Schema.Literal("Cause"),
+      reasons: Schema.Array(
+        Schema.Union([
+          Schema.Struct({ _tag: Schema.Literal("Fail"), error: nested }),
+          Schema.Struct({ _tag: Schema.Literal("Die"), defect: nested }),
+          Schema.Struct({
+            _tag: Schema.Literal("Interrupt"),
+            fiberId: Schema.optionalKey(Schema.Finite),
+          }),
+        ]),
+      ).check(Schema.isMaxLength(128)),
+      truncated: Schema.optionalKey(Schema.Literal(true)),
+    }),
+    Schema.Struct({ _tag: Schema.Literal("Value"), value: Scalar }),
+    Schema.Struct({
+      _tag: Schema.Literal("Omitted"),
+      reason: Schema.Literals(["redacted", "cycle", "limit", "unsupported"]),
+    }),
+  ]);
+
+/** Structured, allowlisted Error fields and ordered Effect Fail/Die/Interrupt reasons. */
+export const Diagnostic: Schema.Codec<Diagnostic> = Schema.suspend(() =>
+  diagnosticSchema(Diagnostic),
+).pipe(strictSchema);
+
+// Inspect one encoded node only; recursion must share capture's depth/node/text budgets.
+const decodeDiagnosticNode = Schema.decodeUnknownExit(
+  diagnosticSchema(Schema.Unknown).pipe(strictSchema),
+);
+
+/** Remove common credential forms; hosts must keep arbitrary private payloads out of error text. */
+export const redactText = (text: string): string =>
+  text
+    .replace(/\b(Bearer|Basic)\s+[A-Za-z0-9._~+/=-]+/gi, "$1 [REDACTED]")
+    .replace(/(https?:\/\/)[^\s/@]+:[^\s/@]+@/gi, "$1[REDACTED]@")
+    .replace(
+      /([?&](?:access_token|api_key|apikey|token|key|secret|password|signature)=)[^\s&#]*/gi,
+      "$1[REDACTED]",
+    )
+    .replace(
+      /\b((?:api[_-]?key|access[_-]?token|authorization|password|secret)\s*[=:]\s*)[^\s,;}]+/gi,
+      "$1[REDACTED]",
+    );
+
+/**
+ * Capture only diagnostic fields. Local values are never mutated. Cycles and exhausted limits
+ * are explicit, not silently dropped; capture visits at most 1,024 nodes, with 56 JSON levels
+ * and 128 KiB text. Inner causes have priority over outer stacks when the text budget is exhausted.
+ * Text remains operator-private. No generic serializer can identify secrets embedded in arbitrary
+ * prose: application error messages must exclude payloads, and hosts may supply stricter redaction.
+ */
+export const capture = (
+  value: unknown,
+  options?: { readonly redactText?: (text: string) => string },
+): Diagnostic => {
+  const seen = new WeakSet<object>();
+  let remainingNodes = 1_024;
+  let remainingText = 128 * 1024;
+
+  const text = (value: string, limit = 16 * 1024): string => {
+    const safe = (options?.redactText ?? redactText)(value);
+    const length = Math.max(0, Math.min(limit, remainingText));
+
+    const marker = "[truncated]".slice(0, length);
+
+    const result =
+      safe.length <= length ? safe : `${safe.slice(0, length - marker.length)}${marker}`;
+
+    remainingText -= result.length;
+
+    return result;
+  };
+
+  const visit = (value: unknown, depth: number): Diagnostic => {
+    if (remainingNodes <= 0 || depth >= 56) return { _tag: "Omitted", reason: "limit" };
+    remainingNodes--;
+    if (Redacted.isRedacted(value)) return { _tag: "Omitted", reason: "redacted" };
+    if (Predicate.isString(value)) return { _tag: "Value", value: text(value) };
+    if (
+      value === null ||
+      Predicate.isBoolean(value) ||
+      (Predicate.isNumber(value) && Number.isFinite(value))
+    )
+      return { _tag: "Value", value };
+    if (!Predicate.isObject(value)) return { _tag: "Omitted", reason: "unsupported" };
+    if (seen.has(value)) return { _tag: "Omitted", reason: "cycle" };
+    seen.add(value);
+    const nested = (value: unknown) => visit(value, depth + 1);
+    // Local errors retain their own tag, even when it happens to be "Error".
+    const decoded = value instanceof Error ? undefined : decodeDiagnosticNode(value);
+    const node = decoded !== undefined && Exit.isSuccess(decoded) ? decoded.value : undefined;
+
+    if (node?._tag === "Omitted" || node?._tag === "Value") {
+      seen.delete(value);
+
+      return node._tag === "Value" && typeof node.value === "string"
+        ? { _tag: "Value", value: text(node.value) }
+        : node;
+    }
+
+    const originalReasons = EffectCause.isCause(value)
+      ? value.reasons
+      : node?._tag === "Cause"
+        ? node.reasons
+        : undefined;
+
+    if (originalReasons !== undefined) {
+      const reasons: Array<CauseReason> = [];
+
+      for (const reason of originalReasons) {
+        if (reasons.length >= 128 || remainingNodes <= 0) break;
+        remainingNodes--;
+
+        // reasons -> array item -> error/defect contributes three JSON levels.
+        switch (reason._tag) {
+          case "Fail":
+            reasons.push({ _tag: "Fail", error: visit(reason.error, depth + 3) });
+            break;
+          case "Die":
+            reasons.push({ _tag: "Die", defect: visit(reason.defect, depth + 3) });
+            break;
+          case "Interrupt":
+            reasons.push({
+              _tag: "Interrupt",
+              ...(reason.fiberId === undefined ? {} : { fiberId: reason.fiberId }),
+            });
+            break;
+        }
+      }
+
+      const result: Diagnostic = {
+        _tag: "Cause",
+        ...(originalReasons.length > reasons.length || (node?._tag === "Cause" && node.truncated)
+          ? { truncated: true }
+          : {}),
+        reasons,
+      };
+
+      seen.delete(value);
+
+      return result;
+    }
+    const retained = node?._tag === "Error" ? node : undefined;
+    const omittedFields: Array<string> = [];
+
+    const read = (key: string): unknown => {
+      // A throwing accessor must not replace the original failure during diagnostic capture.
+      try {
+        return Reflect.get(value, key);
+      } catch {
+        omittedFields.push(key);
+
+        return undefined;
+      }
+    };
+
+    const tag = retained === undefined ? read("_tag") : retained.errorTag;
+    const name = read("name");
+    const message = read("message");
+    const stack = read("stack");
+    const reason = read("reason");
+    const code = read("code");
+    const cause = read("cause");
+    const errors = read("errors");
+    const capturedCause = cause === undefined ? undefined : nested(cause);
+    const capturedReason = reason === undefined ? undefined : nested(reason);
+    const capturedErrors: Array<Diagnostic> = [];
+
+    if (Array.isArray(errors))
+      for (const error of errors) {
+        if (capturedErrors.length >= 128 || remainingNodes <= 0) break;
+        capturedErrors.push(visit(error, depth + 2));
+      }
+
+    for (const field of retained?.omittedFields ?? []) omittedFields.push(text(field, 1_024));
+
+    const context: Record<string, string> = {};
+
+    for (const key of [
+      "agentId",
+      "threadId",
+      "runId",
+      "submissionId",
+      "attemptId",
+      "turnId",
+      "toolCallId",
+      "toolName",
+      "callId",
+      "check",
+      "operation",
+    ] as const) {
+      const field = retained === undefined ? read(key) : retained.context?.[key];
+
+      if (Predicate.isString(field)) context[key] = text(field, 1_024);
+    }
+
+    const result: Diagnostic = {
+      _tag: "Error",
+      ...(Predicate.isString(tag) ? { errorTag: text(tag, 1_024) } : {}),
+      ...(Predicate.isString(name) ? { name: text(name, 1_024) } : {}),
+      ...(Predicate.isString(message) ? { message: text(message) } : {}),
+      ...(Predicate.isString(stack) ? { stack: text(stack) } : {}),
+      ...(capturedReason === undefined ? {} : { reason: capturedReason }),
+      ...(Predicate.isString(code)
+        ? { code: text(code, 1_024) }
+        : Predicate.isNumber(code) && Number.isFinite(code)
+          ? { code }
+          : {}),
+      ...(capturedCause === undefined ? {} : { cause: capturedCause }),
+      ...(Array.isArray(errors) ? { errors: capturedErrors } : {}),
+      ...(Object.keys(context).length === 0 ? {} : { context }),
+      ...(omittedFields.length === 0 ? {} : { omittedFields }),
+      ...(retained?.truncated ||
+      (Array.isArray(errors) && errors.length > capturedErrors.length) ||
+      remainingText === 0
+        ? { truncated: true }
+        : {}),
+    };
+
+    seen.delete(value);
+
+    return result;
+  };
+
+  return visit(value, 0);
+};
+
+/** Bound and redact a diagnostic copy; canonical identities stay in their owning records. */
+export const captureContext = (context: Context): Context => {
+  const diagnostic = capture(context);
+
+  return diagnostic._tag === "Error" ? (diagnostic.context ?? {}) : {};
+};
+
+/**
+ * Preserve the original value in-process; across JSON retain its structured diagnostic projection.
+ * Decoding returns Diagnostic data, never claims to reconstruct an application error class.
+ */
+export const Value = Diagnostic.pipe(
+  Schema.decodeTo(
+    Schema.Unknown,
+    SchemaTransformation.transform({
+      decode: (diagnostic): unknown => diagnostic,
+      encode: (value: unknown) => capture(value),
+    }),
+  ),
+);
+
+/** Original local Effect Cause; its JSON codec preserves ordered typed, defect and interrupt reasons. */
+export const Cause = Schema.Cause(Value, Value).pipe(
+  Schema.decodeTo(
+    Schema.declare<EffectCause.Cause<unknown>>(EffectCause.isCause),
+    SchemaTransformation.transform({ decode: (cause) => cause, encode: (cause) => cause }),
+  ),
+);
+
+/** Safe summary plus optional operator-private causal evidence retained at a terminal boundary. */
+export const Failure = Schema.Struct({
+  errorTag: Schema.NonEmptyString.check(Schema.isMaxLength(256)),
+  message: Text,
+  diagnostic: Schema.optionalKey(Diagnostic),
+  context: Schema.optionalKey(Context),
+}).pipe(strictSchema);
+
+export type Failure = typeof Failure.Type;

package/src/core/Worker.ts

@@ -2,6 +2,7 @@ import { Schema } from "effect";
 
 import { AgentPolicy } from "./AgentPolicy.ts";
 import { Update } from "./AgentUpdates.ts";
+import * as FailureDiagnostic from "./FailureDiagnostic.ts";
 import { AgentId, DelegationId, RunId, SettlementId, ThreadId, ToolCallId } from "./Identifiers.ts";
 import { Receipt } from "./Receipt.ts";
 import { SubagentExecutionFailure, SubagentGrant } from "./SubagentContract.ts";
@@ -82,11 +83,13 @@ export const WorkerHistoryEntry = Schema.Struct({
 export type WorkerHistoryEntry = typeof WorkerHistoryEntry.Type;
 
 /**
- * Closed host-boundary failures. Infrastructure diagnostics remain in host telemetry.
+ * Closed host-boundary failures. Original causes stay private and survive diagnostic transport.
  * `delivery-pending` confirms retained input, not destination acceptance or execution.
  * Keep the same idempotency key and parameters when reconciling; never launch a replacement.
  */
 export class WorkerError extends Schema.TaggedError<WorkerError>()("WorkerError", {
+  cause: Schema.optionalKey(FailureDiagnostic.Value),
+  stack: Schema.optionalKey(Schema.String),
   /** Pending input or concurrency pressure may clear without changing the request. */
   retryable: Schema.optionalKey(Schema.Literal(true)),
   operation: Schema.Literals([

package/src/durable/Digest.ts

@@ -34,7 +34,7 @@ const canonicalJson = (value: Schema.Json): string => {
 };
 
 /** Digest a JSON value using a stable, locale-independent object-key ordering (UTF-16 code units, RFC 8785 style). */
-export const digestJson = Effect.fn("Thread.digestJson")(function* (
+export const digestJson = Effect.fnUntraced(function* (
   value: Schema.Json,
 ): Effect.fn.Return<Digest, DigestError, Crypto.Crypto> {
   const crypto = yield* Crypto.Crypto;
@@ -55,38 +55,32 @@ export const digestJson = Effect.fn("Thread.digestJson")(function* (
 });
 
 /** Digest a canonical batch together with the prior tail to form an append-only hash chain. */
-export const digestCanonicalBatch = Effect.fn("Thread.digestCanonicalBatch")(
-  (
-    previousTailDigest: Digest,
-    batch: CanonicalBatch,
-  ): Effect.Effect<Digest, DigestError, Crypto.Crypto> =>
-    Schema.encodeEffect(CanonicalBatch)(batch).pipe(
-      Effect.mapError(() => DigestError.make({ message: "Canonical batch encoding failed" })),
-      Effect.flatMap((encoded) =>
-        digestJson({
-          previousTailDigest,
-          batch: encoded,
-        }),
-      ),
+export const digestCanonicalBatch = (
+  previousTailDigest: Digest,
+  batch: CanonicalBatch,
+): Effect.Effect<Digest, DigestError, Crypto.Crypto> =>
+  Schema.encodeEffect(CanonicalBatch)(batch).pipe(
+    Effect.mapError(() => DigestError.make({ message: "Canonical batch encoding failed" })),
+    Effect.flatMap((encoded) =>
+      digestJson({
+        previousTailDigest,
+        batch: encoded,
+      }),
     ),
-);
+  );
 
 /** Digest one schema-encoded Agent, Model, or Toolkit definition. */
-export const digestDefinition = Effect.fn("Thread.digestDefinition")((definition: Schema.Json) =>
-  digestJson(definition),
-);
+export const digestDefinition = (definition: Schema.Json) => digestJson(definition);
 
 /** Digest all replay-relevant definitions without hiding which authority changed. */
-export const digestDefinitions = Effect.fn("Thread.digestDefinitions")(
-  (
-    definitions: DefinitionDigestInput,
-  ): Effect.Effect<DefinitionDigests, DigestError, Crypto.Crypto> =>
-    Effect.all({
-      agent: digestDefinition(definitions.agent),
-      model: digestDefinition(definitions.model),
-      tools: digestDefinition(definitions.tools),
-    }).pipe(Effect.map((digests) => DefinitionDigests.make(digests))),
-);
+export const digestDefinitions = (
+  definitions: DefinitionDigestInput,
+): Effect.Effect<DefinitionDigests, DigestError, Crypto.Crypto> =>
+  Effect.all({
+    agent: digestDefinition(definitions.agent),
+    model: digestDefinition(definitions.model),
+    tools: digestDefinition(definitions.tools),
+  }).pipe(Effect.map((digests) => DefinitionDigests.make(digests)));
 
 export const EMPTY_TAIL_DIGEST = Schema.decodeSync(Digest)(
   "0000000000000000000000000000000000000000000000000000000000000000",

package/src/durable/DurableAgentRuntime.ts

@@ -31,10 +31,12 @@ import {
   AgentApprovalPending,
   AgentInputError,
   AgentToolAuthorizationDenied,
+  type AgentToolAuthorizationCheckError,
   PolicyLimit,
 } from "../core/AgentError.ts";
 import { AgentPolicy } from "../core/AgentPolicy.ts";
 import { UpdateError } from "../core/AgentUpdates.ts";
+import * as FailureDiagnostic from "../core/FailureDiagnostic.ts";
 import {
   type ReceiptId,
   ThreadId,
@@ -2922,7 +2924,7 @@ const make = Effect.fn("DurableAgentRuntime.make")(function* (
       .completeInput(submission)
       .pipe(
         Effect.mapError((cause) =>
-          LedgerError.make({ operation: "worker-completion", message: cause.reason }),
+          LedgerError.make({ operation: "worker-completion", message: cause.reason, cause }),
         ),
       );
     const linkage = submission.parentLinkage;
@@ -4231,12 +4233,18 @@ const make = Effect.fn("DurableAgentRuntime.make")(function* (
     }
   });
 
-  const failureOutcome = (error: unknown): Effect.Effect<AttemptOutcome> =>
+  const failureOutcome = (
+    error: unknown,
+    cause: Cause.Cause<unknown>,
+    context: FailureDiagnostic.Context,
+  ): Effect.Effect<AttemptOutcome> =>
     Schema.decodeEffect(SettlementFailureDiagnostic)({
       errorTag: errorTagOf(error).slice(0, 256) || "UnknownError",
       message: errorMessageOf(error).slice(0, MAX_FAILURE_MESSAGE_LENGTH),
+      diagnostic: FailureDiagnostic.capture(cause),
+      context: FailureDiagnostic.captureContext(context),
     }).pipe(
-      // The exact diagnostic Schema admits no raw Cause, stack, or provider payload.
+      // The exact diagnostic Schema admits only causal fields, never arbitrary provider payloads.
       Effect.orDie,
       Effect.map((result) => ({
         _tag: "failed" as const,
@@ -6729,7 +6737,7 @@ const make = Effect.fn("DurableAgentRuntime.make")(function* (
         join: joinSubagent,
       };
 
-      const toolAuthorization: RunToolAuthorizationHook = {
+      const toolAuthorization: RunToolAuthorizationHook<AgentToolAuthorizationCheckError> = {
         authorize: (request: RunToolAuthorizationRequest) =>
           inheritedGrant !== undefined &&
           !inheritedGrant.allowedToolNames.includes(request.call.toolName)
@@ -6750,6 +6758,7 @@ const make = Effect.fn("DurableAgentRuntime.make")(function* (
 
       const options: RunOptions<
         | CoordinatorHalt
+        | AgentToolAuthorizationCheckError
         | CompactionError
         | RunContextPreparationError
         | Agent.Failure<typeof agent>,
@@ -7364,9 +7373,11 @@ const make = Effect.fn("DurableAgentRuntime.make")(function* (
       ).pipe(Effect.provideService(IdGenerator, idGenerator));
 
       const result = yield* raced.pipe(
-        Effect.catch(
+        Effect.catchCauseFilter(
+          Cause.findError,
           (
             error,
+            cause,
           ): Effect.Effect<
             | { readonly _tag: "failedRun"; readonly outcome: AttemptOutcome }
             | { readonly _tag: "aborted" }
@@ -7430,14 +7441,19 @@ const make = Effect.fn("DurableAgentRuntime.make")(function* (
                 }
               }
 
-              // Settlement keeps only a bounded diagnostic. Report the live failure here,
+              // Report the original live Cause here, before its private diagnostic projection,
               // after excluding suspensions, so hosts retain its cause and stack exactly
               // once per failed Run; reading or retrying its receipt never reports again.
               if (
-                !(error instanceof AgentApprovalDenied) &&
-                !(error instanceof AgentToolAuthorizationDenied)
+                cause.reasons.some(
+                  (reason) =>
+                    reason._tag === "Die" ||
+                    (reason._tag === "Fail" &&
+                      !(reason.error instanceof AgentApprovalDenied) &&
+                      !(reason.error instanceof AgentToolAuthorizationDenied)),
+                )
               )
-                yield* Effect.logError("Agent run failed", Cause.fail(error)).pipe(
+                yield* Effect.logError("Agent run failed", cause).pipe(
                   Effect.annotateLogs({
                     agentId: agent.definition.id,
                     runId,
@@ -7449,7 +7465,13 @@ const make = Effect.fn("DurableAgentRuntime.make")(function* (
 
               return {
                 _tag: "failedRun" as const,
-                outcome: yield* failureOutcome(error),
+                outcome: yield* failureOutcome(error, cause, {
+                  agentId: agent.definition.id,
+                  runId,
+                  threadId: ctx.threadId,
+                  submissionId,
+                  attemptId: lineage.attemptId,
+                }),
               };
             });
           },
@@ -7574,7 +7596,7 @@ const make = Effect.fn("DurableAgentRuntime.make")(function* (
           .ensureOrigin(submission.workerAdmission.origin)
           .pipe(
             Effect.mapError((cause) =>
-              LedgerError.make({ operation: "worker-origin", message: cause.reason }),
+              LedgerError.make({ operation: "worker-origin", message: cause.reason, cause }),
             ),
           );
       }
@@ -9007,7 +9029,7 @@ const make = Effect.fn("DurableAgentRuntime.make")(function* (
               .ensureOrigin(submission.workerAdmission.origin)
               .pipe(
                 Effect.mapError((cause) =>
-                  LedgerError.make({ operation: "worker-origin", message: cause.reason }),
+                  LedgerError.make({ operation: "worker-origin", message: cause.reason, cause }),
                 ),
               );
           }
@@ -9578,6 +9600,7 @@ const make = Effect.fn("DurableAgentRuntime.make")(function* (
                         ? "occupied"
                         : "refused",
                   code: `worker-${cause.reason}`,
+                  cause,
                 }),
               ),
             );
@@ -9609,6 +9632,7 @@ const make = Effect.fn("DurableAgentRuntime.make")(function* (
                     ? "unavailable"
                     : "refused",
                 code: `message-${cause.reason}`,
+                cause,
               }),
             ),
           );
@@ -9701,7 +9725,7 @@ const make = Effect.fn("DurableAgentRuntime.make")(function* (
         .ensureOrigin(workerAdmission.origin)
         .pipe(
           Effect.mapError((cause) =>
-            LedgerError.make({ operation: "worker-origin", message: cause.reason }),
+            LedgerError.make({ operation: "worker-origin", message: cause.reason, cause }),
           ),
         );
     }