@agent-spaces/server 0.3.65 → 0.4.0

package/dist/adapters/open-agent-sdk-runtime.js

@@ -1,5 +1,10 @@
-import { createAgent } from '@codeany/open-agent-sdk';
+import { existsSync, readFileSync, statSync } from 'node:fs';
+import { basename, join } from 'node:path';
+import { createAgent, registerSkill, unregisterSkill } from '@codeany/open-agent-sdk';
 import { appendOutputStyleToPrompt, summarizeResult } from './agent-runtime-types.js';
+import { startCodexFunctionToolBridge } from './codex-function-tool-bridge.js';
+const registeredConfiguredSkills = new Set();
+const DEFAULT_DATA_DIR = join(process.env.HOME || '~', '.agent-spaces-data');
 /**
  * Runtime backed by @codeany/open-agent-sdk.
  * Runs the agent loop in-process with the SDK's built-in tools.
@@ -17,9 +22,13 @@ export class OpenAgentSdkRuntime {
         const cwd = workingDir || process.cwd();
         const startTime = Date.now();
         const d = (msg) => console.log(`[agent] ${msg}`);
-        d(`starting | cwd=${cwd} provider=${this.config.provider ?? 'default'} model=${this.config.model ?? 'default'} baseURL=${this.config.baseURL ?? 'default'} permissionMode=${this.config.permissionMode ?? 'bypassPermissions'} maxTurns=${options?.maxTurns ?? '∞'} tools=${options?.tools?.join(',') ?? 'all'} sandboxDirs=${options?.sandboxDirs?.join(',') ?? '-'}`);
+        let functionToolBridge;
+        d(`starting | cwd=${cwd} provider=${this.config.provider ?? 'default'} model=${this.config.model ?? 'default'} baseURL=${this.config.baseURL ?? 'default'} permissionMode=${this.config.permissionMode ?? 'bypassPermissions'} maxTurns=${options?.maxTurns ?? '∞'} allowedTools=${options?.tools?.join(',') ?? 'all'} mcpServers=${Object.keys(options?.mcpServers ?? {}).join(',') || '-'} functionTools=${options?.functionTools?.map((tool) => tool.name).join(',') || '-'} sandboxDirs=${options?.sandboxDirs?.join(',') ?? '-'}`);
         d(`prompt: ${prompt.slice(0, 300)}${prompt.length > 300 ? '...' : ''}`);
         try {
+            functionToolBridge = await startCodexFunctionToolBridge(options?.functionTools, d);
+            const mcpServers = withFunctionToolBridge(normalizeOpenAgentMcpServers(options?.mcpServers), functionToolBridge);
+            d(`resolved tools | allowedTools=${options?.tools?.join(',') ?? 'all'} mcpServers=${Object.keys(mcpServers ?? {}).join(',') || '-'} functionTools=${options?.functionTools?.map((tool) => tool.name).join(',') || '-'}`);
             this.agent = createAgent({
                 apiType: normalizeApiType(this.config.provider),
                 model: this.config.model,
@@ -29,13 +38,17 @@ export class OpenAgentSdkRuntime {
                 systemPrompt: options?.systemPrompt,
                 maxTurns: options?.maxTurns,
                 allowedTools: options?.tools,
+                mcpServers,
                 additionalDirectories: options?.sandboxDirs,
                 permissionMode: this.config.permissionMode ?? 'bypassPermissions',
                 abortController: this.abortController,
             });
+            const registeredSkills = registerConfiguredSkills(options?.configDir, options?.skills);
+            if (options?.skills?.length) {
+                d(`skills registered | requested=${options.skills.join(',') || '-'} registered=${registeredSkills.join(',') || '-'}`);
+            }
             d('agent created, sending prompt...');
-            d('tool debug | open-agent-sdk runtime does not expose per-tool stream events through prompt(); only final text/usage is available here');
-            const result = await this.agent.prompt(appendOutputStyleToPrompt(prompt, options?.outputStyle));
+            const result = await collectQueryResult(this.agent.query(appendOutputStyleToPrompt(prompt, options?.outputStyle)), output, options, d);
             const elapsed = Date.now() - startTime;
             const inputTokens = result.usage.input_tokens;
             const outputTokens = result.usage.output_tokens;
@@ -68,7 +81,18 @@ export class OpenAgentSdkRuntime {
             return { success: false, summary: 'Agent execution failed', artifacts: [], error: message, output };
         }
         finally {
-            await this.agent?.close();
+            try {
+                await this.agent?.close();
+            }
+            finally {
+                try {
+                    await functionToolBridge?.close();
+                }
+                catch (err) {
+                    const message = err instanceof Error ? err.message : String(err);
+                    d(`function tool bridge close failed | ${message}`);
+                }
+            }
             this.agent = null;
             this.abortController = null;
         }
@@ -78,10 +102,183 @@ export class OpenAgentSdkRuntime {
         this.agent?.interrupt();
     }
 }
+function withFunctionToolBridge(mcpServers, bridge) {
+    if (!bridge)
+        return mcpServers;
+    return {
+        ...(mcpServers ?? {}),
+        [bridge.name]: { type: 'http', url: bridge.url },
+    };
+}
+export function normalizeOpenAgentMcpServers(mcpServers) {
+    if (!mcpServers)
+        return undefined;
+    return Object.fromEntries(Object.entries(mcpServers).map(([name, server]) => [name, normalizeOpenAgentMcpServer(server)]));
+}
+function normalizeOpenAgentMcpServer(server) {
+    if (!isRecord(server))
+        return server;
+    const args = Array.isArray(server.args) ? server.args.map(String) : undefined;
+    const badFetchPackageIndex = args?.indexOf('@modelcontextprotocol/server-fetch') ?? -1;
+    if (String(server.command) !== 'npx' || !args || badFetchPackageIndex < 0)
+        return server;
+    return {
+        ...server,
+        command: 'uvx',
+        args: ['mcp-server-fetch', ...args.slice(badFetchPackageIndex + 1)],
+        env: {
+            PYTHONIOENCODING: 'utf-8',
+            ...(isRecord(server.env) ? server.env : {}),
+        },
+    };
+}
+function isRecord(value) {
+    return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+}
+async function collectQueryResult(events, output, options, log) {
+    const collected = {
+        text: '',
+        usage: { input_tokens: 0, output_tokens: 0 },
+        num_turns: 0,
+    };
+    for await (const event of events) {
+        if (event.type === 'system' && event.subtype === 'init') {
+            log(`sdk init | session=${event.session_id} model=${event.model} cwd=${event.cwd} permissionMode=${event.permission_mode} tools=${event.tools.join(',') || '-'} mcpServers=${event.mcp_servers.map((server) => `${server.name}:${server.status}`).join(',') || '-'}`);
+            options?.onEvent?.({ type: 'session', sessionId: event.session_id });
+            continue;
+        }
+        if (event.type === 'assistant') {
+            const text = event.message.content
+                .filter((block) => block.type === 'text')
+                .map((block) => block.text)
+                .join('');
+            if (text)
+                collected.text = text;
+            for (const block of event.message.content) {
+                if (block.type !== 'tool_use')
+                    continue;
+                const line = `Tool: ${block.name} input=${JSON.stringify(block.input)}`;
+                log(`tool use | id=${block.id} name=${block.name} input=${JSON.stringify(block.input)}`);
+                output.push(line);
+                options?.onEvent?.({ type: 'tool_use', id: block.id, name: block.name, input: block.input, line });
+            }
+            continue;
+        }
+        if (event.type === 'tool_result') {
+            const result = event.result;
+            log(`tool result | id=${result.tool_use_id} name=${result.tool_name} output=${truncateForLog(result.output)}`);
+            options?.onEvent?.({ type: 'tool_result', toolUseId: result.tool_use_id, result: result.output });
+            continue;
+        }
+        if (event.type === 'result') {
+            collected.num_turns = event.num_turns ?? 0;
+            collected.usage = {
+                input_tokens: event.usage?.input_tokens ?? 0,
+                output_tokens: event.usage?.output_tokens ?? 0,
+                cache_read_input_tokens: event.usage?.cache_read_input_tokens,
+                cache_creation_input_tokens: event.usage?.cache_creation_input_tokens,
+            };
+            if (event.is_error) {
+                log(`sdk result error | subtype=${event.subtype} errors=${event.errors?.join('; ') || '-'}`);
+            }
+        }
+    }
+    return collected;
+}
+function truncateForLog(value, max = 1000) {
+    return value.length > max ? `${value.slice(0, max)}...` : value;
+}
 function normalizeApiType(provider) {
     if (provider === 'anthropic-messages' || provider === 'openai-completions') {
         return provider;
     }
     return undefined;
 }
+export function registerConfiguredSkills(agentDir, skills) {
+    for (const skill of registeredConfiguredSkills)
+        unregisterSkill(skill);
+    registeredConfiguredSkills.clear();
+    if (!agentDir || !Array.isArray(skills))
+        return [];
+    const registered = [];
+    for (const rawSkill of skills) {
+        const skillName = sanitizeSkillName(rawSkill);
+        if (!skillName)
+            continue;
+        const skillFile = resolveSkillFile(agentDir, skillName);
+        if (!skillFile)
+            continue;
+        const source = readFileSync(skillFile, 'utf-8');
+        const parsed = parseSkillMarkdown(source);
+        const name = sanitizeSkillName(parsed.meta.name) || skillName;
+        const aliases = new Set(parseListMeta(parsed.meta.aliases).map(sanitizeSkillName).filter(Boolean));
+        if (name !== skillName)
+            aliases.add(skillName);
+        registerSkill({
+            name,
+            aliases: aliases.size ? [...aliases] : undefined,
+            description: parsed.meta.description || summarizeSkillDescription(parsed.body, skillName),
+            whenToUse: parsed.meta['when-to-use'] || parsed.meta.whenToUse,
+            userInvocable: true,
+            async getPrompt() {
+                return [{ type: 'text', text: parsed.body || source }];
+            },
+        });
+        registeredConfiguredSkills.add(name);
+        registered.push(name);
+    }
+    return registered;
+}
+function resolveSkillFile(agentDir, skillName) {
+    const skillsBase = join(agentDir, 'skills');
+    const folderSkillFile = join(skillsBase, skillName, 'SKILL.md');
+    if (existsSync(folderSkillFile) && statSync(folderSkillFile).size > 0)
+        return folderSkillFile;
+    const legacySkillFile = join(skillsBase, `${skillName}.md`);
+    if (existsSync(legacySkillFile) && statSync(legacySkillFile).size > 0)
+        return legacySkillFile;
+    const globalSkillFile = join(getDataDir(), 'skills', skillName, 'SKILL.md');
+    if (existsSync(globalSkillFile) && statSync(globalSkillFile).size > 0)
+        return globalSkillFile;
+    const globalLegacySkillFile = join(getDataDir(), 'skills', `${skillName}.md`);
+    if (existsSync(globalLegacySkillFile) && statSync(globalLegacySkillFile).size > 0)
+        return globalLegacySkillFile;
+    return undefined;
+}
+function getDataDir() {
+    return process.env.AGENT_SPACES_DATA_DIR || DEFAULT_DATA_DIR;
+}
+function parseSkillMarkdown(source) {
+    const match = source.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n?/);
+    if (!match)
+        return { meta: {}, body: source.trim() };
+    const meta = {};
+    for (const line of match[1].split(/\r?\n/)) {
+        const parsed = line.match(/^([A-Za-z0-9_-]+):\s*(.*)$/);
+        if (!parsed)
+            continue;
+        meta[parsed[1]] = parsed[2].trim().replace(/^['"]|['"]$/g, '');
+    }
+    return { meta, body: source.slice(match[0].length).trim() };
+}
+function summarizeSkillDescription(body, skillName) {
+    const firstLine = body
+        .split(/\r?\n/)
+        .map((line) => line.replace(/^#+\s*/, '').trim())
+        .find(Boolean);
+    return firstLine || `Configured skill ${skillName}`;
+}
+function parseListMeta(value) {
+    if (!value)
+        return [];
+    const trimmed = value.trim();
+    if (trimmed.startsWith('[') && trimmed.endsWith(']')) {
+        return trimmed.slice(1, -1).split(',').map((item) => item.trim().replace(/^['"]|['"]$/g, ''));
+    }
+    return trimmed.split(',').map((item) => item.trim());
+}
+function sanitizeSkillName(name) {
+    const raw = basename(name ?? '').replace(/\.md$/i, '').trim();
+    return raw.replace(/[^a-zA-Z0-9._-]+/g, '-').replace(/^-+|-+$/g, '');
+}
 //# sourceMappingURL=open-agent-sdk-runtime.js.map

package/dist/adapters/open-agent-sdk-runtime.test.js

@@ -0,0 +1,35 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtempSync, mkdirSync, writeFileSync, rmSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { clearSkills, getSkill } from '@codeany/open-agent-sdk';
+import { registerConfiguredSkills } from './open-agent-sdk-runtime.js';
+test('registerConfiguredSkills loads folder skills from agent config', async () => {
+    clearSkills();
+    const agentDir = mkdtempSync(join(tmpdir(), 'agent-skills-'));
+    try {
+        mkdirSync(join(agentDir, 'skills', 'brainstorming'), { recursive: true });
+        writeFileSync(join(agentDir, 'skills', 'brainstorming', 'SKILL.md'), [
+            '---',
+            'name: brainstorming',
+            'description: Explore requirements before implementation.',
+            '---',
+            '',
+            'Ask clarifying questions and produce a design.',
+        ].join('\n'), 'utf-8');
+        const registered = registerConfiguredSkills(agentDir, ['brainstorming']);
+        const skill = getSkill('brainstorming');
+        assert.deepEqual(registered, ['brainstorming']);
+        assert.ok(skill);
+        assert.equal(skill.description, 'Explore requirements before implementation.');
+        assert.deepEqual(await skill.getPrompt('', {}), [
+            { type: 'text', text: 'Ask clarifying questions and produce a design.' },
+        ]);
+    }
+    finally {
+        rmSync(agentDir, { recursive: true, force: true });
+        clearSkills();
+    }
+});
+//# sourceMappingURL=open-agent-sdk-runtime.test.js.map

package/dist/agents/agent-message-parts.js

@@ -63,7 +63,8 @@ export function createAgentMessagePartsTracker(input) {
     };
 }
 function buildAgentMessageParts(input) {
-    const lines = normalizeOutputLines(input.output);
+    const extractedReasoning = extractInlineReasoning(normalizeOutputLines(input.output));
+    const lines = extractedReasoning.lines;
     const finalTextRange = findFinalTextRange(lines);
     const finalText = finalTextRange
         ? collapseRepeatedTextBlock(lines.slice(finalTextRange.start, finalTextRange.end + 1)).join('\n').trim()
@@ -71,7 +72,10 @@ function buildAgentMessageParts(input) {
     const usage = input.usage ?? extractUsage(lines);
     const parts = [];
     const chainItems = buildChainItems(lines, finalTextRange, finalText, input.workspaceRoot, input.toolDetails, input.persistentContext);
-    const reasoningText = normalizeReasoningText(input.reasoning);
+    const reasoningText = normalizeReasoningText([
+        ...(input.reasoning ?? []),
+        ...extractedReasoning.reasoning.map((text) => ({ text })),
+    ]);
     if (reasoningText) {
         parts.push({
             id: `reasoning-${input.sessionId}`,
@@ -124,6 +128,52 @@ function normalizeReasoningText(reasoning) {
         .map((item) => item.text.trim())
         .filter(Boolean)).join('\n\n').trim();
 }
+function extractInlineReasoning(lines) {
+    const reasoning = [];
+    const outputLines = [];
+    let buffer = [];
+    let inThinkBlock = false;
+    const flushReasoning = () => {
+        const text = buffer.join('\n').trim();
+        if (text)
+            reasoning.push(text);
+        buffer = [];
+    };
+    for (const line of lines) {
+        let rest = line;
+        let visible = '';
+        while (rest) {
+            if (inThinkBlock) {
+                const closeIndex = rest.search(/<\/think>/i);
+                if (closeIndex < 0) {
+                    buffer.push(rest);
+                    rest = '';
+                    continue;
+                }
+                buffer.push(rest.slice(0, closeIndex));
+                flushReasoning();
+                rest = rest.slice(closeIndex).replace(/^<\/think>/i, '');
+                inThinkBlock = false;
+                continue;
+            }
+            const openIndex = rest.search(/<think>/i);
+            if (openIndex < 0) {
+                visible += rest;
+                rest = '';
+                continue;
+            }
+            visible += rest.slice(0, openIndex);
+            rest = rest.slice(openIndex).replace(/^<think>/i, '');
+            inThinkBlock = true;
+        }
+        const cleaned = visible.trimEnd();
+        if (cleaned.trim())
+            outputLines.push(cleaned);
+    }
+    if (inThinkBlock)
+        flushReasoning();
+    return { lines: outputLines, reasoning };
+}
 function hasTokenUsage(usage) {
     return Boolean(usage.totalTokens || usage.inputTokens || usage.outputTokens || usage.cachedInputTokens || usage.reasoningTokens);
 }

package/dist/agents/issue-task-controller.js

@@ -4,12 +4,13 @@ import * as channelService from '../services/channel.js';
 import * as issueService from '../services/issue.js';
 import * as taskService from '../services/task.js';
 import * as workspaceService from '../services/workspace.js';
-import { mapWorkflowToTaskDrafts, validateWorkflowForRun } from '../services/workflow.js';
+import { getWorkflow, mapWorkflowToTaskDrafts, validateWorkflowForRun } from '../services/workflow.js';
 import { createIssueFunctionTools } from '../services/builtin-tools/index.js';
 import { getThinkingRuntimeConfig } from '../services/llm-model-config.js';
 import { prependPersistentAgentContext } from '../services/persistent-agent-context.js';
 import { completeIssueAgentProgress, createIssueAgentProgress, createIssueAgentProgressTracker } from './issue-agent-progress.js';
 import { wrapOnEventWithHooks } from '../services/hook-engine.js';
+import { executeCommandNode } from '../services/workflow-command-runner.js';
 const ACTIVE_TASK_STATUSES = ['running', 'reviewing', 'retrying', 'waiting_review'];
 const activeIssueRuntimes = new Map();
 export async function syncIssueTasksAfterPlanning(workspaceId, issueId, input, ctx) {
@@ -137,6 +138,13 @@ export async function runIssueTask(workspaceId, issueId, taskId, ctx) {
     if (task.status !== 'pending') {
         return;
     }
+    // Check if this task came from a command workflow node
+    const workflow = findWorkflowForIssue(workspaceId, issue);
+    const commandNode = findCommandNodeForTask(workflow, task);
+    if (commandNode) {
+        await runCommandTask(workspaceId, issueId, taskId, commandNode, ctx);
+        return;
+    }
     const taskAgentPreset = findAgentForTask(workspaceId, issue, task);
     if (!taskAgentPreset) {
         if (issueService.getById(workspaceId, issueId)?.status === 'error')
@@ -274,6 +282,50 @@ export async function runIssueTask(workspaceId, issueId, taskId, ctx) {
         await scheduleRunnableIssueTasks(workspaceId, issueId, ctx);
     }
 }
+async function runCommandTask(workspaceId, issueId, taskId, commandNode, ctx) {
+    const task = taskService.getById(workspaceId, taskId);
+    if (!task || task.status !== 'pending')
+        return;
+    const runningTask = taskService.updateStatus(workspaceId, taskId, 'running');
+    if (!runningTask)
+        return;
+    broadcastTaskUpdate(ctx, runningTask, 'pending');
+    const cmdData = commandNode.data;
+    const cmdScript = cmdData.script;
+    ctx.broadcast('task.output', { taskId, data: `$ ${cmdScript.split('\n')[0]}${cmdScript.includes('\n') ? ' ...' : ''}` });
+    const result = await executeCommandNode(workspaceId, commandNode);
+    ctx.broadcast('task.output', { taskId, data: result.stdout });
+    if (result.stderr) {
+        ctx.broadcast('task.output', { taskId, data: result.stderr });
+    }
+    if (!result.success) {
+        const failedTask = taskService.updateStatus(workspaceId, taskId, 'failed', {
+            result: {
+                success: false,
+                summary: `Command failed with exit code ${result.exitCode}`,
+                artifacts: [],
+                error: result.stderr || `Exit code: ${result.exitCode}`,
+            },
+        });
+        broadcastTaskUpdate(ctx, failedTask, 'running');
+        await handleTaskFailure(workspaceId, issueId, taskId, {
+            success: false,
+            summary: `Command failed with exit code ${result.exitCode}`,
+            artifacts: [],
+            error: result.stderr || `Exit code: ${result.exitCode}`,
+        }, ctx);
+        return;
+    }
+    const completedTask = taskService.complete(workspaceId, taskId, {
+        success: true,
+        summary: result.stdout.slice(-500) || 'Command completed',
+        artifacts: [],
+    });
+    broadcastTaskUpdate(ctx, completedTask, 'running');
+    if (issueService.getById(workspaceId, issueId)?.continuousRun !== false) {
+        await scheduleRunnableIssueTasks(workspaceId, issueId, ctx);
+    }
+}
 export async function continueIssueTaskScheduling(workspaceId, issueId, ctx) {
     await scheduleRunnableIssueTasks(workspaceId, issueId, ctx, { force: true });
 }
@@ -402,7 +454,7 @@ export function createTasksFromWorkflow(workspaceId, issueId, template, ctx) {
     });
 }
 function ensureWorkflowAgentsForRun(workspaceId, issue, template, ctx) {
-    const workflowAgentIds = [...new Set(template.nodes.map((node) => node.data.agentConfigId).filter(Boolean))];
+    const workflowAgentIds = [...new Set(template.nodes.filter((n) => n.type === 'agent').map((node) => node.data.agentConfigId).filter(Boolean))];
     const mergedMembers = [...new Set([...(issue.members ?? []), ...workflowAgentIds])];
     const membersChanged = mergedMembers.length !== (issue.members ?? []).length
         || mergedMembers.some((member, index) => member !== issue.members?.[index]);
@@ -502,6 +554,23 @@ function unregisterActiveIssueRuntime(workspaceId, issueId, agentId) {
 function issueRunKey(workspaceId, issueId) {
     return `${workspaceId}:${issueId}`;
 }
+function findWorkflowForIssue(workspaceId, issue) {
+    if (!issue.workflowId)
+        return null;
+    return getWorkflow(issue.workflowId);
+}
+function findCommandNodeForTask(workflow, task) {
+    if (!workflow)
+        return null;
+    if (task.agentConfigId)
+        return null;
+    for (const node of workflow.nodes) {
+        if (node.type === 'command' && (task.title === node.label || task.description?.startsWith('Command:'))) {
+            return node;
+        }
+    }
+    return null;
+}
 function broadcastTaskUpdate(ctx, task, from) {
     if (!task)
         return;

package/dist/agents/pull-request-agent.js

@@ -0,0 +1,115 @@
+import * as agentService from '../services/agent.js';
+import { AGENT_GENERATOR_PRESET_ID } from '../services/agent.js';
+import { createAgentRuntime } from '../adapters/agent-runtime.js';
+import { getWorkspace } from '../storage/workspace-store.js';
+import { getThinkingRuntimeConfig } from '../services/llm-model-config.js';
+import { prependPersistentAgentContext } from '../services/persistent-agent-context.js';
+const DEFAULT_SYSTEM_PROMPT = [
+    'You are a pull request description generator.',
+    'Return a concise, useful PR body based only on the provided commits and diff.',
+    'Use Markdown with these sections: Summary and Changes.',
+    'Keep it short. Do not greet, explain your process, ask questions, provide options, or wrap the response in code fences.',
+    'Output only the final PR body text.',
+].join(' ');
+export async function runPullRequestAgent(workspaceId, input) {
+    const ws = getWorkspace(workspaceId);
+    if (!ws)
+        throw new Error('Workspace not found');
+    if (!input.diff.trim() && input.commits.length === 0)
+        throw new Error('No changes found');
+    const agent = findPullRequestAgent(workspaceId);
+    const session = agentService.getOrCreateSessionForConfig(workspaceId, agent);
+    agentService.updateStatus(workspaceId, session.id, 'active');
+    const runtime = createAgentRuntime({
+        kind: agent.runtimeKind,
+        provider: agent.modelProvider,
+        model: agent.modelId,
+        apiKey: agent.apiKey,
+        baseURL: agent.apiBase,
+        ...getThinkingRuntimeConfig(agent),
+    });
+    const workingDir = agentService.resolveWorkingDir(workspaceId, agent);
+    const systemPrompt = DEFAULT_SYSTEM_PROMPT;
+    const truncatedDiff = input.diff.length > 12000
+        ? `${input.diff.substring(0, 12000)}\n... (truncated)`
+        : input.diff;
+    const userPrompt = [
+        `Generate a pull request body for branch ${input.worktree.branch} targeting ${input.baseBranch}.`,
+        '',
+        'Commits:',
+        input.commits.length > 0 ? input.commits.map((commit) => `- ${commit}`).join('\n') : '- No commit messages available',
+        '',
+        'Diff:',
+        truncatedDiff,
+    ].join('\n');
+    const result = await runtime.execute(prependPersistentAgentContext(userPrompt, {
+        workspaceId,
+        workingDir,
+        boundDirs: ws.boundDirs,
+        includeWorkspacePrompt: false,
+        excludeNativeClaudeMd: agent.runtimeKind === 'claude-code',
+    }), workingDir, {
+        maxTurns: 1,
+        userPrompt,
+        systemPrompt,
+        outputStyle: agent.outputStyle,
+    });
+    agentService.complete(workspaceId, session.id, result.success ? undefined : result.error, {
+        runtime: agent.runtimeKind,
+        model: agent.modelId,
+        summary: result.summary,
+        output: result.output,
+        usage: result.usage,
+        costUsd: result.costUsd,
+    });
+    if (!result.success) {
+        throw new Error(result.error || 'Pull request agent failed');
+    }
+    const body = sanitizePullRequestBody(result.output);
+    if (!body)
+        throw new Error('Empty response from pull request agent');
+    return body;
+}
+function findPullRequestAgent(workspaceId) {
+    const presets = agentService.listPresets(workspaceId);
+    const preset = presets?.find((a) => a.id === AGENT_GENERATOR_PRESET_ID);
+    if (preset)
+        return preset;
+    const template = agentService.readAgentTemplate(AGENT_GENERATOR_PRESET_ID);
+    if (template)
+        return template;
+    return agentService.listTemplates().find((a) => a.id === AGENT_GENERATOR_PRESET_ID) ?? agentService.listTemplates()[0];
+}
+function sanitizePullRequestBody(output) {
+    const chunks = (Array.isArray(output) ? output : [output])
+        .map((chunk) => cleanOutputChunk(chunk))
+        .filter(Boolean);
+    const uniqueChunks = dedupeAdjacentChunks(chunks);
+    return (uniqueChunks.at(-1) || uniqueChunks.join('\n\n')).trim();
+}
+function cleanOutputChunk(chunk) {
+    return chunk
+        .split('\n')
+        .filter((line) => !isRuntimeNoise(line))
+        .join('\n')
+        .replace(/```(?:\w+)?\n([\s\S]*?)```/g, '$1')
+        .trim();
+}
+function dedupeAdjacentChunks(chunks) {
+    const result = [];
+    for (const chunk of chunks) {
+        if (result.at(-1)?.trim() === chunk.trim())
+            continue;
+        result.push(chunk);
+    }
+    return result;
+}
+function isRuntimeNoise(line) {
+    const trimmed = line.trim();
+    return /^\[Usage\]/.test(trimmed)
+        || /^Claude Code initialized\b/i.test(trimmed)
+        || /^Codex initialized\b/i.test(trimmed)
+        || /^Tool:/i.test(trimmed)
+        || /^Todo:/i.test(trimmed);
+}
+//# sourceMappingURL=pull-request-agent.js.map

package/dist/agents/scheduler-agent.js

@@ -16,7 +16,7 @@ export function startScheduler(workspaceId, ctx) {
     const tick = async () => {
         // 检查 workspace 是否关闭了自动处理
         const workspace = workspaceService.getById(workspaceId);
-        if (workspace && workspace.autoProcessIssues === false) {
+        if (workspace && workspace.autoProcessIssues !== true) {
             console.log(`[scheduler:${workspaceId}] auto-processing disabled for this workspace, skip`);
             return;
         }