effect-agent 0.1.0-beta.9 → 0.1.0-beta.90

package/dist/SubscriptionInput-vAAOBrK7.d.mts

@@ -0,0 +1,41 @@
+import { t as AgentId } from "./Identifiers-CN2s30fF.mjs";
+import { O as PersistedJson, h as DefinitionDigests } from "./Records-BAGkekt8.mjs";
+import { E as SubscriptionSourceError, b as SubscriptionRecord, i as EventSourceVersion, m as SubscriptionError, t as AcceptedEvent, u as SubscriptionConfiguration } from "./Subscription-BEP8oQO5.mjs";
+import { Context, Effect, Schema, Scope } from "effect";
+declare namespace SubscriptionInput_d_exports {
+  export { SubscriptionInputBinding, SubscriptionInputBindings, makeSubscriptionInputBinding, resolveSubscriptionInput };
+}
+/** Host-retained preparation code for one source and exact destination Agent definition. */
+interface SubscriptionInputBinding {
+  readonly source: EventSourceVersion;
+  readonly agentId: AgentId;
+  readonly definitions: DefinitionDigests;
+  readonly context: (value: unknown) => Effect.Effect<PersistedJson, SubscriptionSourceError>;
+  readonly prepare: (event: AcceptedEvent, subscription: SubscriptionRecord) => Effect.Effect<PersistedJson, SubscriptionSourceError>;
+}
+declare const SubscriptionInputBindings_base: Context.ServiceClass<SubscriptionInputBindings, "@effect-agent/thread/SubscriptionInputBindings", {
+  readonly bindings: ReadonlyArray<SubscriptionInputBinding>;
+}>;
+declare class SubscriptionInputBindings extends SubscriptionInputBindings_base {}
+/** Missing or ambiguous code stays pending. Never substitute a newer destination definition. */
+declare const resolveSubscriptionInput: (bindings: ReadonlyArray<SubscriptionInputBinding>, configuration: Pick<SubscriptionConfiguration, "source" | "agentId" | "definitions">) => Effect.Effect<SubscriptionInputBinding, SubscriptionError>;
+/**
+ * Capture explicit dependencies at host assembly. Pass the destination definition's input Schema.
+ * Include the context Schema and mapper in its retained definition version; changing either
+ * requires new definition digests. Preparation may repeat until its envelope is committed.
+ * Each operation owns a fresh Scope for its callbacks and codecs; captured host services
+ * retain their host lifetime. Operation resources finalize on success, failure, or interruption.
+ */
+declare const makeSubscriptionInputBinding: <Event extends Schema.Top, Parameters extends Schema.Top, Continuation extends Schema.Top, Input extends Schema.Top, R>(options: {
+  readonly source: EventSourceVersion;
+  readonly agentId: AgentId;
+  readonly definitions: DefinitionDigests;
+  readonly event: Event;
+  readonly parameters: Parameters;
+  readonly context: Continuation;
+  readonly input: Input;
+  readonly prepare: (event: Event["Type"], parameters: Parameters["Type"], context: Continuation["Type"]) => Effect.Effect<Input["Type"], SubscriptionSourceError, R>;
+}) => Effect.Effect<SubscriptionInputBinding, never, Exclude<R, Scope.Scope> | Exclude<Continuation["DecodingServices"], Scope.Scope> | Exclude<Continuation["EncodingServices"], Scope.Scope> | Exclude<Event["DecodingServices"], Scope.Scope> | Exclude<Input["EncodingServices"], Scope.Scope> | Exclude<Parameters["DecodingServices"], Scope.Scope>>;
+//#endregion
+export { resolveSubscriptionInput as a, makeSubscriptionInputBinding as i, SubscriptionInputBindings as n, SubscriptionInput_d_exports as r, SubscriptionInputBinding as t };
+//# sourceMappingURL=SubscriptionInput-vAAOBrK7.d.mts.map

package/dist/Thread-DOBQ0QUY.d.mts

@@ -0,0 +1,96 @@
+import { s as RunId, u as ThreadId } from "./Identifiers-CN2s30fF.mjs";
+import { Prompt } from "effect/unstable/ai";
+import { Context, Effect, Layer, Schema } from "effect";
+declare namespace Thread_d_exports {
+  export { Store, Thread, ThreadAppend, ThreadEncodingError, ThreadError, ThreadExport, ThreadHistoryDiverged, ThreadLimitExceeded, ThreadMessage, ThreadNotFound, ThreadText, layerMemory, toPrompt };
+}
+/** Bound applied to one text projection before it can enter a model context. */
+declare const ThreadText: Schema.String;
+declare const ThreadMessage_base: Schema.Class<ThreadMessage, Schema.Struct<{
+  readonly threadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+  readonly sequence: Schema.Natural;
+  readonly runId: Schema.optionalKey<Schema.brand<Schema.NonEmptyString, "@effect-agent/core/RunId">>;
+  readonly message: Schema.Codec<Prompt.Message, Prompt.MessageEncoded, never, never>;
+  readonly encodedBytes: Schema.Natural;
+  readonly timestamp: Schema.DateTimeUtcFromString;
+}>, {}>;
+/** One append-only native Effect AI message in a conversation. */
+declare class ThreadMessage extends ThreadMessage_base {}
+declare const Thread_base: Schema.Class<Thread, Schema.Struct<{
+  readonly version: Schema.Literal<1>;
+  readonly threadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+  readonly nextSequence: Schema.Natural;
+  readonly contentBytes: Schema.Natural;
+  readonly messages: Schema.$Array<typeof ThreadMessage>;
+}>, {}>;
+/** An identified, ordered conversation snapshot. Storage and execution recovery are separate concerns. */
+declare class Thread extends Thread_base {}
+declare const ThreadExport_base: Schema.Class<ThreadExport, Schema.Struct<{
+  readonly format: Schema.Literal<"effect-agent/ephemeral-thread@1">;
+  readonly exportedAt: Schema.DateTimeUtcFromString;
+  readonly snapshot: typeof Thread;
+}>, {}>;
+/** Portable conversation snapshot. Its format is independent of the durable execution journal. */
+declare class ThreadExport extends ThreadExport_base {}
+declare const ThreadAppend_base: Schema.Class<ThreadAppend, Schema.Struct<{
+  readonly runId: Schema.optionalKey<Schema.brand<Schema.NonEmptyString, "@effect-agent/core/RunId">>;
+  readonly message: Schema.Codec<Prompt.Message, Prompt.MessageEncoded, never, never>;
+}>, {}>;
+/** Native message accepted by the append-only thread. */
+declare class ThreadAppend extends ThreadAppend_base {}
+declare const ThreadNotFound_base: Schema.Class<ThreadNotFound, Schema.TaggedStruct<"ThreadNotFound", {
+  readonly threadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+}>, import("effect/Cause").YieldableError>;
+/** The requested Thread has not been created in this store. */
+declare class ThreadNotFound extends ThreadNotFound_base {}
+declare const ThreadLimitExceeded_base: Schema.Class<ThreadLimitExceeded, Schema.TaggedStruct<"ThreadLimitExceeded", {
+  readonly threadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+  readonly limit: Schema.Literals<readonly ["messages", "content-bytes", "threads", "store-content-bytes"]>;
+  readonly limitValue: Schema.Natural;
+  readonly observedValue: Schema.Natural;
+}>, import("effect/Cause").YieldableError>;
+/** A process-local Thread store reached an explicit count or encoded-content bound. */
+declare class ThreadLimitExceeded extends ThreadLimitExceeded_base {}
+declare const ThreadHistoryDiverged_base: Schema.Class<ThreadHistoryDiverged, Schema.TaggedStruct<"ThreadHistoryDiverged", {
+  readonly threadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+  readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/** Engine history was not an append-only extension of the official snapshot. */
+declare class ThreadHistoryDiverged extends ThreadHistoryDiverged_base {}
+declare const ThreadEncodingError_base: Schema.Class<ThreadEncodingError, Schema.TaggedStruct<"ThreadEncodingError", {
+  readonly threadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+  readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/** Native Prompt encoding failed before a bounded state mutation. */
+declare class ThreadEncodingError extends ThreadEncodingError_base {}
+type ThreadError = ThreadNotFound | ThreadLimitExceeded | ThreadHistoryDiverged | ThreadEncodingError;
+/** Reconstruct exact Effect AI Prompt history, including tools, reasoning, files, and options. */
+declare const toPrompt: (snapshot: Thread) => Prompt.Prompt;
+declare const Store_base: Context.ServiceClass<Store, "@effect-agent/capabilities/EphemeralThreads", {
+  readonly create: (threadId: ThreadId) => Effect.Effect<Thread, ThreadLimitExceeded>;
+  readonly append: (threadId: ThreadId, message: ThreadAppend) => Effect.Effect<Thread, ThreadNotFound | ThreadLimitExceeded | ThreadEncodingError>;
+  /**
+   * Record an engine-emitted full history only when it is an append-only
+   * extension of the exact official Prompt already stored. The entire
+   * suffix commits in one transaction or not at all: concurrent writers are
+   * serialized, a writer whose history no longer extends the committed
+   * official history fails with ThreadHistoryDiverged, and a limit
+   * failure inside the suffix records nothing. Earlier updates remain committed if the Run
+   * later fails or is interrupted; this transaction covers one update, not the whole Run.
+   */
+  readonly recordHistory: (threadId: ThreadId, runId: RunId, history: Prompt.Prompt) => Effect.Effect<Thread, ThreadError>;
+  readonly snapshot: (threadId: ThreadId) => Effect.Effect<Thread, ThreadNotFound>;
+  readonly export: (threadId: ThreadId) => Effect.Effect<ThreadExport, ThreadNotFound>;
+}>;
+/**
+ * Process-local state for conversation history. Updates remain visible even
+ * when a Run later fails; this service has no successful-Run commit boundary or durable recovery.
+ * ThreadHistory.layer uses this store for ordinary Runs and interactive history.
+ * Scope closure releases all in-memory state.
+ */
+declare class Store extends Store_base {}
+/** In-memory storage shared for the consumer's Scope; it does not survive process loss. */
+declare const layerMemory: Layer.Layer<Store, never, never>;
+//#endregion
+export { ThreadError as a, ThreadLimitExceeded as c, ThreadText as d, Thread_d_exports as f, ThreadEncodingError as i, ThreadMessage as l, toPrompt as m, Thread as n, ThreadExport as o, layerMemory as p, ThreadAppend as r, ThreadHistoryDiverged as s, Store as t, ThreadNotFound as u };
+//# sourceMappingURL=Thread-DOBQ0QUY.d.mts.map

package/dist/ThreadHistory-tS1KwxHR.d.mts

@@ -0,0 +1,60 @@
+import { s as RunId, u as ThreadId } from "./Identifiers-CN2s30fF.mjs";
+import { t as Store } from "./Thread-DOBQ0QUY.mjs";
+import { c as RunCompleted } from "./RunEvent-DIrzkjLr.mjs";
+import { Prompt } from "effect/unstable/ai";
+import { Context, Effect, Layer, Schema } from "effect";
+declare namespace ThreadHistory_d_exports {
+  export { ThreadHistory, ThreadHistoryError, ThreadHistoryRun, layer };
+}
+declare const ThreadHistoryError_base: Schema.Class<ThreadHistoryError, Schema.TaggedStruct<"ThreadHistoryError", {
+  readonly threadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+  readonly reason: Schema.Literals<readonly ["not-found", "conflict", "fenced", "incompatible", "limit", "encoding", "storage"]>;
+  readonly message: Schema.String;
+  readonly cause: Schema.optionalKey<Schema.Defect>;
+}>, import("effect/Cause").YieldableError>;
+/** A history adapter rejected a read, staged value, or completed Run commit. */
+declare class ThreadHistoryError extends ThreadHistoryError_base {}
+/**
+ * One Run's history owner. Incremental adapters retain each stageHistory update; on-success
+ * adapters stage privately until commit. Before commit, the interpreter
+ * finishes run-owned work and closes resources acquired for that Run, then validates the result
+ * for run/start.await. Shared model, provider, and client services supplied by an enclosing
+ * application Layer remain owned by that application's Scope and may outlive multiple Runs.
+ * Commit must succeed before RunCompleted becomes observable. Schema-encoded input is opaque
+ * here; the adapter owns its persistence boundary. A failed commit may have reached storage;
+ * callers must inspect history before retrying external execution.
+ */
+interface ThreadHistoryRun {
+  readonly prompt: Prompt.Prompt;
+  readonly stageInput: (input: unknown) => Effect.Effect<void, ThreadHistoryError>;
+  readonly stageHistory: (history: Prompt.Prompt) => Effect.Effect<void, ThreadHistoryError>;
+  readonly commit: (completed: RunCompleted) => Effect.Effect<void, ThreadHistoryError>;
+}
+declare const ThreadHistory_base: Context.ServiceClass<ThreadHistory, "@effect-agent/engine/ThreadHistory", {
+  readonly retention: "incremental" | "on-success";
+  readonly open: (request: {
+    readonly threadId: ThreadId;
+    readonly runId: RunId;
+  }) => Effect.Effect<ThreadHistoryRun, ThreadHistoryError>;
+  readonly load: (threadId: ThreadId) => Effect.Effect<Prompt.Prompt, ThreadHistoryError>;
+}>;
+/**
+ * History shared by Runs with the same Thread ID. The default layer retains native messages
+ * incrementally in memory for its application Scope, including completed updates before a failure.
+ * PersistentHistory.layer from effect-agent/persistent-history instead commits successful
+ * Runs to an explicit ThreadStore. Durable hosts retain history through their journal hooks.
+ * No implementation may retry model or Tool execution or claim interrupted-work recovery.
+ */
+declare class ThreadHistory extends ThreadHistory_base {
+  /**
+   * Retain bounded in-memory history across Runs. Provide once around the application so
+   * all Runs share the same store. The underlying Thread.Store service is exposed for
+   * snapshots and interactive hooks; separate Layer builds own separate stores.
+   */
+  static readonly layer: Layer.Layer<Store | ThreadHistory, never, never>;
+}
+/** Retain in-memory conversation history for the application Scope. */
+declare const layer: Layer.Layer<Store | ThreadHistory, never, never>;
+//#endregion
+export { layer as a, ThreadHistory_d_exports as i, ThreadHistoryError as n, ThreadHistoryRun as r, ThreadHistory as t };
+//# sourceMappingURL=ThreadHistory-tS1KwxHR.d.mts.map

package/dist/ToolBroker-DWs4tZra.d.mts

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

package/dist/ToolExposure-9uF_Yo0T.mjs

@@ -0,0 +1,10 @@
+import { Context } from "effect";
+//#region src/engine/ToolExposure.ts
+/** Engine-owned per-Turn snapshot. All candidates passed host visibility and inherited grants. */
+var CurrentToolCatalog = class extends Context.Service()("@effect-agent/engine/ToolExposure/CurrentToolCatalog") {};
+/** Optional host policy captured by durable runtimes; action authorization remains independent. */
+const RunToolVisibility = Context.Reference("@effect-agent/engine/ToolExposure/RunToolVisibility", { defaultValue: () => void 0 });
+//#endregion
+export { RunToolVisibility as n, CurrentToolCatalog as t };
+
+//# sourceMappingURL=ToolExposure-9uF_Yo0T.mjs.map

package/dist/ToolExposure-9uF_Yo0T.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"ToolExposure-9uF_Yo0T.mjs","names":[],"sources":["../src/engine/ToolExposure.ts"],"sourcesContent":["import { Context, type Effect } from \"effect\";\nimport type { Tool } from \"effect/unstable/ai\";\n\nimport type { RunId, ThreadId } from \"../core/Identifiers.ts\";\n\nexport type CatalogEntry =\n  | {\n      readonly kind: \"native\";\n      readonly tool: Tool.Any;\n      readonly namespace?: string | undefined;\n      readonly nativeToolName: string;\n    }\n  | {\n      readonly kind: \"code-mode\";\n      readonly tool: Tool.Any;\n      readonly namespace: string;\n      readonly method: string;\n      readonly nativeToolName: string;\n    };\n\n/** Engine-owned per-Turn snapshot. All candidates passed host visibility and inherited grants. */\nexport class CurrentToolCatalog extends Context.Service<\n  CurrentToolCatalog,\n  {\n    readonly entries: ReadonlyArray<CatalogEntry>;\n  }\n>()(\"@effect-agent/engine/ToolExposure/CurrentToolCatalog\") {}\n\n/** Host visibility is checked before a discovery Handler may inspect candidate documentation. */\nexport interface VisibilityRequest {\n  readonly threadId: ThreadId;\n  readonly runId: RunId;\n  readonly turn: number;\n  readonly input: unknown;\n  /** Includes registered native names and explicitly advertised programmatic names. */\n  readonly toolNames: ReadonlyArray<string>;\n}\n\n/** Resolve host dependencies when constructing the policy Layer. */\nexport interface VisibilityHook {\n  readonly visible: (request: VisibilityRequest) => Effect.Effect<ReadonlyArray<string>>;\n}\n\n/** Optional host policy captured by durable runtimes; action authorization remains independent. */\nexport const RunToolVisibility = Context.Reference<VisibilityHook | undefined>(\n  \"@effect-agent/engine/ToolExposure/RunToolVisibility\",\n  { defaultValue: () => undefined },\n);\n"],"mappings":";;;AAqBA,IAAa,qBAAb,cAAwC,QAAQ,QAK9C,CAAC,CAAC,sDAAsD,CAAC,CAAC,CAAC;;AAkB7D,MAAa,oBAAoB,QAAQ,UACvC,uDACA,EAAE,oBAAoB,KAAA,EAAU,CAClC"}

package/dist/ToolExposure-C93U1sPu.mjs

@@ -0,0 +1,30 @@
+import { Context, Schema } from "effect";
+//#region src/core/ToolExposure.ts
+/** Registered native names only. Empty selection deliberately clears non-pinned Tools. */
+const ToolNames = Schema.Array(Schema.String.check(Schema.isMinLength(1), Schema.isMaxLength(256))).check(Schema.isMaxLength(1024), Schema.makeFilter((names) => new Set(names).size === names.length, { title: "Tool names are unique" }));
+/** One run-scoped replacement, independent of search and of model-visible result text. */
+var Selection = class extends Schema.Class("@effect-agent/core/ToolExposure/Selection")({ toolNames: ToolNames }) {};
+/** Exact declarations used by one model request, with the selection that produced them. */
+var Snapshot = class extends Schema.Class("@effect-agent/core/ToolExposure/Snapshot")({
+	exposedToolNames: ToolNames,
+	selection: Schema.optionalKey(Selection)
+}) {};
+const Limits = Schema.Struct({
+	maxTools: Schema.Int.check(Schema.isGreaterThan(0), Schema.isLessThanOrEqualTo(1024)),
+	maxSchemaBytes: Schema.Int.check(Schema.isGreaterThan(0), Schema.isLessThanOrEqualTo(4194304))
+});
+/** Trusted grouping metadata; never inferred from a Tool's name. */
+const ToolNamespace = Context.Reference("@effect-agent/core/ToolExposure/ToolNamespace", { defaultValue: () => void 0 });
+/** An ordinary readonly Tool whose successful result has a `toolNames` field of native names. */
+const DiscoveryTool = Context.Reference("@effect-agent/core/ToolExposure/DiscoveryTool", { defaultValue: () => false });
+/** Remains selected while eligible. Host visibility and inherited grants may hide an explicit
+* pin without failing the Run; discovery, context rollover and required completion stay mandatory.
+*/
+const PinnedTool = Context.Reference("@effect-agent/core/ToolExposure/PinnedTool", { defaultValue: () => false });
+const AdditionalToolCatalog = Context.Reference("@effect-agent/core/ToolExposure/AdditionalToolCatalog", { defaultValue: () => [] });
+/** The owning Tool description embeds its complete additional catalogue. */
+const IncludesCatalogDocumentation = Context.Reference("@effect-agent/core/ToolExposure/IncludesCatalogDocumentation", { defaultValue: () => false });
+//#endregion
+export { PinnedTool as a, ToolNames as c, Limits as i, ToolNamespace as l, DiscoveryTool as n, Selection as o, IncludesCatalogDocumentation as r, Snapshot as s, AdditionalToolCatalog as t };
+
+//# sourceMappingURL=ToolExposure-C93U1sPu.mjs.map

package/dist/ToolExposure-C93U1sPu.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"ToolExposure-C93U1sPu.mjs","names":[],"sources":["../src/core/ToolExposure.ts"],"sourcesContent":["import { Context, Schema } from \"effect\";\nimport type { Tool } from \"effect/unstable/ai\";\n\n/** Registered native names only. Empty selection deliberately clears non-pinned Tools. */\nexport const ToolNames = Schema.Array(\n  Schema.String.check(Schema.isMinLength(1), Schema.isMaxLength(256)),\n).check(\n  Schema.isMaxLength(1_024),\n  Schema.makeFilter((names) => new Set(names).size === names.length, {\n    title: \"Tool names are unique\",\n  }),\n);\n\n/** One run-scoped replacement, independent of search and of model-visible result text. */\nexport class Selection extends Schema.Class<Selection>(\"@effect-agent/core/ToolExposure/Selection\")(\n  {\n    toolNames: ToolNames,\n  },\n) {}\n\n/** Exact declarations used by one model request, with the selection that produced them. */\nexport class Snapshot extends Schema.Class<Snapshot>(\"@effect-agent/core/ToolExposure/Snapshot\")({\n  exposedToolNames: ToolNames,\n  selection: Schema.optionalKey(Selection),\n}) {}\n\nexport const Limits = Schema.Struct({\n  maxTools: Schema.Int.check(Schema.isGreaterThan(0), Schema.isLessThanOrEqualTo(1_024)),\n  maxSchemaBytes: Schema.Int.check(Schema.isGreaterThan(0), Schema.isLessThanOrEqualTo(4_194_304)),\n});\n\n/** Omission preserves eager exposure. Selection changes take effect only after a complete batch. */\nexport interface Configuration {\n  readonly initialToolNames?: ReadonlyArray<string> | undefined;\n  readonly maxTools?: number | undefined;\n  readonly maxSchemaBytes?: number | undefined;\n}\n\n/** Trusted grouping metadata; never inferred from a Tool's name. */\nexport const ToolNamespace = Context.Reference<string | undefined>(\n  \"@effect-agent/core/ToolExposure/ToolNamespace\",\n  { defaultValue: () => undefined },\n);\n\n/** An ordinary readonly Tool whose successful result has a `toolNames` field of native names. */\nexport const DiscoveryTool = Context.Reference<boolean>(\n  \"@effect-agent/core/ToolExposure/DiscoveryTool\",\n  { defaultValue: () => false },\n);\n\n/** Remains selected while eligible. Host visibility and inherited grants may hide an explicit\n * pin without failing the Run; discovery, context rollover and required completion stay mandatory.\n */\nexport const PinnedTool = Context.Reference<boolean>(\"@effect-agent/core/ToolExposure/PinnedTool\", {\n  defaultValue: () => false,\n});\n\n/** Extra documentation candidates executed through their owning native Tool, such as Code Mode. */\nexport interface AdditionalCatalogEntry {\n  readonly tool: Tool.Any;\n  readonly namespace: string;\n  readonly method: string;\n}\n\nexport const AdditionalToolCatalog = Context.Reference<ReadonlyArray<AdditionalCatalogEntry>>(\n  \"@effect-agent/core/ToolExposure/AdditionalToolCatalog\",\n  { defaultValue: () => [] },\n);\n\n/** The owning Tool description embeds its complete additional catalogue. */\nexport const IncludesCatalogDocumentation = Context.Reference<boolean>(\n  \"@effect-agent/core/ToolExposure/IncludesCatalogDocumentation\",\n  { defaultValue: () => false },\n);\n"],"mappings":";;;AAIA,MAAa,YAAY,OAAO,MAC9B,OAAO,OAAO,MAAM,OAAO,YAAY,CAAC,GAAG,OAAO,YAAY,GAAG,CAAC,CACpE,CAAC,CAAC,MACA,OAAO,YAAY,IAAK,GACxB,OAAO,YAAY,UAAU,IAAI,IAAI,KAAK,CAAC,CAAC,SAAS,MAAM,QAAQ,EACjE,OAAO,wBACT,CAAC,CACH;;AAGA,IAAa,YAAb,cAA+B,OAAO,MAAiB,2CAA2C,CAAC,CACjG,EACE,WAAW,UACb,CACF,CAAC,CAAC,CAAC;;AAGH,IAAa,WAAb,cAA8B,OAAO,MAAgB,0CAA0C,CAAC,CAAC;CAC/F,kBAAkB;CAClB,WAAW,OAAO,YAAY,SAAS;AACzC,CAAC,CAAC,CAAC,CAAC;AAEJ,MAAa,SAAS,OAAO,OAAO;CAClC,UAAU,OAAO,IAAI,MAAM,OAAO,cAAc,CAAC,GAAG,OAAO,oBAAoB,IAAK,CAAC;CACrF,gBAAgB,OAAO,IAAI,MAAM,OAAO,cAAc,CAAC,GAAG,OAAO,oBAAoB,OAAS,CAAC;AACjG,CAAC;;AAUD,MAAa,gBAAgB,QAAQ,UACnC,iDACA,EAAE,oBAAoB,KAAA,EAAU,CAClC;;AAGA,MAAa,gBAAgB,QAAQ,UACnC,iDACA,EAAE,oBAAoB,MAAM,CAC9B;;;;AAKA,MAAa,aAAa,QAAQ,UAAmB,8CAA8C,EACjG,oBAAoB,MACtB,CAAC;AASD,MAAa,wBAAwB,QAAQ,UAC3C,yDACA,EAAE,oBAAoB,CAAC,EAAE,CAC3B;;AAGA,MAAa,+BAA+B,QAAQ,UAClD,gEACA,EAAE,oBAAoB,MAAM,CAC9B"}

package/dist/ToolExposure-UCN12eCd.d.mts

@@ -0,0 +1,39 @@
+import { s as RunId, u as ThreadId } from "./Identifiers-CN2s30fF.mjs";
+import { Tool } from "effect/unstable/ai";
+import { Context, Effect } from "effect";
+//#region src/engine/ToolExposure.d.ts
+type CatalogEntry = {
+  readonly kind: "native";
+  readonly tool: Tool.Any;
+  readonly namespace?: string | undefined;
+  readonly nativeToolName: string;
+} | {
+  readonly kind: "code-mode";
+  readonly tool: Tool.Any;
+  readonly namespace: string;
+  readonly method: string;
+  readonly nativeToolName: string;
+};
+declare const CurrentToolCatalog_base: Context.ServiceClass<CurrentToolCatalog, "@effect-agent/engine/ToolExposure/CurrentToolCatalog", {
+  readonly entries: ReadonlyArray<CatalogEntry>;
+}>;
+/** Engine-owned per-Turn snapshot. All candidates passed host visibility and inherited grants. */
+declare class CurrentToolCatalog extends CurrentToolCatalog_base {}
+/** Host visibility is checked before a discovery Handler may inspect candidate documentation. */
+interface VisibilityRequest {
+  readonly threadId: ThreadId;
+  readonly runId: RunId;
+  readonly turn: number;
+  readonly input: unknown;
+  /** Includes registered native names and explicitly advertised programmatic names. */
+  readonly toolNames: ReadonlyArray<string>;
+}
+/** Resolve host dependencies when constructing the policy Layer. */
+interface VisibilityHook {
+  readonly visible: (request: VisibilityRequest) => Effect.Effect<ReadonlyArray<string>>;
+}
+/** Optional host policy captured by durable runtimes; action authorization remains independent. */
+declare const RunToolVisibility: Context.Reference<VisibilityHook | undefined>;
+//#endregion
+export { VisibilityRequest as a, VisibilityHook as i, CurrentToolCatalog as n, RunToolVisibility as r, CatalogEntry as t };
+//# sourceMappingURL=ToolExposure-UCN12eCd.d.mts.map

package/dist/ToolExposure-r2eOWk4F.d.mts

@@ -0,0 +1,46 @@
+import { Tool } from "effect/unstable/ai";
+import { Context, Schema } from "effect";
+//#region src/core/ToolExposure.d.ts
+/** Registered native names only. Empty selection deliberately clears non-pinned Tools. */
+declare const ToolNames: Schema.$Array<Schema.String>;
+declare const Selection_base: Schema.Class<Selection, Schema.Struct<{
+  readonly toolNames: Schema.$Array<Schema.String>;
+}>, {}>;
+/** One run-scoped replacement, independent of search and of model-visible result text. */
+declare class Selection extends Selection_base {}
+declare const Snapshot_base: Schema.Class<Snapshot, Schema.Struct<{
+  readonly exposedToolNames: Schema.$Array<Schema.String>;
+  readonly selection: Schema.optionalKey<typeof Selection>;
+}>, {}>;
+/** Exact declarations used by one model request, with the selection that produced them. */
+declare class Snapshot extends Snapshot_base {}
+declare const Limits: Schema.Struct<{
+  readonly maxTools: Schema.Int;
+  readonly maxSchemaBytes: Schema.Int;
+}>;
+/** Omission preserves eager exposure. Selection changes take effect only after a complete batch. */
+interface Configuration {
+  readonly initialToolNames?: ReadonlyArray<string> | undefined;
+  readonly maxTools?: number | undefined;
+  readonly maxSchemaBytes?: number | undefined;
+}
+/** Trusted grouping metadata; never inferred from a Tool's name. */
+declare const ToolNamespace: Context.Reference<string | undefined>;
+/** An ordinary readonly Tool whose successful result has a `toolNames` field of native names. */
+declare const DiscoveryTool: Context.Reference<boolean>;
+/** Remains selected while eligible. Host visibility and inherited grants may hide an explicit
+ * pin without failing the Run; discovery, context rollover and required completion stay mandatory.
+ */
+declare const PinnedTool: Context.Reference<boolean>;
+/** Extra documentation candidates executed through their owning native Tool, such as Code Mode. */
+interface AdditionalCatalogEntry {
+  readonly tool: Tool.Any;
+  readonly namespace: string;
+  readonly method: string;
+}
+declare const AdditionalToolCatalog: Context.Reference<readonly AdditionalCatalogEntry[]>;
+/** The owning Tool description embeds its complete additional catalogue. */
+declare const IncludesCatalogDocumentation: Context.Reference<boolean>;
+//#endregion
+export { IncludesCatalogDocumentation as a, Selection as c, ToolNamespace as d, DiscoveryTool as i, Snapshot as l, AdditionalToolCatalog as n, Limits as o, Configuration as r, PinnedTool as s, AdditionalCatalogEntry as t, ToolNames as u };
+//# sourceMappingURL=ToolExposure-r2eOWk4F.d.mts.map

package/dist/ToolExposure.d.mts

@@ -0,0 +1,8 @@
+import { a as IncludesCatalogDocumentation, c as Selection, d as ToolNamespace, i as DiscoveryTool, l as Snapshot, n as AdditionalToolCatalog, o as Limits, r as Configuration, s as PinnedTool, t as AdditionalCatalogEntry, u as ToolNames } from "./ToolExposure-r2eOWk4F.mjs";
+import { a as VisibilityRequest, i as VisibilityHook, n as CurrentToolCatalog, r as RunToolVisibility, t as CatalogEntry } from "./ToolExposure-UCN12eCd.mjs";
+declare namespace ToolExposure_d_exports {
+  export { AdditionalCatalogEntry, AdditionalToolCatalog, CatalogEntry, Configuration, CurrentToolCatalog, DiscoveryTool, IncludesCatalogDocumentation, Limits, PinnedTool, RunToolVisibility, Selection, Snapshot, ToolNames, ToolNamespace, VisibilityHook, VisibilityRequest };
+}
+//#endregion
+export { AdditionalCatalogEntry, AdditionalToolCatalog, CatalogEntry, Configuration, CurrentToolCatalog, DiscoveryTool, IncludesCatalogDocumentation, Limits, PinnedTool, RunToolVisibility, Selection, Snapshot, ToolNames, ToolNamespace, VisibilityHook, VisibilityRequest, ToolExposure_d_exports as t };
+//# sourceMappingURL=ToolExposure.d.mts.map

package/dist/ToolExposure.mjs

@@ -0,0 +1,21 @@
+import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
+import { a as PinnedTool, c as ToolNames, i as Limits, l as ToolNamespace, n as DiscoveryTool, o as Selection, r as IncludesCatalogDocumentation, s as Snapshot, t as AdditionalToolCatalog } from "./ToolExposure-C93U1sPu.mjs";
+import { n as RunToolVisibility, t as CurrentToolCatalog } from "./ToolExposure-9uF_Yo0T.mjs";
+//#region src/ToolExposure.ts
+var ToolExposure_exports = /* @__PURE__ */ __exportAll({
+	AdditionalToolCatalog: () => AdditionalToolCatalog,
+	CurrentToolCatalog: () => CurrentToolCatalog,
+	DiscoveryTool: () => DiscoveryTool,
+	IncludesCatalogDocumentation: () => IncludesCatalogDocumentation,
+	Limits: () => Limits,
+	PinnedTool: () => PinnedTool,
+	RunToolVisibility: () => RunToolVisibility,
+	Selection: () => Selection,
+	Snapshot: () => Snapshot,
+	ToolNames: () => ToolNames,
+	ToolNamespace: () => ToolNamespace
+});
+//#endregion
+export { AdditionalToolCatalog, CurrentToolCatalog, DiscoveryTool, IncludesCatalogDocumentation, Limits, PinnedTool, RunToolVisibility, Selection, Snapshot, ToolNames, ToolNamespace, ToolExposure_exports as t };
+
+//# sourceMappingURL=ToolExposure.mjs.map

package/dist/ToolExposure.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"ToolExposure.mjs","names":[],"sources":["../src/ToolExposure.ts"],"sourcesContent":["export * from \"./core/ToolExposure.ts\";\nexport * from \"./engine/ToolExposure.ts\";\n"],"mappings":""}

package/dist/ToolReconciler-DQVaJfpE.d.mts

@@ -0,0 +1,76 @@
+import { Context, Effect, Layer, Schema } from "effect";
+declare namespace ToolReconciler_d_exports {
+  export { PreparedToolCallEvidence, ReconciliationCompleted, ReconciliationDecision, ReconciliationNeverStarted, ReconciliationSafeToRetry, ReconciliationUncertain, ToolReconciler, ToolReconcilerError };
+}
+declare const PreparedToolCallEvidence_base: Schema.Class<PreparedToolCallEvidence, Schema.Struct<{
+  readonly threadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+  readonly submissionId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/SubmissionId">;
+  readonly runId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/RunId">;
+  readonly turn: Schema.Int;
+  readonly toolCallId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ToolCallId">;
+  readonly toolName: Schema.NonEmptyString;
+  readonly parameters: Schema.declare<Schema.Json, Schema.Json>;
+  readonly parametersDigest: Schema.brand<Schema.String, "@effect-agent/thread/Digest">;
+}>, {}>;
+/**
+ * Everything a reconciliation policy can consult about one prepared-but-unsettled ordinary Tool
+ * Call (durability §10): deterministic identities for supplier-side lookup plus the exact
+ * Schema-encoded parameters and their digest. Built from the canonical `ToolCallPrepared` record
+ * and the owning Submission's identities — never from in-memory Attempt state.
+ */
+declare class PreparedToolCallEvidence extends PreparedToolCallEvidence_base {}
+declare const ReconciliationNeverStarted_base: Schema.Class<ReconciliationNeverStarted, Schema.TaggedStruct<"NeverStarted", {}>, {}>;
+/** Proof that the external execution never started: the call may re-execute on resume. */
+declare class ReconciliationNeverStarted extends ReconciliationNeverStarted_base {}
+declare const ReconciliationCompleted_base: Schema.Class<ReconciliationCompleted, Schema.TaggedStruct<"CompletedWithResult", {
+  readonly result: Schema.declare<Schema.Json, Schema.Json>;
+  readonly isFailure: Schema.Boolean;
+}>, {}>;
+/**
+ * Proof that the external execution completed: `result` is the recovered supplier truth, which
+ * becomes canonical (`ToolCallSettled` + `ToolCallResolved`) WITHOUT executing anything.
+ */
+declare class ReconciliationCompleted extends ReconciliationCompleted_base {}
+declare const ReconciliationSafeToRetry_base: Schema.Class<ReconciliationSafeToRetry, Schema.TaggedStruct<"SafeToRetry", {}>, {}>;
+/** The call is safe to repeat under a stable external idempotency contract. */
+declare class ReconciliationSafeToRetry extends ReconciliationSafeToRetry_base {}
+declare const ReconciliationUncertain_base: Schema.Class<ReconciliationUncertain, Schema.TaggedStruct<"Uncertain", {
+  readonly reason: Schema.String;
+}>, {}>;
+/** No proof either way: the outcome is Unknown and requires authorized resolution (DUR-017). */
+declare class ReconciliationUncertain extends ReconciliationUncertain_base {}
+/**
+ * What a reconciliation policy can prove about one prepared-but-unsettled ordinary Tool Call
+ * (durability §10): execution never started, execution completed with a recoverable result,
+ * execution is safe to repeat, or nothing — in which case the Run enters Unknown. The engine
+ * never manufactures an error result and continues.
+ */
+declare const ReconciliationDecision: Schema.Union<readonly [typeof ReconciliationNeverStarted, typeof ReconciliationCompleted, typeof ReconciliationSafeToRetry, typeof ReconciliationUncertain]>;
+type ReconciliationDecision = typeof ReconciliationDecision.Type;
+declare const ToolReconcilerError_base: Schema.Class<ToolReconcilerError, Schema.TaggedStruct<"ToolReconcilerError", {
+  readonly toolCallId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ToolCallId">;
+  readonly message: Schema.String;
+  readonly cause: Schema.optionalKey<Schema.Defect>;
+}>, import("effect/Cause").YieldableError>;
+/** The reconciliation policy itself failed (supplier unreachable, corrupt lookup, ...). The
+ * caller treats this as no proof: the call stays open and the pass may retry. */
+declare class ToolReconcilerError extends ToolReconcilerError_base {}
+declare const ToolReconciler_base: Context.ServiceClass<ToolReconciler, "@effect-agent/thread/ToolReconciler", {
+  readonly reconcile: (evidence: PreparedToolCallEvidence) => Effect.Effect<ReconciliationDecision, ToolReconcilerError>;
+}>;
+/**
+ * Application-registered reconciliation policy consulted by recovery for every open ordinary
+ * Tool Call before an Unknown Outcome is recorded (durability §10, DUR-009). A decision is a
+ * claim about EXTERNAL truth — typically an idempotency-keyed supplier lookup — never a guess
+ * from canonical state alone.
+ *
+ * `ToolReconciler.uncertain` is the fail-closed default (AGENTS rule 11): with no registered
+ * policy, every open call stays Unknown and routes to the authorized DUR-017 resolution path.
+ */
+declare class ToolReconciler extends ToolReconciler_base {
+  /** Fail-closed default: no proof is ever asserted, every open call stays Unknown. */
+  static readonly uncertain: Layer.Layer<ToolReconciler>;
+}
+//#endregion
+export { ReconciliationSafeToRetry as a, ToolReconcilerError as c, ReconciliationNeverStarted as i, ToolReconciler_d_exports as l, ReconciliationCompleted as n, ReconciliationUncertain as o, ReconciliationDecision as r, ToolReconciler as s, PreparedToolCallEvidence as t };
+//# sourceMappingURL=ToolReconciler-DQVaJfpE.d.mts.map