effect-agent 0.1.0-beta.15 → 0.1.0-beta.151

package/dist/engine/ThreadHistory.d.mts

@@ -0,0 +1,2 @@
+import { a as layer, n as ThreadHistoryError, r as ThreadHistoryRun, t as ThreadHistory } from "../ThreadHistory-tS1KwxHR.mjs";
+export { ThreadHistory, ThreadHistoryError, ThreadHistoryRun, layer };

package/dist/engine/ThreadHistory.mjs

@@ -0,0 +1,67 @@
+import { t as __exportAll } from "../rolldown-runtime-D7D4PA-g.mjs";
+import { ThreadId } from "../core/Identifiers.mjs";
+import { Store, layerMemory, toPrompt } from "../core/Thread.mjs";
+import { Context, Effect, Layer, Schema } from "effect";
+//#region src/engine/ThreadHistory.ts
+var ThreadHistory_exports = /* @__PURE__ */ __exportAll({
+	ThreadHistory: () => ThreadHistory,
+	ThreadHistoryError: () => ThreadHistoryError,
+	layer: () => layer
+});
+/** A history adapter rejected a read, staged value, or completed Run commit. */
+var ThreadHistoryError = class extends Schema.TaggedError()("ThreadHistoryError", {
+	threadId: ThreadId,
+	reason: Schema.Literals([
+		"not-found",
+		"conflict",
+		"fenced",
+		"incompatible",
+		"limit",
+		"encoding",
+		"storage"
+	]),
+	message: Schema.String,
+	cause: Schema.optionalKey(Schema.Defect())
+}) {};
+/**
+* History shared by Runs with the same Thread ID. The default layer retains native messages
+* incrementally in memory for its application Scope, including completed updates before a failure.
+* PersistentHistory.layer from effect-agent/persistent-history instead commits successful
+* Runs to an explicit ThreadStore. Durable hosts retain history through their journal hooks.
+* No implementation may retry model or Tool execution or claim interrupted-work recovery.
+*/
+var ThreadHistory = class ThreadHistory extends Context.Service()("@effect-agent/engine/ThreadHistory") {
+	/**
+	* Retain bounded in-memory history across Runs. Provide once around the application so
+	* all Runs share the same store. The underlying Thread.Store service is exposed for
+	* snapshots and interactive hooks; separate Layer builds own separate stores.
+	*/
+	static layer = Layer.effect(ThreadHistory, Effect.gen(function* () {
+		const threads = yield* Store;
+		const historyError = (cause) => ThreadHistoryError.make({
+			threadId: cause.threadId,
+			reason: cause._tag === "ThreadNotFound" ? "not-found" : cause._tag === "ThreadLimitExceeded" ? "limit" : cause._tag === "ThreadHistoryDiverged" ? "conflict" : "encoding",
+			message: cause._tag === "ThreadNotFound" ? "Thread history is not present in this application Scope" : cause._tag === "ThreadLimitExceeded" ? `In-memory history exceeds the ${cause.limit} limit of ${cause.limitValue}` : cause.message,
+			cause
+		});
+		return ThreadHistory.of({
+			retention: "incremental",
+			load: (threadId) => threads.snapshot(threadId).pipe(Effect.map(toPrompt), Effect.mapError(historyError)),
+			open: Effect.fn("ThreadHistory.open")(function* ({ threadId, runId }) {
+				const snapshot = yield* threads.create(threadId).pipe(Effect.mapError(historyError));
+				return {
+					prompt: toPrompt(snapshot),
+					stageInput: () => Effect.void,
+					stageHistory: (history) => threads.recordHistory(threadId, runId, history).pipe(Effect.asVoid, Effect.mapError(historyError)),
+					commit: () => Effect.void
+				};
+			})
+		});
+	})).pipe(Layer.provideMerge(layerMemory));
+};
+/** Retain in-memory conversation history for the application Scope. */
+const layer = ThreadHistory.layer;
+//#endregion
+export { ThreadHistory, ThreadHistoryError, layer, ThreadHistory_exports as t };
+
+//# sourceMappingURL=ThreadHistory.mjs.map

package/dist/engine/ThreadHistory.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"ThreadHistory.mjs","names":["ConversationStore"],"sources":["../../src/engine/ThreadHistory.ts"],"sourcesContent":["import { Context, Effect, Layer, Schema } from \"effect\";\nimport type { Prompt } from \"effect/unstable/ai\";\n\nimport { ThreadId, type RunId } from \"../core/Identifiers.ts\";\nimport { type RunCompleted } from \"../core/RunEvent.ts\";\nimport {\n  Store as ConversationStore,\n  layerMemory,\n  toPrompt,\n  type ThreadError,\n} from \"../core/Thread.ts\";\n\n/** A history adapter rejected a read, staged value, or completed Run commit. */\nexport class ThreadHistoryError extends Schema.TaggedError<ThreadHistoryError>()(\n  \"ThreadHistoryError\",\n  {\n    threadId: ThreadId,\n    reason: Schema.Literals([\n      \"not-found\",\n      \"conflict\",\n      \"fenced\",\n      \"incompatible\",\n      \"limit\",\n      \"encoding\",\n      \"storage\",\n    ]),\n    message: Schema.String,\n    cause: Schema.optionalKey(Schema.Defect()),\n  },\n) {}\n\n/**\n * One Run's history owner. Incremental adapters retain each stageHistory update; on-success\n * adapters stage privately until commit. Before commit, the interpreter\n * finishes run-owned work and closes resources acquired for that Run, then validates the result\n * for run/start.await. Shared model, provider, and client services supplied by an enclosing\n * application Layer remain owned by that application's Scope and may outlive multiple Runs.\n * Commit must succeed before RunCompleted becomes observable. Schema-encoded input is opaque\n * here; the adapter owns its persistence boundary. A failed commit may have reached storage;\n * callers must inspect history before retrying external execution.\n */\nexport interface ThreadHistoryRun {\n  readonly prompt: Prompt.Prompt;\n  readonly stageInput: (input: unknown) => Effect.Effect<void, ThreadHistoryError>;\n  readonly stageHistory: (history: Prompt.Prompt) => Effect.Effect<void, ThreadHistoryError>;\n  readonly commit: (completed: RunCompleted) => Effect.Effect<void, ThreadHistoryError>;\n}\n\n/**\n * History shared by Runs with the same Thread ID. The default layer retains native messages\n * incrementally in memory for its application Scope, including completed updates before a failure.\n * PersistentHistory.layer from effect-agent/persistent-history instead commits successful\n * Runs to an explicit ThreadStore. Durable hosts retain history through their journal hooks.\n * No implementation may retry model or Tool execution or claim interrupted-work recovery.\n */\nexport class ThreadHistory extends Context.Service<\n  ThreadHistory,\n  {\n    readonly retention: \"incremental\" | \"on-success\";\n    readonly open: (request: {\n      readonly threadId: ThreadId;\n      readonly runId: RunId;\n    }) => Effect.Effect<ThreadHistoryRun, ThreadHistoryError>;\n    readonly load: (threadId: ThreadId) => Effect.Effect<Prompt.Prompt, ThreadHistoryError>;\n  }\n>()(\"@effect-agent/engine/ThreadHistory\") {\n  /**\n   * Retain bounded in-memory history across Runs. Provide once around the application so\n   * all Runs share the same store. The underlying Thread.Store service is exposed for\n   * snapshots and interactive hooks; separate Layer builds own separate stores.\n   */\n  static readonly layer = Layer.effect(\n    ThreadHistory,\n    Effect.gen(function* () {\n      const threads = yield* ConversationStore;\n\n      const historyError = (cause: ThreadError): ThreadHistoryError =>\n        ThreadHistoryError.make({\n          threadId: cause.threadId,\n          reason:\n            cause._tag === \"ThreadNotFound\"\n              ? \"not-found\"\n              : cause._tag === \"ThreadLimitExceeded\"\n                ? \"limit\"\n                : cause._tag === \"ThreadHistoryDiverged\"\n                  ? \"conflict\"\n                  : \"encoding\",\n          message:\n            cause._tag === \"ThreadNotFound\"\n              ? \"Thread history is not present in this application Scope\"\n              : cause._tag === \"ThreadLimitExceeded\"\n                ? `In-memory history exceeds the ${cause.limit} limit of ${cause.limitValue}`\n                : cause.message,\n          cause,\n        });\n\n      return ThreadHistory.of({\n        retention: \"incremental\",\n        load: (threadId) =>\n          threads.snapshot(threadId).pipe(Effect.map(toPrompt), Effect.mapError(historyError)),\n        open: Effect.fn(\"ThreadHistory.open\")(function* ({ threadId, runId }) {\n          const snapshot = yield* threads.create(threadId).pipe(Effect.mapError(historyError));\n\n          return {\n            prompt: toPrompt(snapshot),\n            stageInput: () => Effect.void,\n            stageHistory: (history: Prompt.Prompt) =>\n              threads\n                .recordHistory(threadId, runId, history)\n                .pipe(Effect.asVoid, Effect.mapError(historyError)),\n            commit: () => Effect.void,\n          };\n        }),\n      });\n    }),\n  ).pipe(Layer.provideMerge(layerMemory));\n}\n\n/** Retain in-memory conversation history for the application Scope. */\nexport const layer = ThreadHistory.layer;\n"],"mappings":";;;;;;;;;;;AAaA,IAAa,qBAAb,cAAwC,OAAO,YAAgC,CAAC,CAC9E,sBACA;CACE,UAAU;CACV,QAAQ,OAAO,SAAS;EACtB;EACA;EACA;EACA;EACA;EACA;EACA;CACF,CAAC;CACD,SAAS,OAAO;CAChB,OAAO,OAAO,YAAY,OAAO,OAAO,CAAC;AAC3C,CACF,CAAC,CAAC,CAAC;;;;;;;;AA0BH,IAAa,gBAAb,MAAa,sBAAsB,QAAQ,QAUzC,CAAC,CAAC,oCAAoC,CAAC,CAAC;;;;;;CAMxC,OAAgB,QAAQ,MAAM,OAC5B,eACA,OAAO,IAAI,aAAa;EACtB,MAAM,UAAU,OAAOA;EAEvB,MAAM,gBAAgB,UACpB,mBAAmB,KAAK;GACtB,UAAU,MAAM;GAChB,QACE,MAAM,SAAS,mBACX,cACA,MAAM,SAAS,wBACb,UACA,MAAM,SAAS,0BACb,aACA;GACV,SACE,MAAM,SAAS,mBACX,4DACA,MAAM,SAAS,wBACb,iCAAiC,MAAM,MAAM,YAAY,MAAM,eAC/D,MAAM;GACd;EACF,CAAC;EAEH,OAAO,cAAc,GAAG;GACtB,WAAW;GACX,OAAO,aACL,QAAQ,SAAS,QAAQ,CAAC,CAAC,KAAK,OAAO,IAAI,QAAQ,GAAG,OAAO,SAAS,YAAY,CAAC;GACrF,MAAM,OAAO,GAAG,oBAAoB,CAAC,CAAC,WAAW,EAAE,UAAU,SAAS;IACpE,MAAM,WAAW,OAAO,QAAQ,OAAO,QAAQ,CAAC,CAAC,KAAK,OAAO,SAAS,YAAY,CAAC;IAEnF,OAAO;KACL,QAAQ,SAAS,QAAQ;KACzB,kBAAkB,OAAO;KACzB,eAAe,YACb,QACG,cAAc,UAAU,OAAO,OAAO,CAAC,CACvC,KAAK,OAAO,QAAQ,OAAO,SAAS,YAAY,CAAC;KACtD,cAAc,OAAO;IACvB;GACF,CAAC;EACH,CAAC;CACH,CAAC,CACH,CAAC,CAAC,KAAK,MAAM,aAAa,WAAW,CAAC;AACxC;;AAGA,MAAa,QAAQ,cAAc"}

package/dist/engine/ToolBroker.d.mts

@@ -0,0 +1,2 @@
+import { a as ProgrammaticCallSuccess, c as ToolBrokerConfigurationError, d as ToolBrokerService, f as ToolBrokerUnavailableError, i as ProgrammaticCallRecord, l as ToolBrokerPass, n as ProgrammaticCallFailure, o as ProgrammaticToolInput, r as ProgrammaticCallOutcome, s as ToolBroker, t as ProgrammaticCallError, u as ToolBrokerPassOptions } from "../ToolBroker-DWs4tZra.mjs";
+export { ProgrammaticCallError, ProgrammaticCallFailure, ProgrammaticCallOutcome, ProgrammaticCallRecord, ProgrammaticCallSuccess, ProgrammaticToolInput, ToolBroker, ToolBrokerConfigurationError, ToolBrokerPass, ToolBrokerPassOptions, ToolBrokerService, ToolBrokerUnavailableError };

package/dist/engine/ToolBroker.mjs

@@ -0,0 +1,42 @@
+import { t as __exportAll } from "../rolldown-runtime-D7D4PA-g.mjs";
+import { Context, Schema } from "effect";
+//#region src/engine/ToolBroker.ts
+var ToolBroker_exports = /* @__PURE__ */ __exportAll({
+	ProgrammaticCallRecord: () => ProgrammaticCallRecord,
+	ToolBroker: () => ToolBroker,
+	ToolBrokerConfigurationError: () => ToolBrokerConfigurationError,
+	ToolBrokerUnavailableError: () => ToolBrokerUnavailableError
+});
+/**
+* Ephemeral execution evidence, ordered by invocation rather than completion. No arguments or
+* results are copied into this diagnostic. A started call without a confirmed result is uncertain;
+* a failed call is a confirmed failure, not a promise that external effects were rolled back.
+*/
+const ProgrammaticCallRecord = Schema.Struct({
+	sequenceIndex: Schema.Natural,
+	toolName: Schema.String,
+	status: Schema.Literals([
+		"not-started",
+		"succeeded",
+		"failed",
+		"uncertain"
+	]),
+	errorTag: Schema.optionalKey(Schema.String)
+});
+/** The broker was used outside a live Tool batch; there is nothing to bind to. */
+var ToolBrokerUnavailableError = class extends Schema.TaggedError()("ToolBrokerUnavailableError", { message: Schema.String }) {};
+/**
+* The pass options are invalid — for example a `maxResultBytes` that is not
+* a positive safe integer, which would make the size comparison fail open.
+*/
+var ToolBrokerConfigurationError = class extends Schema.TaggedError()("ToolBrokerConfigurationError", { message: Schema.String }) {};
+/**
+* Engine-provided programmatic Tool broker (RUN-016, RUN-017). Declare it
+* with `.addDependency(ToolBroker)` on a Tool that performs programmatic
+* invocation; the interpreter supplies it, and an application Layer must not.
+*/
+var ToolBroker = class extends Context.Service()("@effect-agent/engine/ToolBroker") {};
+//#endregion
+export { ProgrammaticCallRecord, ToolBroker, ToolBrokerConfigurationError, ToolBrokerUnavailableError, ToolBroker_exports as t };
+
+//# sourceMappingURL=ToolBroker.mjs.map

package/dist/engine/ToolBroker.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"ToolBroker.mjs","names":[],"sources":["../../src/engine/ToolBroker.ts"],"sourcesContent":["import type { Effect } from \"effect\";\nimport { Context, Schema } from \"effect\";\nimport type { Tool, Toolkit } from \"effect/unstable/ai\";\n\n/**\n * Programmatic Tool invocation seam for Code Mode (runtime spec §12.1,\n * ADR-0017 decision 3). The interpreter provides `ToolBroker` locally in the\n * same pattern as `AgentSpawner` and `DurableStep`: a fail-closed Run-level\n * default shadowed by a live per-outer-Tool-Call service, excluded from\n * `AgentRuntimeRequirements`. The live service is bound to the outer Tool\n * Call's identity, the Run's policy context, and the already-held scheduling\n * permit; per-call input from generated code is data only, and the broker\n * allocates every sequence index from its own monotonic per-pass state.\n */\n\n/** One programmatic invocation request. Data only: the broker owns identity. */\nexport interface ProgrammaticToolInput {\n  /** The exact Effect AI Tool name resolved by the capability's namespace map. */\n  readonly toolName: string;\n  /** Schema-encoded (wire-form) parameters, exactly as they cross the sandbox. */\n  readonly encodedArguments: unknown;\n}\n\n/** The handler ran and settled with an owned JSON snapshot of its encoded success value. */\nexport interface ProgrammaticCallSuccess {\n  readonly _tag: \"ProgrammaticCallSuccess\";\n  /** Broker-owned invocation index within the pass; rejected calls leave gaps. */\n  readonly index: number;\n  readonly encodedResult: unknown;\n}\n\n/**\n * The handler settled with the Tool's declared, Schema-encoded typed failure\n * (an Effect AI `failureMode: \"return\"` result). The program may catch and\n * branch on it.\n */\nexport interface ProgrammaticCallFailure {\n  readonly _tag: \"ProgrammaticCallFailure\";\n  readonly index: number;\n  readonly encodedResult: unknown;\n}\n\n/**\n * The call never produced a settled handler result: a broker preflight\n * rejected it (authorization, budget, unknown Tool, approval-requiring Tool,\n * invalid parameters), the handler failed in its typed error channel, or the\n * result failed encoding or the broker-owned size bound. `errorTag` and\n * `message` are the same bounded projection the direct path uses for\n * `ToolCallFailed` events; `index` is present only when the handler was\n * actually started (preflight rejections consume no identity and no budget).\n */\nexport interface ProgrammaticCallError {\n  readonly _tag: \"ProgrammaticCallError\";\n  readonly index: number | undefined;\n  readonly errorTag: string;\n  readonly message: string;\n}\n\n/**\n * Total outcome of one programmatic invocation; defects stay defects. Trusted applications may\n * install `CurrentToolFailureObserver` to receive non-propagating failures before the outcome\n * returns, with the live Cause retained before projection. Neither Causes nor observation values\n * cross the broker boundary.\n */\nexport type ProgrammaticCallOutcome =\n  | ProgrammaticCallSuccess\n  | ProgrammaticCallFailure\n  | ProgrammaticCallError;\n\n/**\n * Ephemeral execution evidence, ordered by invocation rather than completion. No arguments or\n * results are copied into this diagnostic. A started call without a confirmed result is uncertain;\n * a failed call is a confirmed failure, not a promise that external effects were rolled back.\n */\nexport const ProgrammaticCallRecord = Schema.Struct({\n  sequenceIndex: Schema.Natural,\n  toolName: Schema.String,\n  status: Schema.Literals([\"not-started\", \"succeeded\", \"failed\", \"uncertain\"]),\n  errorTag: Schema.optionalKey(Schema.String),\n});\n\nexport type ProgrammaticCallRecord = typeof ProgrammaticCallRecord.Type;\n\n/** Broker-owned per-pass policy for results crossing back into the sandbox. */\nexport interface ToolBrokerPassOptions {\n  /** Maximum active invocations in this pass, from one through 64. Defaults to four. */\n  readonly concurrency?: number | undefined;\n  /**\n   * Maximum UTF-8 byte size of one encoded success result at the sandbox\n   * boundary. The returned value is decoded from the exact JSON representation\n   * admitted by this bound, after redaction. Later handler or redactor mutations\n   * cannot change it. The executor enforces its own transport bound independently.\n   */\n  readonly maxResultBytes: number;\n  /**\n   * Optional broker-owned redaction pass applied to every encoded success\n   * result before the size bound. It must be total; a defect stays a defect.\n   */\n  readonly redactResult?: ((encodedResult: unknown) => Effect.Effect<unknown>) | undefined;\n}\n\n/**\n * One open programmatic pass, bound to one outer Tool Call. A finite Effect Semaphore bounds\n * execution. The caller owns invocation fibers and must join or interrupt them before leaving\n * its Scope. Results return as soon as they settle, without waiting for unrelated earlier calls.\n */\nexport interface ToolBrokerPass {\n  readonly invoke: (input: ProgrammaticToolInput) => Effect.Effect<ProgrammaticCallOutcome>;\n  /** Owned snapshot in invocation order, including interrupted and rejected calls. Never replay it. */\n  readonly snapshot: Effect.Effect<ReadonlyArray<ProgrammaticCallRecord>>;\n}\n\n/** The broker was used outside a live Tool batch; there is nothing to bind to. */\nexport class ToolBrokerUnavailableError extends Schema.TaggedError<ToolBrokerUnavailableError>()(\n  \"ToolBrokerUnavailableError\",\n  {\n    message: Schema.String,\n  },\n) {}\n\n/**\n * The pass options are invalid — for example a `maxResultBytes` that is not\n * a positive safe integer, which would make the size comparison fail open.\n */\nexport class ToolBrokerConfigurationError extends Schema.TaggedError<ToolBrokerConfigurationError>()(\n  \"ToolBrokerConfigurationError\",\n  {\n    message: Schema.String,\n  },\n) {}\n\n/**\n * The engine-owned broker service. `openPass` fixes the capability-supplied\n * Toolkit and per-pass result policy once for the whole pass and captures the\n * handler services present at the call site, so nothing inside business\n * execution — least of all generated code — can substitute handlers, policy,\n * or identity afterwards.\n */\nexport interface ToolBrokerService {\n  readonly openPass: <Tools extends Record<string, Tool.Any>>(\n    toolkit: Toolkit.WithHandler<Tools>,\n    options: ToolBrokerPassOptions,\n  ) => Effect.Effect<\n    ToolBrokerPass,\n    ToolBrokerUnavailableError | ToolBrokerConfigurationError,\n    Tool.HandlerServices<Tools[keyof Tools]>\n  >;\n}\n\n/**\n * Engine-provided programmatic Tool broker (RUN-016, RUN-017). Declare it\n * with `.addDependency(ToolBroker)` on a Tool that performs programmatic\n * invocation; the interpreter supplies it, and an application Layer must not.\n */\nexport class ToolBroker extends Context.Service<ToolBroker, ToolBrokerService>()(\n  \"@effect-agent/engine/ToolBroker\",\n) {}\n"],"mappings":";;;;;;;;;;;;;;AA0EA,MAAa,yBAAyB,OAAO,OAAO;CAClD,eAAe,OAAO;CACtB,UAAU,OAAO;CACjB,QAAQ,OAAO,SAAS;EAAC;EAAe;EAAa;EAAU;CAAW,CAAC;CAC3E,UAAU,OAAO,YAAY,OAAO,MAAM;AAC5C,CAAC;;AAkCD,IAAa,6BAAb,cAAgD,OAAO,YAAwC,CAAC,CAC9F,8BACA,EACE,SAAS,OAAO,OAClB,CACF,CAAC,CAAC,CAAC;;;;;AAMH,IAAa,+BAAb,cAAkD,OAAO,YAA0C,CAAC,CAClG,gCACA,EACE,SAAS,OAAO,OAClB,CACF,CAAC,CAAC,CAAC;;;;;;AAyBH,IAAa,aAAb,cAAgC,QAAQ,QAAuC,CAAC,CAC9E,iCACF,CAAC,CAAC,CAAC"}

package/dist/foreign-diagnostic-DBQ1XHKh.mjs

@@ -0,0 +1,37 @@
+import { Option, Schema } from "effect";
+//#region src/durable/internal/foreign-diagnostic.ts
+const ErrorMessage = Schema.Struct({ message: Schema.String });
+const ErrorTag = Schema.Struct({ _tag: Schema.NonEmptyString });
+const decodeErrorMessage = Schema.decodeUnknownOption(ErrorMessage);
+const decodeErrorTag = Schema.decodeUnknownOption(ErrorTag);
+/**
+* Inspect a foreign failure without trusting its property accessors. Schema owns the accepted
+* fields, while the guards around each decode keep hostile proxies and getters from escaping as
+* defects during diagnostic projection.
+*/
+const inspectForeignDiagnostic = (value) => {
+	let tag;
+	let message;
+	try {
+		tag = Option.getOrUndefined(decodeErrorTag(value))?._tag;
+	} catch {}
+	try {
+		message = Option.getOrUndefined(decodeErrorMessage(value))?.message;
+	} catch {}
+	return {
+		...tag === void 0 ? {} : { tag },
+		...message === void 0 ? {} : { message }
+	};
+};
+/** Render an opaque foreign value without allowing its coercion hooks to escape. */
+const safeUnknownString = (value, fallback) => {
+	try {
+		return String(value);
+	} catch {
+		return fallback;
+	}
+};
+//#endregion
+export { safeUnknownString as n, inspectForeignDiagnostic as t };
+
+//# sourceMappingURL=foreign-diagnostic-DBQ1XHKh.mjs.map

package/dist/foreign-diagnostic-DBQ1XHKh.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"foreign-diagnostic-DBQ1XHKh.mjs","names":[],"sources":["../src/durable/internal/foreign-diagnostic.ts"],"sourcesContent":["import { Option, Schema } from \"effect\";\n\nconst ErrorMessage = Schema.Struct({ message: Schema.String });\nconst ErrorTag = Schema.Struct({ _tag: Schema.NonEmptyString });\nconst decodeErrorMessage = Schema.decodeUnknownOption(ErrorMessage);\nconst decodeErrorTag = Schema.decodeUnknownOption(ErrorTag);\n\ninterface ForeignDiagnostic {\n  readonly tag?: string | undefined;\n  readonly message?: string | undefined;\n}\n\n/**\n * Inspect a foreign failure without trusting its property accessors. Schema owns the accepted\n * fields, while the guards around each decode keep hostile proxies and getters from escaping as\n * defects during diagnostic projection.\n */\nexport const inspectForeignDiagnostic = (value: unknown): ForeignDiagnostic => {\n  let tag: string | undefined;\n  let message: string | undefined;\n\n  try {\n    tag = Option.getOrUndefined(decodeErrorTag(value))?._tag;\n  } catch {\n    // A diagnostic is best effort. The caller supplies the stable fallback classification.\n  }\n\n  try {\n    message = Option.getOrUndefined(decodeErrorMessage(value))?.message;\n  } catch {\n    // A hostile message accessor must not replace the original failure with a defect.\n  }\n\n  return {\n    ...(tag === undefined ? {} : { tag }),\n    ...(message === undefined ? {} : { message }),\n  };\n};\n\n/** Render an opaque foreign value without allowing its coercion hooks to escape. */\nexport const safeUnknownString = (value: unknown, fallback: string): string => {\n  try {\n    return String(value);\n  } catch {\n    return fallback;\n  }\n};\n"],"mappings":";;AAEA,MAAM,eAAe,OAAO,OAAO,EAAE,SAAS,OAAO,OAAO,CAAC;AAC7D,MAAM,WAAW,OAAO,OAAO,EAAE,MAAM,OAAO,eAAe,CAAC;AAC9D,MAAM,qBAAqB,OAAO,oBAAoB,YAAY;AAClE,MAAM,iBAAiB,OAAO,oBAAoB,QAAQ;;;;;;AAY1D,MAAa,4BAA4B,UAAsC;CAC7E,IAAI;CACJ,IAAI;CAEJ,IAAI;EACF,MAAM,OAAO,eAAe,eAAe,KAAK,CAAC,CAAC,EAAE;CACtD,QAAQ,CAER;CAEA,IAAI;EACF,UAAU,OAAO,eAAe,mBAAmB,KAAK,CAAC,CAAC,EAAE;CAC9D,QAAQ,CAER;CAEA,OAAO;EACL,GAAI,QAAQ,KAAA,IAAY,CAAC,IAAI,EAAE,IAAI;EACnC,GAAI,YAAY,KAAA,IAAY,CAAC,IAAI,EAAE,QAAQ;CAC7C;AACF;;AAGA,MAAa,qBAAqB,OAAgB,aAA6B;CAC7E,IAAI;EACF,OAAO,OAAO,KAAK;CACrB,QAAQ;EACN,OAAO;CACT;AACF"}

package/dist/index.d.mts

@@ -1,6 +1,92 @@
-import { CommandDrainPolicy, RunSchedulingOverride } from "@effect-agent/capabilities";
-import { delegationToolPrefix, isDelegationToolName } from "@effect-agent/core";
-export * from "@effect-agent/capabilities";
-export * from "@effect-agent/core";
-export * from "@effect-agent/engine";
-export { CommandDrainPolicy, RunSchedulingOverride, delegationToolPrefix, isDelegationToolName };
+import { a as Identifiers_d_exports } from "./Identifiers-CN2s30fF.mjs";
+import { f as Thread_d_exports } from "./Thread-DOBQ0QUY.mjs";
+import { a as SubagentContract_d_exports } from "./SubagentContract-DdT7Cqe6.mjs";
+import { t as SubagentReservations_d_exports } from "./capabilities/SubagentReservations.mjs";
+import { o as Receipt_d_exports } from "./Receipt-BAHyigAF.mjs";
+import { t as AgentUpdates_d_exports } from "./AgentUpdates-DMJ-_xow.mjs";
+import { f as Usage_d_exports } from "./Usage-Dx0aknfk.mjs";
+import { u as RunEvent_d_exports } from "./RunEvent-DIrzkjLr.mjs";
+import { i as ThreadHistory_d_exports } from "./ThreadHistory-tS1KwxHR.mjs";
+import { t as InMemory_d_exports } from "./InMemory.mjs";
+import { t as ToolExposure_d_exports } from "./ToolExposure.mjs";
+import { t as Redaction_d_exports } from "./capabilities/Redaction.mjs";
+import { t as Approval_d_exports } from "./capabilities/Approval.mjs";
+import { t as Budget_d_exports } from "./capabilities/Budget.mjs";
+import { p as ToolBroker_d_exports } from "./ToolBroker-DWs4tZra.mjs";
+import { D as Sandbox_d_exports } from "./Sandbox-CEsDWBLq.mjs";
+import { t as CodeExecutor_d_exports } from "./sandbox/CodeExecutor.mjs";
+import { t as CodeMode_d_exports } from "./capabilities/CodeMode.mjs";
+import { a as FailureDiagnostic_d_exports } from "./FailureDiagnostic-CaAkzGHL.mjs";
+import { i as AgentError_d_exports } from "./AgentError-Bn1ytXRD.mjs";
+import { r as ToolResult_d_exports } from "./ToolResult-BKdqWRff.mjs";
+import { r as AgentPolicy_d_exports } from "./AgentPolicy-BqDoSXO6.mjs";
+import { t as Agent_d_exports } from "./Agent-Cjd_ZveM.mjs";
+import { c as MemoryReference_d_exports } from "./MemoryReference-B8Q3UJoJ.mjs";
+import { n as RunPolicyUsage_d_exports } from "./RunPolicyUsage-ClZxyR46.mjs";
+import { x as Worker_d_exports } from "./Worker-fwWkBg12.mjs";
+import { s as ContextWindow_d_exports } from "./ContextWindow-DRQ5Mbm2.mjs";
+import { s as ContextCompactor_d_exports } from "./ContextCompactor-WwSIG_Z2.mjs";
+import { i as DurableStep_d_exports } from "./DurableStep-Cry_iol4.mjs";
+import { F as RunOptions_d_exports } from "./RunOptions-Bv9NpkPZ.mjs";
+import { t as Commands_d_exports } from "./capabilities/Commands.mjs";
+import { t as ContextHistory_d_exports } from "./engine/ContextHistory.mjs";
+import { t as ContextTools_d_exports } from "./capabilities/ContextTools.mjs";
+import { t as Mcp_d_exports } from "./capabilities/Mcp.mjs";
+import { t as McpClient_d_exports } from "./capabilities/McpClient.mjs";
+import { i as MemoryNamespace_d_exports } from "./MemoryNamespace-BbRW5p71.mjs";
+import { t as MemoryStore_d_exports } from "./core/MemoryStore.mjs";
+import { t as MemoryNotes_d_exports } from "./capabilities/MemoryNotes.mjs";
+import { n as MessagingHost_d_exports } from "./MessagingHost-D04wE-7W.mjs";
+import { t as Messaging_d_exports } from "./Messaging-ccQURKCf.mjs";
+import { t as ModelContext_d_exports } from "./capabilities/ModelContext.mjs";
+import { t as RememberingStore_d_exports } from "./core/RememberingStore.mjs";
+import { t as Remembering_d_exports } from "./capabilities/Remembering.mjs";
+import { t as RunHooks_d_exports } from "./capabilities/RunHooks.mjs";
+import { t as MemoryRevalidation_d_exports } from "./core/MemoryRevalidation.mjs";
+import { t as SemanticMemoryIndex_d_exports } from "./core/SemanticMemoryIndex.mjs";
+import { t as SemanticMemoryRevalidation_d_exports } from "./core/SemanticMemoryRevalidation.mjs";
+import { t as SemanticMemory_d_exports } from "./capabilities/SemanticMemory.mjs";
+import { s as SubagentHost_d_exports } from "./SubagentHost-C-4A7tA2.mjs";
+import { t as AgentRuntime_d_exports } from "./AgentRuntime-sXpKcyxu.mjs";
+import { i as RunEventSink_d_exports } from "./RunEventSink-D5aVhISG.mjs";
+import { v as Subagent_d_exports } from "./Subagent-VHrANXFy.mjs";
+import { t as ToolDiscovery_d_exports } from "./capabilities/ToolDiscovery.mjs";
+import { D as PageCapture_d_exports } from "./PageCapture-Df8Xwskw.mjs";
+import { t as WebCapture_d_exports } from "./capabilities/WebCapture.mjs";
+import { t as WebSearch_d_exports } from "./capabilities/WebSearch.mjs";
+import { t as IdGenerator_d_exports } from "./core/IdGenerator.mjs";
+import { t as Memory_d_exports } from "./core/Memory.mjs";
+import { N as Records_d_exports } from "./Records-B5GFWCpn.mjs";
+import { t as ActivityStore_d_exports } from "./durable/ActivityStore.mjs";
+import { n as Digest_d_exports } from "./Digest-U69rDHuO.mjs";
+import { J as Recovery_d_exports, Pa as AgentRegistration_d_exports, Pi as RunJournal_d_exports, Qn as DurableAgentRuntime_d_exports, Si as LifecyclePublication_d_exports, bn as SubmissionLedger_d_exports, ki as SubmissionStatus_d_exports, oi as ThreadStore_d_exports, t as Admin_d_exports } from "./Admin-CKIdJoP8.mjs";
+import { t as DurableFailpoint_d_exports } from "./DurableFailpoint-Cnr3wx1L.mjs";
+import { a as OperationAuthorizer_d_exports } from "./OperationAuthorizer-TzcQtpX5.mjs";
+import { l as ToolReconciler_d_exports } from "./ToolReconciler-BmVRAHKs.mjs";
+import { n as WakeScheduler_d_exports } from "./WakeScheduler-EjUF-GhC.mjs";
+import { t as CommittedActivity_d_exports } from "./durable/CommittedActivity.mjs";
+import { R as Schedule_d_exports } from "./Schedule-CtYREFnz.mjs";
+import { k as Subscription_d_exports } from "./Subscription-BJAzYNw1.mjs";
+import { n as EventSource_d_exports } from "./EventSource-CMbXXmwe.mjs";
+import { n as PreparedInputAdmission_d_exports } from "./PreparedInputAdmission-Bt6rgtVu.mjs";
+import { r as SubscriptionInput_d_exports } from "./SubscriptionInput-CkBJt0AS.mjs";
+import { t as Subscriptions_d_exports } from "./durable/Subscriptions.mjs";
+import { t as MessageDelivery_d_exports } from "./durable/MessageDelivery.mjs";
+import { t as PersistentHistory_d_exports } from "./durable/PersistentHistory.mjs";
+import { t as ScheduleTransition_d_exports } from "./durable/ScheduleTransition.mjs";
+import { t as Scheduling_d_exports } from "./durable/Scheduling.mjs";
+import { t as SubscriptionTools_d_exports } from "./durable/SubscriptionTools.mjs";
+import { t as SubscriptionTransition_d_exports } from "./durable/SubscriptionTransition.mjs";
+import { t as ThreadContextHistory_d_exports } from "./durable/ThreadContextHistory.mjs";
+import { t as ThreadContextHistoryProjection_d_exports } from "./durable/ThreadContextHistoryProjection.mjs";
+import { t as ThreadInvariants_d_exports } from "./durable/ThreadInvariants.mjs";
+import { t as ThreadProjection_d_exports } from "./durable/ThreadProjection.mjs";
+import { t as ThreadProjectionMaintenance_d_exports } from "./durable/ThreadProjectionMaintenance.mjs";
+import { t as WorkerAdmission_d_exports } from "./durable/WorkerAdmission.mjs";
+import { t as WorkerHost_d_exports } from "./durable/WorkerHost.mjs";
+import { t as Compaction_d_exports } from "./engine/Compaction.mjs";
+import { t as Output_d_exports } from "./Output-CFD1CPfU.mjs";
+import { t as PageScreenshot_d_exports } from "./sandbox/PageScreenshot.mjs";
+import { t as InteractiveBrowser_d_exports } from "./sandbox/InteractiveBrowser.mjs";
+import { t as PageCrawl_d_exports } from "./sandbox/PageCrawl.mjs";
+export { ActivityStore_d_exports as ActivityStore, Admin_d_exports as Admin, Agent_d_exports as Agent, AgentError_d_exports as AgentError, AgentPolicy_d_exports as AgentPolicy, AgentRegistration_d_exports as AgentRegistration, AgentRuntime_d_exports as AgentRuntime, AgentUpdates_d_exports as AgentUpdates, Approval_d_exports as Approval, Budget_d_exports as Budget, CodeExecutor_d_exports as CodeExecutor, CodeMode_d_exports as CodeMode, Commands_d_exports as Commands, CommittedActivity_d_exports as CommittedActivity, Compaction_d_exports as Compaction, ContextCompactor_d_exports as ContextCompactor, ContextHistory_d_exports as ContextHistory, ContextTools_d_exports as ContextTools, ContextWindow_d_exports as ContextWindow, Digest_d_exports as Digest, DurableAgentRuntime_d_exports as DurableAgentRuntime, DurableFailpoint_d_exports as DurableFailpoint, DurableStep_d_exports as DurableStep, EventSource_d_exports as EventSource, FailureDiagnostic_d_exports as FailureDiagnostic, IdGenerator_d_exports as IdGenerator, Identifiers_d_exports as Identifiers, InMemory_d_exports as InMemory, InteractiveBrowser_d_exports as InteractiveBrowser, LifecyclePublication_d_exports as LifecyclePublication, Mcp_d_exports as Mcp, McpClient_d_exports as McpClient, Memory_d_exports as Memory, MemoryNamespace_d_exports as MemoryNamespace, MemoryNotes_d_exports as MemoryNotes, MemoryReference_d_exports as MemoryReference, MemoryRevalidation_d_exports as MemoryRevalidation, MemoryStore_d_exports as MemoryStore, MessageDelivery_d_exports as MessageDelivery, Messaging_d_exports as Messaging, MessagingHost_d_exports as MessagingHost, ModelContext_d_exports as ModelContext, OperationAuthorizer_d_exports as OperationAuthorizer, Output_d_exports as Output, PageCapture_d_exports as PageCapture, PageCrawl_d_exports as PageCrawl, PageScreenshot_d_exports as PageScreenshot, PersistentHistory_d_exports as PersistentHistory, PreparedInputAdmission_d_exports as PreparedInputAdmission, Receipt_d_exports as Receipt, Records_d_exports as Records, Recovery_d_exports as Recovery, Redaction_d_exports as Redaction, Remembering_d_exports as Remembering, RememberingStore_d_exports as RememberingStore, RunEvent_d_exports as RunEvent, RunEventSink_d_exports as RunEventSink, RunHooks_d_exports as RunHooks, RunJournal_d_exports as RunJournal, RunOptions_d_exports as RunOptions, RunPolicyUsage_d_exports as RunPolicyUsage, Sandbox_d_exports as Sandbox, Schedule_d_exports as Schedule, ScheduleTransition_d_exports as ScheduleTransition, Scheduling_d_exports as Scheduling, SemanticMemory_d_exports as SemanticMemory, SemanticMemoryIndex_d_exports as SemanticMemoryIndex, SemanticMemoryRevalidation_d_exports as SemanticMemoryRevalidation, Subagent_d_exports as Subagent, SubagentContract_d_exports as SubagentContract, SubagentHost_d_exports as SubagentHost, SubagentReservations_d_exports as SubagentReservations, SubmissionLedger_d_exports as SubmissionLedger, SubmissionStatus_d_exports as SubmissionStatus, Subscription_d_exports as Subscription, SubscriptionInput_d_exports as SubscriptionInput, SubscriptionTools_d_exports as SubscriptionTools, SubscriptionTransition_d_exports as SubscriptionTransition, Subscriptions_d_exports as Subscriptions, Thread_d_exports as Thread, ThreadContextHistory_d_exports as ThreadContextHistory, ThreadContextHistoryProjection_d_exports as ThreadContextHistoryProjection, ThreadHistory_d_exports as ThreadHistory, ThreadInvariants_d_exports as ThreadInvariants, ThreadProjection_d_exports as ThreadProjection, ThreadProjectionMaintenance_d_exports as ThreadProjectionMaintenance, ThreadStore_d_exports as ThreadStore, ToolBroker_d_exports as ToolBroker, ToolDiscovery_d_exports as ToolDiscovery, ToolExposure_d_exports as ToolExposure, ToolReconciler_d_exports as ToolReconciler, ToolResult_d_exports as ToolResult, Usage_d_exports as Usage, WakeScheduler_d_exports as WakeScheduler, WebCapture_d_exports as WebCapture, WebSearch_d_exports as WebSearch, Worker_d_exports as Worker, WorkerAdmission_d_exports as WorkerAdmission, WorkerHost_d_exports as WorkerHost };

package/dist/index.mjs

@@ -1,6 +1,100 @@
-import { CommandDrainPolicy, RunSchedulingOverride } from "@effect-agent/capabilities";
-import { delegationToolPrefix, isDelegationToolName } from "@effect-agent/core";
-export * from "@effect-agent/capabilities";
-export * from "@effect-agent/core";
-export * from "@effect-agent/engine";
-export { CommandDrainPolicy, RunSchedulingOverride, delegationToolPrefix, isDelegationToolName };
+import { t as Identifiers_exports } from "./core/Identifiers.mjs";
+import { t as ToolResult_exports } from "./core/ToolResult.mjs";
+import { t as AgentPolicy_exports } from "./core/AgentPolicy.mjs";
+import { t as Receipt_exports } from "./core/Receipt.mjs";
+import { t as AgentUpdates_exports } from "./core/AgentUpdates.mjs";
+import { t as Agent_exports } from "./Agent-1DMSO_Fl.mjs";
+import { a as FailureDiagnostic_exports } from "./FailureDiagnostic-BElLOoED.mjs";
+import { t as AgentError_exports } from "./core/AgentError.mjs";
+import { t as IdGenerator_exports } from "./core/IdGenerator.mjs";
+import { t as SubagentContract_exports } from "./core/SubagentContract.mjs";
+import { t as Usage_exports } from "./core/Usage.mjs";
+import { t as RunEvent_exports } from "./core/RunEvent.mjs";
+import { x as Worker_exports } from "./Worker-CfwzMZEK.mjs";
+import { n as MessagingHost_exports } from "./MessagingHost-DfsbMPvq.mjs";
+import { t as SubagentHost_exports } from "./engine/SubagentHost.mjs";
+import { t as Thread_exports } from "./core/Thread.mjs";
+import { t as ThreadHistory_exports } from "./engine/ThreadHistory.mjs";
+import { t as AgentRuntime_exports } from "./AgentRuntime-D8U9gl9Q.mjs";
+import { t as ContextWindow_exports } from "./engine/ContextWindow.mjs";
+import { t as DurableStep_exports } from "./engine/DurableStep.mjs";
+import { t as ContextCompactor_exports } from "./engine/ContextCompactor.mjs";
+import { t as RunEventSink_exports } from "./engine/RunEventSink.mjs";
+import { t as MemoryReference_exports } from "./core/MemoryReference.mjs";
+import { t as RunPolicyUsage_exports } from "./core/RunPolicyUsage.mjs";
+import { t as RunOptions_exports } from "./engine/RunOptions.mjs";
+import { t as ToolBroker_exports } from "./engine/ToolBroker.mjs";
+import { t as Redaction_exports } from "./capabilities/Redaction.mjs";
+import { t as Approval_exports } from "./capabilities/Approval.mjs";
+import { t as Budget_exports } from "./capabilities/Budget.mjs";
+import { t as Sandbox_exports } from "./sandbox/Sandbox.mjs";
+import { t as CodeExecutor_exports } from "./sandbox/CodeExecutor.mjs";
+import { t as CodeMode_exports } from "./capabilities/CodeMode.mjs";
+import { t as Commands_exports } from "./capabilities/Commands.mjs";
+import { t as Compaction_exports } from "./engine/Compaction.mjs";
+import { t as ContextHistory_exports } from "./engine/ContextHistory.mjs";
+import { t as ContextTools_exports } from "./capabilities/ContextTools.mjs";
+import { t as SubagentReservations_exports } from "./capabilities/SubagentReservations.mjs";
+import { t as InMemory_exports } from "./InMemory.mjs";
+import { t as InteractiveBrowser_exports } from "./sandbox/InteractiveBrowser.mjs";
+import { t as Mcp_exports } from "./capabilities/Mcp.mjs";
+import { t as McpClient_exports } from "./capabilities/McpClient.mjs";
+import { t as Memory_exports } from "./core/Memory.mjs";
+import { t as MemoryNamespace_exports } from "./core/MemoryNamespace.mjs";
+import { t as MemoryStore_exports } from "./core/MemoryStore.mjs";
+import { t as MemoryNotes_exports } from "./capabilities/MemoryNotes.mjs";
+import { t as MemoryRevalidation_exports } from "./core/MemoryRevalidation.mjs";
+import { t as Messaging_exports } from "./capabilities/Messaging.mjs";
+import { t as ModelContext_exports } from "./capabilities/ModelContext.mjs";
+import { t as Output_exports } from "./engine/Output.mjs";
+import { t as PageCapture_exports } from "./sandbox/PageCapture.mjs";
+import { t as PageCrawl_exports } from "./sandbox/PageCrawl.mjs";
+import { t as PageScreenshot_exports } from "./sandbox/PageScreenshot.mjs";
+import { t as RememberingStore_exports } from "./core/RememberingStore.mjs";
+import { t as Remembering_exports } from "./capabilities/Remembering.mjs";
+import { t as RunHooks_exports } from "./capabilities/RunHooks.mjs";
+import { t as SemanticMemoryIndex_exports } from "./core/SemanticMemoryIndex.mjs";
+import { t as SemanticMemoryRevalidation_exports } from "./core/SemanticMemoryRevalidation.mjs";
+import { t as SemanticMemory_exports } from "./capabilities/SemanticMemory.mjs";
+import { r as Subagent_exports } from "./Subagent-hG9lJ7tJ.mjs";
+import { t as ToolDiscovery_exports } from "./capabilities/ToolDiscovery.mjs";
+import { t as ToolExposure_exports } from "./ToolExposure.mjs";
+import { t as WebCapture_exports } from "./capabilities/WebCapture.mjs";
+import { t as WebSearch_exports } from "./capabilities/WebSearch.mjs";
+import { t as Records_exports } from "./durable/Records.mjs";
+import { t as ActivityStore_exports } from "./durable/ActivityStore.mjs";
+import { t as SubmissionLedger_exports } from "./durable/SubmissionLedger.mjs";
+import { t as Recovery_exports } from "./durable/Recovery.mjs";
+import { t as Admin_exports } from "./durable/Admin.mjs";
+import { t as Digest_exports } from "./durable/Digest.mjs";
+import { t as AgentRegistration_exports } from "./durable/AgentRegistration.mjs";
+import { r as DurableAgentRuntime_exports } from "./DurableAgentRuntime-R2LUYnRl.mjs";
+import { n as RunJournal_exports } from "./RunJournal-Gd83HYqG.mjs";
+import { t as ThreadStore_exports } from "./durable/ThreadStore.mjs";
+import { t as CommittedActivity_exports } from "./durable/CommittedActivity.mjs";
+import { t as DurableFailpoint_exports } from "./durable/DurableFailpoint.mjs";
+import { t as Schedule_exports } from "./durable/Schedule.mjs";
+import { t as PreparedInputAdmission_exports } from "./durable/PreparedInputAdmission.mjs";
+import { t as Subscription_exports } from "./durable/Subscription.mjs";
+import { t as MessageDelivery_exports } from "./durable/MessageDelivery.mjs";
+import { t as WakeScheduler_exports } from "./durable/WakeScheduler.mjs";
+import { i as WorkerAdmission_exports } from "./WorkerAdmission-CJ_oWRuS.mjs";
+import { t as WorkerHost_exports } from "./durable/WorkerHost.mjs";
+import { t as OperationAuthorizer_exports } from "./durable/OperationAuthorizer.mjs";
+import { t as SubmissionStatus_exports } from "./durable/SubmissionStatus.mjs";
+import { t as ThreadInvariants_exports } from "./durable/ThreadInvariants.mjs";
+import { t as ToolReconciler_exports } from "./durable/ToolReconciler.mjs";
+import { t as EventSource_exports } from "./durable/EventSource.mjs";
+import { t as PersistentHistory_exports } from "./durable/PersistentHistory.mjs";
+import { t as ScheduleTransition_exports } from "./durable/ScheduleTransition.mjs";
+import { i as Scheduling_exports } from "./Scheduling-DPb2QyAK.mjs";
+import { t as SubscriptionInput_exports } from "./durable/SubscriptionInput.mjs";
+import { t as Subscriptions_exports } from "./durable/Subscriptions.mjs";
+import { t as SubscriptionTools_exports } from "./durable/SubscriptionTools.mjs";
+import { t as SubscriptionTransition_exports } from "./durable/SubscriptionTransition.mjs";
+import { t as ThreadProjection_exports } from "./durable/ThreadProjection.mjs";
+import { t as ThreadProjectionMaintenance_exports } from "./durable/ThreadProjectionMaintenance.mjs";
+import { t as ThreadContextHistoryProjection_exports } from "./durable/ThreadContextHistoryProjection.mjs";
+import { t as ThreadContextHistory_exports } from "./durable/ThreadContextHistory.mjs";
+import { t as LifecyclePublication_exports } from "./durable/LifecyclePublication.mjs";
+export { ActivityStore_exports as ActivityStore, Admin_exports as Admin, Agent_exports as Agent, AgentError_exports as AgentError, AgentPolicy_exports as AgentPolicy, AgentRegistration_exports as AgentRegistration, AgentRuntime_exports as AgentRuntime, AgentUpdates_exports as AgentUpdates, Approval_exports as Approval, Budget_exports as Budget, CodeExecutor_exports as CodeExecutor, CodeMode_exports as CodeMode, Commands_exports as Commands, CommittedActivity_exports as CommittedActivity, Compaction_exports as Compaction, ContextCompactor_exports as ContextCompactor, ContextHistory_exports as ContextHistory, ContextTools_exports as ContextTools, ContextWindow_exports as ContextWindow, Digest_exports as Digest, DurableAgentRuntime_exports as DurableAgentRuntime, DurableFailpoint_exports as DurableFailpoint, DurableStep_exports as DurableStep, EventSource_exports as EventSource, FailureDiagnostic_exports as FailureDiagnostic, IdGenerator_exports as IdGenerator, Identifiers_exports as Identifiers, InMemory_exports as InMemory, InteractiveBrowser_exports as InteractiveBrowser, LifecyclePublication_exports as LifecyclePublication, Mcp_exports as Mcp, McpClient_exports as McpClient, Memory_exports as Memory, MemoryNamespace_exports as MemoryNamespace, MemoryNotes_exports as MemoryNotes, MemoryReference_exports as MemoryReference, MemoryRevalidation_exports as MemoryRevalidation, MemoryStore_exports as MemoryStore, MessageDelivery_exports as MessageDelivery, Messaging_exports as Messaging, MessagingHost_exports as MessagingHost, ModelContext_exports as ModelContext, OperationAuthorizer_exports as OperationAuthorizer, Output_exports as Output, PageCapture_exports as PageCapture, PageCrawl_exports as PageCrawl, PageScreenshot_exports as PageScreenshot, PersistentHistory_exports as PersistentHistory, PreparedInputAdmission_exports as PreparedInputAdmission, Receipt_exports as Receipt, Records_exports as Records, Recovery_exports as Recovery, Redaction_exports as Redaction, Remembering_exports as Remembering, RememberingStore_exports as RememberingStore, RunEvent_exports as RunEvent, RunEventSink_exports as RunEventSink, RunHooks_exports as RunHooks, RunJournal_exports as RunJournal, RunOptions_exports as RunOptions, RunPolicyUsage_exports as RunPolicyUsage, Sandbox_exports as Sandbox, Schedule_exports as Schedule, ScheduleTransition_exports as ScheduleTransition, Scheduling_exports as Scheduling, SemanticMemory_exports as SemanticMemory, SemanticMemoryIndex_exports as SemanticMemoryIndex, SemanticMemoryRevalidation_exports as SemanticMemoryRevalidation, Subagent_exports as Subagent, SubagentContract_exports as SubagentContract, SubagentHost_exports as SubagentHost, SubagentReservations_exports as SubagentReservations, SubmissionLedger_exports as SubmissionLedger, SubmissionStatus_exports as SubmissionStatus, Subscription_exports as Subscription, SubscriptionInput_exports as SubscriptionInput, SubscriptionTools_exports as SubscriptionTools, SubscriptionTransition_exports as SubscriptionTransition, Subscriptions_exports as Subscriptions, Thread_exports as Thread, ThreadContextHistory_exports as ThreadContextHistory, ThreadContextHistoryProjection_exports as ThreadContextHistoryProjection, ThreadHistory_exports as ThreadHistory, ThreadInvariants_exports as ThreadInvariants, ThreadProjection_exports as ThreadProjection, ThreadProjectionMaintenance_exports as ThreadProjectionMaintenance, ThreadStore_exports as ThreadStore, ToolBroker_exports as ToolBroker, ToolDiscovery_exports as ToolDiscovery, ToolExposure_exports as ToolExposure, ToolReconciler_exports as ToolReconciler, ToolResult_exports as ToolResult, Usage_exports as Usage, WakeScheduler_exports as WakeScheduler, WebCapture_exports as WebCapture, WebSearch_exports as WebSearch, Worker_exports as Worker, WorkerAdmission_exports as WorkerAdmission, WorkerHost_exports as WorkerHost };

package/dist/output-contract-DS-S8mTv.mjs

@@ -0,0 +1,135 @@
+import { Prompt, Tool } from "effect/unstable/ai";
+import { Schema } from "effect";
+//#region src/engine/internal/output-contract.ts
+const outputFormatAnnotation = "@effect-agent/engine/Output/format";
+/**
+* Declare ordinary assistant text as an Agent's final-output wire format. Apply this to the
+* complete output Schema after composing transformations. Its encoded type must be string;
+* decoding, checks, transformations, and service requirements remain owned by that Schema.
+* Text is preserved verbatim, including whitespace, quotes, and an empty reply when allowed.
+* Required completion Tools still take precedence. Unmarked Schemas use JSON final output.
+*
+* @example
+* ```ts
+* output: Output.text(Schema.String.check(Schema.isMaxLength(20_000)))
+* ```
+*/
+const textOutput = (schema) => schema.annotate({ [outputFormatAnnotation]: "text" });
+const isTextOutput = (schema) => Schema.resolveAnnotations(schema)?.[outputFormatAnnotation] === "text";
+const contractDirective = (definition) => definition.completion === void 0 ? "Final output contract: when the task is complete, the final assistant message must be only JSON that is valid against this JSON Schema — no prose, no Markdown code fences, nothing before or after the JSON." : `Final output contract: when the task is complete without calling the "${definition.completion.tool}" completion Tool, the final assistant message must be only JSON that is valid against this JSON Schema — no prose, no Markdown code fences, nothing before or after the JSON. When calling the "${definition.completion.tool}" completion Tool, never place this private Agent output JSON in any Tool argument; follow the Tool's parameter schema instead. Call it as the sole application Tool Call, after receiving any other needed application Tool results. Completed provider Tool results may accompany it. The engine projects the successful completion Tool result into the Agent output.`;
+const requiredCompletionDirective = (tool, hasAlternatives) => `Final output contract: ${hasAlternatives ? "otherwise complete" : "complete only"} by calling the required completion Tool ${JSON.stringify(tool)} as the sole application Tool Call in its batch. Completed provider Tool results may accompany it. Do not emit an ordinary final assistant text answer. The Tool's canonical parameters and successful result are projected and validated as the Agent output.`;
+/**
+* Render the model-visible final-output contract for one definition. The
+* derivation and message identity are stable for an immutable definition.
+* An output Schema the Effect AI derivation cannot represent is reported as
+* `unrenderable`; the caller falls back to the prior behavior — the contract
+* is guidance, and a Schema that decodes but does not render must not become
+* a new failure mode.
+*/
+const rendered = (message) => ({
+	_tag: "rendered",
+	message,
+	part: Prompt.makeMessage("system", { content: message })
+});
+const renderOutputSchemaContract = (definition) => {
+	if (definition.completion?.required === true) return rendered(requiredCompletionDirective(definition.completion.tool, (definition.completionFromTools?.length ?? 0) > 0));
+	if (isTextOutput(definition.output)) return rendered("Final output contract: write the final reply as ordinary assistant text, without JSON wrapping. An empty reply is valid only when allowed by the output Schema and the task instructions." + (definition.completion === void 0 ? "" : ` When calling the "${definition.completion.tool}" completion Tool, follow its parameter schema instead and call it as the sole application Tool Call, after receiving any other needed application Tool results; completed provider Tool results may accompany it; the engine projects its successful result into the Agent output.`));
+	try {
+		const jsonSchema = Tool.getJsonSchemaFromSchema(definition.output);
+		return rendered(`${contractDirective(definition)}\n\n${JSON.stringify(jsonSchema, void 0, 2)}`);
+	} catch (cause) {
+		return {
+			_tag: "unrenderable",
+			reason: cause instanceof Error ? cause.message : String(cause)
+		};
+	}
+};
+const outputContracts = /* @__PURE__ */ new WeakMap();
+const outputSchemaContract = (definition) => {
+	const cached = outputContracts.get(definition);
+	if (cached !== void 0) return cached;
+	const base = renderOutputSchemaContract(definition);
+	const alternatives = definition.completionFromTools ?? [];
+	const contract = base._tag === "rendered" && alternatives.length > 0 ? rendered(`The following action Tools may complete the Run from their successful canonical result: ${alternatives.map((declaration) => JSON.stringify(declaration.tool)).join(", ")}. Call such a Tool as the sole application Tool Call, following its parameter schema. Completed provider Tool results may accompany it. It may complete the Run only when it satisfies the whole request. An incomplete or pending result continues the Run. These actions are unavailable during finalization after budget exhaustion.
+
+` + base.message) : base;
+	outputContracts.set(definition, contract);
+	return contract;
+};
+const sameSystemMessage = Schema.toEquivalence(Prompt.SystemMessage);
+/**
+* Keep supported system instructions in conversation order so changing late guidance
+* cannot invalidate the preceding user/tool cache prefix. Omit an exact repeat
+* only when no distinct system instruction intervened; returning to an earlier
+* instruction after a different one must preserve the new directive's precedence.
+* Anchor the immutable output contract after the initial system block.
+* Restore leading static instructions for caller-supplied conversation-only history.
+*
+* This runs after preparation and compaction. Canonical messages, protected
+* instruction/input spans and compaction coverage retain their original positions.
+* Adapters without this capability retain the grouped-system projection: keep the
+* last equivalent instruction with its native options, then the contract and
+* conversation. This prevents older Anthropic adapters from discarding system groups.
+*/
+const prepareModelPrompt = (prompt, contract, systemMessagesInHistory, staticInstructions) => {
+	if (systemMessagesInHistory) {
+		const content = [];
+		let lastSystem;
+		let ordered = prompt.content;
+		if (staticInstructions !== void 0) {
+			const firstConversation = prompt.content.findIndex((message) => message.role !== "system");
+			const leading = prompt.content.slice(0, firstConversation === -1 ? prompt.content.length : firstConversation);
+			const restored = [];
+			const instructions = typeof staticInstructions === "string" ? [Prompt.systemMessage({ content: staticInstructions })] : Prompt.make(staticInstructions).content;
+			for (const message of instructions) {
+				if (message.role !== "system") break;
+				if (leading.some((candidate) => candidate.role === "system" && sameSystemMessage(candidate, message))) break;
+				const original = prompt.content.find((candidate) => candidate.role === "system" && sameSystemMessage(candidate, message));
+				if (original === void 0) break;
+				restored.push(original);
+			}
+			if (restored.length > 0) ordered = [
+				...leading,
+				...restored,
+				...prompt.content.slice(leading.length)
+			];
+		}
+		for (const message of ordered) {
+			if (message.role === "system") {
+				if (lastSystem !== void 0 && sameSystemMessage(lastSystem, message)) continue;
+				lastSystem = message;
+			}
+			content.push(message);
+		}
+		if (contract !== void 0) {
+			const firstConversation = content.findIndex((message) => message.role !== "system");
+			content.splice(firstConversation === -1 ? content.length : firstConversation, 0, contract);
+		}
+		return Prompt.fromMessages(content);
+	}
+	const systems = [];
+	const conversation = [];
+	const seen = /* @__PURE__ */ new Map();
+	for (let index = prompt.content.length - 1; index >= 0; index -= 1) {
+		const message = prompt.content[index];
+		if (message === void 0) continue;
+		if (message.role !== "system") {
+			conversation.push(message);
+			continue;
+		}
+		const variants = seen.get(message.content);
+		if (variants?.some((previous) => sameSystemMessage(previous, message))) continue;
+		if (variants === void 0) seen.set(message.content, [message]);
+		else variants.push(message);
+		systems.push(message);
+	}
+	return Prompt.fromMessages([
+		...systems.reverse(),
+		...contract === void 0 ? [] : [contract],
+		...conversation.reverse()
+	]);
+};
+//#endregion
+export { textOutput as i, outputSchemaContract as n, prepareModelPrompt as r, isTextOutput as t };
+
+//# sourceMappingURL=output-contract-DS-S8mTv.mjs.map

package/dist/output-contract-DS-S8mTv.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"output-contract-DS-S8mTv.mjs","names":[],"sources":["../src/engine/internal/output-contract.ts"],"sourcesContent":["import { Schema } from \"effect\";\nimport { Prompt, Tool } from \"effect/unstable/ai\";\n\nimport type * as Agent from \"../../core/Agent.ts\";\n\nconst outputFormatAnnotation = \"@effect-agent/engine/Output/format\";\n\n/**\n * Declare ordinary assistant text as an Agent's final-output wire format. Apply this to the\n * complete output Schema after composing transformations. Its encoded type must be string;\n * decoding, checks, transformations, and service requirements remain owned by that Schema.\n * Text is preserved verbatim, including whitespace, quotes, and an empty reply when allowed.\n * Required completion Tools still take precedence. Unmarked Schemas use JSON final output.\n *\n * @example\n * ```ts\n * output: Output.text(Schema.String.check(Schema.isMaxLength(20_000)))\n * ```\n */\nexport const textOutput = <S extends Schema.Top & { readonly Encoded: string }>(\n  schema: S,\n): S[\"Rebuild\"] => schema.annotate({ [outputFormatAnnotation]: \"text\" });\n\nexport const isTextOutput = (schema: Schema.Top): boolean =>\n  Schema.resolveAnnotations(schema)?.[outputFormatAnnotation] === \"text\";\n\n/**\n * Model-visible final-output contract (RUN-028).\n *\n * For ordinary text completion, the interpreter's only output-conformance\n * point is `decodeFinalOutput`, which validates the final text after the\n * model has already finished. This module renders that Schema's wire contract\n * with the same Effect AI derivation the providers use for Tool parameters\n * and states it as one framework-owned system message on every model request.\n * A required completion Tool instead gets a native-tool directive: its Tool\n * parameter Schema is already carried by the provider request, and ordinary\n * final text is not an allowed completion path.\n *\n * The contract is a per-request projection of the immutable definition —\n * exactly like the Tool schemas the request already carries. It is inserted\n * at model-request materialization (after context preparation) and never\n * into official history, so canonical records, run events, and the committed\n * DN/DC golden are unchanged.\n *\n */\n\n/** Rendering outcome for one definition's output Schema. */\ntype OutputContract =\n  | {\n      readonly _tag: \"rendered\";\n      /** The complete system-message text: directive plus the derived JSON Schema. */\n      readonly message: string;\n      readonly part: Prompt.SystemMessage;\n    }\n  | {\n      readonly _tag: \"unrenderable\";\n      /** Why Effect AI's JSON-Schema derivation rejected the output Schema. */\n      readonly reason: string;\n    };\n\nconst contractDirective = (definition: Agent.AnyDefinition): string =>\n  definition.completion === undefined\n    ? \"Final output contract: when the task is complete, the final assistant message must be only \" +\n      \"JSON that is valid against this JSON Schema — no prose, no Markdown code fences, nothing \" +\n      \"before or after the JSON.\"\n    : `Final output contract: when the task is complete without calling the \"${definition.completion.tool}\" completion Tool, the final assistant message must be only ` +\n      \"JSON that is valid against this JSON Schema — no prose, no Markdown code fences, nothing \" +\n      `before or after the JSON. When calling the \"${definition.completion.tool}\" completion Tool, never place this private Agent output JSON in any Tool argument; follow the Tool's parameter schema instead. Call it as the sole application Tool Call, after receiving any other needed application Tool results. Completed provider Tool results may accompany it. The engine projects the successful completion Tool result into the Agent output.`;\n\nconst requiredCompletionDirective = (tool: string, hasAlternatives: boolean): string =>\n  `Final output contract: ${hasAlternatives ? \"otherwise complete\" : \"complete only\"} by calling the required completion Tool ${JSON.stringify(tool)} ` +\n  \"as the sole application Tool Call in its batch. Completed provider Tool results may accompany it. Do not emit an ordinary final assistant text answer. \" +\n  \"The Tool's canonical parameters and successful result are projected and validated as the Agent output.\";\n\n/**\n * Render the model-visible final-output contract for one definition. The\n * derivation and message identity are stable for an immutable definition.\n * An output Schema the Effect AI derivation cannot represent is reported as\n * `unrenderable`; the caller falls back to the prior behavior — the contract\n * is guidance, and a Schema that decodes but does not render must not become\n * a new failure mode.\n */\nconst rendered = (message: string): OutputContract => ({\n  _tag: \"rendered\",\n  message,\n  part: Prompt.makeMessage(\"system\", { content: message }),\n});\n\nconst renderOutputSchemaContract = (definition: Agent.AnyDefinition): OutputContract => {\n  if (definition.completion?.required === true) {\n    return rendered(\n      requiredCompletionDirective(\n        definition.completion.tool,\n        (definition.completionFromTools?.length ?? 0) > 0,\n      ),\n    );\n  }\n  if (isTextOutput(definition.output)) {\n    return rendered(\n      \"Final output contract: write the final reply as ordinary assistant text, without JSON wrapping. \" +\n        \"An empty reply is valid only when allowed by the output Schema and the task instructions.\" +\n        (definition.completion === undefined\n          ? \"\"\n          : ` When calling the \"${definition.completion.tool}\" completion Tool, follow its parameter schema instead and call it as the sole application Tool Call, after receiving any other needed application Tool results; completed provider Tool results may accompany it; the engine projects its successful result into the Agent output.`),\n    );\n  }\n  try {\n    const jsonSchema = Tool.getJsonSchemaFromSchema(definition.output);\n\n    return rendered(\n      `${contractDirective(definition)}\\n\\n${JSON.stringify(jsonSchema, undefined, 2)}`,\n    );\n  } catch (cause) {\n    return {\n      _tag: \"unrenderable\",\n      reason: cause instanceof Error ? cause.message : String(cause),\n    };\n  }\n};\n\n// Native incremental-response tracking recognizes message objects, not rendered text.\n// Weak keys retain neither discarded definitions nor their Schema graphs.\nconst outputContracts = new WeakMap<Agent.AnyDefinition, OutputContract>();\n\nexport const outputSchemaContract = (definition: Agent.AnyDefinition): OutputContract => {\n  const cached = outputContracts.get(definition);\n\n  if (cached !== undefined) return cached;\n  const base = renderOutputSchemaContract(definition);\n  const alternatives = definition.completionFromTools ?? [];\n\n  const contract =\n    base._tag === \"rendered\" && alternatives.length > 0\n      ? rendered(\n          `The following action Tools may complete the Run from their successful canonical result: ${alternatives.map((declaration) => JSON.stringify(declaration.tool)).join(\", \")}. ` +\n            \"Call such a Tool as the sole application Tool Call, following its parameter schema. Completed provider Tool results may accompany it. It may complete the Run only when it satisfies the whole request. \" +\n            \"An incomplete or pending result continues the Run. These actions are unavailable during finalization after budget exhaustion.\\n\\n\" +\n            base.message,\n        )\n      : base;\n\n  outputContracts.set(definition, contract);\n\n  return contract;\n};\n\nconst sameSystemMessage = Schema.toEquivalence(Prompt.SystemMessage);\n\n/**\n * Keep supported system instructions in conversation order so changing late guidance\n * cannot invalidate the preceding user/tool cache prefix. Omit an exact repeat\n * only when no distinct system instruction intervened; returning to an earlier\n * instruction after a different one must preserve the new directive's precedence.\n * Anchor the immutable output contract after the initial system block.\n * Restore leading static instructions for caller-supplied conversation-only history.\n *\n * This runs after preparation and compaction. Canonical messages, protected\n * instruction/input spans and compaction coverage retain their original positions.\n * Adapters without this capability retain the grouped-system projection: keep the\n * last equivalent instruction with its native options, then the contract and\n * conversation. This prevents older Anthropic adapters from discarding system groups.\n */\nexport const prepareModelPrompt = (\n  prompt: Prompt.Prompt,\n  contract: Prompt.SystemMessage | undefined,\n  systemMessagesInHistory: boolean,\n  staticInstructions: Prompt.RawInput | undefined,\n): Prompt.Prompt => {\n  if (systemMessagesInHistory) {\n    const content: Array<Prompt.Message> = [];\n    let lastSystem: Prompt.SystemMessage | undefined;\n    let ordered = prompt.content;\n\n    if (staticInstructions !== undefined) {\n      const firstConversation = prompt.content.findIndex((message) => message.role !== \"system\");\n\n      const leading = prompt.content.slice(\n        0,\n        firstConversation === -1 ? prompt.content.length : firstConversation,\n      );\n\n      const restored: Array<Prompt.Message> = [];\n\n      const instructions =\n        typeof staticInstructions === \"string\"\n          ? [Prompt.systemMessage({ content: staticInstructions })]\n          : Prompt.make(staticInstructions).content;\n\n      for (const message of instructions) {\n        if (message.role !== \"system\") break;\n        if (\n          leading.some(\n            (candidate) => candidate.role === \"system\" && sameSystemMessage(candidate, message),\n          )\n        )\n          break;\n\n        const original = prompt.content.find(\n          (candidate) => candidate.role === \"system\" && sameSystemMessage(candidate, message),\n        );\n\n        if (original === undefined) break;\n        restored.push(original);\n      }\n      if (restored.length > 0)\n        ordered = [...leading, ...restored, ...prompt.content.slice(leading.length)];\n    }\n\n    for (const message of ordered) {\n      if (message.role === \"system\") {\n        if (lastSystem !== undefined && sameSystemMessage(lastSystem, message)) continue;\n        lastSystem = message;\n      }\n      content.push(message);\n    }\n    if (contract !== undefined) {\n      const firstConversation = content.findIndex((message) => message.role !== \"system\");\n\n      content.splice(firstConversation === -1 ? content.length : firstConversation, 0, contract);\n    }\n\n    return Prompt.fromMessages(content);\n  }\n\n  const systems: Array<Prompt.SystemMessage> = [];\n  const conversation: Array<Prompt.Message> = [];\n  const seen = new Map<string, Array<Prompt.SystemMessage>>();\n\n  for (let index = prompt.content.length - 1; index >= 0; index -= 1) {\n    const message = prompt.content[index];\n\n    if (message === undefined) continue;\n    if (message.role !== \"system\") {\n      conversation.push(message);\n      continue;\n    }\n    const variants = seen.get(message.content);\n\n    if (variants?.some((previous) => sameSystemMessage(previous, message))) continue;\n    if (variants === undefined) seen.set(message.content, [message]);\n    else variants.push(message);\n    systems.push(message);\n  }\n\n  return Prompt.fromMessages([\n    ...systems.reverse(),\n    ...(contract === undefined ? [] : [contract]),\n    ...conversation.reverse(),\n  ]);\n};\n"],"mappings":"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"}

package/dist/rolldown-runtime-D7D4PA-g.mjs

@@ -0,0 +1,13 @@
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+//#endregion
+export { __exportAll as t };