agentfootprint 13.0.0 → 14.0.0

package/dist/esm/core/agent/stages/toolCalls/execution/dispatchCall.js

@@ -0,0 +1,511 @@
+import { prepareCallState } from '../access/callState.js';
+import { checkToolPermission } from '../access/toolPermission.js';
+import { buildCapabilityQuestion } from '../access/capabilityQuestion.js';
+import { checkerGoverns } from '../../../../../provider-contract/types.js';
+import { prepareArgumentGate } from '../access/argumentGate.js';
+import { admitMiddlewareCall } from '../access/middlewareAdmission.js';
+import { changedArgKeys, shownArgsOf } from '../../../../toolShownArgs.js';
+import { atMountedCursor } from '../helpers/mountedCursor.js';
+import { skillTarget } from '../../../../../security/skillTarget.js';
+import { admitCheckInCall } from '../access/checkInAdmission.js';
+import { admitWantedArguments } from './wantedArguments.js';
+import { admitToolCredential } from './credentialAdmission.js';
+import { invokeInitialTool } from './initialInvocation.js';
+import { applyReadSkillRoute } from '../routing/readSkillRoute.js';
+import { PRESENT_TOOL_NAME } from '../../../../../artifacts/present.js';
+import { recordCallSettlement } from '../observation/callSettlement.js';
+import { safeStringify } from '../../../validators.js';
+import { landCallResult } from './deliveredResult.js';
+import { judgeLanded } from '../evidence/judgeLanded.js';
+import { activateLandedSkill } from '../routing/skillActivation.js';
+import { haltLandedCall } from '../routing/policyHalt.js';
+/** Execute one original serial-loop call using the native handler's scope and exact batch references. */
+export function buildCallDispatch(deps, operations) {
+    const dispatchCall = async (scope, tc, callIndex, batch) => {
+        const { emitSecurity, resolved, tool, args, proposedProgram, viewOf, historyForCallbacks, startMs, findingsRefusal, invalidateViews, } = operations.beginDispatchCall(scope, tc, batch.iteration, batch.towers, callIndex, batch.toolCalls, batch.findingsRefusals, batch.frozenTurn, batch.callbackHistory, batch.frozenArgsAt);
+        const { outcome, resolution, runArgs, callArguments, execution } = prepareCallState(tc, findingsRefusal, batch.resolutions, batch.inputs, args);
+        if (!execution.denied && operations.permissionChecker) {
+            await checkToolPermission({
+                historyForCallbacks,
+                iteration: batch.iteration,
+                permissionChecker: operations.permissionChecker,
+                tc,
+                viewOf,
+                runArgs,
+                runIdentity: batch.runIdentity,
+                env: batch.env,
+                emitSecurity,
+                execution,
+                outcome,
+            });
+        }
+        const askCapability = buildCapabilityQuestion({
+            permissionChecker: operations.permissionChecker,
+            viewOf,
+            historyForCallbacks,
+            iteration: batch.iteration,
+            runIdentity: batch.runIdentity,
+            env: batch.env,
+            emitSecurity,
+            tc,
+            callArguments,
+            execution,
+            outcome,
+        });
+        // ── Declared tool capabilities (9.11.0) ──────────────────────────
+        // Beside the tool_call gate, at the same layer and before any
+        // middleware, so an existing checker still decides first. Asked once
+        // per capability the TOOL declared and the CHECKER governs — either
+        // side silent and this loop does not run at all, which is why an agent
+        // that has not opted in is byte-identical.
+        if (!execution.denied && operations.permissionChecker && tool?.capabilities) {
+            for (const capability of tool.capabilities) {
+                if (execution.denied)
+                    break;
+                if (!checkerGoverns(operations.permissionChecker, capability))
+                    continue;
+                await askCapability(capability, tc.name, `Tool '${tc.name}' is not available in this context.`);
+            }
+        }
+        const { argumentGate, consentGate, unmounted } = prepareArgumentGate(scope, { tc, tool, iteration: batch.iteration, execution, outcome }, {
+            unmountedRules: operations.unmountedRules,
+            warnUnmountedToolPeriod: operations.warnUnmountedToolPeriod,
+        });
+        const rulesRefusal = argumentGate.argsRejected
+            ? undefined
+            : resolution?.refused ?? (unmounted === undefined ? undefined : await unmounted);
+        if (!execution.denied && rulesRefusal !== undefined) {
+            argumentGate.argsRejected = true;
+            outcome.error = true;
+            outcome.result = rulesRefusal;
+        }
+        // ── The middleware chain ─────────────────────────────────────────
+        // Walked only for a call the permission gate let through, so an
+        // existing checker keeps deciding first and a denial there costs
+        // nothing. A denial from the chain lands as the tool result, exactly
+        // like every other refusal in this loop — the model reads it and
+        // adapts. An `ask` commits partial state and pauses, on the same wire
+        // the check-in gate uses. Never walked for a call whose arguments the
+        // inputs layer refused (above).
+        if (!execution.denied &&
+            !argumentGate.argsRejected &&
+            deps.toolMiddleware &&
+            deps.toolMiddleware.length > 0) {
+            const pause = await admitMiddlewareCall(scope, deps, {
+                tc,
+                tool,
+                iteration: batch.iteration,
+                callArguments,
+                historyForCallbacks,
+                runIdentity: batch.runIdentity,
+                env: batch.env,
+                oneQuestionAsked: batch.oneQuestionAsked,
+                resolved,
+                decisionLedger: operations.decisionLedger,
+                inputs: batch.inputs,
+                invalidateViews,
+                execution,
+                outcome,
+                askedLayer: batch.askedLayer,
+                resolution,
+                assertComponentDeliverable: operations.assertComponentDeliverable,
+                newHistory: batch.newHistory,
+                startMs,
+                fileScript: operations.fileScript,
+                proposedProgram,
+                programOfCall: operations.programOfCall,
+            });
+            if (pause !== undefined)
+                return { kind: 'paused', pause };
+        }
+        // The keys the tool will run with a different value for than the
+        // model proposed — a link's rewrite, or a key the tool's own
+        // redaction hides (`../../../../toolShownArgs.ts` · `changedArgKeys`).
+        // Taken HERE, before anything executes: names only, so nothing the
+        // tool later writes into its arguments can ride `tool_end`.
+        const changedKeys = changedArgKeys(args, shownArgsOf(tool, callArguments.chainedArgs));
+        // Tool-args validation (#9) — AFTER the permission gate (policy must
+        // see every attempted call, valid or not) and BEFORE credential
+        // resolution (never acquire credentials for a call that won't run).
+        // On 'enforce' mismatch the tool is NOT executed; the model gets a
+        // structured retry message as the tool result and corrects its args
+        // on the next ReAct iteration. Unknown tools keep the existing
+        // "Unknown tool" path below — validation only applies to resolved
+        // tools (their inputSchema is the contract the LLM was shown).
+        // (`argsRejected` is declared above the middleware chain: the inputs
+        // layer's refusals land in the same shape, before the chain.)
+        if (!execution.denied && !argumentGate.argsRejected && tool) {
+            const invalidArgs = operations.argumentRefusal(scope, tool, callArguments.callArgs, {
+                toolName: tc.name,
+                toolCallId: tc.id,
+                iteration: batch.iteration,
+            });
+            if (invalidArgs !== undefined) {
+                argumentGate.argsRejected = true;
+                outcome.error = true;
+                outcome.result = invalidArgs;
+            }
+        }
+        // ── Skill-activation gate (9.11.0) ───────────────────────────────
+        // `read_skill` activating a skill the policy hides for this role. The
+        // menu the model reads was already filtered (the Tools slot asks the
+        // same checker the same question), so this is the second half of one
+        // rule rather than a second rule: a model that guessed a hidden id, or
+        // remembered one from an earlier turn, reads the policy's own message.
+        //
+        // Ordered AFTER arg validation so the id judged is the one that will
+        // actually run — a middleware may have rewritten it — and BEFORE
+        // check-in, credentials and execute, so a refused skill's body is
+        // never even computed (`surfaceMode: 'tool-only'` returns it from
+        // `execute`). Off entirely unless the checker declares it governs
+        // `'skill_read'`.
+        if (!execution.denied &&
+            !argumentGate.argsRejected &&
+            tc.name === 'read_skill' &&
+            checkerGoverns(operations.permissionChecker, 'skill_read')) {
+            const requestedSkillId = callArguments.callArgs.id;
+            if (typeof requestedSkillId === 'string' && requestedSkillId.length > 0) {
+                // ── A SELF-CALL AT A MOUNTED CURSOR EXERCISES NO CAPABILITY ───
+                // (9.86.0.) A MOUNTED cursor's own skill is already served: its
+                // body is in that call's system prompt and its tools are on that
+                // call's wire. Asking to read it activates nothing, moves nothing,
+                // and reveals nothing the request did not already carry — so there
+                // is no capability here for a policy to grant or deny, and denying
+                // it told the model its current skill was "not available in this
+                // context" while it was standing in it. That is the exact sentence
+                // the self-call arm exists to stop the model reading. The gate's
+                // self-call arm answers instead.
+                //
+                // A PARKED cursor is the one case where the same id is not a
+                // no-op, and the skip is scoped to exclude it (9.86.0 fix pass):
+                // parking suppressed the map's contribution, so the dispatch gate
+                // 480 lines below reads that call as a RE-ENGAGEMENT and serves the
+                // body and tools again on the next pass. That moves something, so
+                // the policy keeps the question. `atMountedCursor` is where that
+                // rule lives; the dispatch gate writes the same rule as two ordered
+                // arms over the same `parkedNow` set. Every OTHER id still goes
+                // through the policy, unchanged — this narrows nothing a role could
+                // see.
+                const stay = atMountedCursor({
+                    ...(typeof scope.currentSkillId === 'string' && {
+                        cursor: scope.currentSkillId,
+                    }),
+                    target: requestedSkillId,
+                    parked: operations.parkedNow(scope),
+                });
+                if (!stay) {
+                    await askCapability('skill_read', skillTarget(requestedSkillId), `Skill '${requestedSkillId}' is not available in this context.`);
+                }
+            }
+        }
+        // ── Check-in gate (evidence-carrying human consent) ──────────────
+        // Ordered AFTER the permission gate + arg-validation (a call the policy
+        // denied or that has invalid args never asks a human) and BEFORE
+        // credential resolution + execute (never acquire credentials for a call
+        // awaiting consent — that's the whole point of "consent WITH the
+        // receipts"). Fires ONLY when the tool declared `checkIn` and it trips,
+        // so tools without the field are byte-identical (no gate, no events, no
+        // pause). Rides the EXISTING pause machinery: returning a defined value
+        // triggers the footprintjs checkpoint, exactly like `pauseHere`.
+        if (!execution.denied &&
+            !argumentGate.argsRejected &&
+            tool &&
+            tool.checkIn !== undefined &&
+            deps.checkIn) {
+            const pause = await admitCheckInCall(scope, deps, {
+                historyForCheckIn: operations.historyForCheckIn,
+                historyForCallbacks,
+                tool,
+                viewOf,
+                callArguments,
+                iteration: batch.iteration,
+                tc,
+                askedLayer: batch.askedLayer,
+                resolved,
+                decisionLedger: operations.decisionLedger,
+                consentGate,
+                outcome,
+                resolution,
+                assertComponentDeliverable: operations.assertComponentDeliverable,
+                env: batch.env,
+                newHistory: batch.newHistory,
+                startMs,
+                fileScript: operations.fileScript,
+                proposedProgram,
+                programOfCall: operations.programOfCall,
+            });
+            if (pause !== undefined)
+                return { kind: 'paused', pause };
+        }
+        if (!execution.denied && !argumentGate.argsRejected && !consentGate.checkInRefused) {
+            const wanted = {
+                // ── Declared artifact arguments (9.22.0) ──────────────────────
+                // The `needs` precedent applied to data: resolve the tool's
+                // declared `wants` refs BEFORE credential resolution (never
+                // acquire credentials for a call that won't run) and BEFORE
+                // execute — a stale/unknown/wrong-kind ref never reaches the
+                // tool; the model reads a teaching refusal listing the live refs
+                // of the wanted kind. On success `callArgs` carries the RESOLVED
+                // DATA and `ctx.wanted` the claim tickets. Tools without `wants`
+                // take the exact path they always took.
+                wantedMeta: undefined,
+                wantsBlocked: false,
+            };
+            if (tool?.wants !== undefined) {
+                await admitWantedArguments(scope, {
+                    resolveWantsAtDispatch: operations.resolveWantsAtDispatch,
+                    tc,
+                    tool,
+                    callArguments,
+                    wanted,
+                    outcome,
+                });
+            }
+            const authorization = {
+                // Declare-and-push: resolve the tool's declared credential BEFORE
+                // invoking, and inject it as ctx.credential. On consent-required or
+                // failure, surface the reason to the LLM (tool result) + emit; the
+                // tool does NOT run (fail-closed — never half-authed; a denial that
+                // throws is surfaced, not retried).
+                resolvedCredential: undefined,
+                credentialBlocked: false,
+            };
+            const need = wanted.wantsBlocked ? undefined : tool?.needs;
+            if (need) {
+                const pause = await admitToolCredential(scope, deps, {
+                    emitSecurity,
+                    need,
+                    credentialsIn: operations.credentialsIn,
+                    runIdentity: batch.runIdentity,
+                    authorization,
+                    onAuthorizationRequired: operations.onAuthorizationRequired,
+                    oneQuestionAsked: batch.oneQuestionAsked,
+                    newHistory: batch.newHistory,
+                    tc,
+                    startMs,
+                    callArguments,
+                    resolved,
+                    fileScript: operations.fileScript,
+                    tool,
+                    iteration: batch.iteration,
+                    proposedProgram,
+                    programOfCall: operations.programOfCall,
+                    outcome,
+                    askedLayer: batch.askedLayer,
+                    resolution,
+                });
+                if (pause !== undefined)
+                    return { kind: 'paused', pause };
+            }
+            if (!authorization.credentialBlocked && !wanted.wantsBlocked) {
+                const pause = await invokeInitialTool(scope, deps, {
+                    tool,
+                    resolved,
+                    tc,
+                    dispatchRoster: operations.dispatchRoster,
+                    noteOffWire: operations.noteOffWire,
+                    iteration: batch.iteration,
+                    callArguments,
+                    env: batch.env,
+                    credentialsIn: operations.credentialsIn,
+                    emitSecurity,
+                    hasCredentials: operations.hasCredentials,
+                    authorization,
+                    toolArtifacts: operations.toolArtifacts,
+                    wanted,
+                    toolProgress: operations.toolProgress,
+                    sessionContext: operations.sessionContext,
+                    toolDispatchCtx: operations.toolDispatchCtx,
+                    searchFunnel: operations.searchFunnel,
+                    execution,
+                    runFactsOf: operations.runFactsOf,
+                    programOfCall: operations.programOfCall,
+                    outcome,
+                    takeCodeRun: operations.takeCodeRun,
+                    warnEffect: operations.warnEffect,
+                    declareCoverage: operations.declareCoverage,
+                    declareSemantics: operations.declareSemantics,
+                    refuseOverCeiling: operations.refuseOverCeiling,
+                    judgeColumns: operations.judgeColumns,
+                    endCall: operations.endCall,
+                    oneQuestionAsked: batch.oneQuestionAsked,
+                    assertComponentDeliverable: operations.assertComponentDeliverable,
+                    newHistory: batch.newHistory,
+                    startMs,
+                    declareRaisedAbsence: operations.declareRaisedAbsence,
+                    fileScript: operations.fileScript,
+                    proposedProgram,
+                    askedLayer: batch.askedLayer,
+                    resolution,
+                });
+                if (pause !== undefined)
+                    return { kind: 'paused', pause };
+            }
+        }
+        const skillRoute = {
+            // ── Skill-graph read_skill GATE ────────────────────────
+            // Reject a read_skill jump OUTSIDE the reachable set from the current
+            // cursor: replace the result with a re-prompt naming the allowed ids (so
+            // the model re-picks) and skip the activation below — cursor + activations
+            // stay unchanged. Off when no skillGraph (deps.allowedSkillIds undefined),
+            // so plain read_skill agents are byte-for-byte unaffected.
+            //
+            // The allowed set is two kinds of id, and the difference is the whole
+            // design (8.4.0): a HOP — a skill the graph routes, reachable from where
+            // the cursor stands — and an OPEN skill, one the graph never wires (a
+            // `.selfExplain()` debug skill, a `.skill()` registered beside the graph,
+            // a skill listed in `skills[]` and wired to nothing). Both activate; only a
+            // hop moves the cursor. Before 8.4.0 the open ones were offered in
+            // read_skill's own menu and then rejected on every single call — the
+            // library refused its own flagship debug feature under its own routing
+            // feature, and the model could burn a whole run re-asking.
+            skillRejected: false,
+            skillHop: false,
+        };
+        applyReadSkillRoute(scope, deps, {
+            tc,
+            iteration: batch.iteration,
+            parkedNow: operations.parkedNow,
+            noteSkillRefusal: operations.noteSkillRefusal,
+            outcome,
+            execution,
+            callArguments,
+            skillRoute,
+        });
+        // ── skip_step bookkeeping (9.18.0) ─────────────────────────────
+        // Same block as the read_skill gate, same mechanism: the stage
+        // OVERWRITES the tool's placeholder with the authoritative sentence
+        // BEFORE the after-tool moment, so governance rules and the cap
+        // compose over what the model will actually read, on both channels.
+        // Postures never gate it — skipping is judgment inside a step, not
+        // routing. Zero-cost gate: `stepPlanFor` is undefined on every agent
+        // without a stepped skill.
+        if (operations.frameworkSkipStepAnswered(tc.name, tool) &&
+            !outcome.error &&
+            !execution.denied) {
+            outcome.result = operations.applySkipStep(scope, {
+                args: callArguments.callArgs,
+                toolCallId: tc.id,
+                iteration: batch.iteration,
+            });
+        }
+        // ── present bookkeeping (9.22.0) ───────────────────────────────
+        // Same mechanism as skip_step: the auto-attached placeholder ran;
+        // the stage overwrites its result with the description snapshot (or
+        // the teaching refusal) BEFORE the after-tool moment, so governance
+        // and the caps compose over what the model will actually read. A
+        // miss is an errored call: the model holds no presentation, and a
+        // procedure step whose tool presented nothing must not advance.
+        if (deps.artifactStore &&
+            tc.name === PRESENT_TOOL_NAME &&
+            execution.executed &&
+            !outcome.error &&
+            !execution.denied) {
+            const presented = await operations.applyPresent(scope, {
+                args: callArguments.callArgs,
+                toolCallId: tc.id,
+                iteration: batch.iteration,
+            });
+            outcome.result = presented.text;
+            if (!presented.ok)
+                outcome.error = true;
+        }
+        // ── The after-tool moment ────────────────────────────────────────
+        // Last thing before the result becomes history, and only for a call
+        // that ran. `modelResult` is what the model reads; `result` stays the
+        // truth about the tool and is what `stream.tool_end` reports.
+        const rawModelResult = execution.executed
+            ? await operations.afterMoment(scope, {
+                ...(tool && { tool }),
+                toolName: tc.name,
+                toolCallId: tc.id,
+                iteration: batch.iteration,
+                args: callArguments.callArgs,
+                result: outcome.result,
+                negativeResultId: execution.negativeDispatch?.resultId,
+                ...(outcome.error === true && { error: true }),
+                history: batch.newHistory,
+                ...(batch.runIdentity && { identity: batch.runIdentity }),
+                ...(batch.env.signal && { signal: batch.env.signal }),
+            })
+            : outcome.result;
+        // Placement next (9.22.0) — the operator's ref-ing, judged on what
+        // the chain let through (a rule that already summarized a huge
+        // result is measured on what it produced, the same reasoning as the
+        // cap). Over the threshold, the payload is checked into the store
+        // and BOTH channels carry the ticket; the truncation net below then
+        // measures the ticket. A refused/denied/errored call is never
+        // placed: a refusal is already short, and 'tool-result/<name>' must
+        // never claim an error is the tool's result.
+        const placedValues = await operations.placeResults(scope, { toolName: tc.name, toolCallId: tc.id, iteration: batch.iteration }, { result: outcome.result, modelResult: rawModelResult }, execution.executed && !outcome.error && !execution.denied && !execution.ceilingRefused);
+        // The write seam (9.77.0) — judged on `result`, the tool's own answer,
+        // and on `newHistory`, which at this point holds every earlier tool
+        // result and not yet this one. Same guard the placement decision uses:
+        // a call that did not run, errored, was denied or had its payload
+        // refused has no lookup answer to read.
+        operations.noticeEmptyLookup(scope, { toolName: tc.name, toolCallId: tc.id, iteration: batch.iteration }, callArguments.callArgs, outcome.result, batch.newHistory, execution.executed && !outcome.error && !execution.denied && !execution.ceilingRefused);
+        // The ceiling, last — after the tool, after the chain. A rule that
+        // already summarized a huge result is measured on what it produced, so
+        // the cap composes with governance rather than pre-empting it.
+        const capped = operations.capResults(tc.name, placedValues);
+        const modelResult = capped.modelResult;
+        const durationMs = Date.now() - startMs;
+        recordCallSettlement(scope, {
+            fileScript: operations.fileScript,
+            tool,
+            tc,
+            iteration: batch.iteration,
+            proposedProgram,
+            execution,
+            programOfCall: operations.programOfCall,
+            callArguments,
+            emitToolEnd: operations.emitToolEnd,
+            capped,
+            durationMs,
+            outcome,
+            modelResult,
+            changedKeys,
+        });
+        const delivery = {
+            resultStr: typeof modelResult === 'string' ? modelResult : safeStringify(modelResult),
+        };
+        landCallResult(scope, deps, {
+            delivery,
+            execution,
+            tc,
+            outcome,
+            skillRoute,
+            callArguments,
+            readSkillStepIntroFor: operations.readSkillStepIntroFor,
+            applyStepReturn: operations.applyStepReturn,
+            iteration: batch.iteration,
+            applyToolEffects: operations.applyToolEffects,
+            transitionState: batch.transitionState,
+            runFactsOf: operations.runFactsOf,
+            tool,
+            repeatLedgers: operations.repeatLedgers,
+            inputs: batch.inputs,
+            resolution,
+            args,
+            noteOptionsFor: operations.noteOptionsFor,
+            newHistory: batch.newHistory,
+            batchResults: batch.batchResults,
+        });
+        await judgeLanded(scope, deps.findingsJudge, execution.executed && !execution.denied && !skillRoute.skillRejected, { toolName: tc.name, result: delivery.resultStr, toolCallId: tc.id }, batch.iteration, operations.turnStampOf(scope));
+        activateLandedSkill(scope, deps, { tc, outcome, execution, skillRoute, callArguments });
+        if (execution.haltContext) {
+            haltLandedCall(scope, {
+                haltContext: execution.haltContext,
+                emitSecurity,
+                tc,
+                newHistory: batch.newHistory,
+                iteration: batch.iteration,
+                callArguments,
+            });
+            return { kind: 'halted' };
+        }
+        return { kind: 'landed' };
+    };
+    return dispatchCall;
+}
+//# sourceMappingURL=dispatchCall.js.map

package/dist/esm/core/agent/stages/toolCalls/execution/dispatchCall.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"dispatchCall.js","sourceRoot":"","sources":["../../../../../../../src/core/agent/stages/toolCalls/execution/dispatchCall.ts"],"names":[],"mappings":"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"}

package/dist/esm/core/agent/stages/toolCalls/execution/initialInvocation.d.ts

@@ -0,0 +1,70 @@
+import type { buildCallStart } from './callStart.js';
+import type { buildDispatchContext } from '../batch/dispatchContext.js';
+import type { buildToolCatalogOperations } from './catalogOperations.js';
+import type { CallArguments, CallExecution, CallResultCell } from '../contracts/callCells.js';
+import type { buildToolCredentialsOperations } from './credentialsOperations.js';
+import type { CallCredentialInput, CallArtifactInputs } from '../contracts/invocationInputs.js';
+import type { buildToolContextOperations } from './contextOperations.js';
+import type { buildToolProgressOperations } from '../observation/progressOperations.js';
+import type { buildToolResourcesOperations } from './resourcesOperations.js';
+import type { buildSearchCoverage } from '../../searchCoverage.js';
+import type { buildToolScriptsOperations } from '../evidence/scriptsOperations.js';
+import type { buildToolEffectsOperations } from '../routing/effectsOperations.js';
+import type { buildToolCoverageOperations } from '../evidence/coverageOperations.js';
+import type { buildToolSemanticsOperations } from '../evidence/semanticsOperations.js';
+import type { buildToolLimitsOperations } from '../decorators/limitsOperations.js';
+import type { buildToolIntegrityOperations } from '../evidence/integrityOperations.js';
+import type { buildToolArtifactsOperations } from './artifactsOperations.js';
+import type { InputsDispatch } from '../contracts/inputsDispatch.js';
+import type { TypedScope } from 'footprintjs';
+import type { AgentState } from '../../../types.js';
+import type { ToolCallsHandlerDeps } from '../contracts/handlerDeps.js';
+import type { DispatchCall } from '../contracts/batchCall.js';
+type CallStartFacts = ReturnType<ReturnType<typeof buildCallStart>['beginDispatchCall']>;
+type DispatchContext = ReturnType<ReturnType<typeof buildDispatchContext>['prepareDispatchContext']>;
+interface InvokeInitialToolFrame {
+    readonly tool: CallStartFacts['tool'];
+    readonly resolved: CallStartFacts['resolved'];
+    readonly tc: DispatchCall;
+    readonly dispatchRoster: ReturnType<typeof buildToolCatalogOperations>['dispatchRoster'];
+    readonly noteOffWire: ReturnType<typeof buildToolCatalogOperations>['noteOffWire'];
+    readonly iteration: number;
+    readonly callArguments: CallArguments;
+    readonly env: DispatchContext['env'];
+    readonly credentialsIn: ReturnType<typeof buildToolCredentialsOperations>['credentialsIn'];
+    readonly emitSecurity: CallStartFacts['emitSecurity'];
+    readonly hasCredentials: boolean;
+    readonly authorization: CallCredentialInput;
+    readonly toolArtifacts: ReturnType<typeof buildToolContextOperations>['toolArtifacts'];
+    readonly wanted: CallArtifactInputs;
+    readonly toolProgress: ReturnType<typeof buildToolProgressOperations>['toolProgress'];
+    readonly sessionContext: ReturnType<typeof buildToolResourcesOperations>['sessionContext'];
+    readonly toolDispatchCtx: ReturnType<typeof buildToolContextOperations>['toolDispatchCtx'];
+    readonly searchFunnel: ReturnType<typeof buildSearchCoverage>;
+    readonly execution: CallExecution;
+    readonly runFactsOf: ReturnType<typeof buildToolResourcesOperations>['runFactsOf'];
+    readonly programOfCall: ReturnType<typeof buildToolScriptsOperations>['programOfCall'];
+    readonly outcome: CallResultCell;
+    readonly takeCodeRun: ReturnType<typeof buildToolScriptsOperations>['takeCodeRun'];
+    readonly warnEffect: ReturnType<typeof buildToolEffectsOperations>['warnEffect'];
+    readonly declareCoverage: ReturnType<typeof buildToolCoverageOperations>['declareCoverage'];
+    readonly declareSemantics: ReturnType<typeof buildToolSemanticsOperations>['declareSemantics'];
+    readonly refuseOverCeiling: ReturnType<typeof buildToolLimitsOperations>['refuseOverCeiling'];
+    readonly judgeColumns: ReturnType<typeof buildToolIntegrityOperations>['judgeColumns'];
+    readonly endCall: ReturnType<typeof buildToolResourcesOperations>['endCall'];
+    readonly oneQuestionAsked: boolean;
+    readonly assertComponentDeliverable: ReturnType<typeof buildToolArtifactsOperations>['assertComponentDeliverable'];
+    readonly newHistory: DispatchContext['newHistory'];
+    readonly startMs: CallStartFacts['startMs'];
+    readonly declareRaisedAbsence: ReturnType<typeof buildToolCoverageOperations>['declareRaisedAbsence'];
+    readonly fileScript: ReturnType<typeof buildToolScriptsOperations>['fileScript'];
+    readonly proposedProgram: CallStartFacts['proposedProgram'];
+    readonly askedLayer: InputsDispatch | undefined;
+    readonly resolution: ReturnType<ReturnType<InputsDispatch['resolutionsFor']>['get']>;
+}
+/** Existing initialInvocation body; original guard and native pause return stay with the handler. */
+export declare function invokeInitialTool(scope: TypedScope<AgentState>, deps: Pick<ToolCallsHandlerDeps, 'time' | 'negativeClaimsArmed' | 'answeredAsk'>, frame: InvokeInitialToolFrame): Promise<{
+    toolCallId: string;
+    toolName: string;
+} | undefined>;
+export {};