@theoremjs/agents 0.3.0 → 0.3.1

package/esm/src/kernel/tools/resolve.d.ts

@@ -5,6 +5,8 @@ export declare function pathMatches(catalogPaths?: string[], turnPath?: string):
 export declare function applyBuiltinMutualExclusions(tools: ToolRegistry, requested: string[]): string[];
 export declare function profileToolAllow(profile: Profile): readonly ToolId[];
 export declare function profileToolsSpec(profile: Profile): ProfileToolsSpec | undefined;
+/** `tools.parallel` as the profile sets it: whether a step's calls run side by side. */
+export declare function profileToolsParallel(profile: Profile): boolean | undefined;
 export declare function resolveAllowedCustomToolIds(tools: ToolRegistry, profile: Profile, req: TurnRequest): ToolId[];
 export declare function resolveModelBuiltinIds(tools: ToolRegistry, profile: ModelProfile, req: TurnRequest, modelId: ModelId): ToolId[];
 export declare function wireForTool(tools: ToolRegistry, name: string): WireFunctionTool | undefined;
@@ -15,6 +17,7 @@ export declare function promoteBuiltin(tools: ToolRegistry, state: TurnToolSnaps
 export declare function initialVisible(tools: ToolRegistry, profile: Profile, gated: ToolId[]): ToolId[];
 export declare function initialBuiltins(tools: ToolRegistry, profile: Profile, gated: ToolId[]): ToolId[];
 export declare function resolveTurnTools(tools: ToolRegistry, profile: Profile, req: TurnRequest, modelId: ModelId | undefined): TurnToolSnapshot;
+/** Resolves the tools a turn may call into a snapshot, then applies the profile's `t1Policy` to it. */
 export declare function prepareTurnToolSnapshot(tools: ToolRegistry, profile: Profile, req: TurnRequest, modelId: ModelId | undefined): Promise<TurnToolSnapshot>;
 /** So concurrent host invokes do not share mutable state. */
 export declare function cloneTurnToolSnapshot(state: TurnToolSnapshot): TurnToolSnapshot;

package/esm/src/kernel/tools/resolve.js

@@ -30,6 +30,10 @@ export function profileToolAllow(profile) {
 export function profileToolsSpec(profile) {
     return profile.type === 'text' || profile.type === 'image' ? profile.tools : undefined;
 }
+/** `tools.parallel` as the profile sets it: whether a step's calls run side by side. */
+export function profileToolsParallel(profile) {
+    return 'tools' in profile ? profile.tools.parallel : undefined;
+}
 export function resolveAllowedCustomToolIds(tools, profile, req) {
     return profileToolAllow(profile).filter((id) => {
         const tool = tools.get(id);
@@ -117,7 +121,10 @@ export function initialBuiltins(tools, profile, gated) {
 }
 export function resolveTurnTools(tools, profile, req, modelId) {
     const customAllowed = resolveAllowedCustomToolIds(tools, profile, req);
-    const modelBuiltins = profile.type === 'host' || profile.type === 'decision' || modelId === undefined
+    const modelBuiltins = profile.type === 'host' ||
+        profile.type === 'decision' ||
+        profile.type === 'embedding' ||
+        modelId === undefined
         ? []
         : resolveModelBuiltinIds(tools, profile, req, modelId);
     const gated = [...customAllowed, ...modelBuiltins];
@@ -134,6 +141,7 @@ export function resolveTurnTools(tools, profile, req, modelId) {
         wire: buildWire(tools, visible),
     };
 }
+/** Resolves the tools a turn may call into a snapshot, then applies the profile's `t1Policy` to it. */
 export async function prepareTurnToolSnapshot(tools, profile, req, modelId) {
     const snapshot = resolveTurnTools(tools, profile, req, modelId);
     await expandT1Policy(tools, snapshot, profile, req);
@@ -174,14 +182,14 @@ export async function expandT1Policy(tools, state, profile, req) {
         });
     }
     if (!Array.isArray(selected)) {
-        throw new TheoremError('config', `Profile '${profile.id}' tools.t1Policy must return ToolId[]`); // lexicon-exempt: developer contract / internal diagnostic — not end-user or model copy (P2)
+        throw new TheoremError('config', `Profile '${profile.id}' tools.t1Policy must return ToolId[]`); // labels-exempt: developer contract / internal diagnostic — not end-user or model copy (P2)
     }
     for (const id of selected) {
         if (!state.gated.includes(id)) {
             continue;
         }
         const tool = tools.get(id);
-        if (!tool || tool.loadTier === 'T0') {
+        if (tool?.loadTier !== 'T2') {
             continue;
         }
         if (tool.type === 'builtin') {
@@ -216,7 +224,7 @@ export function promoteLoadedTools(tools, state, loaded, profile) {
                 failure: {
                     code: 'invalid_output',
                     kind: 'bad_response',
-                    message: 'tools.t2Loader loaded ids must be plain strings', // lexicon-exempt: developer contract / internal diagnostic — not end-user or model copy (P2)
+                    message: 'tools.t2Loader loaded ids must be plain strings', // labels-exempt: developer contract / internal diagnostic — not end-user or model copy (P2)
                 },
             };
         }

package/esm/src/kernel/tools/run.d.ts

@@ -0,0 +1,28 @@
+/**
+ * A call's end, for a host that wants how a call settled rather than its stream:
+ * `settledCall` and `settledCalls` read a started `invokeTool` or `invokeToolStep` and give each
+ * call's terminal `tool` event with every event it emitted. `runTool` and `runToolStep` use them.
+ */
+import type { ToolPhaseEvent, TurnEvent } from '../turn-events.js';
+import type { StartedInvoke, StartedStep } from './invoke.js';
+/** The phase a call ends on: it completed, a gate held it, or it failed. */
+export type SettledToolCall = Extract<ToolPhaseEvent, {
+    phase: 'complete' | 'gate' | 'error';
+}> & {
+    /** Kernel-issued identity; a gate's resume carries it. */
+    operationId?: string;
+};
+/** A settled call, every event it emitted in order, and the last activity label it ran under. */
+export type ToolCallResult = SettledToolCall & {
+    events: TurnEvent[];
+    activity?: string;
+};
+/** A step's call, settled: its place in the step's `calls` beside its result. */
+export type ToolStepCallResult = ToolCallResult & {
+    index: number;
+};
+/** Run one call to its end. */
+declare function settledCall(started: StartedInvoke): Promise<ToolCallResult>;
+/** Run a step's calls, yielding each one's result as it settles; a call the step never settled comes last. */
+declare function settledCalls(started: StartedStep): AsyncGenerator<ToolStepCallResult>;
+export { settledCall, settledCalls };

package/esm/src/kernel/tools/run.js

@@ -0,0 +1,86 @@
+/**
+ * A call's end, for a host that wants how a call settled rather than its stream:
+ * `settledCall` and `settledCalls` read a started `invokeTool` or `invokeToolStep` and give each
+ * call's terminal `tool` event with every event it emitted. `runTool` and `runToolStep` use them.
+ */
+import { labelText } from '../../guardrails/labels.js';
+function isSettled(tool) {
+    return tool.phase === 'complete' || tool.phase === 'gate' || tool.phase === 'error';
+}
+function foldTool(fold, tool) {
+    if (tool.phase === 'running')
+        fold.activity = tool.activity ?? fold.activity;
+    if (isSettled(tool))
+        fold.settled = tool;
+}
+/** The call's result; a call that never settled failed as the invoke's own error says, else as not run. */
+function settle(fold, invokeError) {
+    const settled = fold.settled ?? {
+        phase: 'error',
+        name: fold.name,
+        callId: fold.callId,
+        at: Date.now(),
+        failure: {
+            code: 'invoke_failed',
+            kind: invokeError?.errorKind ?? 'internal',
+            message: invokeError?.errorInternal ??
+                invokeError?.error ??
+                labelText('tool.did_not_run', { tool: fold.name }),
+        },
+    };
+    return {
+        ...settled,
+        events: fold.events,
+        ...(fold.activity ? { activity: fold.activity } : {}),
+    };
+}
+/** Run one call to its end. */
+async function settledCall(started) {
+    const fold = {
+        name: started.name,
+        callId: started.callId,
+        events: [],
+    };
+    let invokeError;
+    for await (const event of started.events) {
+        fold.events.push(event);
+        if (event.type === 'error')
+            invokeError = event;
+        if (event.type === 'tool' && event.tool.callId === started.callId) {
+            foldTool(fold, event.tool);
+        }
+    }
+    return settle(fold, invokeError);
+}
+/** Run a step's calls, yielding each one's result as it settles; a call the step never settled comes last. */
+async function* settledCalls(started) {
+    const folds = started.calls.map(({ name, callId }) => ({
+        name,
+        callId,
+        events: [],
+    }));
+    const byCallId = new Map(started.calls.map(({ callId }, index) => [callId, index]));
+    const yielded = new Set();
+    let invokeError;
+    for await (const event of started.events) {
+        if (event.type === 'error')
+            invokeError = event;
+        if (event.type !== 'tool')
+            continue;
+        const index = byCallId.get(event.tool.callId);
+        const fold = index === undefined ? undefined : folds[index];
+        if (index === undefined || !fold)
+            continue;
+        fold.events.push(event);
+        foldTool(fold, event.tool);
+        if (fold.settled && !yielded.has(index)) {
+            yielded.add(index);
+            yield { ...settle(fold, invokeError), index };
+        }
+    }
+    for (const [index, fold] of folds.entries()) {
+        if (!yielded.has(index))
+            yield { ...settle(fold, invokeError), index };
+    }
+}
+export { settledCall, settledCalls };

package/esm/src/kernel/tools/schema.d.ts

@@ -1,9 +1,9 @@
 import { type ZodType } from 'zod';
 export type JsonSchema = Record<string, unknown>;
-declare function validateToolInputSchema(schema: JsonSchema, mode?: 'gemini' | 'structural'): void;
-declare function validateToolOutputSchema(schema: JsonSchema, mode?: 'gemini' | 'structural'): void;
+/** A structural check only: what a provider accepts is its own API's answer. */
+declare function validateToolSchema(schema: JsonSchema, label: 'input' | 'output'): void;
 declare function jsonSchemaFromZod(schema: ZodType, io?: 'input' | 'output'): JsonSchema;
-export { jsonSchemaFromZod, validateToolInputSchema, validateToolOutputSchema };
+export { jsonSchemaFromZod, validateToolSchema };
 /** Strips prototype-pollution keys before validation. */
 export declare function plainToolInput(input: unknown): unknown;
 /** A placeholder in the scheme or authority would let tool input choose where the credential goes. */

package/esm/src/kernel/tools/schema.js

@@ -1,153 +1,74 @@
 import { z } from 'zod';
 import { TheoremError } from '../../guardrails/error.js';
-const GEMINI_SUPPORTED_SCHEMA_KEYS = [
-    'type',
-    'format',
-    'title',
-    'description',
-    'nullable',
-    'enum',
-    'default',
-    'example',
-    'items',
-    'minItems',
-    'maxItems',
-    'properties',
-    'required',
-    'propertyOrdering',
-    'minProperties',
-    'maxProperties',
-    'minimum',
-    'maximum',
-    'pattern',
-    'minLength',
-    'maxLength',
-    'anyOf',
-    'oneOf',
-];
-function validateGeminiKeys(schema, path, errors) {
-    for (const key of Object.keys(schema)) {
-        if (!GEMINI_SUPPORTED_SCHEMA_KEYS.includes(key)) {
-            errors.push(`${path}: unsupported Gemini schema key '${key}'`); // lexicon-exempt: developer contract / internal diagnostic — not end-user or model copy (P2)
-        }
-    }
-}
-function validateSchemaShape(schema, path, mode, errors) {
+function validateSchemaShape(schema, path, errors) {
     if (!schema || typeof schema !== 'object' || Array.isArray(schema)) {
-        errors.push(`${path}: schema must be an object`); // lexicon-exempt: developer contract / internal diagnostic — not end-user or model copy (P2)
+        errors.push(`${path}: schema must be an object`); // labels-exempt: developer contract / internal diagnostic — not end-user or model copy (P2)
         return false;
     }
     const hasType = typeof schema.type === 'string' || Array.isArray(schema.type);
     const hasCombinator = schema.anyOf !== undefined || schema.oneOf !== undefined;
     if (!hasType && !hasCombinator) {
-        if (mode === 'structural' && path !== '$') {
+        if (path !== '$') {
             return true;
         }
-        errors.push(`${path}: missing type or combinator`); // lexicon-exempt: developer contract / internal diagnostic — not end-user or model copy (P2)
-    }
-    if (mode === 'gemini') {
-        validateGeminiKeys(schema, path, errors);
+        errors.push(`${path}: missing type or combinator`); // labels-exempt: developer contract / internal diagnostic — not end-user or model copy (P2)
     }
     if (schema.type === 'array' && schema.items === undefined) {
-        errors.push(`${path}: array schema must define items`); // lexicon-exempt: developer contract / internal diagnostic — not end-user or model copy (P2)
+        errors.push(`${path}: array schema must define items`); // labels-exempt: developer contract / internal diagnostic — not end-user or model copy (P2)
     }
     return true;
 }
-function walkSchemaProperties(props, required, path, mode, errors) {
+function walkSchemaProperties(props, required, path, errors) {
     const reqList = Array.isArray(required) ? required : [];
     for (const req of reqList) {
-        if (typeof req === 'string' && !(req in props)) {
-            errors.push(`${path}: required key '${req}' missing from properties`); // lexicon-exempt: developer contract / internal diagnostic — not end-user or model copy (P2)
+        if (typeof req === 'string' && !Object.hasOwn(props, req)) {
+            errors.push(`${path}: required key '${req}' missing from properties`); // labels-exempt: developer contract / internal diagnostic — not end-user or model copy (P2)
         }
     }
     for (const [key, child] of Object.entries(props)) {
         if (child && typeof child === 'object') {
-            walkSchema(child, `${path}.properties.${key}`, mode, errors);
+            walkSchema(child, `${path}.properties.${key}`, errors);
         }
     }
 }
-function walkSchema(schema, path, mode, errors) {
-    if (!validateSchemaShape(schema, path, mode, errors))
+function walkSchema(schema, path, errors) {
+    if (!validateSchemaShape(schema, path, errors))
         return;
     const props = schema.properties;
     if (props && typeof props === 'object' && !Array.isArray(props)) {
-        walkSchemaProperties(props, schema.required, path, mode, errors);
+        walkSchemaProperties(props, schema.required, path, errors);
     }
     if (schema.items && typeof schema.items === 'object' && !Array.isArray(schema.items)) {
-        walkSchema(schema.items, `${path}.items`, mode, errors);
+        walkSchema(schema.items, `${path}.items`, errors);
     }
     for (const combinator of ['anyOf', 'oneOf']) {
         const branch = schema[combinator];
         if (Array.isArray(branch)) {
             branch.forEach((entry, index) => {
                 if (entry && typeof entry === 'object') {
-                    walkSchema(entry, `${path}.${combinator}[${index}]`, mode, errors);
+                    walkSchema(entry, `${path}.${combinator}[${index}]`, errors);
                 }
             });
         }
     }
 }
-function validateToolWireSchema(schema, mode = 'gemini', label = 'input') {
+/** A structural check only: what a provider accepts is its own API's answer. */
+function validateToolSchema(schema, label) {
     const errors = [];
-    walkSchema(schema, '$', mode, errors);
+    walkSchema(schema, '$', errors);
     if (errors.length > 0) {
-        throw new TheoremError('config', `Invalid tool ${label} schema: ${errors.join('; ')}`); // lexicon-exempt: developer contract / internal diagnostic — not end-user or model copy (P2)
-    }
-}
-function validateToolInputSchema(schema, mode = 'gemini') {
-    validateToolWireSchema(schema, mode, 'input');
-}
-function validateToolOutputSchema(schema, mode = 'structural') {
-    validateToolWireSchema(schema, mode, 'output');
-}
-function stripProperties(value) {
-    const props = {};
-    if (value && typeof value === 'object' && !Array.isArray(value)) {
-        for (const [propKey, propValue] of Object.entries(value)) {
-            if (propValue && typeof propValue === 'object') {
-                props[propKey] = stripUnsupportedGeminiKeys(propValue);
-            }
-        }
-    }
-    return props;
-}
-function stripBranches(branches) {
-    return branches.map((entry) => entry && typeof entry === 'object' ? stripUnsupportedGeminiKeys(entry) : entry);
-}
-function stripUnsupportedGeminiKeys(schema) {
-    const out = {};
-    for (const [key, value] of Object.entries(schema)) {
-        if (!GEMINI_SUPPORTED_SCHEMA_KEYS.includes(key)) {
-            continue;
-        }
-        if (key === 'properties') {
-            out.properties = stripProperties(value);
-            continue;
-        }
-        if (key === 'items' && value && typeof value === 'object' && !Array.isArray(value)) {
-            out.items = stripUnsupportedGeminiKeys(value);
-            continue;
-        }
-        if ((key === 'anyOf' || key === 'oneOf') && Array.isArray(value)) {
-            out[key] = stripBranches(value);
-            continue;
-        }
-        out[key] = value;
+        throw new TheoremError('config', `Invalid tool ${label} schema: ${errors.join('; ')}`); // labels-exempt: developer contract / internal diagnostic — not end-user or model copy (P2)
     }
-    return out;
 }
 function jsonSchemaFromZod(schema, io = 'output') {
-    const json = z.toJSONSchema(schema, {
-        target: 'openApi3',
-        io,
-    });
+    const json = z.toJSONSchema(schema, { target: 'draft-7', io });
     delete json.$schema;
     if (!json.type) {
         json.type = 'object';
     }
-    return stripUnsupportedGeminiKeys(json);
+    return json;
 }
-export { jsonSchemaFromZod, validateToolInputSchema, validateToolOutputSchema };
+export { jsonSchemaFromZod, validateToolSchema };
 /** Strips prototype-pollution keys before validation. */
 export function plainToolInput(input) {
     if (input === null || typeof input !== 'object') {

package/esm/src/kernel/tools/signed-in-fetch.d.ts

@@ -5,7 +5,7 @@
  * @module
  */
 import type { RequestChecks } from './events.js';
-import { type CredentialRefusal } from './remote.js';
+import { type CredentialQuery, type CredentialRefusal } from './remote.js';
 import type { SignedInFetch, ToolContext } from './types.js';
 /** Thrown by a signed-in fetch when the service refuses the credential; the kernel settles it. */
 export declare class CredentialRefusedError extends Error {
@@ -14,5 +14,6 @@ export declare class CredentialRefusedError extends Error {
 }
 export declare function signedInFetch(prepared: {
     authHeaders: Record<string, string>;
+    query?: CredentialQuery;
     audience?: string;
 }, ctx: ToolContext, checks: RequestChecks): SignedInFetch;

package/esm/src/kernel/tools/signed-in-fetch.js

@@ -7,12 +7,12 @@
 import { fetchGuarded } from '../../guardrails/network.js';
 import { TheoremError } from '../../guardrails/theorem-error.js';
 import { toolNetworkPolicy } from './events.js';
-import { audienceMismatch, credentialRefusal, refusalAsksForSignIn, } from './remote.js';
+import { audienceMismatch, credentialRefusal, refusalAsksForSignIn, withCredentialQuery, } from './remote.js';
 /** Thrown by a signed-in fetch when the service refuses the credential; the kernel settles it. */
 export class CredentialRefusedError extends Error {
     refusal;
     constructor(refusal) {
-        super(`The service refused the credential (HTTP ${refusal.status}).`); // lexicon-exempt: developer contract / internal diagnostic — not end-user or model copy (P2)
+        super(`The service refused the credential (HTTP ${refusal.status}).`); // labels-exempt: developer contract / internal diagnostic — not end-user or model copy (P2)
         this.name = 'CredentialRefusedError';
         this.refusal = refusal;
     }
@@ -23,7 +23,7 @@ export function signedInFetch(prepared, ctx, checks) {
         const mismatch = audienceMismatch(prepared.audience, target);
         if (mismatch)
             throw new TheoremError('config', mismatch);
-        const response = await fetchGuarded(target.href, {
+        const response = await fetchGuarded(withCredentialQuery(target, prepared.query).href, {
             method: request.method ?? 'GET',
             headers: request.headers,
             body: request.body,

package/esm/src/kernel/tools/stage-run.d.ts

@@ -1,10 +1,21 @@
 import type { z } from 'zod';
-import { type LexiconOverrides } from '../../guardrails/lexicon.js';
+import { type LabelOverrides } from '../../guardrails/labels.js';
 import type { SpanHandle } from '../../observability/trace-span.js';
-import { type InjectUnit, type StageHandler, type StageResult } from '../stages.js';
+import type { ToolAccess } from '../schema.js';
+import { type InjectUnit, type StageHandler, type StageResult, type StepCall } from '../stages.js';
 import type { Profile, TurnEvent, TurnHistoryMessage } from '../types.js';
 import { type ToolCallBase } from './events.js';
-import type { ModelToolResult, ToolContext, ToolFailure, ToolGate } from './types.js';
+import type { ModelToolResult, ToolContext, ToolFailure, ToolGate, ToolLabels } from './types.js';
+/** How a call's wait for other calls in its step ended: they settled, or the wait cannot end. */
+export type StepWaitOutcome = {
+    ok: true;
+} | {
+    ok: false;
+    reason: 'unknown' | 'cycle';
+    callIds: string[];
+};
+/** Holds `callId` until the calls it names have settled. */
+export type StepWait = (callId: string, waitFor: readonly string[]) => Promise<StepWaitOutcome>;
 export interface ToolStageSupport {
     /** In order: request `onStage`, then turn/session ambient. */
     handlers: StageHandler[];
@@ -17,6 +28,12 @@ export interface ToolStageSupport {
     host?: unknown;
     signal?: AbortSignal;
     span?: SpanHandle;
+    /** The step's calls, shown to `pre_tool`. Unset outside a turn's step. */
+    stepCalls?: readonly StepCall[];
+    /** Holds a call for the calls its `pre_tool` `waitFor` names. Unset outside a turn's step. */
+    wait?: StepWait;
+    /** The host sees a handler's drafts: `outputs.streaming.mode` `sse`. Unset outside a turn's step. */
+    drafts?: boolean;
 }
 export type PreBodyOutcome = {
     ok: true;
@@ -31,6 +48,7 @@ export type PreBodyOutcome = {
     ok: false;
     kind: 'gated';
     gate: ToolGate;
+    input?: unknown;
 } | {
     ok: false;
     kind: 'failed';
@@ -52,6 +70,7 @@ export type PostToolStageOutcome = {
     mutate?: {
         output: unknown;
     };
+    labelFailed?: true;
 };
 /** Tool `preTool` → host `pre_tool` → mutate re-parse. */
 export declare function runPreToolPipeline(args: {
@@ -60,6 +79,8 @@ export declare function runPreToolPipeline(args: {
         input: {
             safeParse: (value: unknown) => z.ZodSafeParseResult<unknown>;
         };
+        access: ToolAccess;
+        labels?: ToolLabels;
         preTool?: (input: never, ctx: ToolContext) => StageResult | undefined | Promise<StageResult | undefined>;
     };
     input: unknown;
@@ -75,6 +96,8 @@ export declare function runPostToolStages(args: {
     callNotStarted?: boolean;
     outputRaw?: unknown;
     outputModel?: ModelToolResult;
+    activityPast?: string;
+    activityFailed?: string;
     failure?: ToolFailure;
     awaiting?: boolean;
     /** False when there is no completed output for `mutate` to replace. */
@@ -89,5 +112,5 @@ export declare function emitGateSettlement(args: {
     gate: ToolGate;
     callId: string;
     toolName: string;
-    lexicon: LexiconOverrides | undefined;
+    labels: LabelOverrides | undefined;
 }): AsyncGenerator<TurnEvent, string | undefined>;

package/esm/src/kernel/tools/stage-run.js

@@ -1,7 +1,9 @@
-import { lexiconText } from '../../guardrails/lexicon.js';
+import { labelText } from '../../guardrails/labels.js';
+import { jsonObjectSchema } from '../json.js';
 import { runStage, stageEventFields, } from '../stages.js';
 import { toolEvent } from './events.js';
-import { isGateResumeGranted } from './permission.js';
+import { operationWireValue } from './operation.js';
+import { gateDetails, isGateResumeGranted } from './permission.js';
 import { plainToolInput } from './schema.js';
 function defaultToolStageSupport(ctx) {
     return {
@@ -18,8 +20,11 @@ function defaultToolStageSupport(ctx) {
 export async function* runPreToolPipeline(args) {
     const { tool, ctx, base, stages } = args;
     let toolPreTool;
-    // An approval skips the tool's own check it already passed — unless the user edited the arguments.
-    const approvedAsIs = isGateResumeGranted(ctx.resume) && ctx.resume?.edited === undefined;
+    // why: An approval skips the tool's own check it already passed — unless the user edited the arguments.
+    const approvedAsIs = isGateResumeGranted(ctx.resume) &&
+        ctx.resume?.edited === undefined &&
+        ctx.resume?.gateKind !== 'permission' &&
+        ctx.resume?.gateKind !== 'auth';
     if (tool.preTool && !approvedAsIs) {
         toolPreTool = (await tool.preTool(args.input, ctx)) ?? undefined;
     }
@@ -32,31 +37,61 @@ export async function* runPreToolPipeline(args) {
         callId: base.callId,
         input: args.input,
         toolPreTool,
+        details: gateDetails(tool, args.input),
     });
     if (!pre.ok) {
-        if (pre.kind === 'gated')
+        if (pre.kind === 'gated') {
+            if ('input' in pre) {
+                const candidate = pre.input;
+                const parsed = tool.input.safeParse(plainToolInput(candidate));
+                if (!parsed.success) {
+                    return {
+                        ok: false,
+                        kind: 'failed',
+                        failure: {
+                            code: 'invalid_input',
+                            kind: 'bad_response',
+                            message: labelText('tool.input_invalid_after_mutate', {}, ctx.profile.labels),
+                            details: parsed.error.flatten(),
+                        },
+                    };
+                }
+                pre.gate = {
+                    ...pre.gate,
+                    ...gateDetails(tool, parsed.data),
+                    preparedArguments: jsonObjectSchema.parse(operationWireValue(plainToolInput(candidate))),
+                };
+            }
+            yield stageEventFields('pre_tool', {
+                callId: base.callId,
+                toolName: tool.name,
+                callNotStarted: true,
+                gate: pre.gate,
+            });
             yield toolEvent(base, { phase: 'gate', gate: pre.gate });
+        }
         return pre;
     }
-    if (!pre.mutated)
-        return { ok: true, input: pre.input };
-    const reparsed = tool.input.safeParse(plainToolInput(pre.input));
-    if (!reparsed.success) {
+    const reparsed = pre.mutated ? tool.input.safeParse(plainToolInput(pre.input)) : undefined;
+    if (reparsed && !reparsed.success) {
         return {
             ok: false,
             kind: 'failed',
             failure: {
                 code: 'invalid_input',
                 kind: 'bad_response',
-                message: lexiconText('tool.input_invalid_after_mutate', {}, args.ctx.profile.lexicon),
+                message: labelText('tool.input_invalid_after_mutate', {}, args.ctx.profile.labels),
                 details: reparsed.error.flatten(),
             },
         };
     }
-    return { ok: true, input: reparsed.data };
+    const waitFailure = await waitForStepCalls(stages, base.callId, tool.name, pre.waitFor, ctx.profile.labels);
+    if (waitFailure)
+        return { ok: false, kind: 'failed', failure: waitFailure };
+    return { ok: true, input: reparsed ? reparsed.data : pre.input };
 }
 async function* runPreToolStages(args) {
-    const { stages, toolName, callId, input, toolPreTool } = args;
+    const { stages, toolName, callId, input, toolPreTool, details } = args;
     const applied = yield* runStage({
         stage: 'pre_tool',
         step: stages.step,
@@ -70,6 +105,7 @@ async function* runPreToolStages(args) {
         callId,
         tool: toolName,
         input,
+        ...(stages.stepCalls ? { stepCalls: stages.stepCalls } : {}),
     });
     if (applied.abort) {
         return { ok: false, kind: 'aborted', aborted: applied.abort };
@@ -87,14 +123,35 @@ async function* runPreToolStages(args) {
             kind: 'confirmation',
             tool: toolName,
             ...(applied.confirm.summary ? { summary: applied.confirm.summary } : {}),
+            ...details,
+        };
+        return {
+            ok: false,
+            kind: 'gated',
+            gate,
+            ...(applied.mutate && 'input' in applied.mutate ? { input: applied.mutate.input } : {}),
         };
-        yield stageEventFields('pre_tool', { callId, toolName, callNotStarted: true, gate });
-        return { ok: false, kind: 'gated', gate };
     }
+    const waitFor = applied.waitFor ? { waitFor: applied.waitFor } : {};
     if (applied.mutate && 'input' in applied.mutate) {
-        return { ok: true, input: applied.mutate.input, mutated: true };
+        return { ok: true, input: applied.mutate.input, mutated: true, ...waitFor };
     }
-    return { ok: true, input, mutated: false };
+    return { ok: true, input, mutated: false, ...waitFor };
+}
+/** Holds the call for the calls its `pre_tool` named; a wait that cannot end fails the call. */
+async function waitForStepCalls(stages, callId, toolName, waitFor, labels) {
+    if (!waitFor)
+        return undefined;
+    const outcome = stages?.wait
+        ? await stages.wait(callId, waitFor)
+        : { ok: false, reason: 'unknown', callIds: [...waitFor] };
+    if (outcome.ok)
+        return undefined;
+    return {
+        code: outcome.reason === 'unknown' ? 'wait_unknown' : 'wait_cycle',
+        kind: 'request',
+        message: labelText(outcome.reason === 'unknown' ? 'tool.wait_unknown' : 'tool.wait_cycle', { tool: toolName, calls: outcome.callIds.join(', ') }, labels),
+    };
 }
 export async function* runPostToolStages(args) {
     const { stages, toolName, callId, mutable, ...call } = args;
@@ -118,6 +175,7 @@ export async function* runPostToolStages(args) {
         ...(applied.abort !== undefined ? { abort: applied.abort } : {}),
         ...(applied.deny ? { deny: applied.deny } : {}),
         ...(applied.mutate && 'output' in applied.mutate ? { mutate: applied.mutate } : {}),
+        ...(applied.labelFailed ? { labelFailed: true } : {}),
         inject: applied.inject,
     };
 }
@@ -133,7 +191,7 @@ export async function* emitGateSettlement(args) {
         gate: args.gate,
     });
     const readBack = args.gate.kind === 'auth'
-        ? lexiconText('sign_in.pending', { service: args.gate.authChallenge.service }, args.lexicon)
+        ? labelText('sign_in.pending', { service: args.gate.authChallenge.service }, args.labels)
         : undefined;
     yield toolEvent(args.base, { phase: 'gate', gate: args.gate, ...(readBack ? { readBack } : {}) });
     return readBack;