effect-agent 0.1.0-beta.11 → 0.1.0-beta.111

package/dist/Worker-T_3RbaKc.mjs

@@ -0,0 +1,210 @@
+import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
+import { AgentId, DelegationId, RunId, SettlementId, ThreadId, ToolCallId } from "./core/Identifiers.mjs";
+import { AgentPolicy } from "./core/AgentPolicy.mjs";
+import { IdempotencyKey, Receipt } from "./core/Receipt.mjs";
+import { Update } from "./core/AgentUpdates.mjs";
+import { o as Value } from "./FailureDiagnostic-BElLOoED.mjs";
+import { SubagentExecutionFailure, SubagentGrant, WorkerOperationTool } from "./core/SubagentContract.mjs";
+import { Schema } from "effect";
+//#region src/core/internal/message-status.ts
+/** A retained outbound delivery identity, not a destination Receipt or access grant. */
+const MessageRef = Schema.Struct({
+	ownerThreadId: ThreadId,
+	messageId: IdempotencyKey
+});
+const Reason = Schema.NonEmptyString.check(Schema.isMaxLength(256));
+const identity = { message: MessageRef };
+/**
+* Source-owned delivery evidence. Pending confirms retention only; accepted supplies the
+* destination Receipt, and processed supplies its canonical settlement. Neither retention nor
+* acceptance proves execution. Refused is a definite rejection; parked stops automatic retry
+* while retaining the same identity and any acceptance evidence. Inspect instead of resending.
+*/
+const MessageStatus = Schema.Union([
+	Schema.Struct({
+		...identity,
+		status: Schema.Literal("pending"),
+		receipt: Schema.Null,
+		settlement: Schema.Null,
+		reason: Schema.NullOr(Reason)
+	}),
+	Schema.Struct({
+		...identity,
+		status: Schema.Literal("accepted"),
+		receipt: Receipt,
+		settlement: Schema.Null,
+		reason: Schema.NullOr(Reason)
+	}),
+	Schema.Struct({
+		...identity,
+		status: Schema.Literal("processed"),
+		receipt: Receipt,
+		settlement: Schema.Struct({
+			settlementId: SettlementId,
+			outcome: Schema.Literals([
+				"completed",
+				"failed",
+				"aborted"
+			])
+		}),
+		reason: Schema.Null
+	}),
+	Schema.Struct({
+		...identity,
+		status: Schema.Literal("refused"),
+		receipt: Schema.Null,
+		settlement: Schema.Null,
+		reason: Reason
+	}),
+	Schema.Struct({
+		...identity,
+		status: Schema.Literal("parked"),
+		receipt: Schema.NullOr(Receipt),
+		settlement: Schema.Null,
+		reason: Reason
+	})
+]);
+//#endregion
+//#region src/core/Worker.ts
+var Worker_exports = /* @__PURE__ */ __exportAll({
+	FrameworkMessage: () => FrameworkMessage,
+	WorkerBudgetScope: () => WorkerBudgetScope,
+	WorkerCompletion: () => WorkerCompletion,
+	WorkerContext: () => WorkerContext,
+	WorkerError: () => WorkerError,
+	WorkerHistoryEntry: () => WorkerHistoryEntry,
+	WorkerOperationTool: () => WorkerOperationTool,
+	WorkerPage: () => WorkerPage,
+	WorkerRef: () => WorkerRef,
+	WorkerReport: () => WorkerReport,
+	WorkerSource: () => WorkerSource,
+	WorkerStarted: () => WorkerStarted,
+	WorkerSummary: () => WorkerSummary,
+	WorkerUpdate: () => WorkerUpdate
+});
+/** A reusable child Thread, correlated with its declaration. This value grants no authority. */
+const WorkerRef = Schema.Struct({
+	schemaVersion: Schema.Literal(1),
+	delegationId: DelegationId,
+	targetAgentId: AgentId,
+	threadId: ThreadId
+});
+/** A continuing worker identity and retained first delivery, never an execution handle. */
+const WorkerStarted = Schema.Struct({
+	worker: WorkerRef,
+	delivery: MessageStatus
+}).check(Schema.makeFilter(({ worker, delivery }) => delivery.receipt === null || worker.threadId === delivery.receipt.threadId));
+/** A host-authorized Run allowance is independent of the immutable delegation lineage. */
+const WorkerBudgetScope = Schema.Literals(["source-subtree", "worker-run"]);
+/** Host-bound caller metadata. Programmatic calls never fabricate Run or Tool Call identities. */
+const WorkerSource = Schema.Union([Schema.Struct({
+	_tag: Schema.Literal("tool"),
+	agentId: AgentId,
+	threadId: ThreadId,
+	runId: RunId,
+	toolCallId: ToolCallId
+}), Schema.Struct({
+	_tag: Schema.Literal("programmatic"),
+	agentId: AgentId,
+	threadId: ThreadId
+})]);
+/** The caller's effective policy and root-relative depth, resolved by its host. */
+const WorkerContext = Schema.Struct({
+	source: WorkerSource,
+	policy: AgentPolicy,
+	depth: Schema.Natural,
+	grant: Schema.optionalKey(SubagentGrant)
+});
+/** Bounded durable listing data; a latest Receipt never substitutes for a requested Receipt. */
+const WorkerSummary = Schema.Struct({
+	worker: WorkerRef,
+	latestReceipt: Schema.NullOr(Receipt),
+	state: Schema.Literals([
+		"starting",
+		"active",
+		"idle"
+	])
+});
+const WorkerPage = Schema.Struct({
+	items: Schema.Array(WorkerSummary).check(Schema.isMaxLength(100)),
+	next: Schema.NullOr(ThreadId)
+});
+/** Authorized canonical history, encoded independently of storage-adapter representations. */
+const WorkerHistoryEntry = Schema.Struct({
+	sequence: Schema.Natural.check(Schema.isGreaterThan(0)),
+	recordId: Schema.NonEmptyString.check(Schema.isMaxLength(1024)),
+	record: Schema.Json
+});
+/**
+* Closed host-boundary failures. Original causes stay private and survive diagnostic transport.
+* Retained delivery states are successful MessageStatus values, including pending and refused.
+* After a storage failure, keep the same idempotency key and parameters when reconciling.
+*/
+var WorkerError = class extends Schema.TaggedError()("WorkerError", {
+	cause: Schema.optionalKey(Value),
+	stack: Schema.optionalKey(Schema.String),
+	/** Concurrency pressure may clear without changing the request. */
+	retryable: Schema.optionalKey(Schema.Literal(true)),
+	operation: Schema.Literals([
+		"context",
+		"start",
+		"followUp",
+		"inspect",
+		"observe",
+		"await",
+		"list",
+		"cancel"
+	]),
+	reason: Schema.Literals([
+		"denied",
+		"declaration-unavailable",
+		"worker-mismatch",
+		"receipt-mismatch",
+		"message-mismatch",
+		"idempotency-conflict",
+		"capacity",
+		"not-found",
+		"delivery-pending",
+		"storage",
+		"corrupt",
+		"unavailable"
+	])
+}) {};
+/** One projected canonical Run outcome. Joined receipts share this identity. */
+const WorkerReport = (success) => {
+	const identity = {
+		_tag: Schema.Literal("Settled"),
+		worker: WorkerRef,
+		receipt: Receipt,
+		runId: RunId,
+		settlementId: SettlementId
+	};
+	return Schema.Union([Schema.Struct({
+		...identity,
+		outcome: Schema.Literal("completed"),
+		result: Schema.Union([success])
+	}), Schema.Struct({
+		...identity,
+		outcome: Schema.Literals(["failed", "aborted"]),
+		failure: SubagentExecutionFailure
+	})]);
+};
+/** Framework message stored separately from the parent's application input. */
+const WorkerCompletion = Schema.Struct({
+	_tag: Schema.Literal("WorkerCompletion"),
+	budgetExhausted: Schema.Boolean,
+	schemaVersion: Schema.Literal(1),
+	report: WorkerReport(Schema.Json)
+}).check(Schema.makeFilter(({ report }) => report.worker.threadId === report.receipt.threadId));
+/** Source-worker intermediate output, kept separate from application input. */
+const WorkerUpdate = Schema.Struct({
+	_tag: Schema.Literal("WorkerUpdate"),
+	schemaVersion: Schema.Literal(1),
+	worker: WorkerRef,
+	update: Update
+}).check(Schema.makeFilter(({ worker, update }) => worker.threadId === update.threadId && worker.targetAgentId === update.agentId));
+const FrameworkMessage = Schema.Union([WorkerCompletion, WorkerUpdate]);
+//#endregion
+export { WorkerError as a, WorkerRef as c, WorkerStarted as d, WorkerSummary as f, MessageStatus as g, MessageRef as h, WorkerContext as i, WorkerReport as l, Worker_exports as m, WorkerBudgetScope as n, WorkerHistoryEntry as o, WorkerUpdate as p, WorkerCompletion as r, WorkerPage as s, FrameworkMessage as t, WorkerSource as u };
+
+//# sourceMappingURL=Worker-T_3RbaKc.mjs.map

package/dist/Worker-T_3RbaKc.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Worker-T_3RbaKc.mjs","names":["FailureDiagnostic.Value"],"sources":["../src/core/internal/message-status.ts","../src/core/Worker.ts"],"sourcesContent":["import { Schema } from \"effect\";\n\nimport { SettlementId, ThreadId } from \"../Identifiers.ts\";\nimport { IdempotencyKey, Receipt } from \"../Receipt.ts\";\n\n/** A retained outbound delivery identity, not a destination Receipt or access grant. */\nexport const MessageRef = Schema.Struct({ ownerThreadId: ThreadId, messageId: IdempotencyKey });\nexport type MessageRef = typeof MessageRef.Type;\n\nconst Reason = Schema.NonEmptyString.check(Schema.isMaxLength(256));\nconst identity = { message: MessageRef };\n\n/**\n * Source-owned delivery evidence. Pending confirms retention only; accepted supplies the\n * destination Receipt, and processed supplies its canonical settlement. Neither retention nor\n * acceptance proves execution. Refused is a definite rejection; parked stops automatic retry\n * while retaining the same identity and any acceptance evidence. Inspect instead of resending.\n */\nexport const MessageStatus = Schema.Union([\n  Schema.Struct({\n    ...identity,\n    status: Schema.Literal(\"pending\"),\n    receipt: Schema.Null,\n    settlement: Schema.Null,\n    reason: Schema.NullOr(Reason),\n  }),\n  Schema.Struct({\n    ...identity,\n    status: Schema.Literal(\"accepted\"),\n    receipt: Receipt,\n    settlement: Schema.Null,\n    reason: Schema.NullOr(Reason),\n  }),\n  Schema.Struct({\n    ...identity,\n    status: Schema.Literal(\"processed\"),\n    receipt: Receipt,\n    settlement: Schema.Struct({\n      settlementId: SettlementId,\n      outcome: Schema.Literals([\"completed\", \"failed\", \"aborted\"]),\n    }),\n    reason: Schema.Null,\n  }),\n  Schema.Struct({\n    ...identity,\n    status: Schema.Literal(\"refused\"),\n    receipt: Schema.Null,\n    settlement: Schema.Null,\n    reason: Reason,\n  }),\n  Schema.Struct({\n    ...identity,\n    status: Schema.Literal(\"parked\"),\n    receipt: Schema.NullOr(Receipt),\n    settlement: Schema.Null,\n    reason: Reason,\n  }),\n]);\n\nexport type MessageStatus = typeof MessageStatus.Type;\n","import { Schema } from \"effect\";\n\nimport { AgentPolicy } from \"./AgentPolicy.ts\";\nimport { Update } from \"./AgentUpdates.ts\";\nimport * as FailureDiagnostic from \"./FailureDiagnostic.ts\";\nimport { AgentId, DelegationId, RunId, SettlementId, ThreadId, ToolCallId } from \"./Identifiers.ts\";\nimport { MessageStatus } from \"./internal/message-status.ts\";\nimport { Receipt } from \"./Receipt.ts\";\nimport { SubagentExecutionFailure, SubagentGrant } from \"./SubagentContract.ts\";\n\n/** A reusable child Thread, correlated with its declaration. This value grants no authority. */\nexport const WorkerRef = Schema.Struct({\n  schemaVersion: Schema.Literal(1),\n  delegationId: DelegationId,\n  targetAgentId: AgentId,\n  threadId: ThreadId,\n});\n\nexport type WorkerRef = typeof WorkerRef.Type;\n\n/** A continuing worker identity and retained first delivery, never an execution handle. */\nexport const WorkerStarted = Schema.Struct({\n  worker: WorkerRef,\n  delivery: MessageStatus,\n}).check(\n  Schema.makeFilter(\n    ({ worker, delivery }) =>\n      delivery.receipt === null || worker.threadId === delivery.receipt.threadId,\n  ),\n);\n\nexport type WorkerStarted = typeof WorkerStarted.Type;\n\n/** A host-authorized Run allowance is independent of the immutable delegation lineage. */\nexport const WorkerBudgetScope = Schema.Literals([\"source-subtree\", \"worker-run\"]);\nexport type WorkerBudgetScope = typeof WorkerBudgetScope.Type;\n\n/** Host-bound caller metadata. Programmatic calls never fabricate Run or Tool Call identities. */\nexport const WorkerSource = Schema.Union([\n  Schema.Struct({\n    _tag: Schema.Literal(\"tool\"),\n    agentId: AgentId,\n    threadId: ThreadId,\n    runId: RunId,\n    toolCallId: ToolCallId,\n  }),\n  Schema.Struct({\n    _tag: Schema.Literal(\"programmatic\"),\n    agentId: AgentId,\n    threadId: ThreadId,\n  }),\n]);\n\nexport type WorkerSource = typeof WorkerSource.Type;\n\n/** The caller's effective policy and root-relative depth, resolved by its host. */\nexport const WorkerContext = Schema.Struct({\n  source: WorkerSource,\n  policy: AgentPolicy,\n  depth: Schema.Natural,\n  grant: Schema.optionalKey(SubagentGrant),\n});\n\nexport type WorkerContext = typeof WorkerContext.Type;\n\n/** Bounded durable listing data; a latest Receipt never substitutes for a requested Receipt. */\nexport const WorkerSummary = Schema.Struct({\n  worker: WorkerRef,\n  latestReceipt: Schema.NullOr(Receipt),\n  state: Schema.Literals([\"starting\", \"active\", \"idle\"]),\n});\n\nexport type WorkerSummary = typeof WorkerSummary.Type;\n\nexport const WorkerPage = Schema.Struct({\n  items: Schema.Array(WorkerSummary).check(Schema.isMaxLength(100)),\n  next: Schema.NullOr(ThreadId),\n});\n\nexport type WorkerPage = typeof WorkerPage.Type;\n\n/** Authorized canonical history, encoded independently of storage-adapter representations. */\nexport const WorkerHistoryEntry = Schema.Struct({\n  sequence: Schema.Natural.check(Schema.isGreaterThan(0)),\n  recordId: Schema.NonEmptyString.check(Schema.isMaxLength(1_024)),\n  record: Schema.Json,\n});\n\nexport type WorkerHistoryEntry = typeof WorkerHistoryEntry.Type;\n\n/**\n * Closed host-boundary failures. Original causes stay private and survive diagnostic transport.\n * Retained delivery states are successful MessageStatus values, including pending and refused.\n * After a storage failure, keep the same idempotency key and parameters when reconciling.\n */\nexport class WorkerError extends Schema.TaggedError<WorkerError>()(\"WorkerError\", {\n  cause: Schema.optionalKey(FailureDiagnostic.Value),\n  stack: Schema.optionalKey(Schema.String),\n  /** Concurrency pressure may clear without changing the request. */\n  retryable: Schema.optionalKey(Schema.Literal(true)),\n  operation: Schema.Literals([\n    \"context\",\n    \"start\",\n    \"followUp\",\n    \"inspect\",\n    \"observe\",\n    \"await\",\n    \"list\",\n    \"cancel\",\n  ]),\n  reason: Schema.Literals([\n    \"denied\",\n    \"declaration-unavailable\",\n    \"worker-mismatch\",\n    \"receipt-mismatch\",\n    \"message-mismatch\",\n    \"idempotency-conflict\",\n    \"capacity\",\n    \"not-found\",\n    // Decode earlier failures without emitting them for retained deliveries.\n    \"delivery-pending\",\n    \"storage\",\n    \"corrupt\",\n    \"unavailable\",\n  ]),\n}) {}\n\nexport { WorkerOperationTool } from \"./SubagentContract.ts\";\n\n/** One projected canonical Run outcome. Joined receipts share this identity. */\nexport const WorkerReport = <Success extends Schema.Top>(success: Success) => {\n  const identity = {\n    _tag: Schema.Literal(\"Settled\"),\n    worker: WorkerRef,\n    receipt: Receipt,\n    runId: RunId,\n    settlementId: SettlementId,\n  };\n\n  return Schema.Union([\n    // Union preserves the Success codec while making the result field required.\n    Schema.Struct({\n      ...identity,\n      outcome: Schema.Literal(\"completed\"),\n      result: Schema.Union([success]),\n    }),\n    Schema.Struct({\n      ...identity,\n      outcome: Schema.Literals([\"failed\", \"aborted\"]),\n      failure: SubagentExecutionFailure,\n    }),\n  ]);\n};\n\nexport type WorkerReport<Success extends Schema.Top> = ReturnType<\n  typeof WorkerReport<Success>\n>[\"Type\"];\n\n/** Framework message stored separately from the parent's application input. */\nexport const WorkerCompletion = Schema.Struct({\n  _tag: Schema.Literal(\"WorkerCompletion\"),\n  budgetExhausted: Schema.Boolean,\n  schemaVersion: Schema.Literal(1),\n  report: WorkerReport(Schema.Json),\n}).check(Schema.makeFilter(({ report }) => report.worker.threadId === report.receipt.threadId));\n\nexport type WorkerCompletion = typeof WorkerCompletion.Type;\n\n/** Source-worker intermediate output, kept separate from application input. */\nexport const WorkerUpdate = Schema.Struct({\n  _tag: Schema.Literal(\"WorkerUpdate\"),\n  schemaVersion: Schema.Literal(1),\n  worker: WorkerRef,\n  update: Update,\n}).check(\n  Schema.makeFilter(\n    ({ worker, update }) =>\n      worker.threadId === update.threadId && worker.targetAgentId === update.agentId,\n  ),\n);\n\nexport type WorkerUpdate = typeof WorkerUpdate.Type;\nexport const FrameworkMessage = Schema.Union([WorkerCompletion, WorkerUpdate]);\nexport type FrameworkMessage = typeof FrameworkMessage.Type;\n"],"mappings":"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"}

package/dist/agent-registration-B5CI-Ygk.mjs

@@ -0,0 +1,201 @@
+import { AgentId } from "./core/Identifiers.mjs";
+import { getToolExecutionKind } from "./core/SubagentContract.mjs";
+import { a as PinnedTool, l as ToolNamespace, n as DiscoveryTool, r as IncludesCatalogDocumentation, t as AdditionalToolCatalog } from "./ToolExposure-C93U1sPu.mjs";
+import { BackgroundReporting, WorkerReportPreparationFailure } from "./engine/SubagentHost.mjs";
+import { ContextRolloverTool } from "./engine/ContextWindow.mjs";
+import { getToolExecutionClass } from "./engine/DurableStep.mjs";
+import { DefinitionDigests, ReplayContract } from "./durable/Records.mjs";
+import { DigestError, digestDefinitions, digestJson } from "./durable/Digest.mjs";
+import { Tool } from "effect/unstable/ai";
+import { Context, Effect, Layer, References, Schema, Tracer } from "effect";
+//#region src/durable/internal/agent-registration.ts
+/** No unique current executable is registered for the stable Agent identity. */
+var BindingUnavailable = class extends Schema.TaggedError()("BindingUnavailable", {
+	agentId: AgentId,
+	message: Schema.String
+}) {};
+/** Exact immutable admission, lineage and delivery evidence; never an executable-code gate. */
+const definitionDigestsEqual = (left, right) => left.agent === right.agent && left.model === right.model && left.tools === right.tools && Schema.toEquivalence(Schema.UndefinedOr(ReplayContract))(left.replay, right.replay);
+/** Hash current operation contracts; no historical definitions or schemas are retained. */
+const toolReplayContracts = Effect.fn("AgentRegistration.toolReplayContracts")(function* (definition, versions, fallbackVersion = null) {
+	const declarations = yield* Effect.try({
+		try: () => {
+			const jsonSchema = (schema) => Schema.decodeUnknownSync(Schema.Json)(Tool.getJsonSchemaFromSchema(schema));
+			return Object.values(definition.toolkit.tools).map((tool) => {
+				const version = versions === void 0 ? fallbackVersion : versions.tools[tool.name];
+				if (version === void 0 || versions !== void 0 && !Object.hasOwn(versions.tools, tool.name)) throw new Error("Every Tool needs an explicit replay semantic version");
+				return {
+					name: tool.name,
+					contract: {
+						version,
+						parameters: jsonSchema(tool.parametersSchema),
+						success: jsonSchema(tool.successSchema),
+						failure: jsonSchema(tool.failureSchema),
+						failureMode: tool.failureMode,
+						needsApproval: typeof tool.needsApproval === "function" ? "dynamic" : tool.needsApproval ?? false,
+						executionClass: getToolExecutionClass(tool),
+						executionKind: getToolExecutionKind(tool.annotations),
+						contextRollover: Context.get(tool.annotations, ContextRolloverTool),
+						completion: definition.completion?.tool === tool.name,
+						completionFromTool: definition.completionFromTools?.some((declaration) => declaration.tool === tool.name) ?? false
+					}
+				};
+			});
+		},
+		catch: () => DigestError.make({ message: "Operation contracts require serializable codecs and a version for every Tool" })
+	});
+	return Object.fromEntries(yield* Effect.forEach(declarations, ({ name, contract }) => digestJson(contract).pipe(Effect.map((digest) => [name, digest]))));
+});
+/** Compile current metadata without acquiring executable services. */
+const compileBindingContracts = Effect.fn("AgentRegistration.compileBindingContracts")(function* (definition, definitions, versions) {
+	const digests = yield* digestDefinitions(definitions);
+	const tools = yield* toolReplayContracts(definition, versions, definitions.tools);
+	return { digests: DefinitionDigests.make({
+		...digests,
+		replay: ReplayContract.make({
+			agent: digests.agent,
+			tools
+		})
+	}) };
+});
+const omitTraceContext = Context.omit(Tracer.ParentSpan, Tracer.Tracer, Tracer.MinimumTraceLevel, Tracer.CurrentTraceLevel, References.TracerEnabled, References.TracerTimingEnabled, References.TracerSpanAnnotations, References.TracerSpanLinks);
+const withoutTraceContext = (context) => omitTraceContext(context);
+const captureReporting = (reports) => Effect.map(Effect.context().pipe(Effect.map(withoutTraceContext)), (context) => reports.map((report) => ({
+	...report,
+	prepare: (value) => Effect.scoped(Effect.suspend(() => report.prepare(value))).pipe(Effect.provide(context), Effect.mapError((error) => Schema.is(WorkerReportPreparationFailure)(error) ? error : WorkerReportPreparationFailure.make({ stage: "preparation" })))
+})));
+const backgroundReports = (definition) => [...new Set(Object.values(definition.toolkit.tools).flatMap((tool) => {
+	const report = Context.get(tool.annotations, BackgroundReporting);
+	return report === void 0 ? [] : [report];
+}))];
+const capture = (agent, attemptLayer) => Effect.map(Effect.context().pipe(Effect.map(withoutTraceContext)), (context) => ({
+	agentId: agent.definition.id,
+	definition: agent.definition,
+	attempt: (driver, threadId, claim) => {
+		const execute = driver(agent, threadId, claim);
+		return (attemptLayer === void 0 ? execute : execute.pipe(Effect.provide(Layer.fresh(attemptLayer({
+			threadId,
+			submissionId: claim.submissionId,
+			attemptId: claim.attemptId
+		}))))).pipe(Effect.provide(context));
+	}
+}));
+/**
+* Build one exact worker registration from an executable Agent Binding and
+* its already-computed definition digests.
+*
+* `make(agent, digests)` captures the binding plus its worker-requirement
+* Context at Layer/effect construction time. Hosts that start from application
+* version declarations should use `compileRegistrations`; low-level fixtures
+* may supply a previously computed digest triple directly.
+*/
+const DurableWorkerBinding = { make: (agent, digests, reporting) => Effect.gen(function* () {
+	const binding = yield* capture(agent);
+	const reports = yield* captureReporting([...reporting ?? [], ...backgroundReports(agent.definition)]);
+	return {
+		...binding,
+		digests,
+		reporting: reports
+	};
+}) };
+/** INTERNAL identity-only capture retained for the legacy direct worker path. */
+const makeLegacyWorkerBinding = capture;
+const resolveWorkerBinding = (bindings, agentId) => {
+	const registered = bindings.filter((binding) => binding.agentId === agentId);
+	const binding = registered[0];
+	return registered.length === 1 && binding !== void 0 ? Effect.succeed(binding) : Effect.fail(BindingUnavailable.make({
+		agentId,
+		message: `Exactly one current Agent Binding must be registered for ${agentId}`
+	}));
+};
+/** Resolve authoring-time admission through the one exact host registration, never by identity alone. */
+const resolveDefinitionBinding = (bindings, definition) => {
+	const candidates = bindings.filter((binding) => binding.agentId === definition.id);
+	const binding = candidates[0];
+	if (candidates.length !== 1 || binding === void 0) return Effect.fail(BindingUnavailable.make({
+		agentId: definition.id,
+		message: "Registered admission requires exactly one binding for the Agent identity"
+	}));
+	if (!Object.is(binding.definition, definition)) return Effect.fail(BindingUnavailable.make({
+		agentId: definition.id,
+		message: "Registered admission requires the exact Agent Definition used in registration"
+	}));
+	return Effect.succeed(binding);
+};
+const registrationDefinitions = (entry) => {
+	const definition = entry.model === void 0 ? entry.agent.definition : entry.agent;
+	const automatic = backgroundReports(definition);
+	const declaredDefinitions = definition.updates === void 0 ? entry.definitions : {
+		...entry.definitions,
+		agent: {
+			declaration: entry.definitions.agent,
+			updates: Schema.decodeUnknownSync(Schema.Json)(Tool.getJsonSchemaFromSchema(definition.updates)),
+			updateProtocol: {
+				schemaVersion: 1,
+				tool: "emit_update"
+			}
+		}
+	};
+	const definitions = automatic.length === 0 ? declaredDefinitions : {
+		...declaredDefinitions,
+		agent: {
+			declaration: declaredDefinitions.agent,
+			backgroundReporting: automatic.map((report) => ({
+				delegationId: report.delegationId,
+				targetAgentId: report.target.id,
+				mode: report.mode ?? "custom",
+				destinationDelegationId: report.destination?.delegationId ?? null
+			}))
+		}
+	};
+	const exposure = definition.toolExposure;
+	if (exposure === void 0 && !Object.values(definition.toolkit.tools).some((tool) => Context.get(tool.annotations, DiscoveryTool) || Context.get(tool.annotations, PinnedTool))) return definitions;
+	return {
+		...definitions,
+		agent: {
+			declaration: definitions.agent,
+			toolExposure: {
+				initialToolNames: exposure === void 0 ? null : [...exposure.initialToolNames ?? []],
+				maxTools: exposure?.maxTools ?? 64,
+				maxSchemaBytes: exposure?.maxSchemaBytes ?? 262144,
+				requiredCompletion: definition.completion?.required === true ? definition.completion.tool : null,
+				tools: Object.values(definition.toolkit.tools).map((tool) => ({
+					name: tool.name,
+					pinned: Context.get(tool.annotations, PinnedTool),
+					discovery: Context.get(tool.annotations, DiscoveryTool),
+					namespace: Context.get(tool.annotations, ToolNamespace) ?? null,
+					includesCatalogDocumentation: Context.get(tool.annotations, IncludesCatalogDocumentation),
+					additional: Context.get(tool.annotations, AdditionalToolCatalog).map((entry) => ({
+						name: entry.tool.name,
+						namespace: entry.namespace,
+						method: entry.method
+					}))
+				}))
+			}
+		}
+	};
+};
+const compileRegistration = (entry) => Effect.flatMap(Effect.try({
+	try: () => registrationDefinitions(entry),
+	catch: () => DigestError.make({ message: "Agent update schema has no serializable wire contract" })
+}), (definitions) => Effect.gen(function* () {
+	const binding = yield* capture(entry.model === void 0 ? entry.agent : {
+		definition: entry.agent,
+		model: entry.model
+	}, entry.attemptLayer);
+	const reporting = yield* captureReporting([...entry.reporting ?? [], ...backgroundReports(binding.definition)]);
+	return {
+		...binding,
+		...yield* compileBindingContracts(binding.definition, definitions, entry.continuity?.versions),
+		reporting
+	};
+}));
+/** Compile heterogeneous Agent descriptors into exact, dependency-closed worker registrations. */
+const compileRegistrations = (entries) => {
+	const compileEntry = compileRegistration;
+	return Effect.forEach(entries, compileEntry);
+};
+//#endregion
+export { definitionDigestsEqual as a, resolveWorkerBinding as c, compileRegistrations as i, toolReplayContracts as l, DurableWorkerBinding as n, makeLegacyWorkerBinding as o, compileBindingContracts as r, resolveDefinitionBinding as s, BindingUnavailable as t };
+
+//# sourceMappingURL=agent-registration-B5CI-Ygk.mjs.map

package/dist/agent-registration-B5CI-Ygk.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent-registration-B5CI-Ygk.mjs","names":["run"],"sources":["../src/durable/internal/agent-registration.ts"],"sourcesContent":["import {\n  type Crypto,\n  type Option,\n  type Scope,\n  Context,\n  Effect,\n  Layer,\n  References,\n  Schema,\n  Tracer,\n} from \"effect\";\nimport { Tool } from \"effect/unstable/ai\";\n\nimport type * as Agent from \"../../core/Agent.ts\";\nimport {\n  type InputPromptSource,\n  type InstructionSource,\n  type ModelServices,\n  type RunDispositionDeclaration,\n} from \"../../core/Agent.ts\";\nimport { type ThreadId, AgentId } from \"../../core/Identifiers.ts\";\nimport { getToolExecutionKind } from \"../../core/SubagentContract.ts\";\nimport {\n  AdditionalToolCatalog,\n  DiscoveryTool,\n  IncludesCatalogDocumentation,\n  PinnedTool,\n  ToolNamespace,\n} from \"../../core/ToolExposure.ts\";\nimport { type RuntimeBinding } from \"../../engine/AgentRuntime.ts\";\nimport { ContextRolloverTool } from \"../../engine/ContextWindow.ts\";\nimport { getToolExecutionClass } from \"../../engine/DurableStep.ts\";\nimport {\n  BackgroundReporting,\n  WorkerReportPreparationFailure,\n  type WorkerReporting,\n} from \"../../engine/SubagentHost.ts\";\nimport { digestDefinitions, digestJson, DigestError } from \"../Digest.ts\";\nimport type { DurableWorkerFailure, DurableWorkerRequirements } from \"../DurableAgentRuntime.ts\";\nimport type { DefinitionDigestInput, PersistedJson } from \"../Records.ts\";\nimport { DefinitionDigests, ReplayContract } from \"../Records.ts\";\nimport type { Claim, Settlement } from \"../SubmissionLedger.ts\";\n\n/** No unique current executable is registered for the stable Agent identity. */\nexport class BindingUnavailable extends Schema.TaggedError<BindingUnavailable>()(\n  \"BindingUnavailable\",\n  { agentId: AgentId, message: Schema.String },\n) {}\n\nexport type DurableBindingFailure = BindingUnavailable;\n\n/** Exact immutable admission, lineage and delivery evidence; never an executable-code gate. */\nexport const definitionDigestsEqual = (\n  left: DefinitionDigests,\n  right: DefinitionDigests,\n): boolean =>\n  left.agent === right.agent &&\n  left.model === right.model &&\n  left.tools === right.tools &&\n  Schema.toEquivalence(Schema.UndefinedOr(ReplayContract))(left.replay, right.replay);\n\n/** Change an operation version when its meaning, durable Steps or idempotency keys change. */\nexport interface ReplayVersions {\n  readonly tools: Readonly<Record<string, PersistedJson>>;\n}\n\n/** Hash current operation contracts; no historical definitions or schemas are retained. */\nexport const toolReplayContracts = Effect.fn(\"AgentRegistration.toolReplayContracts\")(function* (\n  definition: Agent.AnyDefinition,\n  versions?: ReplayVersions,\n  fallbackVersion: PersistedJson = null,\n) {\n  const declarations = yield* Effect.try({\n    try: () => {\n      const jsonSchema = (schema: Schema.Top) =>\n        Schema.decodeUnknownSync(Schema.Json)(Tool.getJsonSchemaFromSchema(schema));\n\n      return Object.values(definition.toolkit.tools).map((tool) => {\n        const version = versions === undefined ? fallbackVersion : versions.tools[tool.name];\n\n        if (\n          version === undefined ||\n          (versions !== undefined && !Object.hasOwn(versions.tools, tool.name))\n        )\n          throw new Error(\"Every Tool needs an explicit replay semantic version\");\n\n        return {\n          name: tool.name,\n          contract: {\n            version,\n            parameters: jsonSchema(tool.parametersSchema),\n            success: jsonSchema(tool.successSchema),\n            failure: jsonSchema(tool.failureSchema),\n            failureMode: tool.failureMode,\n            needsApproval:\n              typeof tool.needsApproval === \"function\" ? \"dynamic\" : (tool.needsApproval ?? false),\n            executionClass: getToolExecutionClass(tool),\n            executionKind: getToolExecutionKind(tool.annotations),\n            contextRollover: Context.get(tool.annotations, ContextRolloverTool),\n            completion: definition.completion?.tool === tool.name,\n            completionFromTool:\n              definition.completionFromTools?.some(\n                (declaration) => declaration.tool === tool.name,\n              ) ?? false,\n          },\n        };\n      });\n    },\n    catch: () =>\n      DigestError.make({\n        message: \"Operation contracts require serializable codecs and a version for every Tool\",\n      }),\n  });\n\n  return Object.fromEntries(\n    yield* Effect.forEach(declarations, ({ name, contract }) =>\n      digestJson(contract).pipe(Effect.map((digest) => [name, digest] as const)),\n    ),\n  );\n});\n\n/** Compile current metadata without acquiring executable services. */\nexport const compileBindingContracts = Effect.fn(\"AgentRegistration.compileBindingContracts\")(\n  function* (\n    definition: Agent.AnyDefinition,\n    definitions: DefinitionDigestInput,\n    versions?: ReplayVersions,\n  ): Effect.fn.Return<Pick<ResolvedBinding, \"digests\">, DigestError, Crypto.Crypto> {\n    const digests = yield* digestDefinitions(definitions);\n    const tools = yield* toolReplayContracts(definition, versions, definitions.tools);\n\n    return {\n      digests: DefinitionDigests.make({\n        ...digests,\n        replay: ReplayContract.make({ agent: digests.agent, tools }),\n      }),\n    };\n  },\n);\n\ntype ExecutableDefinition = Agent.AnyDefinition & {\n  readonly instructions: InstructionSource<never, unknown, unknown>;\n  readonly inputPrompt?: InputPromptSource<never, unknown, unknown> | undefined;\n};\n\n/** Executable model Binding accepted by durable registration descriptors. */\nexport type ExecutableAgentBinding = {\n  readonly definition: ExecutableDefinition;\n  readonly model: Layer.Layer<ModelServices, never, unknown>;\n};\n\n/**\n * Internal coordinator entry point for one fenced Attempt over an already-granted claim.\n * The generic signature matches `runAttempt` and is specialized for each captured Agent.\n */\ntype ResolvedAttemptDriver = <\n  InputSchema extends Schema.Top,\n  OutputSchema extends Schema.Top,\n  Instructions,\n  Tools extends Record<string, Tool.Any>,\n  Provider,\n  ModelProvides,\n  ModelRequires,\n  InstructionError,\n  InstructionRequirements,\n  RunDispositionValue extends\n    | RunDispositionDeclaration<OutputSchema[\"Type\"], Schema.Top>\n    | undefined,\n  InputPromptValue extends InputPromptSource<InputSchema[\"Type\"], unknown, unknown> | undefined,\n  UpdatesSchema extends Schema.Top | undefined,\n>(\n  agent: RuntimeBinding<\n    InputSchema,\n    OutputSchema,\n    Instructions,\n    Tools,\n    Provider,\n    ModelProvides,\n    ModelRequires,\n    InstructionError,\n    InstructionRequirements,\n    RunDispositionValue,\n    InputPromptValue,\n    UpdatesSchema\n  >,\n  threadId: ThreadId,\n  claim: Claim,\n) => Effect.Effect<\n  Option.Option<Settlement>,\n  DurableWorkerFailure,\n  DurableWorkerRequirements<\n    RuntimeBinding<\n      InputSchema,\n      OutputSchema,\n      Instructions,\n      Tools,\n      Provider,\n      ModelProvides,\n      ModelRequires,\n      InstructionError,\n      InstructionRequirements,\n      RunDispositionValue,\n      InputPromptValue,\n      UpdatesSchema\n    >,\n    InstructionRequirements\n  >\n>;\n\ntype CapturedAttempt<A extends ExecutableAgentBinding> = (\n  agent: A,\n  threadId: ThreadId,\n  claim: Claim,\n) => Effect.Effect<Option.Option<Settlement>, DurableWorkerFailure, DurableWorkerRequirements<A>>;\n\n/**\n * An Agent with its worker services captured, ready to drive a fenced Attempt.\n * Concrete Schema and model types stay inside this closure when registrations are collected.\n */\ninterface CapturedBinding {\n  readonly agentId: AgentId;\n  /** Exact immutable definition whose codecs and behavior the worker captured. */\n  readonly definition: Agent.AnyDefinition;\n  /** Captured independently from per-Attempt services: report preparation has no fenced Claim. */\n  readonly reporting?: ReadonlyArray<WorkerReporting<WorkerReportPreparationFailure>>;\n  readonly attempt: (\n    driver: ResolvedAttemptDriver,\n    threadId: ThreadId,\n    claim: Claim,\n  ) => Effect.Effect<Option.Option<Settlement>, DurableWorkerFailure>;\n}\n\ntype ReportRequirements<Reports> =\n  Reports extends ReadonlyArray<WorkerReporting<unknown, unknown>>\n    ? [Reports[number]] extends [never]\n      ? never\n      : Reports[number] extends WorkerReporting<unknown, infer R>\n        ? Exclude<R, Scope.Scope>\n        : never\n    : never;\n\n// Registrations outlive their construction span. Dependencies remain captured,\n// while every attempt/report inherits the invoking fiber's tracing state.\nconst omitTraceContext = Context.omit(\n  Tracer.ParentSpan,\n  Tracer.Tracer,\n  Tracer.MinimumTraceLevel,\n  Tracer.CurrentTraceLevel,\n  References.TracerEnabled,\n  References.TracerTimingEnabled,\n  References.TracerSpanAnnotations,\n  References.TracerSpanLinks,\n);\n\n// R describes captured application services; ParentSpan is supplied by the\n// live invocation rather than stored as a registration dependency.\nconst withoutTraceContext = <R>(context: Context.Context<R>): Context.Context<R> =>\n  omitTraceContext(context) as Context.Context<R>;\n\nconst captureReporting = <R>(reports: ReadonlyArray<WorkerReporting<unknown, R>>) =>\n  Effect.map(\n    Effect.context<Exclude<R, Scope.Scope>>().pipe(Effect.map(withoutTraceContext)),\n    (context) =>\n      reports.map((report): WorkerReporting<WorkerReportPreparationFailure> => ({\n        ...report,\n        prepare: (value) =>\n          Effect.scoped(Effect.suspend(() => report.prepare(value))).pipe(\n            Effect.provide(context),\n            Effect.mapError((error) =>\n              Schema.is(WorkerReportPreparationFailure)(error)\n                ? error\n                : WorkerReportPreparationFailure.make({ stage: \"preparation\" }),\n            ),\n          ),\n      })),\n  );\n\nconst backgroundReports = (definition: Agent.AnyDefinition) => [\n  ...new Set(\n    Object.values(definition.toolkit.tools).flatMap((tool) => {\n      const report = Context.get(tool.annotations, BackgroundReporting);\n\n      return report === undefined ? [] : [report];\n    }),\n  ),\n];\n\n/** One exact executable registration used by durable claim-time resolution. */\nexport interface ResolvedBinding extends CapturedBinding {\n  readonly digests: DefinitionDigests;\n}\n\n/** Trusted claim identity for resolving per-Attempt application services. Not model input. */\nexport interface AgentAttemptContext {\n  readonly threadId: ThreadId;\n  readonly submissionId: Claim[\"submissionId\"];\n  readonly attemptId: Claim[\"attemptId\"];\n}\n\nconst capture = <A extends ExecutableAgentBinding, Provides = never, Requires = never>(\n  agent: A,\n  attemptLayer?: (context: AgentAttemptContext) => Layer.Layer<Provides, never, Requires>,\n): Effect.Effect<\n  CapturedBinding,\n  never,\n  Exclude<DurableWorkerRequirements<A>, Provides> | Requires\n> =>\n  Effect.map(\n    Effect.context<Exclude<DurableWorkerRequirements<A>, Provides> | Requires>().pipe(\n      Effect.map(withoutTraceContext),\n    ),\n    (context): CapturedBinding => ({\n      agentId: agent.definition.id,\n      definition: agent.definition,\n      attempt: (driver, threadId, claim) => {\n        // Registration closes one concrete Binding before heterogeneous registrations are\n        // collected. TypeScript cannot instantiate the higher-rank RuntimeBinding parameters\n        // from the intentionally erased public shape, so specialize the driver back to A here.\n        const run = driver as unknown as CapturedAttempt<A>;\n        const execute = run(agent, threadId, claim);\n\n        const scoped =\n          attemptLayer === undefined\n            ? execute\n            : execute.pipe(\n                Effect.provide(\n                  Layer.fresh(\n                    attemptLayer({\n                      threadId,\n                      submissionId: claim.submissionId,\n                      attemptId: claim.attemptId,\n                    }),\n                  ),\n                ),\n              );\n\n        return scoped.pipe(Effect.provide(context)) as Effect.Effect<\n          Option.Option<Settlement>,\n          DurableWorkerFailure\n        >;\n      },\n    }),\n  );\n\n/**\n * Build one exact worker registration from an executable Agent Binding and\n * its already-computed definition digests.\n *\n * `make(agent, digests)` captures the binding plus its worker-requirement\n * Context at Layer/effect construction time. Hosts that start from application\n * version declarations should use `compileRegistrations`; low-level fixtures\n * may supply a previously computed digest triple directly.\n */\nexport const DurableWorkerBinding = {\n  make: <\n    A extends ExecutableAgentBinding,\n    const Reports extends ReadonlyArray<WorkerReporting<unknown, unknown>> = readonly [],\n  >(\n    agent: A,\n    digests: DefinitionDigests,\n    reporting?: Reports,\n  ): Effect.Effect<\n    ResolvedBinding,\n    never,\n    DurableWorkerRequirements<A> | ReportRequirements<Reports>\n  > =>\n    Effect.gen(function* () {\n      const binding = yield* capture(agent);\n\n      const reports = yield* captureReporting([\n        ...(reporting ?? []),\n        ...backgroundReports(agent.definition),\n      ]);\n\n      return { ...binding, digests, reporting: reports };\n    }) as Effect.Effect<\n      ResolvedBinding,\n      never,\n      DurableWorkerRequirements<A> | ReportRequirements<Reports>\n    >,\n} as const;\n\n/** INTERNAL identity-only capture retained for the legacy direct worker path. */\nexport const makeLegacyWorkerBinding = capture;\n\nexport const resolveWorkerBinding = (\n  bindings: ReadonlyArray<ResolvedBinding>,\n  agentId: AgentId,\n): Effect.Effect<ResolvedBinding, BindingUnavailable> => {\n  const registered = bindings.filter((binding) => binding.agentId === agentId);\n  const binding = registered[0];\n\n  return registered.length === 1 && binding !== undefined\n    ? Effect.succeed(binding)\n    : Effect.fail(\n        BindingUnavailable.make({\n          agentId,\n          message: `Exactly one current Agent Binding must be registered for ${agentId}`,\n        }),\n      );\n};\n\n/** Resolve authoring-time admission through the one exact host registration, never by identity alone. */\nexport const resolveDefinitionBinding = (\n  bindings: ReadonlyArray<ResolvedBinding>,\n  definition: Pick<Agent.AnyDefinition, \"id\">,\n): Effect.Effect<ResolvedBinding, BindingUnavailable> => {\n  const candidates = bindings.filter((binding) => binding.agentId === definition.id);\n  const binding = candidates[0];\n\n  if (candidates.length !== 1 || binding === undefined) {\n    return Effect.fail(\n      BindingUnavailable.make({\n        agentId: definition.id,\n        message: \"Registered admission requires exactly one binding for the Agent identity\",\n      }),\n    );\n  }\n\n  if (!Object.is(binding.definition, definition)) {\n    return Effect.fail(\n      BindingUnavailable.make({\n        agentId: definition.id,\n        message: \"Registered admission requires the exact Agent Definition used in registration\",\n      }),\n    );\n  }\n\n  return Effect.succeed(binding);\n};\n\n/** Application versions and a model Layer, supplied directly or through an existing Binding. */\nexport type AgentRegistration<A extends ExecutableAgentBinding = ExecutableAgentBinding> = (\n  | { readonly agent: A; readonly model?: never; readonly definitions: DefinitionDigestInput }\n  | {\n      readonly agent: A[\"definition\"];\n      readonly model: A[\"model\"];\n      readonly definitions: DefinitionDigestInput;\n    }\n) & {\n  /** Explicit operation versions let unchanged unfinished handlers survive toolbox changes. */\n  readonly continuity?: {\n    readonly versions: ReplayVersions;\n  };\n  /**\n   * Source-owned reports capture services outside attemptLayer and open a fresh Scope per\n   * preparation. Version changes with this registration. Missing exact code and preparation\n   * failures become retained report refusals; durable delivery retries reuse the frozen input.\n   */\n  readonly reporting?: ReadonlyArray<WorkerReporting<unknown, unknown>>;\n  /**\n   * Build fresh services for exactly one fenced Attempt, across all its Tool/model turns.\n   * Finalizes on completion, suspension, failure and interruption. Never reused after eviction.\n   * Resolve invocation authority from the trusted claim identity, not captured caller state.\n   * Keep fallible resource acquisition lazy in typed Tool operations; this Layer cannot fail.\n   */\n  readonly attemptLayer?: (context: AgentAttemptContext) => Layer.Layer<never, never, unknown>;\n};\n\ntype EntryWorkerRequirements<Entry> = Entry extends {\n  readonly agent: infer A extends ExecutableAgentBinding;\n}\n  ? DurableWorkerRequirements<A>\n  : Entry extends {\n        readonly agent: infer D extends ExecutableDefinition;\n        readonly model: infer M extends ExecutableAgentBinding[\"model\"];\n      }\n    ? DurableWorkerRequirements<{ readonly definition: D; readonly model: M }>\n    : never;\n\ntype AttemptLayerRequirements<Requirements, AttemptLayer> = AttemptLayer extends (\n  context: AgentAttemptContext,\n) => Layer.Layer<infer Provides, never, infer Requires>\n  ? Exclude<Requirements, Provides> | Requires\n  : Requirements;\n\n// Conditional options retain every service they may consume. An absent attempt Layer\n// still needs the original worker services; only a definite Layer can remove them.\ntype EntryRequirements<Entry> = Entry extends unknown\n  ?\n      | AttemptLayerRequirements<\n          EntryWorkerRequirements<Entry>,\n          \"attemptLayer\" extends keyof Entry ? Entry[\"attemptLayer\"] : undefined\n        >\n      | (\"reporting\" extends keyof Entry ? ReportRequirements<Entry[\"reporting\"]> : never)\n  : never;\n\ntype RegistrationRequirements<Entries extends ReadonlyArray<AgentRegistration>> = [\n  Entries[number],\n] extends [never]\n  ? never\n  : EntryRequirements<Entries[number]>;\n\nconst registrationDefinitions = (entry: AgentRegistration): DefinitionDigestInput => {\n  const definition = entry.model === undefined ? entry.agent.definition : entry.agent;\n  const automatic = backgroundReports(definition);\n\n  const declaredDefinitions =\n    definition.updates === undefined\n      ? entry.definitions\n      : {\n          ...entry.definitions,\n          agent: {\n            declaration: entry.definitions.agent,\n            updates: Schema.decodeUnknownSync(Schema.Json)(\n              Tool.getJsonSchemaFromSchema(definition.updates),\n            ),\n            updateProtocol: { schemaVersion: 1, tool: \"emit_update\" },\n          },\n        };\n\n  const definitions =\n    automatic.length === 0\n      ? declaredDefinitions\n      : {\n          ...declaredDefinitions,\n          agent: {\n            declaration: declaredDefinitions.agent,\n            backgroundReporting: automatic.map((report) => ({\n              delegationId: report.delegationId,\n              targetAgentId: report.target.id,\n              mode: report.mode ?? \"custom\",\n              destinationDelegationId: report.destination?.delegationId ?? null,\n            })),\n          },\n        };\n\n  const exposure = definition.toolExposure;\n\n  if (\n    exposure === undefined &&\n    !Object.values(definition.toolkit.tools).some(\n      (tool) =>\n        Context.get(tool.annotations, DiscoveryTool) || Context.get(tool.annotations, PinnedTool),\n    )\n  )\n    return definitions;\n\n  return {\n    ...definitions,\n    agent: {\n      declaration: definitions.agent,\n      toolExposure: {\n        initialToolNames: exposure === undefined ? null : [...(exposure.initialToolNames ?? [])],\n        maxTools: exposure?.maxTools ?? 64,\n        maxSchemaBytes: exposure?.maxSchemaBytes ?? 262_144,\n        requiredCompletion:\n          definition.completion?.required === true ? definition.completion.tool : null,\n        tools: Object.values(definition.toolkit.tools).map((tool) => ({\n          name: tool.name,\n          pinned: Context.get(tool.annotations, PinnedTool),\n          discovery: Context.get(tool.annotations, DiscoveryTool),\n          namespace: Context.get(tool.annotations, ToolNamespace) ?? null,\n          includesCatalogDocumentation: Context.get(tool.annotations, IncludesCatalogDocumentation),\n          additional: Context.get(tool.annotations, AdditionalToolCatalog).map((entry) => ({\n            name: entry.tool.name,\n            namespace: entry.namespace,\n            method: entry.method,\n          })),\n        })),\n      },\n    },\n  };\n};\n\nconst compileRegistration = <Entry extends AgentRegistration>(\n  entry: Entry,\n): Effect.Effect<ResolvedBinding, DigestError, Crypto.Crypto | EntryRequirements<Entry>> =>\n  Effect.flatMap(\n    Effect.try({\n      try: () => registrationDefinitions(entry),\n      catch: () =>\n        DigestError.make({ message: \"Agent update schema has no serializable wire contract\" }),\n    }),\n    (definitions) =>\n      Effect.gen(function* () {\n        const binding = yield* capture(\n          entry.model === undefined ? entry.agent : { definition: entry.agent, model: entry.model },\n          entry.attemptLayer,\n        );\n\n        const reporting = yield* captureReporting([\n          ...(entry.reporting ?? []),\n          ...backgroundReports(binding.definition),\n        ]);\n\n        return {\n          ...binding,\n          ...(yield* compileBindingContracts(\n            binding.definition,\n            definitions,\n            entry.continuity?.versions,\n          )),\n          reporting,\n        };\n      }),\n    // The erased descriptor accepts arbitrary provided services. Restore the concrete entry's\n    // Exclude<worker requirements, provided services> | layer requirements at this collection seam.\n  ) as Effect.Effect<ResolvedBinding, DigestError, Crypto.Crypto | EntryRequirements<Entry>>;\n\n/** Compile heterogeneous Agent descriptors into exact, dependency-closed worker registrations. */\nexport const compileRegistrations = <const Entries extends ReadonlyArray<AgentRegistration>>(\n  entries: Entries,\n): Effect.Effect<\n  ReadonlyArray<ResolvedBinding>,\n  DigestError,\n  Crypto.Crypto | RegistrationRequirements<Entries>\n> => {\n  // `Effect.forEach` instantiates a generic callback at its constraint. Specialize the callback to\n  // this tuple's distributed requirement union before collection so empty and heterogeneous tuples\n  // retain their exact service requirements.\n  const compileEntry = compileRegistration as unknown as (\n    entry: Entries[number],\n  ) => Effect.Effect<\n    ResolvedBinding,\n    DigestError,\n    Crypto.Crypto | RegistrationRequirements<Entries>\n  >;\n\n  return Effect.forEach(entries, compileEntry);\n};\n"],"mappings":"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"}

package/dist/capabilities/Approval.d.mts

@@ -0,0 +1,114 @@
+import { RedactionError, Redactor } from "./Redaction.mjs";
+import { Context, Effect, Layer, Schema } from "effect";
+declare namespace Approval_d_exports {
+  export { ApprovalApproved, ApprovalAudit, ApprovalAuditEvent, ApprovalAuditEvents, ApprovalAuditLimitExceeded, ApprovalAuditMemoryLive, ApprovalDecision, ApprovalDecisionMismatch, ApprovalDecisionRecorded, ApprovalDenied, ApprovalDenyAll, ApprovalRequest, ApprovalRequestDraft, ApprovalRequestRecorded, ApprovalResolver, ApprovalResolverError, ApprovalTimedOut, makeApprovalRequest, requestApproval };
+}
+declare const ApprovalRequestDraft_base: Schema.Class<ApprovalRequestDraft, Schema.Struct<{
+  readonly requestId: Schema.NonEmptyString;
+  readonly runId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/RunId">;
+  readonly threadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+  readonly toolCallId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ToolCallId">;
+  readonly toolName: Schema.NonEmptyString;
+  readonly actionSummary: Schema.String;
+  readonly resourceTargets: Schema.refine<readonly string[], Schema.$Array<Schema.String>>;
+  readonly risk: Schema.Literals<readonly ["low", "medium", "high", "critical"]>;
+  readonly expiresAt: Schema.DateTimeUtcFromString;
+  readonly denial: Schema.Literals<readonly ["terminal", "recoverable"]>;
+}>, {}>;
+/** Decoded approval metadata before the Redactor owns Tool input preview creation. */
+export declare class ApprovalRequestDraft extends ApprovalRequestDraft_base {}
+declare const ApprovalRequest_base: Schema.Class<ApprovalRequest, Schema.Struct<{
+  readonly requestId: Schema.NonEmptyString;
+  readonly runId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/RunId">;
+  readonly threadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+  readonly toolCallId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ToolCallId">;
+  readonly toolName: Schema.NonEmptyString;
+  readonly actionSummary: Schema.String;
+  readonly resourceTargets: Schema.refine<readonly string[], Schema.$Array<Schema.String>>;
+  readonly risk: Schema.Literals<readonly ["low", "medium", "high", "critical"]>;
+  readonly expiresAt: Schema.DateTimeUtcFromString;
+  readonly denial: Schema.Literals<readonly ["terminal", "recoverable"]>;
+  readonly redactedInputPreview: Schema.brand<Schema.refine<string, Schema.String>, "@effect-agent/capabilities/RedactedPreview">;
+}>, {}>;
+/** Fully decoded, structurally redacted approval input. */
+export declare class ApprovalRequest extends ApprovalRequest_base {}
+declare const ApprovalApproved_base: Schema.Class<ApprovalApproved, Schema.TaggedStruct<"ApprovalApproved", {
+  readonly requestId: Schema.NonEmptyString;
+  readonly decidedAt: Schema.DateTimeUtcFromString;
+  readonly resolver: Schema.NonEmptyString;
+}>, {}>;
+export declare class ApprovalApproved extends ApprovalApproved_base {}
+declare const ApprovalDenied_base: Schema.Class<ApprovalDenied, Schema.TaggedStruct<"ApprovalDenied", {
+  readonly requestId: Schema.NonEmptyString;
+  readonly decidedAt: Schema.DateTimeUtcFromString;
+  readonly resolver: Schema.NonEmptyString;
+  readonly reason: Schema.String;
+  readonly timedOut: Schema.Boolean;
+}>, {}>;
+export declare class ApprovalDenied extends ApprovalDenied_base {}
+export declare const ApprovalDecision: Schema.Union<readonly [typeof ApprovalApproved, typeof ApprovalDenied]>;
+export type ApprovalDecision = typeof ApprovalDecision.Type;
+declare const ApprovalResolverError_base: Schema.Class<ApprovalResolverError, Schema.TaggedStruct<"ApprovalResolverError", {
+  readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/** Resolver infrastructure failed before it could make a policy decision. */
+export declare class ApprovalResolverError extends ApprovalResolverError_base {}
+declare const ApprovalTimedOut_base: Schema.Class<ApprovalTimedOut, Schema.TaggedStruct<"ApprovalTimedOut", {
+  readonly requestId: Schema.NonEmptyString;
+}>, import("effect/Cause").YieldableError>;
+/** The resolver explicitly observed its request deadline; callers turn this into a denial. */
+export declare class ApprovalTimedOut extends ApprovalTimedOut_base {}
+declare const ApprovalResolver_base: Context.ServiceClass<ApprovalResolver, "@effect-agent/capabilities/ApprovalResolver", {
+  readonly request: (request: ApprovalRequest) => Effect.Effect<ApprovalDecision, ApprovalResolverError | ApprovalTimedOut>;
+}>;
+/** First-class approval authority. Interactive, policy, and remote adapters implement this service. */
+export declare class ApprovalResolver extends ApprovalResolver_base {}
+declare const ApprovalRequestRecorded_base: Schema.Class<ApprovalRequestRecorded, Schema.TaggedStruct<"ApprovalRequestRecorded", {
+  readonly sequence: Schema.Natural;
+  readonly recordedAt: Schema.DateTimeUtcFromString;
+  readonly request: typeof ApprovalRequest;
+}>, {}>;
+export declare class ApprovalRequestRecorded extends ApprovalRequestRecorded_base {}
+declare const ApprovalDecisionRecorded_base: Schema.Class<ApprovalDecisionRecorded, Schema.TaggedStruct<"ApprovalDecisionRecorded", {
+  readonly sequence: Schema.Natural;
+  readonly recordedAt: Schema.DateTimeUtcFromString;
+  readonly decision: Schema.Union<readonly [typeof ApprovalApproved, typeof ApprovalDenied]>;
+}>, {}>;
+export declare class ApprovalDecisionRecorded extends ApprovalDecisionRecorded_base {}
+export declare const ApprovalAuditEvent: Schema.Union<readonly [typeof ApprovalRequestRecorded, typeof ApprovalDecisionRecorded]>;
+export type ApprovalAuditEvent = typeof ApprovalAuditEvent.Type;
+export declare const ApprovalAuditEvents: Schema.$Array<Schema.Union<readonly [typeof ApprovalRequestRecorded, typeof ApprovalDecisionRecorded]>>;
+declare const ApprovalAuditLimitExceeded_base: Schema.Class<ApprovalAuditLimitExceeded, Schema.TaggedStruct<"ApprovalAuditLimitExceeded", {
+  readonly limitValue: Schema.Natural;
+  readonly observedValue: Schema.Natural;
+}>, import("effect/Cause").YieldableError>;
+export declare class ApprovalAuditLimitExceeded extends ApprovalAuditLimitExceeded_base {}
+declare const ApprovalDecisionMismatch_base: Schema.Class<ApprovalDecisionMismatch, Schema.TaggedStruct<"ApprovalDecisionMismatch", {
+  readonly expectedRequestId: Schema.NonEmptyString;
+  readonly observedRequestId: Schema.NonEmptyString;
+}>, import("effect/Cause").YieldableError>;
+/** A resolver or audit sink tried to associate a decision with another request. */
+export declare class ApprovalDecisionMismatch extends ApprovalDecisionMismatch_base {}
+declare const ApprovalAudit_base: Context.ServiceClass<ApprovalAudit, "@effect-agent/capabilities/ApprovalAudit", {
+  readonly recordRequest: (request: ApprovalRequest) => Effect.Effect<void, ApprovalAuditLimitExceeded>;
+  readonly recordDecision: (decision: ApprovalDecision) => Effect.Effect<void, ApprovalAuditLimitExceeded | ApprovalDecisionMismatch>;
+  readonly events: Effect.Effect<ReadonlyArray<ApprovalAuditEvent>>;
+}>;
+/** P2 semantic audit sink; durable runtimes replace this with canonical records. */
+export declare class ApprovalAudit extends ApprovalAudit_base {}
+/** Scoped in-memory audit projection with monotonic event order. */
+export declare const ApprovalAuditMemoryLive: Layer.Layer<ApprovalAudit, never, never>;
+/** Construct an ApprovalRequest only after decoded input passes the configured Redactor. */
+export declare const makeApprovalRequest: (draft: ApprovalRequestDraft, decodedToolInput: unknown) => Effect.Effect<ApprovalRequest, RedactionError, Redactor>;
+/**
+ * Resolve with fail-closed deadline semantics and record request/decision audit
+ * events around every successful, denied, timed-out, or resolver-failed
+ * resolution. A resolver infrastructure failure records a synthetic denial so
+ * the audit reservation is released before the typed error propagates.
+ */
+export declare const requestApproval: (request: ApprovalRequest) => Effect.Effect<ApprovalApproved | ApprovalDenied, ApprovalAuditLimitExceeded | ApprovalDecisionMismatch | ApprovalResolverError, ApprovalAudit | ApprovalResolver>;
+/** Deterministic policy layer for tests and deny-by-default deployments. */
+export declare const ApprovalDenyAll: Layer.Layer<ApprovalResolver, never, never>;
+//#endregion
+export { Approval_d_exports as t };
+//# sourceMappingURL=Approval.d.mts.map