agentfootprint 9.6.0 → 9.7.0

package/dist/esm/core/codeRunnerTool.d.ts

@@ -0,0 +1,120 @@
+/**
+ * codeRunnerTool — the tool that turns a {@link CodeRunner} into something an
+ * LLM can call, holding ONE session per isolation key.
+ *
+ * Pattern: Factory over `defineTool` + the 9.7.0 tool-session contract.
+ * Role:    the first consumer of `ctx.onTeardown` — and the proof it works.
+ * Emits:   nothing directly; the teardown tier reports
+ *          `agentfootprint.tools.session_started` / `_reused` / `_closed` /
+ *          `_close_failed`.
+ *
+ * ── The doctrine: summarize prose, compute data ─────────────────────────────
+ * A tool that hands the model 40,000 rows has not given it data; it has spent
+ * the window. The motivating failure is real and measured: a production request
+ * of 879,073 tokens, almost all of it one tool result pasted into the prompt.
+ * (Since 9.6.0 that shape at least fails by NAME —
+ * `ContextWindowExceededError` — instead of as a vendor 400. This is the other
+ * half: not failing better, but not needing to.)
+ *
+ * With a code runner the model writes an aggregation, the RUNNER holds the
+ * rows, and what comes back is the number. Prose gets summarized; data gets
+ * computed.
+ *
+ * ── Why the session must be keyed, and keyed WIDELY ENOUGH ──────────────────
+ * The session is the whole value: a code interpreter costs seconds to start and
+ * milliseconds to invoke. But a session holds a filesystem, an environment and
+ * half-run state, so the thing it is keyed on IS the isolation boundary. A
+ * standing agent serving many people from one process, holding one session in a
+ * module map, gives person B person A's files.
+ *
+ * So the key comes from `toolSessionKey(ctx, scope)` — one exported
+ * implementation, composing tenant + principal + (session | run). Never a bare
+ * `sessionId`: that is caller data, and anyone who can reach the host can put
+ * someone else's there.
+ *
+ * ── Degradation is REFUSED, never silent ────────────────────────────────────
+ * Ask for `scope: 'session'` at a door with no session and this throws, naming
+ * the door. It does not quietly fall back. Falling back to a WIDER key is the
+ * cross-binding bug itself; falling back to a NARROWER one is a silent 30×
+ * latency change nobody sees until the bill.
+ *
+ * @example a session per run, on a local dev machine
+ *   const agent = Agent.create({ provider })
+ *     .tool(codeRunnerTool({ runner: localCodeRunner() }))
+ *     .build();
+ *
+ * @example a session per hosted conversation, on a real sandbox
+ *   const runner = agentCoreCodeRunner({ region, identifier: 'aws.codeinterpreter.v1' });
+ *   const agent = Agent.create({ provider })
+ *     .tool(codeRunnerTool({ runner, scope: 'session', language: 'python' }))
+ *     .build();
+ *   // the composition root says when a session is over:
+ *   conversation.onClose(() => void agent.closeToolSessions({ sessionId }));
+ */
+import type { CodeRunner, CodeSession } from '../adapters/types.js';
+import type { CredentialNeed } from '../identity/types.js';
+import type { CheckInDemand } from './checkin.js';
+import { type Tool } from './tools.js';
+import { type TeardownScope } from './toolSessions.js';
+/** The scopes a code session can be held under. `'shutdown'` is not one: it is
+ *  when everything goes, not a thing to key a session on. */
+export type CodeRunnerToolScope = Extract<TeardownScope, 'call' | 'run' | 'session'>;
+export interface CodeRunnerToolOptions {
+    /** The backend. `localCodeRunner()` for a dev loop, `agentCoreCodeRunner(...)`
+     *  for a real sandbox — the tool is identical across the swap. */
+    readonly runner: CodeRunner;
+    /** Tool name the model sees. Default `'run_code'`. */
+    readonly name?: string;
+    /** Description the model sees. A sensible one is composed from `scope` +
+     *  `language` when you do not pass one. */
+    readonly description?: string;
+    /**
+     * How long one session lives. Default `'run'` — a turn's worth of work shares
+     * one interpreter, and nothing outlives the turn.
+     *
+     * `'session'` keeps the interpreter across the turns of one hosted
+     * conversation (variables persist, files persist) and REQUIRES a
+     * session-bound run plus a composition root that calls
+     * `agent.closeToolSessions({ sessionId })`.
+     *
+     * `'call'` starts and stops per invocation — the safest and the slowest.
+     */
+    readonly scope?: CodeRunnerToolScope;
+    /** Default language for the code the model writes. Default `'python'`. */
+    readonly language?: string;
+    /** Per-stream ceiling for what reaches the model, in characters. Default 4000.
+     *  Anything cut is STATED in the result, never dropped quietly. */
+    readonly maxOutputChars?: number;
+    /** Per-execution ceiling handed to the runner. */
+    readonly timeoutMs?: number;
+    /** Demand a human check-in before code runs — `'always'`, or a predicate over
+     *  the code string. A pause here does NOT tear the session down. */
+    readonly checkIn?: CheckInDemand<{
+        code: string;
+    }>;
+    /** A credential this tool needs (declare-and-push). Resolved before execute.
+     *  Do NOT cache it past the call: a session outliving a run outlives its token. */
+    readonly needs?: CredentialNeed;
+}
+/**
+ * The per-tool session map, riding the `Tool` under a REGISTRY symbol.
+ *
+ * `Symbol.for`, not a unique symbol: this package ships CJS and ESM, and a tool
+ * built through one entry point must be readable through the other. The same
+ * move `INNER_RUN_RECORDS` makes for `flowchartAsTool({ keepRecord })` — and
+ * deliberately a DIFFERENT symbol, so one tool can carry both (spreading a tool
+ * preserves symbol keys, which is why `{...tool, [SYM]: store}` composes).
+ *
+ * Invisible to the LLM, invisible to `Tool`'s shape, reachable by a test and by
+ * whatever inspector comes next.
+ */
+export declare const TOOL_SESSIONS: unique symbol;
+/** A `Tool` that holds live sessions, keyed by isolation key. */
+export interface HoldsToolSessions {
+    readonly [TOOL_SESSIONS]: ReadonlyMap<string, CodeSession>;
+}
+/** Read the live-session map off a candidate, or `undefined` when it holds none. */
+export declare function toolSessionsOf(candidate: unknown): ReadonlyMap<string, CodeSession> | undefined;
+export declare function codeRunnerTool(options: CodeRunnerToolOptions): Tool<{
+    code: string;
+}, string> & HoldsToolSessions;

package/dist/esm/core/codeRunnerTool.js

@@ -0,0 +1,247 @@
+/**
+ * codeRunnerTool — the tool that turns a {@link CodeRunner} into something an
+ * LLM can call, holding ONE session per isolation key.
+ *
+ * Pattern: Factory over `defineTool` + the 9.7.0 tool-session contract.
+ * Role:    the first consumer of `ctx.onTeardown` — and the proof it works.
+ * Emits:   nothing directly; the teardown tier reports
+ *          `agentfootprint.tools.session_started` / `_reused` / `_closed` /
+ *          `_close_failed`.
+ *
+ * ── The doctrine: summarize prose, compute data ─────────────────────────────
+ * A tool that hands the model 40,000 rows has not given it data; it has spent
+ * the window. The motivating failure is real and measured: a production request
+ * of 879,073 tokens, almost all of it one tool result pasted into the prompt.
+ * (Since 9.6.0 that shape at least fails by NAME —
+ * `ContextWindowExceededError` — instead of as a vendor 400. This is the other
+ * half: not failing better, but not needing to.)
+ *
+ * With a code runner the model writes an aggregation, the RUNNER holds the
+ * rows, and what comes back is the number. Prose gets summarized; data gets
+ * computed.
+ *
+ * ── Why the session must be keyed, and keyed WIDELY ENOUGH ──────────────────
+ * The session is the whole value: a code interpreter costs seconds to start and
+ * milliseconds to invoke. But a session holds a filesystem, an environment and
+ * half-run state, so the thing it is keyed on IS the isolation boundary. A
+ * standing agent serving many people from one process, holding one session in a
+ * module map, gives person B person A's files.
+ *
+ * So the key comes from `toolSessionKey(ctx, scope)` — one exported
+ * implementation, composing tenant + principal + (session | run). Never a bare
+ * `sessionId`: that is caller data, and anyone who can reach the host can put
+ * someone else's there.
+ *
+ * ── Degradation is REFUSED, never silent ────────────────────────────────────
+ * Ask for `scope: 'session'` at a door with no session and this throws, naming
+ * the door. It does not quietly fall back. Falling back to a WIDER key is the
+ * cross-binding bug itself; falling back to a NARROWER one is a silent 30×
+ * latency change nobody sees until the bill.
+ *
+ * @example a session per run, on a local dev machine
+ *   const agent = Agent.create({ provider })
+ *     .tool(codeRunnerTool({ runner: localCodeRunner() }))
+ *     .build();
+ *
+ * @example a session per hosted conversation, on a real sandbox
+ *   const runner = agentCoreCodeRunner({ region, identifier: 'aws.codeinterpreter.v1' });
+ *   const agent = Agent.create({ provider })
+ *     .tool(codeRunnerTool({ runner, scope: 'session', language: 'python' }))
+ *     .build();
+ *   // the composition root says when a session is over:
+ *   conversation.onClose(() => void agent.closeToolSessions({ sessionId }));
+ */
+import { defineTool } from './tools.js';
+import { toolSessionKey } from './toolSessions.js';
+const DEFAULT_MAX_OUTPUT_CHARS = 4_000;
+/**
+ * The per-tool session map, riding the `Tool` under a REGISTRY symbol.
+ *
+ * `Symbol.for`, not a unique symbol: this package ships CJS and ESM, and a tool
+ * built through one entry point must be readable through the other. The same
+ * move `INNER_RUN_RECORDS` makes for `flowchartAsTool({ keepRecord })` — and
+ * deliberately a DIFFERENT symbol, so one tool can carry both (spreading a tool
+ * preserves symbol keys, which is why `{...tool, [SYM]: store}` composes).
+ *
+ * Invisible to the LLM, invisible to `Tool`'s shape, reachable by a test and by
+ * whatever inspector comes next.
+ */
+export const TOOL_SESSIONS = Symbol.for('agentfootprint.tools.sessions');
+/** Read the live-session map off a candidate, or `undefined` when it holds none. */
+export function toolSessionsOf(candidate) {
+    if (candidate === null || typeof candidate !== 'object')
+        return undefined;
+    const held = candidate[TOOL_SESSIONS];
+    return held instanceof Map ? held : undefined;
+}
+export function codeRunnerTool(options) {
+    const name = options.name ?? 'run_code';
+    const scope = options.scope ?? 'run';
+    const language = options.language ?? 'python';
+    const maxOutputChars = options.maxOutputChars ?? DEFAULT_MAX_OUTPUT_CHARS;
+    /**
+     * Live sessions by isolation key.
+     *
+     * A `Map` and not a closure variable, because two keys are two sandboxes: one
+     * variable would be exactly the cross-binding this whole feature exists to
+     * prevent. Entries are removed by the teardown the tool registers alongside
+     * them, so the map cannot outlive what it points at.
+     */
+    const sessions = new Map();
+    /** In-flight starts, so two parallel tool calls under one key open ONE session. */
+    const starting = new Map();
+    const tool = defineTool({
+        name,
+        description: options.description ?? describe(scope, language),
+        inputSchema: {
+            type: 'object',
+            properties: {
+                code: {
+                    type: 'string',
+                    description: `${language} source to execute. Print what you want back — stdout is the result. ` +
+                        'Compute over big data here rather than asking for it to be pasted back to you.',
+                },
+            },
+            required: ['code'],
+        },
+        ...(options.checkIn !== undefined && { checkIn: options.checkIn }),
+        ...(options.needs && { needs: options.needs }),
+        execute: async (args, ctx) => {
+            const key = requireKey(ctx, scope, name);
+            const session = await acquire(key, ctx);
+            const result = await session.execute({
+                code: args.code,
+                language,
+                ...(options.timeoutMs !== undefined && { timeoutMs: options.timeoutMs }),
+                ...(ctx.signal && { signal: ctx.signal }),
+            });
+            return render(result, maxOutputChars);
+        },
+    });
+    /** Get the session for `key`, opening one if this is the first call. */
+    const acquire = async (key, ctx) => {
+        const live = sessions.get(key);
+        if (live) {
+            // A reuse re-registers under the SAME (tool, scope, key). The tier keeps
+            // the FIRST cleanup — it is the one holding this handle — and treats the
+            // repeat as a touch, which is how the idle sweep and the LRU bound learn
+            // this session is still in use. Registering only once would make a busy
+            // session look as cold as an abandoned one.
+            register(key, live, ctx);
+            return live;
+        }
+        // Two parallel tool calls in one iteration must not open two sandboxes.
+        const inFlight = starting.get(key);
+        if (inFlight)
+            return inFlight;
+        const opening = options.runner
+            .start({ key, language, ...(ctx.signal && { signal: ctx.signal }) })
+            .then((opened) => {
+            sessions.set(key, opened);
+            register(key, opened, ctx);
+            return opened;
+        })
+            .finally(() => {
+            starting.delete(key);
+        });
+        starting.set(key, opening);
+        return opening;
+    };
+    const register = (key, session, ctx) => {
+        ctx.onTeardown?.(async () => {
+            // Drop the entry FIRST: if `stop()` throws, the map must not keep
+            // handing out a session the runtime has already given up on.
+            sessions.delete(key);
+            await session.stop();
+        }, { scope, key, runnerId: options.runner.id, label: language });
+    };
+    // The live map rides the Tool under a registry symbol — see TOOL_SESSIONS.
+    return { ...tool, [TOOL_SESSIONS]: sessions };
+}
+/**
+ * Derive the isolation key, or REFUSE by name.
+ *
+ * The three refusals are the security surface of this tool, so each says what
+ * is missing, why it matters, and the one-line fix. None of them degrades
+ * quietly: a fallback to a wider key is the cross-binding bug, and a fallback
+ * to a narrower one silently multiplies latency and cost.
+ */
+function requireKey(ctx, scope, name) {
+    const supported = ctx.teardownScopes;
+    if (supported !== undefined && !supported.includes(scope)) {
+        throw new Error(`${name}: this tool holds a '${scope}'-scoped code session, and the door it is running ` +
+            `behind honours ${supported.length === 0 ? 'no teardown scopes' : supported.join(', ')}. ` +
+            'A session nothing will ever close is a sandbox left running. Either run this tool ' +
+            `inside an Agent, or build it with scope: '${supported[0] ?? 'call'}'.`);
+    }
+    const key = toolSessionKey(ctx, scope);
+    if (key)
+        return key;
+    if (scope === 'session') {
+        throw new Error(`${name}: scope 'session' needs a hosting session, and this run has no sessionId. ` +
+            'Pass one — `agent.run({ message, sessionId })`, which `standingAgent` does from ' +
+            "`HostRequest.sessionId` — or build this tool with scope: 'run'. It is not silently " +
+            'narrowed, because a session-scoped interpreter and a run-scoped one differ by about ' +
+            '30x in start-up cost, and by everything in what persists between turns.');
+    }
+    throw new Error(`${name}: scope 'run' needs a run, and this call has no runId — it is being served ` +
+        'outside an Agent (over `mcpServe`, or from a script). A served call is one call, not a ' +
+        "turn, so nothing would ever end the session. Build this tool with scope: 'call' for " +
+        'that door.');
+}
+/** The description the model reads when the caller did not write one. */
+function describe(scope, language) {
+    const persistence = scope === 'call'
+        ? 'Each call runs in a fresh environment — nothing carries over, so include everything you need.'
+        : scope === 'run'
+            ? 'State persists across calls within this turn: variables and files you create stay available.'
+            : 'State persists across the whole conversation: variables and files you create stay available in later turns.';
+    return (`Execute ${language} code and return its output. ${persistence} ` +
+        'Use this to COMPUTE over data rather than asking for the data itself — fetch, filter, ' +
+        'aggregate and print the answer, so a large result never has to travel through this ' +
+        'conversation. Print what you want to see; stdout is what you get back.');
+}
+/**
+ * Render a `CodeResult` for the model.
+ *
+ * TRUNCATION IS ALWAYS STATED. A slice the model cannot see is a silent
+ * success: it goes on to reason over a fragment of a table believing it has the
+ * table. The marker is deliberately plain text in the result body, not
+ * metadata, because the result body is the only channel the model reads.
+ */
+function render(result, maxOutputChars) {
+    const parts = [];
+    const stdout = clip(result.stdout, maxOutputChars, result.truncated?.stdout === true);
+    const stderr = clip(result.stderr, maxOutputChars, result.truncated?.stderr === true);
+    if (stdout.text.length > 0)
+        parts.push(stdout.text);
+    if (stderr.text.length > 0)
+        parts.push(`stderr:\n${stderr.text}`);
+    if (!result.ok) {
+        parts.push(`[exit ${result.exitCode ?? 'non-zero'}] the code did not complete successfully — read ` +
+            'stderr above and fix it.');
+    }
+    for (const artifact of result.artifacts ?? []) {
+        parts.push(`[artifact: ${artifact.name}, ${artifact.bytes} bytes${artifact.uri ? `, ${artifact.uri}` : ''}]`);
+    }
+    if (parts.length === 0) {
+        // "Nothing was printed" and "this returned nothing" are different facts and
+        // only one of them tells the model what to do next.
+        parts.push('(the code ran and printed nothing — print the value you want returned)');
+    }
+    return parts.join('\n');
+}
+/** Clip to the tool's ceiling, and SAY SO — including a cut the runner made. */
+function clip(text, max, alreadyCutUpstream) {
+    const cutHere = text.length > max;
+    const shown = cutHere ? text.slice(0, max) : text;
+    if (!cutHere && !alreadyCutUpstream)
+        return { text: shown };
+    const of = cutHere ? text.length : undefined;
+    return {
+        text: `${shown}\n[truncated: showing ${shown.length}${of !== undefined ? ` of ${of}` : ''} ` +
+            'characters. Re-run printing a summary, a slice, or an aggregate instead of the whole ' +
+            'value.]',
+    };
+}
+//# sourceMappingURL=codeRunnerTool.js.map

package/dist/esm/core/codeRunnerTool.js.map

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