effect-agent 0.1.0-beta.155 → 0.1.0-beta.157

package/src/core/Agent.ts

@@ -6,7 +6,7 @@ import {
   type Model,
   type Prompt,
   Tool,
-  type Toolkit,
+  Toolkit,
 } from "effect/unstable/ai";
 
 import type { AgentInputError, AgentOutputError, AgentRunDispositionError } from "./AgentError.ts";
@@ -569,9 +569,23 @@ export function make(
     completionNames.add(declaration.tool);
   }
 
+  const tools = Object.values(options.toolkit.tools);
+
+  const readonlyTools = tools.map((tool) =>
+    Tool.isProviderDefined(tool) &&
+    !tool.requiresHandler &&
+    ["web_search", "web_search_preview", "file_search"].includes(tool.providerName)
+      ? tool.annotate(Tool.Readonly, true)
+      : tool,
+  );
+
+  const toolkit = readonlyTools.some((tool, index) => tool !== tools[index])
+    ? Toolkit.make(...readonlyTools)
+    : options.toolkit;
+
   return Object.freeze({
     ...options,
-    toolkit: withUpdateTool(options.toolkit, options.updates),
+    toolkit: withUpdateTool(toolkit, options.updates),
     policy: AgentPolicy.resolve(options.policy),
     policyOverrides: Object.freeze({ ...options.policy }),
     toolExposure:

package/src/core/Usage.ts

@@ -68,6 +68,8 @@ export class ModelCallUsage extends Schema.Class<ModelCallUsage>(
   pricingStatus: Schema.optionalKey(Schema.Literals(["estimated", "unknown"])),
   inputTokens: InputTokenUsage,
   outputTokens: OutputTokenUsage,
+  /** Observed hosted web searches; excludes OpenAI page/find actions. Absent in legacy records. */
+  webSearchCalls: Schema.optionalKey(Schema.Natural),
   costMicrousd: Schema.Natural,
 }) {}
 
@@ -80,6 +82,8 @@ export class RunTotals extends Schema.Class<RunTotals>("@effect-agent/core/RunTo
   modelCalls: Schema.Natural,
   inputTokens: Schema.Natural,
   outputTokens: Schema.Natural,
+  /** Observed hosted web searches; excludes OpenAI page/find actions. Absent in legacy records. */
+  webSearchCalls: Schema.optionalKey(Schema.Natural),
   costMicrousd: Schema.Natural,
   usageStatus: Schema.optionalKey(UsageCompleteness),
   pricingStatus: Schema.optionalKey(UsageCompleteness),
@@ -104,6 +108,7 @@ export class ChildRunUsage extends Schema.Class<ChildRunUsage>("@effect-agent/co
 export const emptyRunTotals = (): RunTotals =>
   RunTotals.make({
     modelCalls: 0,
+    webSearchCalls: 0,
     inputTokens: 0,
     outputTokens: 0,
     costMicrousd: 0,
@@ -133,6 +138,8 @@ export class ModelUsageGroup extends Schema.Class<ModelUsageGroup>(
   modelCalls: Schema.Natural.check(Schema.isGreaterThan(0)),
   inputTokens: InputTokenUsage,
   outputTokens: OutputTokenUsage,
+  /** Observed hosted web searches; excludes OpenAI page/find actions. Absent in legacy records. */
+  webSearchCalls: Schema.optionalKey(Schema.Natural),
   costMicrousd: Schema.Natural,
 }) {}
 
@@ -140,6 +147,8 @@ const RunUsageSummaryFields = Schema.Struct({
   modelCalls: Schema.Natural,
   inputTokens: InputTokenUsage,
   outputTokens: OutputTokenUsage,
+  /** Observed hosted web searches; excludes OpenAI page/find actions. Absent in legacy records. */
+  webSearchCalls: Schema.optionalKey(Schema.Natural),
   costMicrousd: Schema.Natural,
   byModel: Schema.Array(ModelUsageGroup),
   /** Coverage of recorded calls only; interruptions can make the Run less complete. */
@@ -162,6 +171,11 @@ const RunUsageSummaryFields = Schema.Struct({
 
       return (
         new Set(identities).size === identities.length &&
+        (summary.webSearchCalls === undefined ||
+          hasAdditiveTotal(
+            summary.webSearchCalls,
+            summary.byModel.map((group) => group.webSearchCalls ?? 0),
+          )) &&
         hasAdditiveTotal(
           summary.modelCalls,
           summary.byModel.map((group) => group.modelCalls),
@@ -219,6 +233,7 @@ interface MutableUsageGroup {
   readonly serviceTier?: string | undefined;
   readonly pricingVersion?: string | undefined;
   modelCalls: number;
+  webSearchCalls: number | undefined;
   inputTokens: {
     total: number;
     uncached: number;
@@ -267,6 +282,7 @@ export const sumRunTotals = Effect.fn("sumRunTotals")(function* (
   contributions: ReadonlyArray<RunTotals>,
 ): Effect.fn.Return<RunTotals, UsageAggregationError> {
   let modelCalls = 0;
+  let webSearchCalls: number | undefined = 0;
   let inputTokens = 0;
   let outputTokens = 0;
   let costMicrousd = 0;
@@ -282,6 +298,13 @@ export const sumRunTotals = Effect.fn("sumRunTotals")(function* (
     );
 
     modelCalls = yield* checkedAdd("modelCalls", modelCalls, value.modelCalls);
+    if (value.webSearchCalls === undefined && value.modelCalls > 0) webSearchCalls = undefined;
+    else if (webSearchCalls !== undefined)
+      webSearchCalls = yield* checkedAdd(
+        "webSearchCalls",
+        webSearchCalls,
+        value.webSearchCalls ?? 0,
+      );
     inputTokens = yield* checkedAdd("inputTokens", inputTokens, value.inputTokens);
     outputTokens = yield* checkedAdd("outputTokens", outputTokens, value.outputTokens);
     costMicrousd = yield* checkedAdd("costMicrousd", costMicrousd, value.costMicrousd);
@@ -316,6 +339,7 @@ export const sumRunTotals = Effect.fn("sumRunTotals")(function* (
 
   return RunTotals.make({
     modelCalls,
+    ...(webSearchCalls === undefined ? {} : { webSearchCalls }),
     inputTokens,
     outputTokens,
     costMicrousd,
@@ -329,6 +353,7 @@ export const sumRunTotals = Effect.fn("sumRunTotals")(function* (
 export const runTotalsFromSummary = (summary: RunUsageSummary): RunTotals =>
   RunTotals.make({
     modelCalls: summary.modelCalls,
+    ...(summary.webSearchCalls === undefined ? {} : { webSearchCalls: summary.webSearchCalls }),
     inputTokens: summary.inputTokens.total,
     outputTokens: summary.outputTokens.total,
     costMicrousd: summary.costMicrousd,
@@ -363,6 +388,10 @@ export const summarizeModelUsage = Effect.fn("summarizeModelUsage")(function* (
   const outputTokens = initial === undefined ? emptyOutputTokens() : { ...initial.outputTokens };
   const groups = new Map<string, MutableUsageGroup>();
   let modelCalls = initial?.modelCalls ?? 0;
+
+  let webSearchCalls =
+    initial === undefined || initial.modelCalls === 0 ? 0 : initial.webSearchCalls;
+
   let costMicrousd = initial?.costMicrousd ?? 0;
   const hasSeedCalls = modelCalls > 0;
 
@@ -387,6 +416,7 @@ export const summarizeModelUsage = Effect.fn("summarizeModelUsage")(function* (
 
     groups.set(key, {
       ...group,
+      webSearchCalls: group.webSearchCalls,
       inputTokens: { ...group.inputTokens },
       outputTokens: { ...group.outputTokens },
     });
@@ -398,6 +428,10 @@ export const summarizeModelUsage = Effect.fn("summarizeModelUsage")(function* (
     allPricingUnknown &&= call.pricingStatus !== "estimated";
     allPricingComplete &&= call.pricingStatus === "estimated";
     modelCalls = yield* checkedAdd("modelCalls", modelCalls, 1);
+    webSearchCalls =
+      webSearchCalls === undefined || call.webSearchCalls === undefined
+        ? undefined
+        : yield* checkedAdd("webSearchCalls", webSearchCalls, call.webSearchCalls);
     inputTokens.total = yield* checkedAdd(
       "inputTokens.total",
       inputTokens.total,
@@ -453,6 +487,7 @@ export const summarizeModelUsage = Effect.fn("summarizeModelUsage")(function* (
         ...(call.serviceTier === undefined ? {} : { serviceTier: call.serviceTier }),
         ...(call.pricingVersion === undefined ? {} : { pricingVersion: call.pricingVersion }),
         modelCalls: 0,
+        webSearchCalls: 0,
         inputTokens: emptyInputTokens(),
         outputTokens: emptyOutputTokens(),
         costMicrousd: 0,
@@ -460,6 +495,10 @@ export const summarizeModelUsage = Effect.fn("summarizeModelUsage")(function* (
       groups.set(key, group);
     }
     group.modelCalls = yield* checkedAdd("byModel.modelCalls", group.modelCalls, 1);
+    group.webSearchCalls =
+      group.webSearchCalls === undefined || call.webSearchCalls === undefined
+        ? undefined
+        : yield* checkedAdd("byModel.webSearchCalls", group.webSearchCalls, call.webSearchCalls);
     group.inputTokens.total = yield* checkedAdd(
       "byModel.inputTokens.total",
       group.inputTokens.total,
@@ -504,6 +543,7 @@ export const summarizeModelUsage = Effect.fn("summarizeModelUsage")(function* (
 
   return RunUsageSummary.make({
     modelCalls,
+    ...(webSearchCalls === undefined ? {} : { webSearchCalls }),
     inputTokens: InputTokenUsage.make(inputTokens),
     outputTokens: OutputTokenUsage.make(outputTokens),
     costMicrousd,
@@ -520,6 +560,7 @@ export const summarizeModelUsage = Effect.fn("summarizeModelUsage")(function* (
         ...(group.serviceTier === undefined ? {} : { serviceTier: group.serviceTier }),
         ...(group.pricingVersion === undefined ? {} : { pricingVersion: group.pricingVersion }),
         modelCalls: group.modelCalls,
+        ...(group.webSearchCalls === undefined ? {} : { webSearchCalls: group.webSearchCalls }),
         inputTokens: InputTokenUsage.make(group.inputTokens),
         outputTokens: OutputTokenUsage.make(group.outputTokens),
         costMicrousd: group.costMicrousd,

package/src/durable/DurableAgentRuntime.ts

@@ -4559,6 +4559,7 @@ const make = Effect.fn("DurableAgentRuntime.make")(function* (
     ctx: AttemptAppendContext,
     submission: SubmissionSnapshot,
     tokenRef: Ref.Ref<OwnershipToken>,
+    renewAtRef: Ref.Ref<number>,
     records: ReadonlyArray<CanonicalRecordEnvelope>,
     canonical: Stream.Stream<CanonicalRecordEnvelope, ThreadStoreError | ThreadNotMaterialized>,
     canonicalThrough: CanonicalSequence,
@@ -5258,6 +5259,9 @@ const make = Effect.fn("DurableAgentRuntime.make")(function* (
           );
 
           return RunUsageSummary.make({
+            ...(legacyCalls === 0 && detailed.webSearchCalls !== undefined
+              ? { webSearchCalls: detailed.webSearchCalls }
+              : {}),
             modelCalls,
             inputTokens: InputTokenUsage.make({
               total: inputTokens,
@@ -7798,18 +7802,33 @@ const make = Effect.fn("DurableAgentRuntime.make")(function* (
       // Liveness only: the lease keeps the claim visible; correctness stays with the epoch fence.
       // OwnershipLost ends the race and interrupts the Run fiber cleanly.
       const renewal = halt(
-        Effect.repeat(
-          Effect.gen(function* () {
-            const ownershipToken = yield* Ref.get(tokenRef);
+        Effect.gen(function* () {
+          // Binding selection and preparation consume the acquired lease too. Carry the next
+          // deadline across model continuations; an overdue first renewal must run immediately.
+          const renewAt = yield* Ref.get(renewAtRef);
+          const now = yield* Clock.currentTimeMillis;
 
-            const renewal = yield* ledger.renewOwnership(
-              RenewOwnershipRequest.make({ submissionId, ownershipToken }),
-            );
+          yield* Effect.sleep(Math.max(0, renewAt - now));
+          yield* Effect.repeat(
+            Effect.gen(function* () {
+              const ownershipToken = yield* Ref.get(tokenRef);
+              const renewingAt = yield* Clock.currentTimeMillis;
+
+              const renewal = yield* ledger.renewOwnership(
+                RenewOwnershipRequest.make({ submissionId, ownershipToken }),
+              );
 
-            yield* Ref.set(tokenRef, renewal.ownershipToken);
-          }).pipe(Effect.uninterruptible),
-          { schedule: Schedule.spaced(config.leaseRenewalInterval) },
-        ).pipe(Effect.andThen(Effect.never)),
+              yield* Ref.set(tokenRef, renewal.ownershipToken);
+              yield* Ref.set(
+                renewAtRef,
+                renewingAt + Duration.toMillis(config.leaseRenewalInterval),
+              );
+            }).pipe(Effect.uninterruptible),
+            { schedule: Schedule.spaced(config.leaseRenewalInterval) },
+          );
+
+          return yield* Effect.never;
+        }),
       );
 
       const execution = Effect.raceFirst(consume, Effect.raceFirst(abortWatcher, renewal));
@@ -8031,6 +8050,7 @@ const make = Effect.fn("DurableAgentRuntime.make")(function* (
     threadId: ThreadId,
     claim: Claim,
     tokenRef: Ref.Ref<OwnershipToken>,
+    renewAtRef: Ref.Ref<number>,
     resumeAfterRetention: () => void,
     onHandoff: (nextSubmissionId: SubmissionId) => void,
     yieldAfter?: DateTime.Utc,
@@ -8467,6 +8487,7 @@ const make = Effect.fn("DurableAgentRuntime.make")(function* (
           ctx,
           submission,
           tokenRef,
+          renewAtRef,
           currentRecords,
           canonical,
           tail.tailSequence,
@@ -8647,6 +8668,8 @@ const make = Effect.fn("DurableAgentRuntime.make")(function* (
     threadId: ThreadId,
     handoff?: ClaimHandoff,
   ) {
+    const acquiringAt = yield* Clock.currentTimeMillis;
+
     const claimed = yield* ledger.claim(
       ClaimRequest.make({
         threadId,
@@ -8659,6 +8682,10 @@ const make = Effect.fn("DurableAgentRuntime.make")(function* (
     const claim = claimed.value;
     const tokenRef = yield* Ref.make(claim.ownershipToken);
 
+    const renewAtRef = yield* Ref.make(
+      acquiringAt + Duration.toMillis(config.leaseRenewalInterval),
+    );
+
     yield* Effect.addFinalizer(() =>
       Ref.get(tokenRef).pipe(
         Effect.flatMap((ownershipToken) =>
@@ -8681,7 +8708,7 @@ const make = Effect.fn("DurableAgentRuntime.make")(function* (
         message: "The submission adapter did not honor the requested handoff",
       });
 
-    return Option.some({ claim, tokenRef });
+    return Option.some({ claim, tokenRef, renewAtRef });
   }, Effect.uninterruptible);
 
   const processThreadHead = (
@@ -8701,7 +8728,7 @@ const make = Effect.fn("DurableAgentRuntime.make")(function* (
           const claimed = yield* acquireClaim(threadId, handoff);
 
           if (Option.isNone(claimed)) return Option.none();
-          const { claim, tokenRef } = claimed.value;
+          const { claim, tokenRef, renewAtRef } = claimed.value;
 
           const attributes = {
             threadId,
@@ -8781,6 +8808,7 @@ const make = Effect.fn("DurableAgentRuntime.make")(function* (
                 attemptThreadId,
                 attemptClaim,
                 tokenRef,
+                renewAtRef,
                 () => {
                   resumeAfterRetention = true;
                 },

package/src/durable/LifecyclePublication.ts

@@ -146,10 +146,13 @@ export type LifecyclePublicationBatch = typeof LifecyclePublicationBatch.Type;
 
 /** Native recovery state, independent of Attempts. Hosts serialize drains per storage owner. */
 export interface LifecyclePublicationStorage {
-  /** Select up to `limit` due owners, with a bounded pending prefix for each selected owner. */
+  /** Select up to `limit` due owners, with a bounded pending prefix for each selected owner.
+   * `retainedOnly` excludes unmaterialized source facts, for a precommitted start prefix.
+   */
   readonly pending: (
     nowMillis: number,
     limit: number,
+    options?: { readonly retainedOnly?: boolean },
   ) => Effect.Effect<ReadonlyArray<LifecyclePublicationBatch>, LifecyclePublicationError>;
   /** Atomically acknowledge the exact batch, retaining its identities and fingerprints. */
   readonly acknowledge: (
@@ -166,6 +169,15 @@ export interface LifecyclePublicationStorage {
     timeoutMillis: number,
   ) => Effect.Effect<boolean, LifecyclePublicationError>;
   readonly pendingDeadline: Effect.Effect<Option.Option<number>, LifecyclePublicationError>;
+  /**
+   * Deadline for `pending(..., { retainedOnly: true })`, excluding unmaterialized source facts.
+   * Source-backed stores provide this when `pendingDeadline` also includes source intent.
+   * Otherwise `pendingDeadline` already describes retained work.
+   */
+  readonly retainedPendingDeadline?: Effect.Effect<
+    Option.Option<number>,
+    LifecyclePublicationError
+  >;
   /** Explicit operator retry after repairing a parked owner's destination. */
   readonly retryParked: (
     ownerThreadId: ThreadId,
@@ -259,9 +271,10 @@ export const drainLifecyclePublications = Effect.fn("LifecyclePublication.drain"
   storage: LifecyclePublicationStorage,
   timeoutMillis = 10_000,
   limit = 4,
+  options?: { readonly retainedOnly?: boolean },
 ) {
   const handler = yield* LifecyclePublicationHandler;
-  const pending = yield* storage.pending(yield* Clock.currentTimeMillis, limit);
+  const pending = yield* storage.pending(yield* Clock.currentTimeMillis, limit, options);
 
   let failures: Cause.Cause<LifecyclePublicationError> = Cause.empty;