effect-agent 0.1.0-beta.12 → 0.1.0-beta.121

package/dist/index.mjs

@@ -1,6 +1,100 @@
-import { CommandDrainPolicy, RunSchedulingOverride } from "@effect-agent/capabilities";
-import { delegationToolPrefix, isDelegationToolName } from "@effect-agent/core";
-export * from "@effect-agent/capabilities";
-export * from "@effect-agent/core";
-export * from "@effect-agent/engine";
-export { CommandDrainPolicy, RunSchedulingOverride, delegationToolPrefix, isDelegationToolName };
+import { t as Identifiers_exports } from "./core/Identifiers.mjs";
+import { t as ToolResult_exports } from "./core/ToolResult.mjs";
+import { t as AgentPolicy_exports } from "./core/AgentPolicy.mjs";
+import { t as Receipt_exports } from "./core/Receipt.mjs";
+import { t as AgentUpdates_exports } from "./core/AgentUpdates.mjs";
+import { t as Agent_exports } from "./Agent-1DMSO_Fl.mjs";
+import { a as FailureDiagnostic_exports } from "./FailureDiagnostic-BElLOoED.mjs";
+import { t as AgentError_exports } from "./core/AgentError.mjs";
+import { t as IdGenerator_exports } from "./core/IdGenerator.mjs";
+import { t as SubagentContract_exports } from "./core/SubagentContract.mjs";
+import { t as Usage_exports } from "./core/Usage.mjs";
+import { t as RunEvent_exports } from "./core/RunEvent.mjs";
+import { x as Worker_exports } from "./Worker-CfwzMZEK.mjs";
+import { n as MessagingHost_exports } from "./MessagingHost-DfsbMPvq.mjs";
+import { t as SubagentHost_exports } from "./engine/SubagentHost.mjs";
+import { t as Thread_exports } from "./core/Thread.mjs";
+import { t as ThreadHistory_exports } from "./engine/ThreadHistory.mjs";
+import { t as AgentRuntime_exports } from "./AgentRuntime-Cp1hAb-W.mjs";
+import { t as ContextWindow_exports } from "./engine/ContextWindow.mjs";
+import { t as DurableStep_exports } from "./engine/DurableStep.mjs";
+import { t as ContextCompactor_exports } from "./engine/ContextCompactor.mjs";
+import { t as RunEventSink_exports } from "./engine/RunEventSink.mjs";
+import { t as MemoryReference_exports } from "./core/MemoryReference.mjs";
+import { t as RunPolicyUsage_exports } from "./core/RunPolicyUsage.mjs";
+import { t as RunOptions_exports } from "./engine/RunOptions.mjs";
+import { t as ToolBroker_exports } from "./engine/ToolBroker.mjs";
+import { t as Redaction_exports } from "./capabilities/Redaction.mjs";
+import { t as Approval_exports } from "./capabilities/Approval.mjs";
+import { t as Budget_exports } from "./capabilities/Budget.mjs";
+import { t as Sandbox_exports } from "./sandbox/Sandbox.mjs";
+import { t as CodeExecutor_exports } from "./sandbox/CodeExecutor.mjs";
+import { t as CodeMode_exports } from "./capabilities/CodeMode.mjs";
+import { t as Commands_exports } from "./capabilities/Commands.mjs";
+import { t as Compaction_exports } from "./engine/Compaction.mjs";
+import { t as ContextHistory_exports } from "./engine/ContextHistory.mjs";
+import { t as ContextTools_exports } from "./capabilities/ContextTools.mjs";
+import { t as SubagentReservations_exports } from "./capabilities/SubagentReservations.mjs";
+import { t as InMemory_exports } from "./InMemory.mjs";
+import { t as InteractiveBrowser_exports } from "./sandbox/InteractiveBrowser.mjs";
+import { t as Mcp_exports } from "./capabilities/Mcp.mjs";
+import { t as McpClient_exports } from "./capabilities/McpClient.mjs";
+import { t as Memory_exports } from "./core/Memory.mjs";
+import { t as MemoryNamespace_exports } from "./core/MemoryNamespace.mjs";
+import { t as MemoryStore_exports } from "./core/MemoryStore.mjs";
+import { t as MemoryNotes_exports } from "./capabilities/MemoryNotes.mjs";
+import { t as MemoryRevalidation_exports } from "./core/MemoryRevalidation.mjs";
+import { t as Messaging_exports } from "./capabilities/Messaging.mjs";
+import { t as ModelContext_exports } from "./capabilities/ModelContext.mjs";
+import { t as Output_exports } from "./engine/Output.mjs";
+import { t as PageCapture_exports } from "./sandbox/PageCapture.mjs";
+import { t as PageCrawl_exports } from "./sandbox/PageCrawl.mjs";
+import { t as PageScreenshot_exports } from "./sandbox/PageScreenshot.mjs";
+import { t as ProtectedBrowser_exports } from "./sandbox/ProtectedBrowser.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-DCrB7an7.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-B-9w7jDt.mjs";
+import { n as RunJournal_exports } from "./RunJournal-BXrq0VIK.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 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 WakeScheduler_exports } from "./durable/WakeScheduler.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 SqlThreadNativeReads_exports } from "./durable/SqlThreadNativeReads.mjs";
+export { ActivityStore_exports as ActivityStore, Admin_exports as Admin, Agent_exports as Agent, AgentError_exports as AgentError, AgentPolicy_exports as AgentPolicy, AgentRegistration_exports as AgentRegistration, AgentRuntime_exports as AgentRuntime, AgentUpdates_exports as AgentUpdates, Approval_exports as Approval, Budget_exports as Budget, CodeExecutor_exports as CodeExecutor, CodeMode_exports as CodeMode, Commands_exports as Commands, CommittedActivity_exports as CommittedActivity, Compaction_exports as Compaction, ContextCompactor_exports as ContextCompactor, ContextHistory_exports as ContextHistory, ContextTools_exports as ContextTools, ContextWindow_exports as ContextWindow, Digest_exports as Digest, DurableAgentRuntime_exports as DurableAgentRuntime, DurableFailpoint_exports as DurableFailpoint, DurableStep_exports as DurableStep, EventSource_exports as EventSource, FailureDiagnostic_exports as FailureDiagnostic, IdGenerator_exports as IdGenerator, Identifiers_exports as Identifiers, InMemory_exports as InMemory, InteractiveBrowser_exports as InteractiveBrowser, 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, ProtectedBrowser_exports as ProtectedBrowser, 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, SqlThreadNativeReads_exports as SqlThreadNativeReads, 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, WorkerHost_exports as WorkerHost };

package/dist/output-contract-BC7tjlGw.mjs

@@ -0,0 +1,84 @@
+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;
+};
+/**
+* Insert the contract immediately after the request prompt's last system
+* message (position 0 when none exists), extending the last contiguous
+* system block. Placement is normative: the Anthropic provider replaces its
+* top-level `system` parameter per contiguous system group, so only the last
+* block survives there — an isolated trailing contract message would discard
+* the author's instructions, and a contract inside an earlier block (for
+* example a resumed Thread's original instructions ahead of this Run's
+* evaluated instructions) would itself be discarded. Extending the last
+* block keeps author content and contract together on every provider and
+* preserves the author's per-message cache-control annotations.
+*/
+const insertOutputContract = (prompt, message) => {
+	const content = prompt.content;
+	let insertAt = 0;
+	for (let index = 0; index < content.length; index += 1) if (content[index]?.role === "system") insertAt = index + 1;
+	return Prompt.fromMessages([
+		...content.slice(0, insertAt),
+		message,
+		...content.slice(insertAt)
+	]);
+};
+//#endregion
+export { textOutput as i, isTextOutput as n, outputSchemaContract as r, insertOutputContract as t };
+
+//# sourceMappingURL=output-contract-BC7tjlGw.mjs.map

package/dist/output-contract-BC7tjlGw.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"output-contract-BC7tjlGw.mjs","names":[],"sources":["../src/engine/internal/output-contract.ts"],"sourcesContent":["import { Schema } from \"effect\";\nimport { Prompt, Tool } from \"effect/unstable/ai\";\n\nimport type * as Agent from \"../../core/Agent.ts\";\n\nconst outputFormatAnnotation = \"@effect-agent/engine/Output/format\";\n\n/**\n * Declare ordinary assistant text as an Agent's final-output wire format. Apply this to the\n * complete output Schema after composing transformations. Its encoded type must be string;\n * decoding, checks, transformations, and service requirements remain owned by that Schema.\n * Text is preserved verbatim, including whitespace, quotes, and an empty reply when allowed.\n * Required completion Tools still take precedence. Unmarked Schemas use JSON final output.\n *\n * @example\n * ```ts\n * output: Output.text(Schema.String.check(Schema.isMaxLength(20_000)))\n * ```\n */\nexport const textOutput = <S extends Schema.Top & { readonly Encoded: string }>(\n  schema: S,\n): S[\"Rebuild\"] => schema.annotate({ [outputFormatAnnotation]: \"text\" });\n\nexport const isTextOutput = (schema: Schema.Top): boolean =>\n  Schema.resolveAnnotations(schema)?.[outputFormatAnnotation] === \"text\";\n\n/**\n * Model-visible final-output contract (RUN-028).\n *\n * For ordinary text completion, the interpreter's only output-conformance\n * point is `decodeFinalOutput`, which validates the final text after the\n * model has already finished. This module renders that Schema's wire contract\n * with the same Effect AI derivation the providers use for Tool parameters\n * and states it as one framework-owned system message on every model request.\n * A required completion Tool instead gets a native-tool directive: its Tool\n * parameter Schema is already carried by the provider request, and ordinary\n * final text is not an allowed completion path.\n *\n * The contract is a per-request projection of the immutable definition —\n * exactly like the Tool schemas the request already carries. It is inserted\n * at model-request materialization (after context preparation) and never\n * into official history, so canonical records, run events, and the committed\n * DN/DC golden are unchanged.\n *\n */\n\n/** Rendering outcome for one definition's output Schema. */\ntype OutputContract =\n  | {\n      readonly _tag: \"rendered\";\n      /** The complete system-message text: directive plus the derived JSON Schema. */\n      readonly message: string;\n      readonly part: Prompt.SystemMessage;\n    }\n  | {\n      readonly _tag: \"unrenderable\";\n      /** Why Effect AI's JSON-Schema derivation rejected the output Schema. */\n      readonly reason: string;\n    };\n\nconst contractDirective = (definition: Agent.AnyDefinition): string =>\n  definition.completion === undefined\n    ? \"Final output contract: when the task is complete, the final assistant message must be only \" +\n      \"JSON that is valid against this JSON Schema — no prose, no Markdown code fences, nothing \" +\n      \"before or after the JSON.\"\n    : `Final output contract: when the task is complete without calling the \"${definition.completion.tool}\" completion Tool, the final assistant message must be only ` +\n      \"JSON that is valid against this JSON Schema — no prose, no Markdown code fences, nothing \" +\n      `before or after the JSON. When calling the \"${definition.completion.tool}\" completion Tool, never place this private Agent output JSON in any Tool argument; follow the Tool's parameter schema instead. Call it as the sole application Tool Call, after receiving any other needed application Tool results. Completed provider Tool results may accompany it. The engine projects the successful completion Tool result into the Agent output.`;\n\nconst requiredCompletionDirective = (tool: string, hasAlternatives: boolean): string =>\n  `Final output contract: ${hasAlternatives ? \"otherwise complete\" : \"complete only\"} by calling the required completion Tool ${JSON.stringify(tool)} ` +\n  \"as the sole application Tool Call in its batch. Completed provider Tool results may accompany it. Do not emit an ordinary final assistant text answer. \" +\n  \"The Tool's canonical parameters and successful result are projected and validated as the Agent output.\";\n\n/**\n * Render the model-visible final-output contract for one definition. The\n * derivation and message identity are stable for an immutable definition.\n * An output Schema the Effect AI derivation cannot represent is reported as\n * `unrenderable`; the caller falls back to the prior behavior — the contract\n * is guidance, and a Schema that decodes but does not render must not become\n * a new failure mode.\n */\nconst rendered = (message: string): OutputContract => ({\n  _tag: \"rendered\",\n  message,\n  part: Prompt.makeMessage(\"system\", { content: message }),\n});\n\nconst renderOutputSchemaContract = (definition: Agent.AnyDefinition): OutputContract => {\n  if (definition.completion?.required === true) {\n    return rendered(\n      requiredCompletionDirective(\n        definition.completion.tool,\n        (definition.completionFromTools?.length ?? 0) > 0,\n      ),\n    );\n  }\n  if (isTextOutput(definition.output)) {\n    return rendered(\n      \"Final output contract: write the final reply as ordinary assistant text, without JSON wrapping. \" +\n        \"An empty reply is valid only when allowed by the output Schema and the task instructions.\" +\n        (definition.completion === undefined\n          ? \"\"\n          : ` When calling the \"${definition.completion.tool}\" completion Tool, follow its parameter schema instead and call it as the sole application Tool Call, after receiving any other needed application Tool results; completed provider Tool results may accompany it; the engine projects its successful result into the Agent output.`),\n    );\n  }\n  try {\n    const jsonSchema = Tool.getJsonSchemaFromSchema(definition.output);\n\n    return rendered(\n      `${contractDirective(definition)}\\n\\n${JSON.stringify(jsonSchema, undefined, 2)}`,\n    );\n  } catch (cause) {\n    return {\n      _tag: \"unrenderable\",\n      reason: cause instanceof Error ? cause.message : String(cause),\n    };\n  }\n};\n\n// Native incremental-response tracking recognizes message objects, not rendered text.\n// Weak keys retain neither discarded definitions nor their Schema graphs.\nconst outputContracts = new WeakMap<Agent.AnyDefinition, OutputContract>();\n\nexport const outputSchemaContract = (definition: Agent.AnyDefinition): OutputContract => {\n  const cached = outputContracts.get(definition);\n\n  if (cached !== undefined) return cached;\n  const base = renderOutputSchemaContract(definition);\n  const alternatives = definition.completionFromTools ?? [];\n\n  const contract =\n    base._tag === \"rendered\" && alternatives.length > 0\n      ? rendered(\n          `The following action Tools may complete the Run from their successful canonical result: ${alternatives.map((declaration) => JSON.stringify(declaration.tool)).join(\", \")}. ` +\n            \"Call such a Tool as the sole application Tool Call, following its parameter schema. Completed provider Tool results may accompany it. It may complete the Run only when it satisfies the whole request. \" +\n            \"An incomplete or pending result continues the Run. These actions are unavailable during finalization after budget exhaustion.\\n\\n\" +\n            base.message,\n        )\n      : base;\n\n  outputContracts.set(definition, contract);\n\n  return contract;\n};\n\n/**\n * Insert the contract immediately after the request prompt's last system\n * message (position 0 when none exists), extending the last contiguous\n * system block. Placement is normative: the Anthropic provider replaces its\n * top-level `system` parameter per contiguous system group, so only the last\n * block survives there — an isolated trailing contract message would discard\n * the author's instructions, and a contract inside an earlier block (for\n * example a resumed Thread's original instructions ahead of this Run's\n * evaluated instructions) would itself be discarded. Extending the last\n * block keeps author content and contract together on every provider and\n * preserves the author's per-message cache-control annotations.\n */\nexport const insertOutputContract = (\n  prompt: Prompt.Prompt,\n  message: Prompt.SystemMessage,\n): Prompt.Prompt => {\n  const content = prompt.content;\n  let insertAt = 0;\n\n  for (let index = 0; index < content.length; index += 1) {\n    if (content[index]?.role === \"system\") {\n      insertAt = index + 1;\n    }\n  }\n\n  return Prompt.fromMessages([...content.slice(0, insertAt), message, ...content.slice(insertAt)]);\n};\n"],"mappings":";;;AAKA,MAAM,yBAAyB;;;;;;;;;;;;;AAc/B,MAAa,cACX,WACiB,OAAO,SAAS,GAAG,yBAAyB,OAAO,CAAC;AAEvE,MAAa,gBAAgB,WAC3B,OAAO,mBAAmB,MAAM,CAAC,GAAG,4BAA4B;AAoClE,MAAM,qBAAqB,eACzB,WAAW,eAAe,KAAA,IACtB,kNAGA,yEAAyE,WAAW,WAAW,KAAK,mMAErD,WAAW,WAAW,KAAK;AAEhF,MAAM,+BAA+B,MAAc,oBACjD,0BAA0B,kBAAkB,uBAAuB,gBAAgB,2CAA2C,KAAK,UAAU,IAAI,EAAE;;;;;;;;;AAYrJ,MAAM,YAAY,aAAqC;CACrD,MAAM;CACN;CACA,MAAM,OAAO,YAAY,UAAU,EAAE,SAAS,QAAQ,CAAC;AACzD;AAEA,MAAM,8BAA8B,eAAoD;CACtF,IAAI,WAAW,YAAY,aAAa,MACtC,OAAO,SACL,4BACE,WAAW,WAAW,OACrB,WAAW,qBAAqB,UAAU,KAAK,CAClD,CACF;CAEF,IAAI,aAAa,WAAW,MAAM,GAChC,OAAO,SACL,+LAEG,WAAW,eAAe,KAAA,IACvB,KACA,sBAAsB,WAAW,WAAW,KAAK,qRACzD;CAEF,IAAI;EACF,MAAM,aAAa,KAAK,wBAAwB,WAAW,MAAM;EAEjE,OAAO,SACL,GAAG,kBAAkB,UAAU,EAAE,MAAM,KAAK,UAAU,YAAY,KAAA,GAAW,CAAC,GAChF;CACF,SAAS,OAAO;EACd,OAAO;GACL,MAAM;GACN,QAAQ,iBAAiB,QAAQ,MAAM,UAAU,OAAO,KAAK;EAC/D;CACF;AACF;AAIA,MAAM,kCAAkB,IAAI,QAA6C;AAEzE,MAAa,wBAAwB,eAAoD;CACvF,MAAM,SAAS,gBAAgB,IAAI,UAAU;CAE7C,IAAI,WAAW,KAAA,GAAW,OAAO;CACjC,MAAM,OAAO,2BAA2B,UAAU;CAClD,MAAM,eAAe,WAAW,uBAAuB,CAAC;CAExD,MAAM,WACJ,KAAK,SAAS,cAAc,aAAa,SAAS,IAC9C,SACE,2FAA2F,aAAa,KAAK,gBAAgB,KAAK,UAAU,YAAY,IAAI,CAAC,CAAC,CAAC,KAAK,IAAI,EAAE;;IAGxK,KAAK,OACT,IACA;CAEN,gBAAgB,IAAI,YAAY,QAAQ;CAExC,OAAO;AACT;;;;;;;;;;;;;AAcA,MAAa,wBACX,QACA,YACkB;CAClB,MAAM,UAAU,OAAO;CACvB,IAAI,WAAW;CAEf,KAAK,IAAI,QAAQ,GAAG,QAAQ,QAAQ,QAAQ,SAAS,GACnD,IAAI,QAAQ,MAAM,EAAE,SAAS,UAC3B,WAAW,QAAQ;CAIvB,OAAO,OAAO,aAAa;EAAC,GAAG,QAAQ,MAAM,GAAG,QAAQ;EAAG;EAAS,GAAG,QAAQ,MAAM,QAAQ;CAAC,CAAC;AACjG"}

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

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

package/dist/sandbox/CodeExecutor.d.mts

@@ -0,0 +1,194 @@
+import { n as NetworkDisabled, p as SandboxImplementation, t as NetworkAllowlist } from "../Sandbox-CEsDWBLq.mjs";
+import { Context, Duration, Effect, Schema, Scope } from "effect";
+declare namespace CodeExecutor_d_exports {
+  export { CodeExecutionError, CodeExecutionHost, CodeExecutionLimits, CodeExecutionNamespace, CodeExecutionProtocolError, CodeExecutionRequest, CodeExecutionResourceUse, CodeExecutionResult, CodeExecutionTimeoutError, CodeExecutor, CodeExecutorExecute, CodeExecutorStartError, CodeExecutorTerminatedError, CodeExecutorUnsupportedError, CodeHostCall, CodeHostCallFailure, CodeHostCallLimitError, CodeHostCallResult, CodeHostCallSuccess, CodeOutputLimitError, CodeProgramFailedError, CodeSourceError, JsIdentifier };
+}
+/** A JavaScript identifier safe to bind as a sandbox global or method name. */
+export declare const JsIdentifier: Schema.refine<string, Schema.NonEmptyString>;
+export type JsIdentifier = typeof JsIdentifier.Type;
+declare const CodeExecutionNamespace_base: Schema.Class<CodeExecutionNamespace, Schema.Struct<{
+  readonly name: Schema.refine<string, Schema.NonEmptyString>;
+  readonly methods: Schema.$Array<Schema.refine<string, Schema.NonEmptyString>>;
+}>, {}>;
+/** One callable namespace exposed to the generated program as a typed global. */
+export declare class CodeExecutionNamespace extends CodeExecutionNamespace_base {}
+declare const CodeExecutionLimits_base: Schema.Class<CodeExecutionLimits, Schema.Struct<{
+  readonly maxSourceBytes: Schema.Int;
+  readonly maxWallTime: Schema.refine<Duration.Duration, Schema.Duration>;
+  readonly cpuMillis: Schema.optionalKey<Schema.Int>;
+  readonly maxLogBytes: Schema.Int;
+  readonly maxResultBytes: Schema.Int;
+  readonly maxHostCalls: Schema.Natural;
+  /** Maximum active host calls per pass; defaults to four. Excess calls wait in Scope. */
+  readonly maxHostCallConcurrency: Schema.optionalKey<Schema.Int>;
+  readonly maxHostCallArgumentBytes: Schema.Int;
+  readonly maxHostCallResultBytes: Schema.Int;
+}>, {}>;
+/**
+ * Limits an executor must either enforce or reject (CAP-015). Byte bounds are
+ * measured on UTF-8 encoded JSON at the sandbox boundary.
+ */
+export declare class CodeExecutionLimits extends CodeExecutionLimits_base {}
+declare const CodeExecutionRequest_base: Schema.Class<CodeExecutionRequest, Schema.Struct<{
+  readonly language: Schema.Literals<readonly ["javascript"]>;
+  readonly source: Schema.String;
+  readonly namespaces: Schema.$Array<typeof CodeExecutionNamespace>;
+  readonly network: Schema.Union<readonly [typeof NetworkDisabled, typeof NetworkAllowlist]>;
+  readonly limits: typeof CodeExecutionLimits;
+}>, {}>;
+/**
+ * One isolated execution pass over bounded generated JavaScript. The source
+ * must be a single expression evaluating to one async function; the executor
+ * harness invokes it exactly once with no arguments (ADR-0017 decision 5).
+ */
+export declare class CodeExecutionRequest extends CodeExecutionRequest_base {}
+declare const CodeHostCall_base: Schema.Class<CodeHostCall, Schema.Struct<{
+  readonly namespace: Schema.refine<string, Schema.NonEmptyString>;
+  readonly method: Schema.refine<string, Schema.NonEmptyString>;
+  readonly argument: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+}>, {}>;
+/** One host invocation from generated code. Data only: the broker owns identity. */
+export declare class CodeHostCall extends CodeHostCall_base {}
+declare const CodeHostCallSuccess_base: Schema.Class<CodeHostCallSuccess, Schema.TaggedStruct<"CodeHostCallSuccess", {
+  readonly value: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+}>, {}>;
+/** A host call settled with the encoded Tool success value. */
+export declare class CodeHostCallSuccess extends CodeHostCallSuccess_base {}
+declare const CodeHostCallFailure_base: Schema.Class<CodeHostCallFailure, Schema.TaggedStruct<"CodeHostCallFailure", {
+  readonly error: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+}>, {}>;
+/**
+ * A host call settled with a Schema-encoded typed failure envelope. Inside the
+ * generated program the call's Promise rejects with the envelope value, so a
+ * program can catch and branch on expected failures.
+ */
+export declare class CodeHostCallFailure extends CodeHostCallFailure_base {}
+/** Outcome of one host call as data; transport failures stay executor errors. */
+export declare const CodeHostCallResult: Schema.Union<readonly [typeof CodeHostCallSuccess, typeof CodeHostCallFailure]>;
+export type CodeHostCallResult = typeof CodeHostCallResult.Type;
+declare const CodeExecutionHost_base: Context.ServiceClass<CodeExecutionHost, "@effect-agent/sandbox/CodeExecutionHost", {
+  readonly call: (call: CodeHostCall) => Effect.Effect<CodeHostCallResult>;
+}>;
+/**
+ * The per-pass host capability: the only authority generated code has over the
+ * host. It is provided at the pass edge by the capability layer, its live
+ * bindings are scoped resources, and it is never persisted (ADR-0017
+ * decision 2). Broker-level failures return as `CodeHostCallFailure` data;
+ * an unexpected host defect remains a defect.
+ */
+export declare class CodeExecutionHost extends CodeExecutionHost_base {}
+declare const CodeExecutionResourceUse_base: Schema.Class<CodeExecutionResourceUse, Schema.Struct<{
+  readonly wallTime: Schema.refine<Duration.Duration, Schema.Duration>;
+  readonly hostCalls: Schema.Natural;
+  readonly logBytes: Schema.Natural;
+  readonly resultBytes: Schema.Natural;
+  readonly cpuMillis: Schema.optionalKey<Schema.Natural>;
+}>, {}>;
+/** Accounting one executor observed for one pass. */
+export declare class CodeExecutionResourceUse extends CodeExecutionResourceUse_base {}
+declare const CodeExecutionResult_base: Schema.Class<CodeExecutionResult, Schema.Struct<{
+  readonly implementation: typeof SandboxImplementation;
+  readonly value: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+  readonly logs: Schema.$Array<Schema.String>;
+  readonly resourceUse: typeof CodeExecutionResourceUse;
+}>, {}>;
+/**
+ * The bounded outcome of one successful pass. `value` and `logs` are the raw
+ * executor capture; the aggregate model-visible egress budget and redaction
+ * pass are owned by the Code Mode capability, not the executor (CAP-016).
+ */
+export declare class CodeExecutionResult extends CodeExecutionResult_base {}
+declare const CodeSourceError_base: Schema.Class<CodeSourceError, Schema.TaggedStruct<"CodeSourceError", {
+  readonly implementation: typeof SandboxImplementation;
+  readonly reason: Schema.Literals<readonly ["invalid", "oversized", "not-a-function"]>;
+  readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/** The source is not one async function expression the executor can run. */
+export declare class CodeSourceError extends CodeSourceError_base {}
+declare const CodeExecutorUnsupportedError_base: Schema.Class<CodeExecutorUnsupportedError, Schema.TaggedStruct<"CodeExecutorUnsupportedError", {
+  readonly implementation: typeof SandboxImplementation;
+  readonly feature: Schema.Literals<readonly ["language", "network", "cpu-limit", "namespaces", "wall-clock", "host-calls"]>;
+  readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/** The executor cannot honestly enforce one requested feature, limit, or policy. */
+export declare class CodeExecutorUnsupportedError extends CodeExecutorUnsupportedError_base {}
+declare const CodeExecutorStartError_base: Schema.Class<CodeExecutorStartError, Schema.TaggedStruct<"CodeExecutorStartError", {
+  readonly implementation: typeof SandboxImplementation;
+  readonly message: Schema.String;
+  readonly cause: Schema.optionalKey<Schema.Defect>;
+}>, import("effect/Cause").YieldableError>;
+/** The executor could not start the isolated pass. */
+export declare class CodeExecutorStartError extends CodeExecutorStartError_base {}
+declare const CodeExecutionTimeoutError_base: Schema.Class<CodeExecutionTimeoutError, Schema.TaggedStruct<"CodeExecutionTimeoutError", {
+  readonly implementation: typeof SandboxImplementation;
+  readonly kind: Schema.Literals<readonly ["cpu", "wall-clock"]>;
+  readonly maxWallTime: Schema.refine<Duration.Duration, Schema.Duration>;
+  readonly logs: Schema.$Array<Schema.String>;
+}>, import("effect/Cause").YieldableError>;
+/** The pass exceeded its CPU or wall-clock budget and was terminated. */
+export declare class CodeExecutionTimeoutError extends CodeExecutionTimeoutError_base {}
+declare const CodeOutputLimitError_base: Schema.Class<CodeOutputLimitError, Schema.TaggedStruct<"CodeOutputLimitError", {
+  readonly implementation: typeof SandboxImplementation;
+  readonly surface: Schema.Literals<readonly ["logs", "result", "host-call-argument", "host-call-result"]>;
+  readonly limit: Schema.Int;
+  readonly observed: Schema.Natural;
+  readonly logs: Schema.$Array<Schema.String>;
+}>, import("effect/Cause").YieldableError>;
+/** A bounded surface (logs, result, or a per-call byte bound) was exceeded. */
+export declare class CodeOutputLimitError extends CodeOutputLimitError_base {}
+declare const CodeHostCallLimitError_base: Schema.Class<CodeHostCallLimitError, Schema.TaggedStruct<"CodeHostCallLimitError", {
+  readonly implementation: typeof SandboxImplementation;
+  readonly limit: Schema.Natural;
+  readonly logs: Schema.$Array<Schema.String>;
+}>, import("effect/Cause").YieldableError>;
+/** The pass issued more host calls than its executor-owned cap allows. */
+export declare class CodeHostCallLimitError extends CodeHostCallLimitError_base {}
+declare const CodeProgramFailedError_base: Schema.Class<CodeProgramFailedError, Schema.TaggedStruct<"CodeProgramFailedError", {
+  readonly implementation: typeof SandboxImplementation;
+  readonly reason: Schema.Literals<readonly ["threw", "rejected", "non-json-result"]>;
+  readonly thrown: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+  readonly message: Schema.String;
+  readonly logs: Schema.$Array<Schema.String>;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * The generated program finished by failing: it threw, its promise rejected,
+ * or it returned a value that is not JSON. The bounded thrown value and log
+ * capture flow back so a model can correct the program without a blind retry.
+ */
+export declare class CodeProgramFailedError extends CodeProgramFailedError_base {}
+declare const CodeExecutionProtocolError_base: Schema.Class<CodeExecutionProtocolError, Schema.TaggedStruct<"CodeExecutionProtocolError", {
+  readonly implementation: typeof SandboxImplementation;
+  readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/** The executor or its transport produced a value outside the protocol Schemas. */
+export declare class CodeExecutionProtocolError extends CodeExecutionProtocolError_base {}
+declare const CodeExecutorTerminatedError_base: Schema.Class<CodeExecutorTerminatedError, Schema.TaggedStruct<"CodeExecutorTerminatedError", {
+  readonly implementation: typeof SandboxImplementation;
+  readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * The pass was terminated externally — isolate eviction or a platform kill —
+ * with no terminal program result. No result is fabricated.
+ */
+export declare class CodeExecutorTerminatedError extends CodeExecutorTerminatedError_base {}
+/** Expected Code Mode execution failures. Interruption stays an Effect interruption. */
+export declare const CodeExecutionError: Schema.Union<readonly [typeof CodeSourceError, typeof CodeExecutorUnsupportedError, typeof CodeExecutorStartError, typeof CodeExecutionTimeoutError, typeof CodeOutputLimitError, typeof CodeHostCallLimitError, typeof CodeProgramFailedError, typeof CodeExecutionProtocolError, typeof CodeExecutorTerminatedError]>;
+export type CodeExecutionError = typeof CodeExecutionError.Type;
+declare const CodeExecutor_base: Context.ServiceClass<CodeExecutor, "@effect-agent/sandbox/CodeExecutor", {
+  readonly execute: (request: CodeExecutionRequest) => Effect.Effect<CodeExecutionResult, CodeExecutionError, Scope.Scope | CodeExecutionHost>;
+}>;
+/**
+ * Callback-capable isolated execution port for Code Mode (ADR-0017), a sibling
+ * of the command-shaped `Sandbox` service. One `execute` is one stateless pass:
+ * the executor owns no approval, Tool, replay, or Thread semantics, holds
+ * every pass resource in the given Scope, and reaches the host only through the
+ * `CodeExecutionHost` service in its requirement channel. Implementations must
+ * identify their isolation posture honestly; an `unisolated` executor is never
+ * a security boundary (CAP-010, CAP-015).
+ */
+export declare class CodeExecutor extends CodeExecutor_base {}
+/** Type helper for implementations that preserve the public CodeExecutor contract. */
+export type CodeExecutorExecute = (request: CodeExecutionRequest) => Effect.Effect<CodeExecutionResult, CodeExecutionError, Scope.Scope | CodeExecutionHost>;
+//#endregion
+export { CodeExecutor_d_exports as t };
+//# sourceMappingURL=CodeExecutor.d.mts.map