effect-agent 0.1.0-beta.16 → 0.1.0-beta.160

package/dist/engine/SubagentHost.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"SubagentHost.mjs","names":[],"sources":["../../src/engine/SubagentHost.ts"],"sourcesContent":["import type { Effect, Option } from \"effect\";\nimport { Context, Schema, Stream } from \"effect\";\n\nimport type * as Agent from \"../core/Agent.ts\";\nimport type { AgentPolicy } from \"../core/AgentPolicy.ts\";\nimport type { Update } from \"../core/AgentUpdates.ts\";\nimport type * as FailureDiagnostic from \"../core/FailureDiagnostic.ts\";\nimport type { DelegationId, RunId, SettlementId, ThreadId } from \"../core/Identifiers.ts\";\nimport type { MessageRef, MessageStatus } from \"../core/Messaging.ts\";\nimport { type IdempotencyKey, type JoinedToHost, type Receipt } from \"../core/Receipt.ts\";\nimport type { SubagentBudgetReservation } from \"../core/SubagentContract.ts\";\nimport {\n  WorkerError,\n  type WorkerStop,\n  type WorkerStopped,\n  type WorkerCompletion,\n  type WorkerHistoryEntry,\n  type WorkerContext,\n  type WorkerBudgetScope,\n  type WorkerSource,\n  type WorkerPage,\n  type WorkerRef,\n  type WorkerStarted,\n  type WorkerSummary,\n} from \"../core/Worker.ts\";\n\n/** Prepared values cross this port only to be Schema-decoded before durable storage. */\nexport interface StartWorkerRequest {\n  readonly delegationId: DelegationId;\n  /** Start a distinct assignment using verified completed predecessor authority. */\n  readonly continuationOf?: WorkerRef;\n  readonly target: Agent.AnyDefinition;\n  readonly idempotencyKey: IdempotencyKey;\n  readonly encodedInput: unknown;\n  readonly encodedParameters: unknown;\n  readonly policy: AgentPolicy;\n  readonly budget: SubagentBudgetReservation;\n  readonly encodedGrant: unknown;\n  readonly toolCallAllowance?: number;\n  /** Author-owned request; the durable host must separately authorize worker-run funding. */\n  readonly budgetScope?: WorkerBudgetScope;\n}\n\n/**\n * First-admission preparation stays lazy until the owner authorizes the caller and checks the\n * retained command. Replays compare declared parameters/options and reuse the original capture.\n * Prepared policy, budget, and allowance are frozen first-admission configuration, not replay\n * arguments; changing them requires a new command key. Current caller authorization still applies.\n * Preparation must be free of external effects: concurrent first admissions can prepare before\n * the retained delivery chooses its first writer.\n */\nexport interface DeferredStartWorkerRequest<E = never, R = never> extends Pick<\n  StartWorkerRequest,\n  | \"delegationId\"\n  | \"continuationOf\"\n  | \"target\"\n  | \"idempotencyKey\"\n  | \"encodedParameters\"\n  | \"encodedGrant\"\n  | \"budgetScope\"\n> {\n  readonly prepare: Effect.Effect<\n    Pick<StartWorkerRequest, \"encodedInput\" | \"policy\" | \"budget\" | \"toolCallAllowance\">,\n    E,\n    R\n  >;\n}\n\nexport interface FollowUpWorkerRequest {\n  readonly worker: WorkerRef;\n  readonly target: Agent.AnyDefinition;\n  readonly idempotencyKey: IdempotencyKey;\n  readonly encodedInput: unknown;\n  readonly encodedParameters: unknown;\n}\n\n/**\n * Like deferred starts, follow-ups prepare only after current authorization and retained-command\n * lookup. Replays compare declared parameters and reuse the original input and worker authority.\n * Preparation must be free of external effects because concurrent first admissions can prepare.\n */\nexport interface DeferredFollowUpWorkerRequest<E = never, R = never> extends Omit<\n  FollowUpWorkerRequest,\n  \"encodedInput\"\n> {\n  readonly prepare: Effect.Effect<Pick<FollowUpWorkerRequest, \"encodedInput\">, E, R>;\n}\n\nexport interface WorkerReceiptRequest {\n  readonly worker: WorkerRef;\n  readonly target: Agent.AnyDefinition;\n  readonly receipt: Receipt;\n}\n\nexport interface WorkerMessageRequest {\n  readonly worker: WorkerRef;\n  readonly target: Agent.AnyDefinition;\n  readonly message: MessageRef;\n}\n\n/**\n * Canonical terminal values remain encoded until the capability decodes the saved parameters\n * and target output and applies its declared result projection. Child E does not survive settlement.\n */\nexport type WorkerObservation =\n  | { readonly _tag: \"Pending\"; readonly receipt: Receipt }\n  | {\n      readonly _tag: \"Settled\";\n      readonly receipt: Receipt;\n      /** Absent when an input failed or was cancelled before any Run started. */\n      readonly runId?: RunId;\n      readonly settlementId: SettlementId;\n      readonly outcome: \"completed\" | \"failed\" | \"aborted\";\n      readonly encodedParameters: unknown;\n      readonly encodedResult: unknown;\n      /** Operator-private failed-settlement evidence; never part of a model Tool result. */\n      readonly diagnostic?: FailureDiagnostic.Failure;\n      readonly budgetExhausted: boolean;\n    };\n\n/** One actual canonical Run, independent of how many input Receipts joined it. */\nexport interface WorkerRunReport {\n  readonly worker: WorkerRef;\n  readonly context: WorkerContext;\n  readonly observation: Extract<WorkerObservation, { readonly _tag: \"Settled\" }> & {\n    readonly runId: RunId;\n  };\n}\n\n/** A bounded projection failure; raw application errors never enter durable report records. */\nexport class WorkerReportPreparationFailure extends Schema.TaggedError<WorkerReportPreparationFailure>()(\n  \"WorkerReportPreparationFailure\",\n  { stage: Schema.Literals([\"projection\", \"input\", \"preparation\"]) },\n) {}\n\n/**\n * Source-owned standard projection discovered from background tools.\n * The concrete descriptor retains its E/R; durable registration captures R and records\n * bounded preparation failure rather than serializing arbitrary application errors.\n */\nexport interface WorkerReporting<E = never, R = never> {\n  readonly delegationId: DelegationId;\n  readonly target: Agent.AnyDefinition;\n  /** Pure first-emission selection. False retains the canonical update without parent delivery. */\n  readonly reportUpdate?: (update: Update) => boolean;\n  /** False retains a filtered report receipt without waking the parent. */\n  readonly reportCompletion?: (report: WorkerRunReport) => boolean;\n  readonly prepare: (report: WorkerRunReport) => Effect.Effect<\n    {\n      readonly message: WorkerCompletion;\n    },\n    E | WorkerReportPreparationFailure,\n    R\n  >;\n}\n\n/** Descriptor carried by background tools; registration discovers it without an app handoff. */\nexport const BackgroundReporting = Context.Reference<\n  WorkerReporting<WorkerReportPreparationFailure> | undefined\n>(\"@effect-agent/engine/BackgroundReporting\", { defaultValue: () => undefined });\n\n/**\n * Trusted, caller-bound host port. The interpreter supplies a fresh facet for each Tool Call;\n * programmatic callers acquire a separately authorized Thread facet. Request values cannot\n * choose the source identity, replace worker provenance or expand its authority and budgets.\n */\nexport class SubagentHost extends Context.Service<\n  SubagentHost,\n  {\n    readonly context: Effect.Effect<WorkerContext, WorkerError>;\n    /** Resolve prepared input through host authority; None retains legacy target inheritance. */\n    readonly resolveTargetPolicy: (request: {\n      readonly continuationOf?: WorkerRef;\n      readonly target: Agent.AnyDefinition;\n      readonly encodedInput: unknown;\n    }) => Effect.Effect<Option.Option<AgentPolicy>, WorkerError>;\n    /** Prepared callers retain strict input/policy conflicts; deferred callers replay the saved capture. */\n    readonly start: <E = never, R = never>(\n      request: StartWorkerRequest | DeferredStartWorkerRequest<E, R>,\n    ) => Effect.Effect<WorkerStarted, WorkerError | E, R>;\n    /** Prepared callers retain strict input conflicts; deferred callers replay the saved capture. */\n    readonly followUp: <E = never, R = never>(\n      request: FollowUpWorkerRequest | DeferredFollowUpWorkerRequest<E, R>,\n    ) => Effect.Effect<MessageStatus, WorkerError | E, R>;\n    readonly inspect: (\n      request: WorkerReceiptRequest | WorkerMessageRequest,\n    ) => Effect.Effect<WorkerObservation | MessageStatus, WorkerError>;\n    /** Inspect the continuing worker using the same summary contract as discovery. */\n    readonly summary: (request: {\n      readonly worker: WorkerRef;\n      readonly target: Agent.AnyDefinition;\n    }) => Effect.Effect<WorkerSummary, WorkerError>;\n    /** A finite snapshot through the captured tail; resume with the last sequence as `after`. */\n    readonly observe: (request: {\n      readonly worker: WorkerRef;\n      readonly target: Agent.AnyDefinition;\n      readonly after?: number;\n    }) => Stream.Stream<WorkerHistoryEntry, WorkerError>;\n    /** Interrupting this wait never requests cancellation of accepted work. */\n    readonly await: (\n      request: WorkerReceiptRequest,\n    ) => Effect.Effect<WorkerObservation, WorkerError>;\n    readonly list: (request: {\n      readonly delegationId: DelegationId;\n      readonly target: Agent.AnyDefinition;\n      readonly limit: number;\n      readonly after?: ThreadId;\n    }) => Effect.Effect<WorkerPage, WorkerError>;\n    /** Seal the whole worker; retries reconcile the same command, including a lost acknowledgement. */\n    readonly stop: (\n      request: WorkerStop & { readonly target: Agent.AnyDefinition },\n    ) => Effect.Effect<WorkerStopped, WorkerError>;\n    /** Cancel exactly this Receipt; preserve JoinedToHost without broadening its target. */\n    readonly cancel: (\n      request: WorkerReceiptRequest,\n    ) => Effect.Effect<void, WorkerError | JoinedToHost>;\n  }\n>()(\"@effect-agent/engine/SubagentHost\") {\n  static readonly unavailable: SubagentHost[\"Service\"] = {\n    context: WorkerError.make({ operation: \"context\", reason: \"unavailable\" }),\n    resolveTargetPolicy: () => WorkerError.make({ operation: \"start\", reason: \"unavailable\" }),\n    start: () => WorkerError.make({ operation: \"start\", reason: \"unavailable\" }),\n    followUp: () => WorkerError.make({ operation: \"followUp\", reason: \"unavailable\" }),\n    inspect: () => WorkerError.make({ operation: \"inspect\", reason: \"unavailable\" }),\n    summary: () => WorkerError.make({ operation: \"inspect\", reason: \"unavailable\" }),\n    observe: () => Stream.fail(WorkerError.make({ operation: \"observe\", reason: \"unavailable\" })),\n    await: () => WorkerError.make({ operation: \"await\", reason: \"unavailable\" }),\n    list: () => WorkerError.make({ operation: \"list\", reason: \"unavailable\" }),\n    stop: () => WorkerError.make({ operation: \"stop\", reason: \"unavailable\" }),\n    cancel: () => WorkerError.make({ operation: \"cancel\", reason: \"unavailable\" }),\n  };\n\n  /** Runtime-owned per-call binding. Unconfigured Runs deny background operations. */\n  static readonly forTool = Context.Reference<\n    (source: Extract<WorkerSource, { readonly _tag: \"tool\" }>) => SubagentHost[\"Service\"]\n  >(\"@effect-agent/engine/SubagentHost/forTool\", {\n    defaultValue: () => () => SubagentHost.unavailable,\n  });\n}\n"],"mappings":";;;;;;;;;;AAkIA,IAAa,iCAAb,cAAoD,OAAO,YAA4C,CAAC,CACtG,kCACA,EAAE,OAAO,OAAO,SAAS;CAAC;CAAc;CAAS;AAAa,CAAC,EAAE,CACnE,CAAC,CAAC,CAAC;;AAwBH,MAAa,sBAAsB,QAAQ,UAEzC,4CAA4C,EAAE,oBAAoB,KAAA,EAAU,CAAC;;;;;;AAO/E,IAAa,eAAb,MAAa,qBAAqB,QAAQ,QAmDxC,CAAC,CAAC,mCAAmC,CAAC,CAAC;CACvC,OAAgB,cAAuC;EACrD,SAAS,YAAY,KAAK;GAAE,WAAW;GAAW,QAAQ;EAAc,CAAC;EACzE,2BAA2B,YAAY,KAAK;GAAE,WAAW;GAAS,QAAQ;EAAc,CAAC;EACzF,aAAa,YAAY,KAAK;GAAE,WAAW;GAAS,QAAQ;EAAc,CAAC;EAC3E,gBAAgB,YAAY,KAAK;GAAE,WAAW;GAAY,QAAQ;EAAc,CAAC;EACjF,eAAe,YAAY,KAAK;GAAE,WAAW;GAAW,QAAQ;EAAc,CAAC;EAC/E,eAAe,YAAY,KAAK;GAAE,WAAW;GAAW,QAAQ;EAAc,CAAC;EAC/E,eAAe,OAAO,KAAK,YAAY,KAAK;GAAE,WAAW;GAAW,QAAQ;EAAc,CAAC,CAAC;EAC5F,aAAa,YAAY,KAAK;GAAE,WAAW;GAAS,QAAQ;EAAc,CAAC;EAC3E,YAAY,YAAY,KAAK;GAAE,WAAW;GAAQ,QAAQ;EAAc,CAAC;EACzE,YAAY,YAAY,KAAK;GAAE,WAAW;GAAQ,QAAQ;EAAc,CAAC;EACzE,cAAc,YAAY,KAAK;GAAE,WAAW;GAAU,QAAQ;EAAc,CAAC;CAC/E;;CAGA,OAAgB,UAAU,QAAQ,UAEhC,6CAA6C,EAC7C,0BAA0B,aAAa,YACzC,CAAC;AACH"}

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-FD-o4TsR.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,93 @@
-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-tyN9v-Jv.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-BNjPR7Zr.mjs";
+import { d as RunEvent_d_exports } from "./RunEvent-D0aepYwN.mjs";
+import { i as ThreadHistory_d_exports } from "./ThreadHistory-FD-o4TsR.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 BrowserUse_d_exports } from "./capabilities/BrowserUse.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-B4oH8TbG.mjs";
+import { t as Agent_d_exports } from "./Agent-ZfnNCQXs.mjs";
+import { c as MemoryReference_d_exports } from "./MemoryReference-B8Q3UJoJ.mjs";
+import { n as RunPolicyUsage_d_exports } from "./RunPolicyUsage-CUudVtg_.mjs";
+import { x as Worker_d_exports } from "./Worker-XEBYxRQv.mjs";
+import { s as ContextWindow_d_exports } from "./ContextWindow-DRQ5Mbm2.mjs";
+import { s as ContextCompactor_d_exports } from "./ContextCompactor-BoKQOjr5.mjs";
+import { i as DurableStep_d_exports } from "./DurableStep-Cry_iol4.mjs";
+import { F as RunOptions_d_exports } from "./RunOptions-BHmBa05n.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-DXwWnrMh.mjs";
+import { t as Messaging_d_exports } from "./Messaging-CICd_CSi.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-VTyf_wEF.mjs";
+import { t as AgentRuntime_d_exports } from "./AgentRuntime-D1MmB_0z.mjs";
+import { i as RunEventSink_d_exports } from "./RunEventSink-9CUdI9Ar.mjs";
+import { v as Subagent_d_exports } from "./Subagent-D59om8SR.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 { P as Records_d_exports } from "./Records-Bm4Qt70a.mjs";
+import { t as ActivityStore_d_exports } from "./durable/ActivityStore.mjs";
+import { n as Digest_d_exports } from "./Digest-COAt3Orl.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-Dirux8PR.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-Bi_XVKLF.mjs";
+import { k as Subscription_d_exports } from "./Subscription-B3ScCBaN.mjs";
+import { n as EventSource_d_exports } from "./EventSource-DOXB0RJR.mjs";
+import { n as PreparedInputAdmission_d_exports } from "./PreparedInputAdmission-B7r401xJ.mjs";
+import { r as SubscriptionInput_d_exports } from "./SubscriptionInput-BP5WVsX_.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-CY7NZByV.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, BrowserUse_d_exports as BrowserUse, 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,101 @@
-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-BMATXYsI.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-CVMHysXm.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 BrowserUse_exports } from "./capabilities/BrowserUse.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-DH6G120f.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-pr7cCaZw.mjs";
+import { n as RunJournal_exports } from "./RunJournal-CA2bsvHn.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-Cmcxd6nS.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, BrowserUse_exports as BrowserUse, 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