@workbench-ai/agent-driver 0.0.44

package/dist/process-env.d.ts

@@ -0,0 +1,20 @@
+export interface ResolvedRuntimeEnv {
+    name: string;
+    value: string | undefined;
+    source: "repo_env" | "home_env" | "process_env" | "missing";
+    envPath: string | null;
+    explicitly_set: boolean;
+    blank: boolean;
+}
+export interface RuntimeEnvOptions {
+    runtimeHome?: string;
+    parentEnv?: NodeJS.ProcessEnv;
+}
+type RuntimeEnvResolutionSource = Exclude<ResolvedRuntimeEnv["source"], "missing">;
+export declare function getRuntimeEnvPath(rootPath: string): string;
+export declare function getRuntimeEnv(name: string, repoRoot: string, options?: RuntimeEnvOptions): string | undefined;
+export declare function resolveRuntimeEnvWithPrecedence(name: string, repoRoot: string, precedence: readonly RuntimeEnvResolutionSource[], options?: RuntimeEnvOptions): ResolvedRuntimeEnv;
+export declare function resolveRuntimeEnv(name: string, repoRoot: string, options?: RuntimeEnvOptions): ResolvedRuntimeEnv;
+export declare function resetRuntimeEnvForTests(): void;
+export {};
+//# sourceMappingURL=process-env.d.ts.map

package/dist/process-env.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"process-env.d.ts","sourceRoot":"","sources":["../src/process-env.ts"],"names":[],"mappings":"AAMA,MAAM,WAAW,kBAAkB;IACjC,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,GAAG,SAAS,CAAC;IAC1B,MAAM,EAAE,UAAU,GAAG,UAAU,GAAG,aAAa,GAAG,SAAS,CAAC;IAC5D,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IACvB,cAAc,EAAE,OAAO,CAAC;IACxB,KAAK,EAAE,OAAO,CAAC;CAChB;AAED,MAAM,WAAW,iBAAiB;IAChC,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,SAAS,CAAC,EAAE,MAAM,CAAC,UAAU,CAAC;CAC/B;AAED,KAAK,0BAA0B,GAAG,OAAO,CACvC,kBAAkB,CAAC,QAAQ,CAAC,EAC5B,SAAS,CACV,CAAC;AAEF,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAE1D;AA4CD,wBAAgB,aAAa,CAC3B,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,MAAM,EAChB,OAAO,GAAE,iBAAsB,GAC9B,MAAM,GAAG,SAAS,CAEpB;AAED,wBAAgB,+BAA+B,CAC7C,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,MAAM,EAChB,UAAU,EAAE,SAAS,0BAA0B,EAAE,EACjD,OAAO,GAAE,iBAAsB,GAC9B,kBAAkB,CA2CpB;AAED,wBAAgB,iBAAiB,CAC/B,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,MAAM,EAChB,OAAO,GAAE,iBAAsB,GAC9B,kBAAkB,CAOpB;AAED,wBAAgB,uBAAuB,IAAI,IAAI,CAG9C"}

package/dist/process-env.js

@@ -0,0 +1,75 @@
+import { existsSync, readFileSync } from "node:fs";
+import path from "node:path";
+import { parseEnv } from "node:util";
+import { resolveRuntimeHome } from "./internal-utils.js";
+export function getRuntimeEnvPath(rootPath) {
+    return path.join(rootPath, ".env");
+}
+function readRuntimeEnvFile(repoRoot) {
+    const envPath = getRuntimeEnvPath(repoRoot);
+    if (!existsSync(envPath)) {
+        return {};
+    }
+    return parseEnv(readFileSync(envPath, "utf8"));
+}
+function collectRuntimeEnvFilesWithOptions(repoRoot, options) {
+    const normalizedRepoRoot = path.resolve(repoRoot);
+    const runtimeHome = resolveRuntimeHome(options.runtimeHome);
+    return {
+        repoValues: readRuntimeEnvFile(normalizedRepoRoot),
+        homeValues: readRuntimeEnvFile(runtimeHome),
+        runtimeHome,
+    };
+}
+function formatResolvedRuntimeEnv(name, source, value, envPath) {
+    return {
+        name,
+        value,
+        source,
+        envPath,
+        explicitly_set: true,
+        blank: !value?.trim(),
+    };
+}
+export function getRuntimeEnv(name, repoRoot, options = {}) {
+    return resolveRuntimeEnv(name, repoRoot, options).value;
+}
+export function resolveRuntimeEnvWithPrecedence(name, repoRoot, precedence, options = {}) {
+    const { repoValues, homeValues, runtimeHome } = collectRuntimeEnvFilesWithOptions(repoRoot, options);
+    const parentEnv = options.parentEnv ?? process.env;
+    const sourceValues = {
+        repo_env: {
+            envPath: getRuntimeEnvPath(repoRoot),
+            values: repoValues,
+        },
+        home_env: {
+            envPath: getRuntimeEnvPath(runtimeHome),
+            values: homeValues,
+        },
+        process_env: {
+            envPath: null,
+            values: parentEnv,
+        },
+    };
+    for (const source of precedence) {
+        const entry = sourceValues[source];
+        if (Object.prototype.hasOwnProperty.call(entry.values, name)) {
+            return formatResolvedRuntimeEnv(name, source, entry.values[name], entry.envPath);
+        }
+    }
+    return {
+        name,
+        value: undefined,
+        source: "missing",
+        envPath: null,
+        explicitly_set: false,
+        blank: false,
+    };
+}
+export function resolveRuntimeEnv(name, repoRoot, options = {}) {
+    return resolveRuntimeEnvWithPrecedence(name, repoRoot, ["repo_env", "home_env", "process_env"], options);
+}
+export function resetRuntimeEnvForTests() {
+    // Env resolution is intentionally stateless so repo-local edits are observed
+    // immediately.
+}

package/dist/session-runtime.d.ts

@@ -0,0 +1,60 @@
+import { type ChildProcessWithoutNullStreams } from "node:child_process";
+import type { HarnessEvent, HarnessSession, JsonValue } from "./types.js";
+import { type NormalizedHarnessActivity } from "./normalized-activity.js";
+import { HarnessTraceBuilder } from "./trace-builder.js";
+import type { HarnessRunResult, HarnessTurnLivePersistence } from "./index.js";
+export interface PendingHarnessTurn {
+    controller: HarnessTurnController;
+    result: Promise<HarnessRunResult>;
+    resolve: (value: HarnessRunResult | Promise<HarnessRunResult>) => void;
+    reject: (error: Error) => void;
+}
+export declare function createHarnessSession(args: {
+    harnessId: string;
+    attemptNumber: number;
+    stageId: string;
+    stageRunIndex: number;
+    harnessSession?: Record<string, JsonValue>;
+}): HarnessSession;
+export declare class HarnessTurnController {
+    private readonly args;
+    readonly trace: HarnessTraceBuilder;
+    readonly events: HarnessEvent[];
+    private finalOutput;
+    private turnStartedRecorded;
+    private timeout;
+    private stallTimeout;
+    private flushTimer;
+    private flushChain;
+    private readonly pendingHarnessEvents;
+    constructor(args: {
+        session: HarnessSession;
+        eventsFile: string;
+        rawEventsFile: string;
+        stageSpanId: string;
+        promptText?: string | null;
+        turnTimeoutMs: number;
+        stallTimeoutMs: number;
+        onTimeout: (message: string) => void;
+        livePersistence?: HarnessTurnLivePersistence;
+    });
+    record(args: {
+        harnessEvent?: HarnessEvent | null;
+        rawEnvelope?: Record<string, unknown> | null;
+        normalized?: NormalizedHarnessActivity | NormalizedHarnessActivity[] | null;
+    }): void;
+    succeed(args?: {
+        endedAt?: string;
+        finalOutput?: string;
+    }): Promise<HarnessRunResult>;
+    dispose(): void;
+    flushNow(): Promise<void>;
+    private clearTimers;
+    private resetStallTimeout;
+    private scheduleFlush;
+    private trackOutput;
+}
+export declare function createPendingHarnessTurn(args: ConstructorParameters<typeof HarnessTurnController>[0]): PendingHarnessTurn;
+export declare function terminateProcess(process: ChildProcessWithoutNullStreams, gracefulTimeoutMs: number, hardKillTimeoutMs: number): Promise<void>;
+export declare function waitForProcessClose(process: ChildProcessWithoutNullStreams): Promise<void>;
+//# sourceMappingURL=session-runtime.d.ts.map

package/dist/session-runtime.d.ts.map

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

package/dist/session-runtime.js

@@ -0,0 +1,240 @@
+import { appendNdjson, createId, nowIso } from "./internal-utils.js";
+import { applyNormalizedHarnessActivity, } from "./normalized-activity.js";
+import { HarnessTraceBuilder } from "./trace-builder.js";
+export function createHarnessSession(args) {
+    return {
+        id: createId("session"),
+        harness_id: args.harnessId,
+        attempt_number: args.attemptNumber,
+        stage_id: args.stageId,
+        stage_run_index: args.stageRunIndex,
+        harness_session: args.harnessSession ?? {},
+        started_at: nowIso(),
+        last_event_at: null,
+    };
+}
+export class HarnessTurnController {
+    args;
+    trace;
+    events = [];
+    finalOutput = "";
+    turnStartedRecorded = false;
+    timeout;
+    stallTimeout;
+    flushTimer = null;
+    flushChain = Promise.resolve();
+    pendingHarnessEvents = [];
+    constructor(args) {
+        this.args = args;
+        this.trace = new HarnessTraceBuilder({
+            attemptNumber: args.session.attempt_number,
+            stageId: args.session.stage_id,
+            stageRunIndex: args.session.stage_run_index,
+            stageSpanId: args.stageSpanId,
+        });
+        this.timeout = setTimeout(() => {
+            this.args.onTimeout(`turn timed out after ${this.args.turnTimeoutMs}ms`);
+        }, args.turnTimeoutMs);
+        this.stallTimeout = setTimeout(() => {
+            this.args.onTimeout(`turn stalled after ${this.args.stallTimeoutMs}ms`);
+        }, args.stallTimeoutMs);
+    }
+    record(args) {
+        if (args.rawEnvelope) {
+            void appendNdjson(this.args.rawEventsFile, args.rawEnvelope);
+        }
+        if (args.harnessEvent) {
+            void appendNdjson(this.args.eventsFile, args.harnessEvent);
+            this.events.push(args.harnessEvent);
+            this.pendingHarnessEvents.push(args.harnessEvent);
+            this.args.session.last_event_at = args.harnessEvent.at;
+        }
+        const normalized = args.normalized
+            ? Array.isArray(args.normalized)
+                ? args.normalized
+                : [args.normalized]
+            : [];
+        for (const activity of normalized) {
+            if (activity.type === "turn.started") {
+                if (this.turnStartedRecorded) {
+                    continue;
+                }
+                this.turnStartedRecorded = true;
+                applyNormalizedHarnessActivity(this.trace, {
+                    ...activity,
+                    sessionId: activity.sessionId ?? this.args.session.id,
+                    attributes: {
+                        ...(activity.attributes ?? {}),
+                        ...(this.args.promptText
+                            ? {
+                                prompt_text: this.args.promptText,
+                                prompt_format: "text",
+                                prompt_source: "rendered_stage_prompt",
+                            }
+                            : {}),
+                    },
+                });
+                this.trackOutput(activity);
+                continue;
+            }
+            applyNormalizedHarnessActivity(this.trace, activity);
+            this.trackOutput(activity);
+        }
+        if (args.rawEnvelope || args.harnessEvent || normalized.length > 0) {
+            this.resetStallTimeout();
+        }
+        if (args.harnessEvent || normalized.length > 0) {
+            this.scheduleFlush();
+        }
+    }
+    async succeed(args) {
+        const finalOutput = (args?.finalOutput ?? this.finalOutput).trim();
+        const endedAt = args?.endedAt ?? nowIso();
+        const trace = {
+            trace_id: this.args.session.id,
+            ...this.trace.buildBundle(finalOutput, endedAt),
+        };
+        await this.flushNow();
+        this.clearTimers();
+        return {
+            sessionId: this.args.session.id,
+            finalOutput,
+            trace,
+            events: this.args.livePersistence?.onFlush ? [] : [...this.events],
+        };
+    }
+    dispose() {
+        void this.flushNow().catch(() => undefined);
+        this.clearTimers();
+    }
+    async flushNow() {
+        if (this.flushTimer) {
+            clearTimeout(this.flushTimer);
+            this.flushTimer = null;
+        }
+        if (!this.args.livePersistence?.onFlush) {
+            return;
+        }
+        const harnessEvents = [...this.pendingHarnessEvents];
+        this.pendingHarnessEvents.length = 0;
+        const traceBundle = this.trace.flushBundle();
+        if (harnessEvents.length === 0 &&
+            traceBundle.spans.length === 0 &&
+            traceBundle.events.length === 0 &&
+            traceBundle.summaries.length === 0) {
+            await this.flushChain;
+            return;
+        }
+        this.flushChain = this.flushChain
+            .catch(() => undefined)
+            .then(async () => {
+            await this.args.livePersistence?.onFlush({
+                harnessEvents,
+                traceBundle: traceBundle,
+            });
+        });
+        await this.flushChain;
+    }
+    clearTimers() {
+        if (this.timeout) {
+            clearTimeout(this.timeout);
+            this.timeout = null;
+        }
+        if (this.stallTimeout) {
+            clearTimeout(this.stallTimeout);
+            this.stallTimeout = null;
+        }
+        if (this.flushTimer) {
+            clearTimeout(this.flushTimer);
+            this.flushTimer = null;
+        }
+    }
+    resetStallTimeout() {
+        if (this.stallTimeout) {
+            clearTimeout(this.stallTimeout);
+        }
+        this.stallTimeout = setTimeout(() => {
+            this.args.onTimeout(`turn stalled after ${this.args.stallTimeoutMs}ms`);
+        }, this.args.stallTimeoutMs);
+    }
+    scheduleFlush() {
+        if (!this.args.livePersistence?.onFlush || this.flushTimer) {
+            return;
+        }
+        this.flushTimer = setTimeout(() => {
+            this.flushTimer = null;
+            void this.flushNow().catch(() => undefined);
+        }, this.args.livePersistence.flushWindowMs ?? 100);
+    }
+    trackOutput(activity) {
+        if (activity.type === "assistant_output.delta") {
+            this.finalOutput += activity.delta;
+            return;
+        }
+        if (activity.type === "assistant_output.completed") {
+            this.finalOutput = activity.text;
+        }
+    }
+}
+export function createPendingHarnessTurn(args) {
+    const controller = new HarnessTurnController(args);
+    let resolveTurn;
+    let rejectTurn;
+    const result = new Promise((resolve, reject) => {
+        resolveTurn = resolve;
+        rejectTurn = reject;
+    });
+    return {
+        controller,
+        result,
+        resolve: resolveTurn,
+        reject: rejectTurn,
+    };
+}
+export async function terminateProcess(process, gracefulTimeoutMs, hardKillTimeoutMs) {
+    if (process.exitCode !== null || process.killed) {
+        return;
+    }
+    const closed = waitForProcessClose(process);
+    process.kill("SIGTERM");
+    if (await raceWithTimeout(closed, gracefulTimeoutMs)) {
+        return;
+    }
+    if (process.exitCode === null && !process.killed) {
+        process.kill("SIGKILL");
+    }
+    await raceWithTimeout(closed, hardKillTimeoutMs);
+}
+export function waitForProcessClose(process) {
+    return new Promise((resolve) => {
+        if (process.exitCode !== null) {
+            resolve();
+            return;
+        }
+        const onClose = () => {
+            process.off("close", onClose);
+            resolve();
+        };
+        process.on("close", onClose);
+    });
+}
+async function raceWithTimeout(promise, timeoutMs) {
+    let resolved = false;
+    let timer = null;
+    try {
+        await Promise.race([
+            promise.then(() => {
+                resolved = true;
+            }),
+            new Promise((resolve) => {
+                timer = setTimeout(resolve, timeoutMs);
+            }),
+        ]);
+        return resolved;
+    }
+    finally {
+        if (timer) {
+            clearTimeout(timer);
+        }
+    }
+}

package/dist/tool-semantics.d.ts

@@ -0,0 +1,22 @@
+import type { JsonValue } from "./types.js";
+export type CanonicalToolSubjectKind = "command" | "query" | "path" | "url" | "pattern";
+export interface CanonicalToolCall {
+    toolName: string | null;
+    attributes: Record<string, JsonValue> | undefined;
+}
+export interface CanonicalToolCallArgs {
+    canonicalToolName?: string | null;
+    rawToolName?: string | null;
+    operation?: string | null;
+    command?: string | null;
+    query?: string | null;
+    path?: string | null;
+    url?: string | null;
+    pattern?: string | null;
+    cwd?: string | null;
+    resultPreview?: string | null;
+    input?: JsonValue;
+    attributes?: Record<string, JsonValue>;
+}
+export declare function buildCanonicalToolCall(args: CanonicalToolCallArgs): CanonicalToolCall;
+//# sourceMappingURL=tool-semantics.d.ts.map

package/dist/tool-semantics.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool-semantics.d.ts","sourceRoot":"","sources":["../src/tool-semantics.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAE5C,MAAM,MAAM,wBAAwB,GAChC,SAAS,GACT,OAAO,GACP,MAAM,GACN,KAAK,GACL,SAAS,CAAC;AAEd,MAAM,WAAW,iBAAiB;IAChC,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IACxB,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,GAAG,SAAS,CAAC;CACnD;AAED,MAAM,WAAW,qBAAqB;IACpC,iBAAiB,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAClC,WAAW,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5B,SAAS,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B,OAAO,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACxB,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACtB,IAAI,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACrB,GAAG,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACpB,OAAO,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACxB,GAAG,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACpB,aAAa,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC9B,KAAK,CAAC,EAAE,SAAS,CAAC;IAClB,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC;CACxC;AAyDD,wBAAgB,sBAAsB,CACpC,IAAI,EAAE,qBAAqB,GAC1B,iBAAiB,CAqHnB"}

package/dist/tool-semantics.js

@@ -0,0 +1,241 @@
+const TOOL_NAME_ALIASES = {
+    bash: { toolName: "shell", operation: "exec" },
+    shell: { toolName: "shell", operation: "exec" },
+    commandexecution: { toolName: "shell", operation: "exec" },
+    read: { toolName: "file", operation: "read" },
+    write: { toolName: "file", operation: "write" },
+    edit: { toolName: "file", operation: "edit" },
+    multiedit: { toolName: "file", operation: "edit" },
+    glob: { toolName: "file", operation: "glob" },
+    grep: { toolName: "file", operation: "grep" },
+    ls: { toolName: "file", operation: "list" },
+    list: { toolName: "file", operation: "list" },
+    image: { toolName: "image", operation: "view" },
+    imageview: { toolName: "image", operation: "view" },
+    viewimage: { toolName: "image", operation: "view" },
+    web: { toolName: "web", operation: null },
+    websearch: { toolName: "web", operation: "search" },
+    webfetch: { toolName: "web", operation: "fetch" },
+    openpage: { toolName: "web", operation: "open" },
+    findinpage: { toolName: "web", operation: "find" },
+    mcp: { toolName: "mcp", operation: null },
+    mcptoolcall: { toolName: "mcp", operation: null },
+};
+const TOOL_OPERATION_ALIASES = {
+    bash: "exec",
+    shell: "exec",
+    command: "exec",
+    commandexecution: "exec",
+    execute: "exec",
+    exec: "exec",
+    read: "read",
+    write: "write",
+    edit: "edit",
+    multiedit: "edit",
+    update: "edit",
+    ls: "list",
+    list: "list",
+    glob: "glob",
+    grep: "grep",
+    search: "search",
+    websearch: "search",
+    webfetch: "fetch",
+    fetch: "fetch",
+    openpage: "open",
+    open: "open",
+    findinpage: "find",
+    find: "find",
+    view: "view",
+    imageview: "view",
+};
+export function buildCanonicalToolCall(args) {
+    const rawToolName = cleanString(args.rawToolName);
+    const canonicalToolName = cleanString(args.canonicalToolName);
+    const operation = cleanString(args.operation);
+    const inputRecord = asRecord(args.input);
+    const inferredName = inferToolName(rawToolName);
+    const toolName = normalizeToolIdentifier(canonicalToolName) ??
+        inferredName.toolName ??
+        normalizeToolIdentifier(rawToolName);
+    const toolOperation = normalizeToolOperation(operation) ??
+        inferredName.operation ??
+        normalizeToolOperation(canonicalToolName) ??
+        null;
+    const command = cleanString(args.command) ??
+        readPreferredInputString(inputRecord, ["command", "cmd"]);
+    const query = cleanString(args.query) ??
+        readPreferredInputString(inputRecord, ["query", "search_query", "searchQuery"]) ??
+        readStringArrayValue(inputRecord?.queries).at(0) ??
+        null;
+    const url = cleanString(args.url) ??
+        readPreferredInputString(inputRecord, ["url", "page_url", "pageUrl"]);
+    const path = cleanString(args.path) ??
+        readPreferredInputString(inputRecord, [
+            "path",
+            "file_path",
+            "filePath",
+            "directory_path",
+            "directoryPath",
+            "target_path",
+            "targetPath",
+        ]) ??
+        readStringArrayValue(inputRecord?.paths).at(0) ??
+        null;
+    const pattern = cleanString(args.pattern) ??
+        readPreferredInputString(inputRecord, [
+            "pattern",
+            "glob",
+            "search_pattern",
+            "searchPattern",
+        ]);
+    const cwd = cleanString(args.cwd) ??
+        readPreferredInputString(inputRecord, ["cwd", "working_directory", "workingDirectory"]);
+    const resultPreview = cleanString(args.resultPreview);
+    const toolInputPreview = buildToolInputPreview(args.input);
+    const subject = command ?? query ?? url ?? path ?? pattern ?? null;
+    const subjectKind = command != null
+        ? "command"
+        : query != null
+            ? "query"
+            : url != null
+                ? "url"
+                : path != null
+                    ? "path"
+                    : pattern != null
+                        ? "pattern"
+                        : null;
+    const attributes = {
+        ...(args.attributes ?? {}),
+    };
+    if (rawToolName &&
+        rawToolName.length > 0 &&
+        normalizeToolIdentifier(rawToolName) !== toolName) {
+        attributes.tool_raw_name = rawToolName;
+    }
+    if (toolOperation) {
+        attributes.tool_operation = toolOperation;
+    }
+    if (subject && subjectKind) {
+        attributes.tool_subject = subject;
+        attributes.tool_subject_kind = subjectKind;
+    }
+    if (command) {
+        attributes.command = command;
+    }
+    if (query) {
+        attributes.query = query;
+    }
+    if (url) {
+        attributes.url = url;
+    }
+    if (path) {
+        attributes.path = path;
+    }
+    if (pattern) {
+        attributes.pattern = pattern;
+    }
+    if (cwd) {
+        attributes.cwd = cwd;
+    }
+    if (resultPreview) {
+        attributes.result_preview = resultPreview;
+    }
+    if (!subject && toolInputPreview) {
+        attributes.tool_input_preview = toolInputPreview;
+    }
+    return {
+        toolName,
+        attributes: Object.keys(attributes).length > 0 ? attributes : undefined,
+    };
+}
+function inferToolName(rawToolName) {
+    if (!rawToolName) {
+        return { toolName: null, operation: null };
+    }
+    const normalized = normalizeLookupKey(rawToolName);
+    const alias = TOOL_NAME_ALIASES[normalized];
+    if (alias) {
+        return {
+            toolName: alias.toolName,
+            operation: alias.operation ?? null,
+        };
+    }
+    return {
+        toolName: normalizeToolIdentifier(rawToolName),
+        operation: null,
+    };
+}
+function normalizeToolIdentifier(value) {
+    if (!value) {
+        return null;
+    }
+    const collapsed = value
+        .replace(/([a-z0-9])([A-Z])/gu, "$1_$2")
+        .replace(/[^A-Za-z0-9]+/gu, "_")
+        .replace(/^_+|_+$/gu, "")
+        .toLowerCase();
+    return collapsed.length > 0 ? collapsed : null;
+}
+function normalizeToolOperation(value) {
+    if (!value) {
+        return null;
+    }
+    const normalized = normalizeLookupKey(value);
+    return TOOL_OPERATION_ALIASES[normalized] ?? normalizeToolIdentifier(value);
+}
+function normalizeLookupKey(value) {
+    return value.replace(/[^A-Za-z0-9]+/gu, "").toLowerCase();
+}
+function readPreferredInputString(input, keys) {
+    if (!input) {
+        return null;
+    }
+    for (const key of keys) {
+        const value = cleanString(input[key]);
+        if (value) {
+            return value;
+        }
+    }
+    return null;
+}
+function readStringArrayValue(value) {
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    return value.filter((entry) => typeof entry === "string");
+}
+function asRecord(value) {
+    if (!value || Array.isArray(value) || typeof value !== "object") {
+        return null;
+    }
+    return value;
+}
+function cleanString(value) {
+    return typeof value === "string" && value.trim().length > 0
+        ? value.trim()
+        : null;
+}
+function buildToolInputPreview(value) {
+    if (value == null) {
+        return null;
+    }
+    const normalized = typeof value === "string" ? value.trim() || null : safeJsonStringify(value);
+    if (!normalized) {
+        return null;
+    }
+    return truncateText(normalized, 240);
+}
+function safeJsonStringify(value) {
+    try {
+        const serialized = JSON.stringify(value);
+        return serialized && serialized !== "{}" && serialized !== "[]"
+            ? serialized
+            : null;
+    }
+    catch {
+        return null;
+    }
+}
+function truncateText(value, limit) {
+    return value.length <= limit ? value : `${value.slice(0, limit - 1)}…`;
+}