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

package/dist/AgentUpdates-DMJ-_xow.d.mts

@@ -0,0 +1,53 @@
+import { t as AgentId } from "./Identifiers-CN2s30fF.mjs";
+import { t as IdempotencyKey } from "./Receipt-BAHyigAF.mjs";
+import { Context, Effect, Schema, Stream } from "effect";
+declare namespace AgentUpdates_d_exports {
+  export { Emitter, Update, UpdateError, decode, emit, observe };
+}
+declare const Update_base: Schema.Class<Update, Schema.Struct<{
+  readonly schemaVersion: Schema.Literal<1>;
+  readonly agentId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/AgentId">;
+  readonly threadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+  readonly runId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/RunId">;
+  readonly updateId: Schema.brand<Schema.NonEmptyString, "@effect-agent/thread/IdempotencyKey">;
+  readonly sequence: Schema.Int;
+  readonly value: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+}>, {}>;
+/** Canonical schema-encoded intermediate output, scoped to one logical Run. */
+declare class Update extends Update_base {}
+declare const UpdateError_base: Schema.Class<UpdateError, Schema.TaggedStruct<"AgentUpdateError", {
+  readonly reason: Schema.Literals<readonly ["validation", "unavailable", "conflict", "capacity", "storage", "identity", "denied"]>;
+}>, import("effect/Cause").YieldableError>;
+/** Fail-closed update acceptance and decoding errors; payloads are never included. */
+declare class UpdateError extends UpdateError_base {}
+declare const Emitter_base: Context.ServiceClass<Emitter, "@effect-agent/core/AgentUpdates/Emitter", {
+  readonly emit: (request: {
+    readonly target: {
+      readonly id: AgentId;
+      readonly updates?: Schema.Top | undefined;
+    };
+    readonly updateId: IdempotencyKey;
+    readonly value: Schema.Json;
+  }) => Effect.Effect<Update, UpdateError>;
+}>;
+/** Engine-owned invocation port. The Agent ID and exact update Schema must match the executing definition. */
+declare class Emitter extends Emitter_base {}
+/** Structural schema boundary accepted by definitions and their model bindings. */
+type Source<S extends Schema.Top> = {
+  readonly id: AgentId;
+  readonly updates?: S | undefined;
+};
+type BoundSource<S extends Schema.Top> = Source<S> | {
+  readonly definition: Source<S>;
+};
+/** Emit a decoded update under an explicit stable key. Retries cannot replace accepted values. */
+declare const emit: <S extends Schema.Top>(agent: BoundSource<S>, value: NoInfer<S["Type"]>, options: {
+  readonly idempotencyKey: IdempotencyKey;
+}) => Effect.Effect<Update, UpdateError, Emitter | S["EncodingServices"]>;
+/** Decode canonical update data through its declaring Agent Schema. */
+declare const decode: <S extends Schema.Top>(agent: BoundSource<S>, update: Update) => Effect.Effect<S["Type"], UpdateError, S["DecodingServices"]>;
+/** Decode an encoded update stream without hiding its failures or requirements. */
+declare const observe: <S extends Schema.Top, E, R>(agent: BoundSource<S>, updates: Stream.Stream<Update, E, R>) => Stream.Stream<S["Type"], E | UpdateError, R | S["DecodingServices"]>;
+//#endregion
+export { decode as a, UpdateError as i, Emitter as n, emit as o, Update as r, observe as s, AgentUpdates_d_exports as t };
+//# sourceMappingURL=AgentUpdates-DMJ-_xow.d.mts.map

package/dist/ContextCompactor-WwSIG_Z2.d.mts

@@ -0,0 +1,161 @@
+import { s as RunId, u as ThreadId } from "./Identifiers-CN2s30fF.mjs";
+import { i as CompactionPolicy } from "./AgentPolicy-BqDoSXO6.mjs";
+import { n as ContextRolloverRequest } from "./ContextWindow-DRQ5Mbm2.mjs";
+import { LanguageModel, Model, Prompt } from "effect/unstable/ai";
+import { Context, Effect, Layer, Option, Schema, Stream } from "effect";
+//#region src/engine/internal/compaction.d.ts
+/**
+ * Pure helpers for engine-native context compaction (RUN-026/RUN-027). Everything here is deterministic and side-effect free:
+ * the engine's turn loop owns the state transitions, the durable coordinator
+ * owns the canonical record, and this module owns the arithmetic.
+ *
+ * Compaction is a VIEW over official history, never a mutation of it. The
+ * durable commit machinery slices official history by length
+ * (`lastCommitLen` in the coordinator), so official history must stay
+ * append-only within an Attempt; only the outgoing model prompt is rebuilt.
+ */
+/** Model-visible replacement for a tool result cleared by prune compaction. */
+declare const CLEARED_TOOL_RESULT = "[tool result cleared by compaction]";
+/** Prefix of the user message that carries a compaction summary into the prompt. */
+declare const COMPACTION_SUMMARY_PREFIX = "The prior thread was compacted into this summary:\n\n";
+/** Rollover text is recovery evidence; it never asserts that an external action succeeded. */
+declare const CONTEXT_ROLLOVER_PREFIX = "A fresh context window has started. Earlier conversation has left this model view. Restore relevant notes and use available history tools to retrieve evidence; verify live state before repeating an action.\n\n";
+/** Stable across Attempts; the initial window uses turn zero. */
+declare const contextWindowId: (runId: string, turn: number) => string;
+/** Shared by the live interpreter and canonical journal projection. */
+declare const contextWindowMessage: (windowId: string, handoff?: string) => Prompt.Message;
+/**
+ * Deterministic UTF-8 bytes/4 token estimate over one message's structural JSON.
+ * Conservative for prose, slightly generous for dense JSON — the estimate
+ * only gates WHEN to compact, never what is preserved.
+ */
+declare const estimateMessageTokens: (message: Prompt.Message) => number;
+/** Sum of `estimateMessageTokens` over a message array. */
+declare const estimatePromptTokens: (messages: ReadonlyArray<Prompt.Message>, estimate?: (message: Prompt.Message) => number) => number;
+/**
+ * Mutable per-Run compaction state held on the engine's RunContext. Indices
+ * are positions in the SOURCE prompt (the official-history basis handed to
+ * each Turn). Ordinary history grows append-only. Prepared history must retain
+ * content-equivalent covered prefixes or the engine rejects the next Turn.
+ */
+interface ContextCompactionState {
+  /**
+   * Source-index bounds `[start, end)` of the protected instruction/input
+   * block, mapped to prepared indices when necessary. `-1` before mapping;
+   * an unmappable protected block fails before any compaction decision.
+   */
+  protectedStart: number;
+  protectedEnd: number;
+  /** Prepared prompts also retain application-added system instructions. */
+  protectSystemMessages?: boolean;
+  /** Tool messages at source index below this bound render as cleared. */
+  clearedThrough: number;
+  /**
+   * Source messages below this bound (outside the protected block) are
+   * replaced by a summary or a fresh-window marker. Absent before the first replacement.
+   */
+  replacement: {
+    readonly kind: "summarize";
+    readonly through: number;
+    readonly summary: string;
+  } | {
+    readonly kind: "rollover";
+    readonly through: number;
+    readonly windowId: string;
+    readonly handoff?: string;
+  } | undefined;
+  /** Loop guard: at most one threshold compaction per Turn. */
+  lastCompactionTurn: number;
+  /** RUN-027 guard: at most one overflow compact-and-retry per Turn. */
+  overflowRetryTurn: number;
+  /**
+   * View length at the last model call, the base of the provider-anchored
+   * estimate. `-1` invalidates it (fresh Run or just compacted), forcing a
+   * full-view estimate.
+   */
+  lastViewLength: number;
+}
+declare namespace ContextCompactor_d_exports {
+  export { CompactionDecision, CompactionError, CompactionModelLayer, CompactionRequest, ContextCompaction, ContextCompactor, ContextMessageTokenEstimator };
+}
+/**
+ * A proposed view change. Source indices are exclusive prefix bounds, never record sequences.
+ * Summaries contain at most 65,536 characters; the interpreter rejects oversized decisions
+ * before committing or changing coverage.
+ */
+declare const CompactionDecision: Schema.Union<readonly [Schema.Struct<{
+  readonly kind: Schema.Literal<"rollover">;
+  readonly through: Schema.Natural;
+  readonly handoff: Schema.optionalKey<Schema.NonEmptyString>;
+}>, Schema.Struct<{
+  readonly kind: Schema.Literal<"clear-tool-results">;
+  readonly through: Schema.Natural;
+}>, Schema.Struct<{
+  readonly kind: Schema.Literal<"summarize">;
+  readonly through: Schema.Natural;
+  readonly summary: Schema.NonEmptyString;
+}>]>;
+type CompactionDecision = typeof CompactionDecision.Type;
+declare const CompactionError_base: Schema.Class<CompactionError, Schema.TaggedStruct<"CompactionError", {
+  readonly message: Schema.String;
+  readonly cause: Schema.optionalKey<Schema.Defect>;
+}>, import("effect/Cause").YieldableError>;
+/** Expected strategy or decision-validation failure. Causes stay in the live Effect only. */
+declare class CompactionError extends CompactionError_base {}
+/** Upstream Model.captureRequirements returns this closed Layer. */
+type CompactionModelLayer = Layer.Layer<LanguageModel.LanguageModel | Model.ProviderName | Model.ModelName>;
+/** A full message estimate, or undefined to use the native structural estimate. */
+type ContextMessageTokenEstimator = (message: Prompt.Message) => number | undefined;
+/**
+ * One bounded pass over an immutable source snapshot. A harness owns state, metering, and
+ * application of decisions. The interpreter permits at most one prune followed by one replacement
+ * (summary or rollover), and one call to summarize per Turn, shared across every trigger.
+ * All model work must use summarize so it is metered.
+ * Callback failures and requirements pass through unchanged; strategy dependencies belong to
+ * its construction Layer. Protected messages cannot be removed and Tool pairs cannot be split by a decision.
+ */
+interface CompactionRequest<E, R> {
+  readonly threadId: ThreadId;
+  readonly runId: RunId;
+  readonly turn: number;
+  readonly source: Prompt.Prompt;
+  readonly state: Readonly<ContextCompactionState>;
+  readonly policy: CompactionPolicy;
+  readonly targetTokens: number | undefined;
+  readonly trigger: "pressure" | "overflow" | "requested";
+  /** Budget admission may prohibit a separate model call while still allowing a rollover. */
+  readonly modelCallAllowed: boolean;
+  /** The current captured Model's message accounting, including native fallback. */
+  readonly estimateMessageTokens?: ContextMessageTokenEstimator | undefined;
+  /** Present for a successful, singleton context rollover Tool; through excludes later steering. */
+  readonly requested?: (ContextRolloverRequest & {
+    readonly through: number;
+  }) | undefined;
+  readonly summarize: (prompt: Prompt.Prompt, model?: CompactionModelLayer) => Effect.Effect<string, E, R>;
+}
+interface ContextCompaction {
+  /** Non-negative finite integer estimate, used for admission and derived prompt overhead too. */
+  readonly estimate: (messages: ReadonlyArray<Prompt.Message>) => number;
+  /** Emit decisions sequentially; the consumer commits each before pulling the next. */
+  readonly compact: <E, R>(request: CompactionRequest<E, R>) => Stream.Stream<CompactionDecision, E | CompactionError, R>;
+}
+declare const ContextCompactor_base: Context.ServiceClass<ContextCompactor, "@effect-agent/engine/ContextCompactor", ContextCompaction>;
+/**
+ * The sole interpreter compaction port. Runs without an installed service provide layer at their
+ * composition boundary. Decorators yield this service during construction and receive their
+ * underlying implementation through Layer.provide. Direct harnesses use the same Layer contract.
+ */
+declare class ContextCompactor extends ContextCompactor_base {
+  static readonly layer: Layer.Layer<ContextCompactor, never, never>;
+  /**
+   * Start fresh windows without a summarizer call. The engine retains instructions/input and
+   * commits each boundary; a bounded emergency handoff preserves user inputs and unseen results.
+   * Applications provide notes/history tools alongside this strategy.
+   */
+  static readonly layerRollover: Layer.Layer<ContextCompactor, never, never>;
+  /** Use the bounded default algorithm with a separate upstream Effect AI Model. */
+  static readonly layerWithModel: <Provider, Requirements>(model: Model.Model<Provider, LanguageModel.LanguageModel, Requirements>) => Layer.Layer<ContextCompactor, never, Requirements>;
+}
+//#endregion
+export { ContextCompaction as a, ContextMessageTokenEstimator as c, CONTEXT_ROLLOVER_PREFIX as d, ContextCompactionState as f, estimatePromptTokens as g, estimateMessageTokens as h, CompactionRequest as i, CLEARED_TOOL_RESULT as l, contextWindowMessage as m, CompactionError as n, ContextCompactor as o, contextWindowId as p, CompactionModelLayer as r, ContextCompactor_d_exports as s, CompactionDecision as t, COMPACTION_SUMMARY_PREFIX as u };
+//# sourceMappingURL=ContextCompactor-WwSIG_Z2.d.mts.map

package/dist/ContextWindow-DRQ5Mbm2.d.mts

@@ -0,0 +1,58 @@
+import { Context, Effect, Schema } from "effect";
+declare namespace ContextWindow_d_exports {
+  export { ContextHandoff, ContextRolloverRequest, ContextRolloverSelection, ContextRolloverTool, ContextWindow, ContextWindowStatus, ModelCallContext };
+}
+/** Model-authored continuation state; fuller notes belong in an application-owned memory store. */
+declare const ContextHandoff: Schema.NonEmptyString;
+/** Successful output of an explicitly designated context-window Tool. */
+declare const ContextRolloverRequest: Schema.Struct<{
+  readonly handoff: Schema.optionalKey<Schema.NonEmptyString>;
+}>;
+type ContextRolloverRequest = typeof ContextRolloverRequest.Type;
+/**
+ * Host-selected exclusive source-message boundary, applied at the next safe model seam.
+ * Omit through to reset the prefix before the protected current instructions/input. The
+ * engine resolves that prefix after preparation; an empty prior prefix needs no new window.
+ */
+declare const ContextRolloverSelection: Schema.Struct<{
+  readonly handoff: Schema.optionalKey<Schema.NonEmptyString>;
+  readonly through: Schema.optionalKey<Schema.Natural>;
+}>;
+type ContextRolloverSelection = typeof ContextRolloverSelection.Type;
+declare const ModelCallContext_base: Schema.Class<ModelCallContext, Schema.Struct<{
+  readonly contextCapacity: Schema.Int;
+  readonly maxInputTokens: Schema.optionalKey<Schema.Int>;
+  readonly outputReserveTokens: Schema.Natural;
+  readonly uncountedOverheadTokens: Schema.Natural;
+}>, {}>;
+/**
+ * Bounds resolved alongside the native model for one Turn. Output reserve must match the
+ * selected provider configuration. Uncounted overhead includes only provider framing or image
+ * token costs absent from the prompt estimate; prompt text, output contracts, and native Tool
+ * schemas are counted by the engine. These are live-context bounds, not cumulative Run budgets.
+ */
+declare class ModelCallContext extends ModelCallContext_base {}
+/**
+ * Definition-owned control annotation. A successful singleton application Tool carrying this
+ * annotation returns ContextRolloverRequest. The engine applies it at the next Turn seam,
+ * including after durable Tool-result replay. A Tool name alone never grants this authority.
+ */
+declare const ContextRolloverTool: Context.Reference<boolean>;
+declare const ContextWindowStatus_base: Schema.Class<ContextWindowStatus, Schema.Struct<{
+  readonly threadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+  readonly runId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/RunId">;
+  readonly windowId: Schema.NonEmptyString;
+  readonly estimatedTokens: Schema.Natural;
+  readonly contextTokenLimit: Schema.NullOr<Schema.Natural>;
+  readonly remainingTokens: Schema.NullOr<Schema.Natural>;
+}>, {}>;
+/** Best available live-context estimate, independent of cumulative Run budgets. */
+declare class ContextWindowStatus extends ContextWindowStatus_base {}
+declare const ContextWindow_base: Context.ServiceClass<ContextWindow, "@effect-agent/engine/ContextWindow", {
+  readonly status: Effect.Effect<ContextWindowStatus>;
+}>;
+/** Engine-owned identity and context accounting for the current Run. */
+declare class ContextWindow extends ContextWindow_base {}
+//#endregion
+export { ContextWindow as a, ModelCallContext as c, ContextRolloverTool as i, ContextRolloverRequest as n, ContextWindowStatus as o, ContextRolloverSelection as r, ContextWindow_d_exports as s, ContextHandoff as t };
+//# sourceMappingURL=ContextWindow-DRQ5Mbm2.d.mts.map