e2e 0.15.2 → 0.17.0

package/dist/.build.json

@@ -1 +1 @@
-{"version":"0.15.2"}
+{"version":"0.17.0"}

package/dist/agent/act-validation.d.ts

@@ -35,6 +35,15 @@ export declare function validateParams(params: AgentParams | undefined): {
     secrets: ReadonlyMap<string, Secret>;
     templates: readonly ParamTemplate[];
 };
+/**
+ * Projected params with `redact` applied to every string in them, object
+ * keys included, and their `unique()` templates moved with their leaves: a
+ * template's pointer follows the redacted keys and its value is redacted as
+ * the leaf is, so the trace cache slots what the params hold.
+ */
+export declare function redactParams(params: Readonly<Record<string, JsonValue>>, templates: readonly ParamTemplate[], redact: (text: string) => string): {
+    params: Readonly<Record<string, JsonValue>>;
+    templates: readonly ParamTemplate[];
+};
 /** Closes the verdict grammar: the executor cannot invent statuses or codes. */
 export declare function validateVerdict(verdict: unknown, executorName: string): StepVerdict;
-//# sourceMappingURL=act-validation.d.ts.map

package/dist/agent/act-validation.js

@@ -90,6 +90,54 @@ export function validateParams(params) {
         templates: found.templates,
     };
 }
+/**
+ * Projected params with `redact` applied to every string in them, object
+ * keys included, and their `unique()` templates moved with their leaves: a
+ * template's pointer follows the redacted keys and its value is redacted as
+ * the leaf is, so the trace cache slots what the params hold.
+ */
+export function redactParams(params, templates, redact) {
+    const pointers = new Map();
+    const redacted = redactJson(params, redact, { from: '', to: '' }, pointers);
+    return {
+        params: redacted,
+        templates: templates.map((template) => ({
+            pointer: pointers.get(template.pointer) ?? template.pointer,
+            value: redact(template.value),
+        })),
+    };
+}
+/**
+ * `value` with `redact` applied to every string in it, object keys included.
+ * Records in `pointers` where each node's pointer (`at.from`) lands once its
+ * keys are redacted (`at.to`). Two keys of one object that redact alike would
+ * leave one value standing for both, so that is `INVALID_ARGUMENT`.
+ */
+function redactJson(value, redact, at, pointers) {
+    pointers.set(at.from, at.to);
+    if (typeof value === 'string')
+        return redact(value);
+    if (Array.isArray(value)) {
+        return value.map((entry, index) => redactJson(entry, redact, { from: paramPointer(at.from, index), to: paramPointer(at.to, index) }, pointers));
+    }
+    if (typeof value !== 'object' || value === null)
+        return value;
+    const out = {};
+    for (const [key, entry] of Object.entries(value)) {
+        const clean = redact(key);
+        if (Object.hasOwn(out, clean)) {
+            throw new TestError('INVALID_ARGUMENT', `agent.act params has two keys that read ${JSON.stringify(clean)} once secret values are redacted; a key cannot be told apart by a secret`);
+        }
+        // Defined, not assigned, so a `__proto__` key stays an own property.
+        Object.defineProperty(out, clean, {
+            value: redactJson(entry, redact, { from: paramPointer(at.from, key), to: paramPointer(at.to, clean) }, pointers),
+            enumerable: true,
+            writable: true,
+            configurable: true,
+        });
+    }
+    return out;
+}
 /** Replaces every Secret leaf with its placeholder and every Unique leaf with its value, collecting both. */
 function projectParams(value, pointer, found, seen) {
     if (isSecret(value)) {
@@ -146,4 +194,3 @@ export function validateVerdict(verdict, executorName) {
         ...(code === undefined ? {} : { errorCode: code }),
     };
 }
-//# sourceMappingURL=act-validation.js.map

package/dist/agent/act.d.ts

@@ -66,5 +66,4 @@ export declare function runAssertStep(runtime: AgentContext, assertion: string,
  * passing is what confirms the traces staged before it at attempt end
  * (cache/context.ts).
  */
-export declare function dispatchAgentStep(runtime: AgentContext, spec: DispatchSpec, agent?: DispatchAgent): Promise<ActResult>;
-//# sourceMappingURL=act.d.ts.map
+export declare function dispatchAgentStep(runtime: AgentContext, raw: DispatchSpec, agent?: DispatchAgent): Promise<ActResult>;

package/dist/agent/act.js

@@ -21,7 +21,7 @@ import { join } from 'node:path';
 import { ConfigurationError } from '../internal/errors.js';
 import { withAbort, withTimeout } from '../internal/time.js';
 import { AgentError, CATEGORY_BY_CODE, toAgentError } from './error.js';
-import { validateActOptions, validateInstruction, validateParams, validateVerdict } from './act-validation.js';
+import { redactParams, validateActOptions, validateInstruction, validateParams, validateVerdict } from './act-validation.js';
 import { ActionDispatcher } from './action-dispatcher.js';
 import { resolveBoundedBudget, resolveTimeout } from './call-options.js';
 import { RUNTIME_CODES } from './executor.js';
@@ -29,6 +29,7 @@ import { projectPriorSteps, serializeLedger } from './ledger.js';
 import { instantiateLanguageModel } from './model/sdk.js';
 import { ObservationFeed } from './observation-feed.js';
 import { recordPolicyEvent } from './phases.js';
+import { appLocation } from '../cache/route.js';
 import { OperationQueue } from './operation-queue.js';
 import { StepAccounting } from './step-accounting.js';
 import { failedStepOutcome, StepTraceSession } from './step-cache.js';
@@ -88,12 +89,16 @@ export async function runAssertStep(runtime, assertion, options) {
  * passing is what confirms the traces staged before it at attempt end
  * (cache/context.ts).
  */
-export async function dispatchAgentStep(runtime, spec, 
+export async function dispatchAgentStep(runtime, raw, 
 // Resolved before the step opens, so an unknown name fails the call, not a
 // recorded step, and the step carries the agent it ran with.
-agent = runtime.select(spec.agent)) {
+agent = runtime.select(raw.agent)) {
+    const spec = redactSpec(raw, runtime.redact);
+    // Redacted per step, not once per agent: the ledger is live, so a value
+    // resolved since the agent was selected is covered too.
+    const context = agent.agentContext === undefined ? undefined : runtime.redact(agent.agentContext);
     return runtime.steps.run('agent', spec.api, spec.instruction, async () => {
-        const dispatch = new ActDispatch(runtime, spec, agent);
+        const dispatch = new ActDispatch(runtime, spec, { ...agent, agentContext: context });
         try {
             let verdict;
             try {
@@ -116,6 +121,20 @@ agent = runtime.select(spec.agent)) {
         }
     }, { verifies: spec.kind === 'assert', agent: agent.name });
 }
+/**
+ * The spec with every registered secret value the test spelled into the
+ * instruction or a param string (a key or a leaf) rewritten to its marker,
+ * before anything reads it: the executor, its model, the step label, the
+ * trace cache, and the prior-step ledger all see the same redacted step. A
+ * `Secret` handle is already a placeholder here and stays fillable through
+ * `typeSecret`.
+ */
+function redactSpec(spec, redact) {
+    const instruction = redact(spec.instruction);
+    if (spec.params === undefined)
+        return { ...spec, instruction };
+    return { ...spec, instruction, ...redactParams(spec.params, spec.templates, redact) };
+}
 /** One step's wiring: the collaborators, the executor's context, and the verdict mapping. */
 class ActDispatch {
     runtime;
@@ -181,7 +200,10 @@ class ActDispatch {
                         name: agent.executor.name,
                         ...(agent.executor.version === undefined ? {} : { version: agent.executor.version }),
                     },
+                    // Redacted already (`dispatchAgentStep`): the key digests the context the executor reads.
+                    agent: { name: agent.name, context: agent.agentContext },
                     redact: runtime.redact,
+                    redactCut: runtime.redactCut,
                     maxActions: this.accounting.maxActions,
                     stepIndex,
                 });
@@ -403,11 +425,10 @@ class ActDispatch {
         const feed = this.feed;
         return {
             get traceEligible() { return feed.traceEligible; },
-            observe: async (mode) => screenOf(await this.feed.probe(mode)),
+            observe: async (mode) => screenOf(await this.feed.probe(mode), this.runtime.app.base?.origin),
             actions: this.dispatcher.actions,
             signal: this.accounting.signal,
             remainingMs: () => this.accounting.remainingMs(),
-            redact: this.runtime.redact,
             replaying: (active) => {
                 this.runtime.steps.replaying(active);
                 this.accounting.replaying(active);
@@ -456,13 +477,12 @@ class ActDispatch {
     }
 }
 /** The replay engine's view of a capture: the nodes, and the viewport a recorded point is checked against. */
-function screenOf(observation) {
+function screenOf(observation, appOrigin) {
     const metadata = {
         viewport: { width: observation.viewport.width, height: observation.viewport.height },
-        ...(observation.path === undefined ? {} : { path: observation.path }),
+        ...(observation.location === undefined ? {} : { path: appLocation(observation.location, appOrigin) }),
     };
     return observation.kind === 'semantic'
         ? { ...metadata, kind: 'semantic', nodes: observation.nodes }
         : { ...metadata, kind: 'pixels' };
 }
-//# sourceMappingURL=act.js.map

package/dist/agent/action-dispatcher.d.ts

@@ -184,4 +184,3 @@ export declare class ActionDispatcher {
     /** The seam a policy records its decisions through, onto this step's events. */
     private policyHost;
 }
-//# sourceMappingURL=action-dispatcher.d.ts.map

package/dist/agent/action-dispatcher.js

@@ -487,10 +487,10 @@ export class ActionDispatcher {
     }
     async runActionNow(name, body) {
         this.accounting.reserveAction();
-        const redact = this.runtime.redact;
+        const redaction = { redact: this.runtime.redact, redactCut: this.runtime.redactCut };
         let action;
         try {
-            action = await instrumentPhase(this.runtime, { api: this.accounting.api, kind: 'engine', phase: 'agent.action', name }, body, (committed) => ({ detail: describeAction(committed, redact).summary }));
+            action = await instrumentPhase(this.runtime, { api: this.accounting.api, kind: 'engine', phase: 'agent.action', name }, body, (committed) => ({ detail: describeAction(committed, redaction).summary }));
         }
         catch (cause) {
             this.accounting.checkpoint(cause);
@@ -579,9 +579,8 @@ export class ActionDispatcher {
      * number picks the same one.
      */
     placementOf({ node, observation }) {
-        const redact = this.runtime.redact;
-        const within = containerKey(node.ref.id, observation.nodes, observation.parents, redact);
-        const position = describePosition(node, within, observation.nodes, { redact });
+        const within = containerKey(node.ref.id, observation.nodes, observation.parents);
+        const position = describePosition(node, within, observation.nodes);
         return {
             ...(within === undefined ? {} : { within }),
             ...(position === undefined ? {} : { position }),
@@ -598,4 +597,3 @@ function isInViewport(rect, viewport) {
         return true;
     return rect.x < viewport.width && rect.y < viewport.height && rect.x + rect.width > 0 && rect.y + rect.height > 0;
 }
-//# sourceMappingURL=action-dispatcher.js.map

package/dist/agent/action-names.d.ts

@@ -25,4 +25,3 @@ export declare const HARNESS_TOOL_NAMES: ReadonlyMap<string, string>;
  * take one: it would be silently shadowed on one engine and live on another.
  */
 export declare const GRAMMAR_TOOL_NAMES: ReadonlySet<string>;
-//# sourceMappingURL=action-names.d.ts.map

package/dist/agent/action-names.js

@@ -78,4 +78,3 @@ export const GRAMMAR_TOOL_NAMES = new Set([
     'select_at',
     'dismiss_keyboard',
 ]);
-//# sourceMappingURL=action-names.js.map

package/dist/agent/actions.d.ts

@@ -8,51 +8,52 @@
  * the same descriptor projection. One owner for all three, so a recorded
  * summary, a live event line, and a relocation candidate can never drift.
  */
-import type { SemanticNode, ViewportPoint, ViewportSize } from '../engine/surface.ts';
+import type { ViewportPoint, ViewportSize } from '../engine/surface.ts';
+import { type NodeRedaction, type RedactedNode } from './observation.ts';
 import { type NodeActionName, type PointActionName, type TraceTargetDescriptor, type TracePosition } from '../cache/trace.ts';
 import type { ScrollDirection } from '../types.ts';
 /** One committed grammar action, addressed by the node it actually ran against. */
 export type RecordableAction = ({
     readonly name: NodeActionName;
-    readonly node: SemanticNode;
+    readonly node: RedactedNode;
 } & Placement) | ({
     readonly name: 'type';
-    readonly node: SemanticNode;
+    readonly node: RedactedNode;
     readonly value: string;
 } & Placement) | ({
     readonly name: 'typeSecret';
-    readonly node: SemanticNode;
+    readonly node: RedactedNode;
     readonly secret: string;
 } & Placement) | ({
     readonly name: 'press';
-    readonly node: SemanticNode;
+    readonly node: RedactedNode;
     readonly key: string;
 } & Placement) | ({
     readonly name: 'select';
-    readonly node: SemanticNode;
+    readonly node: RedactedNode;
     readonly value: string;
 } & Placement) | ({
     readonly name: 'check';
-    readonly node: SemanticNode;
+    readonly node: RedactedNode;
     readonly checked: boolean;
 } & Placement)
 /** Project-relative paths as the executor gave them; replay authorizes them again. */
  | ({
     readonly name: 'upload';
-    readonly node: SemanticNode;
+    readonly node: RedactedNode;
     readonly paths: readonly string[];
 } & Placement)
 /** The dragged node with its placement, and where it was dropped, with its own. */
  | ({
     readonly name: 'drag';
-    readonly node: SemanticNode;
+    readonly node: RedactedNode;
     readonly destination: {
-        readonly node: SemanticNode;
+        readonly node: RedactedNode;
     } & Placement;
 } & Placement) | ({
     readonly name: 'scroll';
     readonly direction: ScrollDirection;
-    readonly node?: SemanticNode;
+    readonly node?: RedactedNode;
     /** The share of the viewport the node covered when scrolled, 0 to 1 (`ScrollAction.spans`). */
     readonly spans?: number;
 } & Placement)
@@ -61,7 +62,7 @@ export type RecordableAction = ({
     readonly name: 'scrollUntil';
     readonly text: string;
     readonly direction: ScrollDirection;
-    readonly node?: SemanticNode;
+    readonly node?: RedactedNode;
     readonly spans?: number;
     /** How many pages it took; in the summary, never in the trace, since a replay pages for itself. */
     readonly screens: number;
@@ -92,7 +93,7 @@ export type RecordableAction = ({
     readonly name: PointActionName;
     readonly point: ViewportPoint;
     readonly viewport: ViewportSize;
-    readonly under?: SemanticNode;
+    readonly under?: RedactedNode;
 };
 /** Where the node sat when it was acted on: its container's key and its place among identical twins. */
 export interface Placement {
@@ -100,14 +101,17 @@ export interface Placement {
     readonly position?: TracePosition;
 }
 /**
- * The key of the nearest named container a node sits in — the first text of
- * its row or list item — when that key says more than the node's own name.
- * Ten rows each with a "Delete" button are ten identical descriptors; "Delete
- * in the row that starts with Budget draft" is one.
+ * The key of the nearest named container a node sits in, the first text of
+ * its row or list item or else the container's own label, when that key says
+ * more than the node's own name. Ten rows each with a "Delete" button are ten
+ * identical descriptors; "Delete in the row that starts with Budget draft" is
+ * one. A row whose only text is its own (`<li>Alpha <button><svg/></li>`)
+ * is keyed by it. Only the nearest container counts: the list around a row
+ * with no text names every row alike, so its key would tell no twin apart.
  */
-export declare function containerKey(id: string, nodes: ReadonlyMap<string, SemanticNode>, parents: ReadonlyMap<string, string>, redact: (text: string) => string): string | undefined;
+export declare function containerKey(id: string, nodes: ReadonlyMap<string, RedactedNode>, parents: ReadonlyMap<string, string>): string | undefined;
 /** Parent id of every non-root node, derived from the tree the node map indexes. */
-export declare function parentsOf(nodes: ReadonlyMap<string, SemanticNode>): ReadonlyMap<string, string>;
+export declare function parentsOf(nodes: ReadonlyMap<string, RedactedNode>): ReadonlyMap<string, string>;
 /** How one committed action reads back: where it acted, and what it did. */
 export interface DescribedAction {
     /**
@@ -124,14 +128,18 @@ export interface DescribedAction {
     /** Where a drag was dropped, described like its target; only a drag has one. */
     readonly destination?: TraceTargetDescriptor;
 }
-/** Describes one committed action for recording and for the live event. */
-export declare function describeAction(action: RecordableAction, redact: (text: string) => string): DescribedAction;
+/**
+ * Describes one committed action for recording and for the live event. Its
+ * nodes pass the ledger again as it is now: a secret resolved after the
+ * capture (inside the action itself) masks what the capture still shows.
+ */
+export declare function describeAction(action: RecordableAction, redaction: NodeRedaction): DescribedAction;
 /**
  * Builds the durable descriptor for one resolved node: the semantic fields
  * replay re-finds it by, plus the engine's structural selector hint (kept as
  * provenance for tuned policies; the conservative relocator ignores it).
  * Values a secure node holds are never part of it — descriptors carry how a
- * node is named, not what it contains.
+ * node is named, not what it contains. The node was redacted with its
+ * observation (`redactNode`), each field in the one-line form read here too.
  */
-export declare function describeTarget(node: SemanticNode, redact: (text: string) => string): TraceTargetDescriptor | undefined;
-//# sourceMappingURL=actions.d.ts.map
+export declare function describeTarget(node: RedactedNode): TraceTargetDescriptor | undefined;

package/dist/agent/actions.js

@@ -8,32 +8,33 @@
  * the same descriptor projection. One owner for all three, so a recorded
  * summary, a live event line, and a relocation candidate can never drift.
  */
+import { redactNode } from './observation.js';
 import { bound, isNodeAction, MAX_TRACE_DESCRIPTOR_CHARS, MAX_TRACE_SUMMARY_CHARS, } from '../cache/trace.js';
 import { sanitizeText } from '../internal/errors.js';
-import { normalizeText } from '../internal/text.js';
+import { collapseText } from '../internal/text.js';
 /** Roles whose first text names the thing a control belongs to: a row's key, a list item's title. */
 const CONTAINER_ROLES = new Set(['row', 'listitem', 'article', 'group', 'region', 'dialog', 'tabpanel']);
 /** Longest container key kept. */
 const MAX_WITHIN_CHARS = 80;
 /**
- * The key of the nearest named container a node sits in — the first text of
- * its row or list item — when that key says more than the node's own name.
- * Ten rows each with a "Delete" button are ten identical descriptors; "Delete
- * in the row that starts with Budget draft" is one.
+ * The key of the nearest named container a node sits in, the first text of
+ * its row or list item or else the container's own label, when that key says
+ * more than the node's own name. Ten rows each with a "Delete" button are ten
+ * identical descriptors; "Delete in the row that starts with Budget draft" is
+ * one. A row whose only text is its own (`<li>Alpha <button><svg/></li>`)
+ * is keyed by it. Only the nearest container counts: the list around a row
+ * with no text names every row alike, so its key would tell no twin apart.
  */
-export function containerKey(id, nodes, parents, redact) {
+export function containerKey(id, nodes, parents) {
     const node = nodes.get(id);
     const own = node === undefined ? '' : squash(node.name ?? node.text ?? '');
     let cursor = parents.get(id);
     while (cursor !== undefined) {
         const container = nodes.get(cursor);
         if (container !== undefined && CONTAINER_ROLES.has(container.role ?? '')) {
-            const key = firstLeafText(container);
-            if (key !== undefined) {
-                const clean = bound(redact(sanitizeText(key)).replace(/\s+/g, ' ').trim(), MAX_WITHIN_CHARS);
-                return clean === '' || squash(clean) === own ? undefined : clean;
-            }
-            return undefined;
+            const key = firstLeafText(container) ?? ownLabel(container);
+            const clean = key === undefined ? '' : bound(collapseText(key), MAX_WITHIN_CHARS);
+            return clean === '' || squash(clean) === own ? undefined : clean;
         }
         cursor = parents.get(cursor);
     }
@@ -60,6 +61,11 @@ function firstLeafText(node) {
     }
     return undefined;
 }
+/** A container's own name or text, when it has one. */
+function ownLabel(node) {
+    const label = (node.name ?? node.text ?? '').trim();
+    return label === '' ? undefined : label;
+}
 function squash(text) {
     return text.replace(/\s+/g, ' ').trim().toLowerCase();
 }
@@ -74,16 +80,20 @@ const NODE_ACTION_PROSE = {
 };
 /** How each point verb reads: `tap the point (x, y)`, `hover over the point (x, y)`. */
 const POINT_ACTION_PROSE = { tapAt: 'tap', hoverAt: 'hover over' };
-/** Describes one committed action for recording and for the live event. */
-export function describeAction(action, redact) {
+/**
+ * Describes one committed action for recording and for the live event. Its
+ * nodes pass the ledger again as it is now: a secret resolved after the
+ * capture (inside the action itself) masks what the capture still shows.
+ */
+export function describeAction(action, redaction) {
     const target = 'node' in action
-        ? describePlaced(action.node, action, redact)
+        ? describePlaced(action.node, action, redaction)
         : 'point' in action
-            ? describePlaced(action.under, {}, redact)
+            ? describePlaced(action.under, {}, redaction)
             : undefined;
-    const destination = action.name === 'drag' ? describePlaced(action.destination.node, action.destination, redact) : undefined;
+    const destination = action.name === 'drag' ? describePlaced(action.destination.node, action.destination, redaction) : undefined;
     const where = describeForSummary(target);
-    const safe = (value) => quote(redact(sanitizeText(value)));
+    const safe = (value) => quote(redaction.redact(sanitizeText(value)));
     const prose = (() => {
         if (isNodeAction(action))
             return NODE_ACTION_PROSE[action.name](where);
@@ -134,13 +144,16 @@ export function describeAction(action, redact) {
     };
 }
 /** A node's durable descriptor with the placement it was acted on in; undefined for no node or nothing durable. */
-function describePlaced(node, placement, redact) {
-    const described = node === undefined ? undefined : describeTarget(node, redact);
+function describePlaced(node, placement, redaction) {
+    if (node === undefined)
+        return undefined;
+    const { children: _children, ...fields } = node;
+    const described = describeTarget(redactNode(fields, redaction));
     if (described === undefined)
         return undefined;
     return {
         ...described,
-        ...(placement.within === undefined ? {} : { within: bound(placement.within, MAX_WITHIN_CHARS) }),
+        ...(placement.within === undefined ? {} : { within: bound(redaction.redact(placement.within), MAX_WITHIN_CHARS) }),
         ...(placement.position === undefined ? {} : { position: placement.position }),
     };
 }
@@ -149,13 +162,14 @@ function describePlaced(node, placement, redact) {
  * replay re-finds it by, plus the engine's structural selector hint (kept as
  * provenance for tuned policies; the conservative relocator ignores it).
  * Values a secure node holds are never part of it — descriptors carry how a
- * node is named, not what it contains.
+ * node is named, not what it contains. The node was redacted with its
+ * observation (`redactNode`), each field in the one-line form read here too.
  */
-export function describeTarget(node, redact) {
+export function describeTarget(node) {
     const field = (value) => {
         if (value === undefined)
             return undefined;
-        const collapsed = normalizeText(redact(sanitizeText(value)));
+        const collapsed = collapseText(value);
         return collapsed === '' ? undefined : bound(collapsed, MAX_TRACE_DESCRIPTOR_CHARS);
     };
     const role = field(node.role);
@@ -193,4 +207,3 @@ function describeWhere(target) {
 function quote(value) {
     return JSON.stringify(bound(value, 40));
 }
-//# sourceMappingURL=actions.js.map

package/dist/agent/agent-brand.d.ts

@@ -11,4 +11,3 @@ export declare const BUILT_IN_AGENT: {
     readonly name: 'e2e-default-agent';
     readonly version: '2';
 };
-//# sourceMappingURL=agent-brand.d.ts.map

package/dist/agent/agent-brand.js

@@ -8,4 +8,3 @@
  * valid whatever options an agents entry sets.
  */
 export const BUILT_IN_AGENT = { name: 'e2e-default-agent', version: '2' };
-//# sourceMappingURL=agent-brand.js.map

package/dist/agent/ai-sdk.d.ts

@@ -19,9 +19,15 @@ export type SdkLanguageModel = Exclude<LanguageModel, string>;
 export declare function asSdkLanguageModel(instance: ModelInstance): SdkLanguageModel;
 /** Loads and caches the AI SDK, or fails with MODEL_UNAVAILABLE. */
 export declare function loadAiSdk(): Promise<AiSdk>;
+/**
+ * The SDK when the optional peer is installed, else undefined: for the seams
+ * that have a way to do their job without it.
+ */
+export declare function loadAiSdkIfInstalled(): Promise<AiSdk | undefined>;
+/** The SDK when an earlier call loaded it, else undefined; never loads it. */
+export declare function loadedAiSdk(): AiSdk | undefined;
 /**
  * The already-loaded SDK, for the few synchronous seams (error-class checks)
  * that run strictly after an async caller primed the cache.
  */
 export declare function aiSdk(): AiSdk;
-//# sourceMappingURL=ai-sdk.d.ts.map

package/dist/agent/ai-sdk.js

@@ -53,6 +53,17 @@ export async function loadAiSdk() {
         throw missing(state.failure);
     }
 }
+/**
+ * The SDK when the optional peer is installed, else undefined: for the seams
+ * that have a way to do their job without it.
+ */
+export async function loadAiSdkIfInstalled() {
+    return loadAiSdk().catch(() => undefined);
+}
+/** The SDK when an earlier call loaded it, else undefined; never loads it. */
+export function loadedAiSdk() {
+    return cache().loaded;
+}
 /**
  * The already-loaded SDK, for the few synchronous seams (error-class checks)
  * that run strictly after an async caller primed the cache.
@@ -69,4 +80,3 @@ function missing(cause) {
         'peer dependency ai@^7 — install it, or configure an agent that brings ' +
         'its own model transport', { cause });
 }
-//# sourceMappingURL=ai-sdk.js.map

package/dist/agent/call-options.d.ts

@@ -7,4 +7,3 @@
 export declare function resolveTimeout(requested: number | undefined, fallback: number): number;
 /** Resolves a per-call budget override, capped at the configured limit. */
 export declare function resolveBoundedBudget(requested: number | undefined, limit: number, label: string): number;
-//# sourceMappingURL=call-options.d.ts.map

package/dist/agent/call-options.js

@@ -25,4 +25,3 @@ export function resolveBoundedBudget(requested, limit, label) {
     }
     return requested;
 }
-//# sourceMappingURL=call-options.js.map

package/dist/agent/default-agent.d.ts

@@ -28,4 +28,3 @@ export declare function createBuiltInAgent(options?: BuiltInAgentOptions): StepE
  * and a host outside the loop reports them its own way.
  */
 export declare function projectTools(context: StepExecutorContext, tools: Readonly<Record<string, AgentTool>>): ToolSet;
-//# sourceMappingURL=default-agent.d.ts.map

package/dist/agent/default-agent.js

@@ -170,4 +170,3 @@ function guardedTools(helpers, tools) {
     }
     return guarded;
 }
-//# sourceMappingURL=default-agent.js.map

package/dist/agent/derived.d.ts

@@ -57,4 +57,3 @@ export interface StepEvidence {
  * the model composed itself.
  */
 export declare function derivedReason(value: string, instruction: string, params: Readonly<Record<string, JsonValue>> | undefined, evidence?: StepEvidence): DerivedReason | undefined;
-//# sourceMappingURL=derived.d.ts.map

package/dist/agent/derived.js

@@ -125,4 +125,3 @@ function paramStrings(params) {
 function normalize(text) {
     return text.toLowerCase().replace(/\s+/g, ' ').trim();
 }
-//# sourceMappingURL=derived.js.map

package/dist/agent/error.d.ts

@@ -64,4 +64,3 @@ export declare function toAgentError(cause: unknown): AgentError;
  * keep honest names and `instanceof` never spans realms.
  */
 export declare function isAgentError(value: unknown): value is AgentError;
-//# sourceMappingURL=error.d.ts.map

package/dist/agent/error.js

@@ -118,4 +118,3 @@ export function isAgentError(value) {
         typeof value.code === 'string' &&
         value.code in CATEGORY_BY_CODE);
 }
-//# sourceMappingURL=error.js.map

package/dist/agent/executor.d.ts

@@ -495,4 +495,3 @@ export declare function isRuntimeHardStop(cause: unknown): cause is AgentError;
 export declare const BLOCKABLE_CODES: ReadonlySet<AgentErrorCode>;
 /** Structural executor check, mirroring how model instances are detected. */
 export declare function isStepExecutor(value: unknown): value is StepExecutor;
-//# sourceMappingURL=executor.d.ts.map

package/dist/agent/executor.js

@@ -52,4 +52,3 @@ export function isStepExecutor(value) {
         candidate['name'] !== '' &&
         typeof candidate['runStep'] === 'function');
 }
-//# sourceMappingURL=executor.js.map

package/dist/agent/index.d.ts

@@ -12,4 +12,3 @@ import type { Agent } from '../types.ts';
 import { type AgentContext } from './invocation.ts';
 /** Builds the agent fixture for one attempt. */
 export declare function createAgentFixture(runtime: AgentContext): Agent;
-//# sourceMappingURL=index.d.ts.map

package/dist/agent/index.js

@@ -350,4 +350,3 @@ function safeJson(value) {
         return undefined;
     }
 }
-//# sourceMappingURL=index.js.map

package/dist/agent/interactive-step.d.ts

@@ -35,4 +35,3 @@ export interface InteractiveStep {
  * never resolved and the budgets a model loop needs do not apply.
  */
 export declare function openInteractiveStep(runtime: AgentContext, options: InteractiveStepOptions): Promise<InteractiveStep>;
-//# sourceMappingURL=interactive-step.d.ts.map

package/dist/agent/interactive-step.js

@@ -129,4 +129,3 @@ class HostExecutor {
             job.settle({ error: reason });
     }
 }
-//# sourceMappingURL=interactive-step.js.map

package/dist/agent/invocation.d.ts

@@ -210,4 +210,3 @@ export declare class Invocation {
     private modelInfo;
     private consumeModelCall;
 }
-//# sourceMappingURL=invocation.d.ts.map