@agent-spaces/server 0.3.64 → 0.3.67

package/dist/adapters/agent-runtime.js

@@ -3,10 +3,12 @@
  */
 import { ClaudeCodeRuntime } from './claude-code-runtime/index.js';
 import { CodexRuntime } from './codex-runtime.js';
+import { HermesRuntime } from './hermes-runtime.js';
 import { LangChainRuntime } from './langchain-runtime.js';
 import { OpenAgentSdkRuntime } from './open-agent-sdk-runtime.js';
 export { ClaudeCodeRuntime } from './claude-code-runtime/index.js';
 export { CodexRuntime } from './codex-runtime.js';
+export { HermesRuntime } from './hermes-runtime.js';
 export { LangChainRuntime } from './langchain-runtime.js';
 export { OpenAgentSdkRuntime } from './open-agent-sdk-runtime.js';
 export function createAgentRuntime(configOrProvider = {}, model) {
@@ -22,6 +24,8 @@ export function createAgentRuntime(configOrProvider = {}, model) {
             return new CodexRuntime(config);
         case 'langchain':
             return new LangChainRuntime(config);
+        case 'hermes':
+            return new HermesRuntime(config);
     }
 }
 //# sourceMappingURL=agent-runtime.js.map

package/dist/adapters/claude-code-runtime/index.js

@@ -4,7 +4,7 @@ import { summarizeResult } from '../agent-runtime-types.js';
 import { prepareClaudeOutputStyleFile } from '../../services/output-style.js';
 import { normalizeAdditionalDirectories, normalizePermissionMode, normalizeSkillNames, prepareConfigDir, resolveBundledClaudeExecutable, buildEnv, normalizeMcpServers } from './sdk-config.js';
 import { startClaudeAdapterIfNeeded, getClaudeCodeModel } from './adapter-pool.js';
-import { extractThinkingEvents, extractToolUseEvents, extractToolResultEvent, logToolDebug, formatMessage, isAskUserQuestionAutoResult, countUsageTokens, formatUsageLine, normalizeUsage } from './message-format.js';
+import { extractClaudeHookEvents, extractThinkingEvents, extractToolUseEvents, extractToolResultEvent, logToolDebug, formatMessage, isAskUserQuestionAutoResult, countUsageTokens, formatUsageLine, normalizeUsage } from './message-format.js';
 export class ClaudeCodeRuntime {
     config;
     abortController = null;
@@ -39,7 +39,33 @@ export class ClaudeCodeRuntime {
         d(`prompt: ${prompt.slice(0, 300)}${prompt.length > 300 ? '...' : ''}`);
         d(`sdk mcp servers | ${sdkMcpServerNames.join(',') || '-'}`);
         const stderrLines = [];
+        let sessionId = options?.resumeSessionId;
+        const emitHook = (event, matcher = '*', payload) => {
+            options?.onEvent?.({ type: 'hook_event', event, matcher, payload });
+        };
         try {
+            emitHook('SessionStart', '*', {
+                cwd,
+                model,
+                provider: this.config.provider,
+                baseURL,
+                permissionMode,
+                configDir,
+                sandboxDirs: additionalDirectories,
+                resumeSessionId: options?.resumeSessionId,
+            });
+            const hookUserPrompt = options?.userPrompt ?? prompt;
+            emitHook('UserPromptSubmit', '*', {
+                prompt: hookUserPrompt,
+                message: hookUserPrompt,
+                userMessage: hookUserPrompt,
+                fullPrompt: prompt,
+                cwd,
+                configDir,
+            });
+            if (/CLAUDE\.md|AGENTS\.md|\.claude\/rules\//.test(prompt)) {
+                emitHook('InstructionsLoaded', '*', { source: 'prompt', promptPreview: prompt.slice(0, 1000) });
+            }
             const queryOptions = {
                 cwd,
                 model,
@@ -76,11 +102,13 @@ export class ClaudeCodeRuntime {
             let usageLine = null;
             let usage;
             let costUsd;
-            let sessionId = options?.resumeSessionId;
             let sawResult = false;
             const pendingAskUserQuestionToolIds = new Set();
             let waitingForUserAnswer = false;
             for await (const message of this.activeQuery) {
+                for (const hookEvent of extractClaudeHookEvents(message)) {
+                    emitHook(hookEvent.event, hookEvent.matcher, hookEvent.payload);
+                }
                 const nextSessionId = readSessionId(message);
                 if (nextSessionId && nextSessionId !== sessionId) {
                     sessionId = nextSessionId;
@@ -145,6 +173,17 @@ export class ClaudeCodeRuntime {
             const elapsed = Date.now() - startTime;
             if (waitingForUserAnswer) {
                 d(`waiting for user answer ${elapsed}ms | turns=${turns} tokens=${tokenCount}`);
+                const message = resultText || output.at(-1) || 'Waiting for user answer';
+                emitHook('Stop', '*', {
+                    status: 'waiting_for_user_answer',
+                    message,
+                    finalMessage: message,
+                    output,
+                    elapsedMs: elapsed,
+                    turns,
+                    tokenCount,
+                    sessionId,
+                });
                 if (usageLine)
                     output.push(usageLine);
                 return {
@@ -161,6 +200,7 @@ export class ClaudeCodeRuntime {
                 const runtimeError = extractRuntimeError([...stderrLines, ...output])
                     || 'Claude Code execution stopped before reporting a final result';
                 d(`failed ${elapsed}ms | turns=${turns} tokens=${tokenCount} | ${runtimeError}`);
+                emitHook('StopFailure', '*', { error: runtimeError, elapsedMs: elapsed, turns, tokenCount, sessionId, stderr: stderrLines });
                 appendUnique(output, stderrLines);
                 appendUnique(output, [runtimeError]);
                 return {
@@ -176,6 +216,17 @@ export class ClaudeCodeRuntime {
             }
             if (waitingForUserAnswer && (!error || isAskUserQuestionAutoResult(error))) {
                 d(`waiting for user answer ${elapsed}ms | turns=${turns} tokens=${tokenCount}`);
+                const message = resultText || output.at(-1) || 'Waiting for user answer';
+                emitHook('Stop', '*', {
+                    status: 'waiting_for_user_answer',
+                    message,
+                    finalMessage: message,
+                    output,
+                    elapsedMs: elapsed,
+                    turns,
+                    tokenCount,
+                    sessionId,
+                });
                 if (usageLine)
                     output.push(usageLine);
                 return {
@@ -191,6 +242,7 @@ export class ClaudeCodeRuntime {
             if (error) {
                 const runtimeError = extractRuntimeError([error, ...stderrLines, ...output]) || error;
                 d(`failed ${elapsed}ms | turns=${turns} tokens=${tokenCount} | ${runtimeError}`);
+                emitHook('StopFailure', '*', { error: runtimeError, elapsedMs: elapsed, turns, tokenCount, sessionId, stderr: stderrLines });
                 appendUnique(output, stderrLines);
                 if (usageLine)
                     output.push(usageLine);
@@ -213,6 +265,18 @@ export class ClaudeCodeRuntime {
             const finalOutput = resultText && !output.includes(resultText) ? [...output, resultText] : output;
             if (usageLine && !finalOutput.includes(usageLine))
                 finalOutput.push(usageLine);
+            emitHook('Stop', '*', {
+                status: 'success',
+                message: text,
+                finalMessage: text,
+                output: finalOutput,
+                elapsedMs: elapsed,
+                turns,
+                tokenCount,
+                sessionId,
+                usage,
+                costUsd,
+            });
             return {
                 success: true,
                 summary: summarizeResult(text),
@@ -230,11 +294,13 @@ export class ClaudeCodeRuntime {
             d(`failed ${elapsed}ms | ${runtimeError}`);
             if (err instanceof Error && err.stack)
                 console.error(err.stack);
+            emitHook('StopFailure', '*', { error: runtimeError, elapsedMs: elapsed, stderr: stderrLines, stack: err instanceof Error ? err.stack : undefined });
             appendUnique(output, stderrLines);
             appendUnique(output, [runtimeError]);
             return { success: false, summary: 'Claude Code execution failed', artifacts: [], error: runtimeError, output, sessionId: options?.resumeSessionId };
         }
         finally {
+            emitHook('SessionEnd', '*', { cwd, sessionId });
             this.activeQuery?.close();
             this.activeQuery = null;
             await this.adapterRun?.release();

package/dist/adapters/claude-code-runtime/message-format.js

@@ -95,6 +95,32 @@ export function extractToolResultEvent(message) {
     }
     return null;
 }
+export function extractClaudeHookEvents(message) {
+    const events = [];
+    if (message.type === 'system') {
+        if (message.subtype === 'task_started') {
+            events.push({ event: 'SubagentStart', matcher: '*', payload: message });
+        }
+        else if (message.subtype === 'task_notification') {
+            events.push({ event: 'Notification', matcher: '*', payload: message });
+        }
+        else if (message.subtype === 'local_command_output') {
+            events.push({ event: 'Notification', matcher: 'local_command_output', payload: message });
+        }
+    }
+    if (message.type === 'tool_use_summary') {
+        events.push({ event: 'PostToolBatch', matcher: '*', payload: message });
+    }
+    for (const toolUse of extractToolUseEvents(message)) {
+        if (toolUse.name === 'TaskCreate') {
+            events.push({ event: 'TaskCreated', matcher: toolUse.name, payload: toolUse });
+        }
+        if (toolUse.name === 'TaskCompleted') {
+            events.push({ event: 'TaskCompleted', matcher: toolUse.name, payload: toolUse });
+        }
+    }
+    return events;
+}
 export function logToolDebug(message, d, options = {}) {
     switch (message.type) {
         case 'assistant':

package/dist/adapters/claude-code-runtime/sdk-config.js

@@ -5,6 +5,7 @@ import { join } from 'node:path';
 import { createSdkMcpServer, tool } from '@anthropic-ai/claude-agent-sdk';
 import { isAnthropicBridgeProvider } from './types.js';
 const require = createRequire(import.meta.url);
+const CLAUDE_BUILT_IN_DIRS = ['agents', 'commands'];
 export function buildEnv(config, configDir, override) {
     const usesAnthropicBridge = isAnthropicBridgeProvider(config.provider);
     return {
@@ -132,6 +133,7 @@ export function prepareConfigDir(configDir, agentDir) {
     mkdirSync(configDir, { recursive: true });
     if (!agentDir)
         return;
+    copyClaudeBuiltInDirs(agentDir, configDir);
     const sourceSkillsDir = join(agentDir, 'skills');
     const targetSkillsDir = join(configDir, 'skills');
     rmSync(targetSkillsDir, { recursive: true, force: true });
@@ -163,6 +165,16 @@ export function prepareConfigDir(configDir, agentDir) {
         copyFileSync(source, join(targetSkillsDir, `${skillName}.md`));
     }
 }
+function copyClaudeBuiltInDirs(agentDir, configDir) {
+    for (const dir of CLAUDE_BUILT_IN_DIRS) {
+        const sourceDir = join(agentDir, dir);
+        const targetDir = join(configDir, dir);
+        rmSync(targetDir, { recursive: true, force: true });
+        if (!existsSync(sourceDir) || !statSync(sourceDir).isDirectory())
+            continue;
+        cpSync(sourceDir, targetDir, { recursive: true, force: true });
+    }
+}
 function hasSkillContent(skill, configDir) {
     if (!configDir)
         return true;

package/dist/adapters/codex-function-tool-bridge.js

@@ -0,0 +1,144 @@
+import { randomUUID } from 'node:crypto';
+import { createServer } from 'node:http';
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
+import { CallToolRequestSchema, ErrorCode, ListToolsRequestSchema, McpError, } from '@modelcontextprotocol/sdk/types.js';
+const AGENT_SPACES_MCP_SERVER_NAME = 'agent-spaces';
+export async function startCodexFunctionToolBridge(functionTools, log) {
+    if (!functionTools?.length)
+        return undefined;
+    const toolsByName = new Map(functionTools.map((functionTool) => [functionTool.name, functionTool]));
+    const mcpServer = new Server({ name: AGENT_SPACES_MCP_SERVER_NAME, version: '0.1.0' }, {
+        capabilities: {
+            tools: { listChanged: false },
+        },
+        instructions: 'Agent Spaces built-in runtime tools for workspace data.',
+    });
+    const transport = new StreamableHTTPServerTransport({
+        sessionIdGenerator: randomUUID,
+        enableJsonResponse: true,
+    });
+    mcpServer.setRequestHandler(ListToolsRequestSchema, () => ({
+        tools: functionTools.map(toMcpTool),
+    }));
+    mcpServer.setRequestHandler(CallToolRequestSchema, async (request) => {
+        const functionTool = toolsByName.get(request.params.name);
+        if (!functionTool) {
+            throw new McpError(ErrorCode.InvalidParams, `Tool ${request.params.name} not found`);
+        }
+        const result = await functionTool.execute(request.params.arguments ?? {});
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: stringifyToolResult(result),
+                },
+            ],
+            ...(isRecord(result) ? { structuredContent: result } : {}),
+        };
+    });
+    await mcpServer.connect(transport);
+    const httpServer = createServer(async (req, res) => {
+        try {
+            const url = new URL(req.url ?? '/', 'http://127.0.0.1');
+            if (url.pathname !== '/mcp') {
+                res.writeHead(404).end('Not found');
+                return;
+            }
+            await transport.handleRequest(req, res);
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            log?.(`function tool bridge request failed | ${message}`);
+            if (!res.headersSent)
+                res.writeHead(500, { 'content-type': 'text/plain; charset=utf-8' });
+            if (!res.writableEnded)
+                res.end(message);
+        }
+    });
+    await listen(httpServer);
+    const address = httpServer.address();
+    if (!address || typeof address === 'string') {
+        await closeHttpServer(httpServer);
+        await mcpServer.close();
+        throw new Error('Failed to start Codex function tool bridge');
+    }
+    const url = `http://127.0.0.1:${address.port}/mcp`;
+    log?.(`function tool bridge started | url=${url} tools=${functionTools.map((tool) => tool.name).join(',')}`);
+    return {
+        name: AGENT_SPACES_MCP_SERVER_NAME,
+        url,
+        close: async () => {
+            await mcpServer.close();
+            await closeHttpServer(httpServer);
+            log?.('function tool bridge stopped');
+        },
+    };
+}
+function toMcpTool(functionTool) {
+    return {
+        name: functionTool.name,
+        description: functionTool.description,
+        inputSchema: normalizeToolInputSchema(functionTool.inputSchema),
+        annotations: toMcpToolAnnotations(functionTool),
+    };
+}
+function normalizeToolInputSchema(schema) {
+    if (schema.type === 'object')
+        return schema;
+    return {
+        type: 'object',
+        properties: normalizeSchemaProperties(schema.properties),
+        required: Array.isArray(schema.required) ? schema.required.map(String) : [],
+    };
+}
+function toMcpToolAnnotations(functionTool) {
+    if (!functionTool.annotations)
+        return undefined;
+    return {
+        readOnlyHint: functionTool.annotations.readOnly,
+        destructiveHint: functionTool.annotations.destructive,
+        openWorldHint: functionTool.annotations.openWorld,
+    };
+}
+function stringifyToolResult(result) {
+    if (result === undefined)
+        return 'null';
+    return JSON.stringify(result, null, 2) ?? String(result);
+}
+function normalizeSchemaProperties(properties) {
+    if (!isRecord(properties))
+        return {};
+    return Object.fromEntries(Object.entries(properties).filter((entry) => isRecord(entry[1])));
+}
+function listen(server) {
+    return new Promise((resolve, reject) => {
+        const onError = (err) => {
+            server.off('listening', onListening);
+            reject(err);
+        };
+        const onListening = () => {
+            server.off('error', onError);
+            resolve();
+        };
+        server.once('error', onError);
+        server.once('listening', onListening);
+        server.listen(0, '127.0.0.1');
+    });
+}
+function closeHttpServer(server) {
+    if (!server.listening)
+        return Promise.resolve();
+    return new Promise((resolve, reject) => {
+        server.close((err) => {
+            if (err)
+                reject(err);
+            else
+                resolve();
+        });
+    });
+}
+function isRecord(value) {
+    return Boolean(value && typeof value === 'object' && !Array.isArray(value));
+}
+//# sourceMappingURL=codex-function-tool-bridge.js.map

package/dist/adapters/codex-runtime.js

@@ -2,6 +2,7 @@ import { existsSync, mkdirSync, readdirSync, readFileSync, rmSync, statSync, wri
 import { basename, extname, join } from 'node:path';
 import { Codex } from '@openai/codex-sdk';
 import { appendOutputStyleToPrompt, summarizeResult } from './agent-runtime-types.js';
+import { startCodexFunctionToolBridge } from './codex-function-tool-bridge.js';
 /**
  * Runtime backed by OpenAI's Codex SDK.
  * Spawns the bundled Codex CLI and consumes its structured JSONL event stream.
@@ -23,12 +24,15 @@ export class CodexRuntime {
         if (codexHome)
             prepareCodexHome(codexHome, agentDir);
         const skillNames = normalizeSkillNames(options?.skills, codexHome);
-        const configOverrides = buildCodexConfig(this.config, options, skillNames);
         const sandboxMode = normalizeSandboxMode(this.config.permissionMode);
         const approvalPolicy = normalizeApprovalPolicy(this.config.permissionMode);
-        d(`starting | cwd=${cwd} model=${this.config.model ?? 'default'} sandboxMode=${sandboxMode} approvalPolicy=${approvalPolicy} maxTurns=${options?.maxTurns ?? '∞'} mcpServers=${Object.keys(options?.mcpServers ?? {}).join(',') || '-'} skills=${skillNames.join(',') || '-'} codexHome=${codexHome ?? 'default'} sandboxDirs=${options?.sandboxDirs?.join(',') ?? '-'}`);
+        let functionToolBridge;
+        d(`starting | cwd=${cwd} model=${this.config.model ?? 'default'} sandboxMode=${sandboxMode} approvalPolicy=${approvalPolicy} maxTurns=${options?.maxTurns ?? '∞'} mcpServers=${Object.keys(options?.mcpServers ?? {}).join(',') || '-'} functionTools=${options?.functionTools?.map((tool) => tool.name).join(',') || '-'} skills=${skillNames.join(',') || '-'} codexHome=${codexHome ?? 'default'} sandboxDirs=${options?.sandboxDirs?.join(',') ?? '-'}`);
         d(`prompt: ${prompt.slice(0, 300)}${prompt.length > 300 ? '...' : ''}`);
         try {
+            functionToolBridge = await startCodexFunctionToolBridge(options?.functionTools, d);
+            const mcpServers = withFunctionToolBridge(options?.mcpServers, functionToolBridge);
+            const configOverrides = buildCodexConfig(this.config, mcpServers, skillNames);
             const codex = new Codex({
                 apiKey: this.config.apiKey,
                 baseUrl: shouldUseCodexOpenAIBaseUrl(this.config) ? this.config.baseURL : undefined,
@@ -127,6 +131,13 @@ export class CodexRuntime {
             return { success: false, summary: 'Codex execution failed', artifacts: [], error: message, output, sessionId: options?.resumeSessionId };
         }
         finally {
+            try {
+                await functionToolBridge?.close();
+            }
+            catch (err) {
+                const message = err instanceof Error ? err.message : String(err);
+                d(`function tool bridge close failed | ${message}`);
+            }
             this.abortController = null;
         }
     }
@@ -143,13 +154,13 @@ function buildEnv(config, codexHome) {
         CODEX_INTERNAL_ORIGINATOR_OVERRIDE: process.env.CODEX_INTERNAL_ORIGINATOR_OVERRIDE || 'agent-spaces/server',
     });
 }
-function buildCodexConfig(runtimeConfig, options, skillNames) {
+function buildCodexConfig(runtimeConfig, rawMcpServers, skillNames) {
     const config = {};
     Object.assign(config, buildCodexProviderConfig(runtimeConfig));
     if (runtimeConfig.thinkingEnabled !== false) {
         config.model_reasoning_effort = runtimeConfig.thinkingEffort ?? 'medium';
     }
-    const mcpServers = normalizeMcpServers(options?.mcpServers);
+    const mcpServers = normalizeMcpServers(rawMcpServers);
     if (mcpServers)
         config.mcp_servers = mcpServers;
     if (skillNames.length > 0) {
@@ -157,6 +168,14 @@ function buildCodexConfig(runtimeConfig, options, skillNames) {
     }
     return removeUndefined(config);
 }
+function withFunctionToolBridge(mcpServers, bridge) {
+    if (!bridge)
+        return mcpServers;
+    return {
+        ...(mcpServers ?? {}),
+        [bridge.name]: { url: bridge.url },
+    };
+}
 function buildCodexProviderConfig(runtimeConfig) {
     if (!runtimeConfig.baseURL || shouldUseCodexOpenAIBaseUrl(runtimeConfig))
         return {};

package/dist/adapters/git.js

@@ -78,18 +78,20 @@ function mapStatus(raw) {
     };
 }
 async function getUpstreamRef(git, branch) {
+    const refExists = async (ref) => {
+        return git.raw(['rev-parse', '--verify', '--quiet', ref])
+            .then(() => true)
+            .catch(() => false);
+    };
     const upstream = await git.raw(['rev-parse', '--abbrev-ref', '--symbolic-full-name', '@{u}'])
         .then(v => v.trim())
         .catch(() => '');
-    if (upstream)
+    if (upstream && await refExists(upstream))
         return upstream;
     if (!branch || branch === 'HEAD')
         return null;
     const originBranch = `origin/${branch}`;
-    const hasOriginBranch = await git.raw(['rev-parse', '--verify', '--quiet', originBranch])
-        .then(() => true)
-        .catch(() => false);
-    return hasOriginBranch ? originBranch : null;
+    return await refExists(originBranch) ? originBranch : null;
 }
 function splitConflictSides(content) {
     const left = [];
@@ -168,6 +170,12 @@ export async function gitStatus(workspaceId) {
     try {
         const upstream = await getUpstreamRef(git, result.branch);
         if (upstream) {
+            const counts = await git.raw(['rev-list', '--left-right', '--count', `HEAD...${upstream}`]);
+            const [ahead, behind] = counts.trim().split(/\s+/).map((value) => Number(value));
+            if (Number.isFinite(ahead))
+                result.ahead = ahead;
+            if (Number.isFinite(behind))
+                result.behind = behind;
             const remoteHeadHash = await git.revparse(['--short', upstream]);
             result.remoteHeadHash = remoteHeadHash.trim();
         }
@@ -266,7 +274,12 @@ export async function gitLog(workspaceId, maxCount = 50) {
     const upstream = await getUpstreamRef(git, status.current || 'HEAD');
     const refs = upstream ? ['HEAD', upstream] : ['HEAD'];
     const pretty = '%H%x1f%s%x1f%an%x1f%aI%x1e';
-    const raw = await git.raw(['log', `--max-count=${maxCount}`, `--pretty=format:${pretty}`, ...refs]);
+    const logArgs = ['log', `--max-count=${maxCount}`, `--pretty=format:${pretty}`];
+    const raw = await git.raw([...logArgs, ...refs]).catch((err) => {
+        if (!upstream)
+            throw err;
+        return git.raw([...logArgs, 'HEAD']);
+    });
     return raw.split('\x1e')
         .map(record => record.trim())
         .filter(Boolean)
@@ -369,7 +382,7 @@ export async function gitPush(workspaceId) {
     const remotes = await git.getRemotes(true);
     if (!remotes.length)
         throw new Error('No remote repository configured. Please add a remote first.');
-    await git.push('origin', branch);
+    await git.push('origin', branch, ['--set-upstream']);
 }
 export async function gitFetch(workspaceId) {
     const ws = getWorkspace(workspaceId);
@@ -385,6 +398,11 @@ export async function gitPull(workspaceId) {
     const git = getGit(ws);
     const status = await git.status();
     const branch = status.current || 'HEAD';
+    const upstream = await getUpstreamRef(git, branch);
+    if (upstream?.startsWith('origin/')) {
+        await git.pull('origin', upstream.slice('origin/'.length));
+        return;
+    }
     await git.pull('origin', branch);
 }
 export async function gitGetRemotes(workspaceId) {