salmon-loop 0.3.2 → 0.5.0

package/dist/core/tools/builtin/git.js

@@ -115,4 +115,246 @@ export async function executeGitStatus(input, ctx) {
         status: res.stdout.toString('utf8'),
     };
 }
+// ── git.blame ─────────────────────────────────────────────────────────
+export const gitBlameSpec = {
+    name: 'git.blame',
+    source: 'builtin',
+    intent: 'READ',
+    description: text.tools.gitBlameDescription,
+    riskLevel: 'low',
+    sideEffects: ['git_read'],
+    concurrency: 'parallel_ok',
+    computeResources: (_input, ctx) => [repoResource(ctx)],
+    inputSchema: z.object({
+        file: z.string().describe('Relative path to the file'),
+        ref: z.string().optional().describe('Git reference (default: HEAD)'),
+        range: z
+            .object({
+            start: z.number().int().min(1).describe('Start line number'),
+            end: z.number().int().min(1).describe('End line number'),
+        })
+            .optional()
+            .describe('Line range to blame'),
+    }),
+    outputSchema: z.object({
+        file: z.string(),
+        lines: z.array(z.object({
+            line: z.number(),
+            content: z.string(),
+            commit: z.string(),
+            author: z.string(),
+            authorTime: z.number(),
+        })),
+    }),
+    allowedPhases: [Phase.SLASH, Phase.CONTEXT, Phase.EXPLORE, Phase.PLAN, Phase.AUTOPILOT],
+};
+export async function executeGitBlame(input, ctx) {
+    const { file, ref, range } = input;
+    if (file.includes('..') || file.startsWith('/') || /^[a-zA-Z]:/.test(file)) {
+        throw new Error(text.tools.invalidRelativePath(file));
+    }
+    const args = ['blame', '--porcelain'];
+    if (range)
+        args.push('-L', `${range.start},${range.end}`);
+    if (ref)
+        args.push(ref);
+    args.push('--', file);
+    const repoRoot = ctx.worktreeRoot || ctx.repoRoot;
+    const git = new GitAdapter(repoRoot);
+    const res = await git.execMeta(args, {
+        cwd: repoRoot,
+        env: ctx.env,
+        limits: { maxStdoutBytes: LIMITS.maxToolOutputBytes, maxStderrChars: 16_384 },
+        timeoutMs: LIMITS.gitTimeoutMs,
+    });
+    if (!res.ok) {
+        if (res.error?.message)
+            throw new Error(text.git.processError(res.error.message));
+        throw new Error(text.git.commandFailedDetailed(res.code, res.stderr.trim()));
+    }
+    if (res.stdoutTruncated)
+        throw new Error(text.git.outputTruncated(LIMITS.maxToolOutputBytes));
+    const lines = parseBlamePorcelain(res.stdout.toString('utf8'));
+    return { file, lines };
+}
+function parseBlamePorcelain(raw) {
+    const result = [];
+    const commitMeta = new Map();
+    let currentCommit = '';
+    let currentAuthor = '';
+    let currentAuthorTime = 0;
+    for (const line of raw.split('\n')) {
+        if (!line)
+            continue;
+        // Header line: "hash origLine finalLine [numLines]"
+        const headerMatch = /^([0-9a-f]{40})\s+\d+\s+(\d+)/.exec(line);
+        if (headerMatch) {
+            currentCommit = headerMatch[1];
+            if (!commitMeta.has(currentCommit)) {
+                const meta = commitMeta.get(currentCommit);
+                if (meta) {
+                    currentAuthor = meta.author;
+                    currentAuthorTime = meta.authorTime;
+                }
+            }
+            continue;
+        }
+        if (line.startsWith('author ')) {
+            currentAuthor = line.slice(7);
+            commitMeta.set(currentCommit, { author: currentAuthor, authorTime: currentAuthorTime });
+            continue;
+        }
+        if (line.startsWith('author-time ')) {
+            currentAuthorTime = Number(line.slice(12));
+            const existing = commitMeta.get(currentCommit);
+            if (existing)
+                existing.authorTime = currentAuthorTime;
+            else
+                commitMeta.set(currentCommit, { author: currentAuthor, authorTime: currentAuthorTime });
+            continue;
+        }
+        // Content line starts with tab
+        if (line.startsWith('\t')) {
+            const meta = commitMeta.get(currentCommit) || {
+                author: currentAuthor,
+                authorTime: currentAuthorTime,
+            };
+            result.push({
+                line: result.length + 1,
+                content: line.slice(1),
+                commit: currentCommit,
+                author: meta.author,
+                authorTime: meta.authorTime,
+            });
+        }
+    }
+    return result;
+}
+// ── git.log ───────────────────────────────────────────────────────────
+export const gitLogSpec = {
+    name: 'git.log',
+    source: 'builtin',
+    intent: 'READ',
+    description: text.tools.gitLogDescription,
+    riskLevel: 'low',
+    sideEffects: ['git_read'],
+    concurrency: 'parallel_ok',
+    computeResources: (_input, ctx) => [repoResource(ctx)],
+    inputSchema: z.object({
+        ref: z.string().optional().describe('Starting ref (default: HEAD)'),
+        maxCount: z.number().int().min(1).max(200).default(20).describe('Max commits to return'),
+        file: z.string().optional().describe('Limit to commits touching this file'),
+        diffStat: z.boolean().default(false).describe('Include diffstat for each commit'),
+    }),
+    outputSchema: z.object({
+        commits: z.array(z.object({
+            hash: z.string(),
+            subject: z.string(),
+            author: z.string(),
+            date: z.string(),
+            parentHashes: z.string(),
+            stat: z.string().optional(),
+        })),
+    }),
+    allowedPhases: [Phase.SLASH, Phase.CONTEXT, Phase.EXPLORE, Phase.PLAN, Phase.AUTOPILOT],
+};
+export async function executeGitLog(input, ctx) {
+    const { ref, maxCount, file, diffStat } = input;
+    const args = ['log', `--format=%H%x00%s%x00%an%x00%aI%x00%P`, '-z', `-n${maxCount}`];
+    if (diffStat)
+        args.push('--stat');
+    if (ref)
+        args.push(ref);
+    if (file)
+        args.push('--', file);
+    const repoRoot = ctx.worktreeRoot || ctx.repoRoot;
+    const git = new GitAdapter(repoRoot);
+    const res = await git.execMeta(args, {
+        cwd: repoRoot,
+        env: ctx.env,
+        limits: { maxStdoutBytes: LIMITS.maxToolOutputBytes, maxStderrChars: 16_384 },
+        timeoutMs: LIMITS.gitTimeoutMs,
+    });
+    if (!res.ok) {
+        if (res.error?.message)
+            throw new Error(text.git.processError(res.error.message));
+        throw new Error(text.git.commandFailedDetailed(res.code, res.stderr.trim()));
+    }
+    if (res.stdoutTruncated)
+        throw new Error(text.git.outputTruncated(LIMITS.maxToolOutputBytes));
+    const commits = parseLogOutput(res.stdout.toString('utf8'), diffStat);
+    return { commits };
+}
+function parseLogOutput(raw, includeStat) {
+    // With -z, records are NUL-separated. Each record is: hash\0subject\0author\0date\0parents[\0stat...]
+    const records = raw.split('\0');
+    const commits = [];
+    // Each commit has 5 core fields; stat is optional extra
+    const fieldsPerCommit = 5;
+    let i = 0;
+    while (i + fieldsPerCommit - 1 < records.length) {
+        const hash = records[i].replace(/^\n/, '');
+        const subject = records[i + 1];
+        const author = records[i + 2];
+        const date = records[i + 3];
+        const parentHashes = records[i + 4];
+        i += fieldsPerCommit;
+        let stat;
+        if (includeStat && i < records.length) {
+            // The stat portion may contain newlines; collect until next commit header or end
+            const nextCommitIdx = records.findIndex((r, idx) => idx >= i && /^[0-9a-f]{40}/.test(r.replace(/^\n/, '')));
+            const endIdx = nextCommitIdx > i ? nextCommitIdx : records.length;
+            stat = records.slice(i, endIdx).join('\0').trim() || undefined;
+            i = endIdx;
+        }
+        commits.push({ hash, subject, author, date, parentHashes, stat });
+    }
+    return commits;
+}
+// ── git.show ──────────────────────────────────────────────────────────
+export const gitShowSpec = {
+    name: 'git.show',
+    source: 'builtin',
+    intent: 'READ',
+    description: text.tools.gitShowDescription,
+    riskLevel: 'low',
+    sideEffects: ['git_read'],
+    concurrency: 'parallel_ok',
+    computeResources: (_input, ctx) => [repoResource(ctx)],
+    inputSchema: z.object({
+        ref: z.string().describe('Git reference (commit hash, branch, tag)'),
+        stat: z.boolean().default(true).describe('Include diffstat'),
+    }),
+    outputSchema: z.object({
+        ref: z.string(),
+        content: z.string(),
+    }),
+    allowedPhases: [Phase.SLASH, Phase.CONTEXT, Phase.EXPLORE, Phase.PLAN, Phase.AUTOPILOT],
+};
+export async function executeGitShow(input, ctx) {
+    const { ref, stat } = input;
+    const args = ['show'];
+    if (stat)
+        args.push('--stat');
+    args.push(ref);
+    const repoRoot = ctx.worktreeRoot || ctx.repoRoot;
+    const git = new GitAdapter(repoRoot);
+    const res = await git.execMeta(args, {
+        cwd: repoRoot,
+        env: ctx.env,
+        limits: { maxStdoutBytes: LIMITS.maxToolOutputBytes, maxStderrChars: 16_384 },
+        timeoutMs: LIMITS.gitTimeoutMs,
+    });
+    if (!res.ok) {
+        if (res.error?.message)
+            throw new Error(text.git.processError(res.error.message));
+        throw new Error(text.git.commandFailedDetailed(res.code, res.stderr.trim()));
+    }
+    if (res.stdoutTruncated)
+        throw new Error(text.git.outputTruncated(LIMITS.maxToolOutputBytes));
+    return {
+        ref,
+        content: res.stdout.toString('utf8'),
+    };
+}
 //# sourceMappingURL=git.js.map

package/dist/core/tools/builtin/glob.js

@@ -0,0 +1,79 @@
+import { join } from 'path';
+import { z } from 'zod';
+import { text } from '../../../locales/index.js';
+import { spawnCommand } from '../../runtime/process-runner.js';
+import { Phase } from '../../types/runtime.js';
+import { normalizePath } from '../../utils/path.js';
+import { pathPrefixResource } from '../parallel/resource-helpers.js';
+const RG_TIMEOUT_MS = 10_000;
+export const globFindSpec = {
+    name: 'glob.find',
+    source: 'builtin',
+    intent: 'SEARCH',
+    description: text.tools.globFindDescription,
+    riskLevel: 'low',
+    sideEffects: ['fs_read'],
+    concurrency: 'parallel_ok',
+    computeResources: (_input, ctx) => [pathPrefixResource(ctx, '.')],
+    inputSchema: z.object({
+        pattern: z.string().describe('Glob pattern (e.g. "**/*.ts", "src/**/*.test.*")'),
+        directory: z.string().optional().describe('Directory to search in (relative, default: ".")'),
+        maxMatches: z
+            .number()
+            .int()
+            .min(1)
+            .max(5000)
+            .default(200)
+            .describe('Maximum number of files to return'),
+        respectGitignore: z.boolean().default(true).describe('Respect .gitignore (default: true)'),
+        includeHidden: z.boolean().default(false).describe('Include hidden files (starting with ".")'),
+    }),
+    outputSchema: z.object({
+        files: z.array(z.string()),
+        truncated: z.boolean(),
+        totalFound: z.number(),
+    }),
+    allowedPhases: [
+        Phase.SLASH,
+        Phase.CONTEXT,
+        Phase.EXPLORE,
+        Phase.PLAN,
+        Phase.AUTOPILOT,
+        Phase.VERIFY,
+    ],
+};
+export async function executeGlobFind(input, ctx) {
+    const repoRoot = ctx.worktreeRoot || ctx.repoRoot;
+    const cwd = input.directory ? join(repoRoot, input.directory) : repoRoot;
+    const args = ['--files'];
+    if (!input.respectGitignore)
+        args.push('--no-ignore');
+    if (input.includeHidden)
+        args.push('--hidden');
+    args.push('--glob', input.pattern);
+    args.push(cwd);
+    let stdout = '';
+    const result = await spawnCommand({
+        command: 'rg',
+        args,
+        cwd: repoRoot,
+        env: ctx.env ?? process.env,
+        timeoutMs: RG_TIMEOUT_MS,
+        onStdoutChunk: (chunk) => {
+            stdout += Buffer.from(chunk).toString();
+        },
+        onStderrChunk: () => { },
+    });
+    if (result.error || result.timedOut || (result.code !== 0 && result.code !== 1)) {
+        return { files: [], truncated: false, totalFound: 0 };
+    }
+    const allFiles = stdout
+        .split('\n')
+        .map((line) => normalizePath(line.trim()).replace(/^(\.\/|\/)+/, ''))
+        .filter(Boolean);
+    const totalFound = allFiles.length;
+    const truncated = totalFound > input.maxMatches;
+    const files = allFiles.slice(0, input.maxMatches);
+    return { files, truncated, totalFound };
+}
+//# sourceMappingURL=glob.js.map

package/dist/core/tools/builtin/index.js

@@ -1,12 +1,16 @@
+import { agentAwaitTaskSpec } from '../../sub-agent/tools/task-await.js';
 import { subAgentTaskSpec } from '../../sub-agent/tools/task-spawn.js';
+import { agentTeamSpec } from '../../sub-agent/tools/team.js';
+import { defineTool } from '../types.js';
 import { artifactReadSpec, executeArtifactRead } from './artifact.js';
 import { astGrepSpec, executeAstGrep } from './ast-grep.js';
-import { astDefsRefsSpec, executeAstDefsRefs } from './ast.js';
+import { astDefsRefsSpec, executeAstDefsRefs, codeFindReferencesSpec, executeCodeFindReferences, } from './ast.js';
 import { benchmarkReportSpec, executeBenchmarkReport, executeGitApplyCheck, executeGitDiffCheck, executeSweBenchGetReport, executeSweBenchLoadInstance, executeSweBenchSubmitPredictions, executeSweBenchWritePrediction, gitApplyCheckSpec, gitDiffCheckSpec, sweBenchGetReportSpec, sweBenchLoadInstanceSpec, sweBenchSubmitPredictionsSpec, sweBenchWritePredictionSpec, } from './benchmark.js';
 import { codeSearchExecutor } from './code-search/executor.js';
 import { CodeSearchSpec } from './code-search/spec.js';
-import { codeReadSpec, executeFsCreateDirectory, executeFsList, executeFsListDirectory, executeFsListFiles, executeFsReadFile, executeFsDeleteFile, executeFsWriteFile, fsCreateDirectorySpec, fsDeleteFileSpec, fsListSpec, fsListDirectorySpec, fsListFilesSpec, fsReadFileSpec, fsWriteFileSpec, } from './fs.js';
-import { gitCatSpec, executeGitCat, gitStatusSpec, executeGitStatus } from './git.js';
+import { codeReadSpec, executeFsCreateDirectory, executeFsEditFile, executeFsList, executeFsListDirectory, executeFsListFiles, executeFsReadFile, executeFsDeleteFile, executeFsWriteFile, fsCreateDirectorySpec, fsDeleteFileSpec, fsEditFileSpec, fsListSpec, fsListDirectorySpec, fsListFilesSpec, fsReadFileSpec, fsWriteFileSpec, } from './fs.js';
+import { gitCatSpec, executeGitCat, gitStatusSpec, executeGitStatus, gitBlameSpec, executeGitBlame, gitLogSpec, executeGitLog, gitShowSpec, executeGitShow, } from './git.js';
+import { globFindSpec, executeGlobFind } from './glob.js';
 import { askUserSpec } from './interaction.js';
 import { updateKnowledgeSpec, executeUpdateKnowledge } from './knowledge.js';
 import { planInitSpec, planReadSpec, planUpdateSpec } from './plan.js';
@@ -15,120 +19,58 @@ import { shellExecSpec, executeShellExec } from './shell.js';
 import { verifyRunSpec, executeVerifyRun } from './verify.js';
 import { workspaceInfoSpec, executeWorkspaceInfo } from './workspace.js';
 /**
- * Registers all builtin tools into the provided registry
+ * Registers all builtin tools into the provided registry.
+ * Uses defineTool() to pair specs with executors type-safely.
  */
 export function registerAllBuiltins(registry) {
-    // Register sub-agent tool
+    // Sub-agent tools (already self-contained)
     registry.register(subAgentTaskSpec);
-    registry.register({
-        ...artifactReadSpec,
-        executor: executeArtifactRead,
-    });
-    registry.register({
-        ...updateKnowledgeSpec,
-        executor: executeUpdateKnowledge,
-    });
-    registry.register({
-        ...workspaceInfoSpec,
-        executor: executeWorkspaceInfo,
-    });
-    registry.register({
-        ...proposalApplySpec,
-        executor: executeProposalApply,
-    });
-    // Register unified code.search with its specific executor
-    registry.register({
-        ...CodeSearchSpec,
-        executor: codeSearchExecutor,
-    });
-    registry.register({
-        ...astDefsRefsSpec,
-        executor: executeAstDefsRefs,
-    });
-    registry.register({
-        ...gitCatSpec,
-        executor: executeGitCat,
-    });
-    registry.register({
-        ...gitStatusSpec,
-        executor: executeGitStatus,
-    });
-    registry.register({
-        ...gitDiffCheckSpec,
-        executor: executeGitDiffCheck,
-    });
-    registry.register({
-        ...gitApplyCheckSpec,
-        executor: executeGitApplyCheck,
-    });
-    registry.register({
-        ...benchmarkReportSpec,
-        executor: executeBenchmarkReport,
-    });
-    registry.register({
-        ...sweBenchLoadInstanceSpec,
-        executor: executeSweBenchLoadInstance,
-    });
-    registry.register({
-        ...sweBenchWritePredictionSpec,
-        executor: executeSweBenchWritePrediction,
-    });
-    registry.register({
-        ...sweBenchSubmitPredictionsSpec,
-        executor: executeSweBenchSubmitPredictions,
-    });
-    registry.register({
-        ...sweBenchGetReportSpec,
-        executor: executeSweBenchGetReport,
-    });
-    registry.register({
-        ...fsReadFileSpec,
-        executor: executeFsReadFile,
-    });
-    registry.register({
-        ...codeReadSpec,
-        executor: executeFsReadFile,
-    });
-    registry.register({
-        ...fsListSpec,
-        executor: executeFsList,
-    });
-    registry.register({
-        ...fsListDirectorySpec,
-        executor: executeFsListDirectory,
-    });
-    registry.register({
-        ...fsListFilesSpec,
-        executor: executeFsListFiles,
-    });
-    registry.register({
-        ...astGrepSpec,
-        executor: executeAstGrep,
-    });
-    registry.register({
-        ...verifyRunSpec,
-        executor: executeVerifyRun,
-    });
-    registry.register({
-        ...shellExecSpec,
-        executor: executeShellExec,
-    });
-    registry.register({
-        ...fsWriteFileSpec,
-        executor: executeFsWriteFile,
-    });
-    registry.register({
-        ...fsCreateDirectorySpec,
-        executor: executeFsCreateDirectory,
-    });
-    registry.register({
-        ...fsDeleteFileSpec,
-        executor: executeFsDeleteFile,
-    });
+    registry.register(agentAwaitTaskSpec);
+    registry.register(agentTeamSpec);
+    // Artifact & knowledge
+    registry.register(defineTool(artifactReadSpec, executeArtifactRead));
+    registry.register(defineTool(updateKnowledgeSpec, executeUpdateKnowledge));
+    registry.register(defineTool(workspaceInfoSpec, executeWorkspaceInfo));
+    registry.register(defineTool(proposalApplySpec, executeProposalApply));
+    // Code search & AST
+    registry.register(defineTool(CodeSearchSpec, codeSearchExecutor));
+    registry.register(defineTool(astDefsRefsSpec, executeAstDefsRefs));
+    registry.register(defineTool(codeFindReferencesSpec, executeCodeFindReferences));
+    registry.register(defineTool(astGrepSpec, executeAstGrep));
+    // Git
+    registry.register(defineTool(gitCatSpec, executeGitCat));
+    registry.register(defineTool(gitStatusSpec, executeGitStatus));
+    registry.register(defineTool(gitBlameSpec, executeGitBlame));
+    registry.register(defineTool(gitLogSpec, executeGitLog));
+    registry.register(defineTool(gitShowSpec, executeGitShow));
+    registry.register(defineTool(gitDiffCheckSpec, executeGitDiffCheck));
+    registry.register(defineTool(gitApplyCheckSpec, executeGitApplyCheck));
+    // Glob
+    registry.register(defineTool(globFindSpec, executeGlobFind));
+    // Benchmark / SWE-bench
+    registry.register(defineTool(benchmarkReportSpec, executeBenchmarkReport));
+    registry.register(defineTool(sweBenchLoadInstanceSpec, executeSweBenchLoadInstance));
+    registry.register(defineTool(sweBenchWritePredictionSpec, executeSweBenchWritePrediction));
+    registry.register(defineTool(sweBenchSubmitPredictionsSpec, executeSweBenchSubmitPredictions));
+    registry.register(defineTool(sweBenchGetReportSpec, executeSweBenchGetReport));
+    // Filesystem
+    registry.register(defineTool(fsReadFileSpec, executeFsReadFile));
+    registry.register(defineTool(codeReadSpec, executeFsReadFile));
+    registry.register(defineTool(fsListSpec, executeFsList));
+    registry.register(defineTool(fsListDirectorySpec, executeFsListDirectory));
+    registry.register(defineTool(fsListFilesSpec, executeFsListFiles));
+    registry.register(defineTool(fsWriteFileSpec, executeFsWriteFile));
+    registry.register(defineTool(fsEditFileSpec, executeFsEditFile));
+    registry.register(defineTool(fsCreateDirectorySpec, executeFsCreateDirectory));
+    registry.register(defineTool(fsDeleteFileSpec, executeFsDeleteFile));
+    // Execution
+    registry.register(defineTool(verifyRunSpec, executeVerifyRun));
+    registry.register(defineTool(shellExecSpec, executeShellExec));
+    // Plan & interaction
     registry.register(planInitSpec);
     registry.register(planReadSpec);
     registry.register(planUpdateSpec);
     registry.register(askUserSpec);
 }
-export { CodeSearchSpec, codeSearchExecutor, astDefsRefsSpec as codeAstSpec, executeAstDefsRefs as executeCodeAst, gitCatSpec, executeGitCat, gitStatusSpec, executeGitStatus, codeReadSpec, fsListSpec, executeFsList, fsReadFileSpec as fsReadSpec, executeFsReadFile as executeFsRead, updateKnowledgeSpec, executeUpdateKnowledge, astGrepSpec as codeSearchAstSpec, executeAstGrep as executeCodeSearchAst, verifyRunSpec as testRunSpec, executeVerifyRun as executeTestRun, gitDiffCheckSpec, executeGitDiffCheck, gitApplyCheckSpec, executeGitApplyCheck, benchmarkReportSpec, executeBenchmarkReport, sweBenchLoadInstanceSpec, executeSweBenchLoadInstance, sweBenchWritePredictionSpec, executeSweBenchWritePrediction, sweBenchSubmitPredictionsSpec, executeSweBenchSubmitPredictions, sweBenchGetReportSpec, executeSweBenchGetReport, workspaceInfoSpec, executeWorkspaceInfo, };
+export { CodeSearchSpec, codeSearchExecutor, astDefsRefsSpec as codeAstSpec, executeAstDefsRefs as executeCodeAst, codeFindReferencesSpec, executeCodeFindReferences, gitCatSpec, executeGitCat, gitStatusSpec, executeGitStatus, gitBlameSpec, executeGitBlame, gitLogSpec, executeGitLog, gitShowSpec, executeGitShow, globFindSpec, executeGlobFind, codeReadSpec, fsListSpec, executeFsList, fsReadFileSpec as fsReadSpec, executeFsReadFile as executeFsRead, updateKnowledgeSpec, executeUpdateKnowledge, astGrepSpec as codeSearchAstSpec, executeAstGrep as executeCodeSearchAst, verifyRunSpec as testRunSpec, executeVerifyRun as executeTestRun, gitDiffCheckSpec, executeGitDiffCheck, gitApplyCheckSpec, executeGitApplyCheck, benchmarkReportSpec, executeBenchmarkReport, sweBenchLoadInstanceSpec, executeSweBenchLoadInstance, sweBenchWritePredictionSpec, executeSweBenchWritePrediction, sweBenchSubmitPredictionsSpec, executeSweBenchSubmitPredictions, sweBenchGetReportSpec, executeSweBenchGetReport, workspaceInfoSpec, executeWorkspaceInfo, };
 //# sourceMappingURL=index.js.map

package/dist/core/tools/builtin/interaction.js

@@ -75,28 +75,26 @@ export const askUserSpec = {
     outputSchema: askUserOutputSchema,
     executor: async (input, ctx) => {
         if (ctx.agentKind === 'subagent') {
-            const err = new Error(text.tools.askUserSubagentBlocked);
-            err.code = 'ASK_USER_SUBAGENT_BLOCKED';
-            throw err;
+            throw Object.assign(new Error(text.tools.askUserSubagentBlocked), {
+                code: 'ASK_USER_SUBAGENT_BLOCKED',
+            });
         }
         if (!ctx.userInputProvider) {
-            const err = new Error(text.tools.askUserRequired);
             const inputRequired = buildInputRequired(input);
-            err.code = 'INTERRUPT_REQUIRED';
-            err.interrupt = {
-                type: 'awaiting_input',
-                reason: inputRequired.reason ?? 'clarification',
-                prompt: inputRequired.prompt,
-                data: { inputRequired },
-            };
-            throw err;
+            throw Object.assign(new Error(text.tools.askUserRequired), {
+                code: 'INTERRUPT_REQUIRED',
+                interrupt: {
+                    type: 'awaiting_input',
+                    reason: inputRequired.reason ?? 'clarification',
+                    prompt: inputRequired.prompt,
+                    data: { inputRequired },
+                },
+            });
         }
         const output = await ctx.userInputProvider.askUser(input, { signal: ctx.signal });
         const validationError = validateAnswers(input, output.answers);
         if (validationError) {
-            const err = new Error(validationError);
-            err.code = 'INVALID_OUTPUT';
-            throw err;
+            throw Object.assign(new Error(validationError), { code: 'INVALID_OUTPUT' });
         }
         return { questions: input.questions, answers: output.answers };
     },