doer-agent 0.9.0 → 0.9.2

package/dist/agent-codex-cli.js

@@ -13,6 +13,11 @@ function toTomlStringLiteral(value) {
 function toTomlStringArray(values) {
     return `[${values.map((value) => toTomlStringLiteral(value)).join(", ")}]`;
 }
+function toTomlStringMap(values) {
+    return `{ ${Object.entries(values)
+        .map(([key, value]) => `${toTomlStringLiteral(key)} = ${toTomlStringLiteral(value)}`)
+        .join(", ")} }`;
+}
 function buildMcpServerConfigArgs(args) {
     const serverName = args.serverName.trim();
     const configArgs = [
@@ -28,6 +33,25 @@ function buildMcpServerConfigArgs(args) {
     }
     return configArgs;
 }
+function buildRemoteMcpServerConfigArgs(args) {
+    const prefix = `mcp_servers.${args.serverName.trim()}`;
+    const configArgs = [
+        "--config",
+        `${prefix}.url=${toTomlStringLiteral(args.url)}`,
+        "--config",
+        `${prefix}.enabled=${args.enabled === false ? "false" : "true"}`,
+    ];
+    if (args.bearerTokenEnvVar?.trim()) {
+        configArgs.push("--config", `${prefix}.bearer_token_env_var=${toTomlStringLiteral(args.bearerTokenEnvVar.trim())}`);
+    }
+    if (Object.keys(args.httpHeaders ?? {}).length > 0) {
+        configArgs.push("--config", `${prefix}.http_headers=${toTomlStringMap(args.httpHeaders ?? {})}`);
+    }
+    if (Object.keys(args.envHttpHeaders ?? {}).length > 0) {
+        configArgs.push("--config", `${prefix}.env_http_headers=${toTomlStringMap(args.envHttpHeaders ?? {})}`);
+    }
+    return configArgs;
+}
 function hasDirectCodexBinary() {
     const result = spawnSync("bash", ["-lc", "command -v codex >/dev/null 2>&1"], {
         stdio: "ignore",
@@ -124,10 +148,22 @@ export function buildCustomMcpConfigArgs(servers) {
     const seenNames = new Set();
     for (const server of servers) {
         const serverName = server.name.trim();
-        if (!server.enabled || !serverName || !server.command.trim() || reservedNames.has(serverName) || seenNames.has(serverName)) {
+        const hasEndpoint = server.transport === "streamable_http" ? server.url.trim() : server.command.trim();
+        if (!server.enabled || !serverName || !hasEndpoint || reservedNames.has(serverName) || seenNames.has(serverName)) {
             continue;
         }
         seenNames.add(serverName);
+        if (server.transport === "streamable_http") {
+            configArgs.push(...buildRemoteMcpServerConfigArgs({
+                serverName,
+                url: server.url,
+                bearerTokenEnvVar: server.bearerTokenEnvVar,
+                httpHeaders: Object.fromEntries(server.httpHeaders.map((header) => [header.key, header.value])),
+                envHttpHeaders: Object.fromEntries(server.envHttpHeaders.map((header) => [header.key, header.value])),
+                enabled: true,
+            }));
+            continue;
+        }
         configArgs.push(...buildMcpServerConfigArgs({
             serverName,
             command: server.command,

package/dist/agent-codex-cli.test.js

@@ -0,0 +1,44 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { buildCustomMcpConfigArgs } from "./agent-codex-cli.js";
+test("buildCustomMcpConfigArgs builds streamable HTTP MCP overrides", () => {
+    const args = buildCustomMcpConfigArgs([{
+            name: "remote_docs",
+            transport: "streamable_http",
+            command: "",
+            args: [],
+            env: [],
+            url: "https://example.com/mcp",
+            bearerTokenEnvVar: "MCP_TOKEN",
+            httpHeaders: [{ key: "X-Region", value: "seoul" }],
+            envHttpHeaders: [{ key: "X-API-Key", value: "MCP_API_KEY" }],
+            enabled: true,
+        }]);
+    assert.deepEqual(args, [
+        "--config", 'mcp_servers.remote_docs.url="https://example.com/mcp"',
+        "--config", "mcp_servers.remote_docs.enabled=true",
+        "--config", 'mcp_servers.remote_docs.bearer_token_env_var="MCP_TOKEN"',
+        "--config", 'mcp_servers.remote_docs.http_headers={ "X-Region" = "seoul" }',
+        "--config", 'mcp_servers.remote_docs.env_http_headers={ "X-API-Key" = "MCP_API_KEY" }',
+    ]);
+});
+test("buildCustomMcpConfigArgs keeps stdio MCP overrides", () => {
+    const args = buildCustomMcpConfigArgs([{
+            name: "local_tools",
+            transport: "stdio",
+            command: "npx",
+            args: ["-y", "local-mcp"],
+            env: [{ key: "LOCAL_TOKEN", value: "secret" }],
+            url: "",
+            bearerTokenEnvVar: "",
+            httpHeaders: [],
+            envHttpHeaders: [],
+            enabled: true,
+        }]);
+    assert.deepEqual(args, [
+        "--config", 'mcp_servers.local_tools.command="npx"',
+        "--config", 'mcp_servers.local_tools.args=["-y", "local-mcp"]',
+        "--config", "mcp_servers.local_tools.enabled=true",
+        "--config", 'mcp_servers.local_tools.env.LOCAL_TOKEN="secret"',
+    ]);
+});

package/dist/agent-connectivity.test.js

@@ -0,0 +1,42 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { buildNatsConnectionOptions } from "./agent-jetstream.js";
+import { heartbeatAgentSession } from "./agent-runtime-io.js";
+test("NATS connection detects stale networks quickly and keeps reconnecting", () => {
+    const options = buildNatsConnectionOptions({
+        servers: ["tls://nats.example.com:4222"],
+        token: "secret",
+    });
+    assert.equal(options.pingInterval, 2_000);
+    assert.equal(options.maxPingOut, 2);
+    assert.equal(options.maxReconnectAttempts, -1);
+    assert.equal(options.reconnectTimeWait, 1_000);
+    assert.equal(options.token, "secret");
+});
+test("heartbeat stops waiting when a NATS flush stalls", async () => {
+    const startedAt = Date.now();
+    await assert.rejects(heartbeatAgentSession({
+        nc: { flush: () => new Promise(() => undefined) },
+        serverBaseUrl: "https://doer.example.com",
+        userId: "user-1",
+        agentToken: "token-1",
+        timeoutMs: 20,
+        postJson: async () => ({ ok: true }),
+    }), /nats flush timed out after 20ms/);
+    assert.ok(Date.now() - startedAt < 500);
+});
+test("heartbeat forwards its timeout to the HTTP probe", async () => {
+    let observedTimeout;
+    await heartbeatAgentSession({
+        nc: { flush: async () => undefined },
+        serverBaseUrl: "https://doer.example.com",
+        userId: "user-1",
+        agentToken: "token-1",
+        timeoutMs: 3_000,
+        postJson: async (_url, _body, options) => {
+            observedTimeout = options?.timeoutMs;
+            return { ok: true };
+        },
+    });
+    assert.equal(observedTimeout, 3_000);
+});

package/dist/agent-jetstream.js

@@ -1,4 +1,20 @@
 import { AckPolicy, connect, DeliverPolicy, JSONCodec, RetentionPolicy, StorageType, } from "nats";
+const NATS_PING_INTERVAL_MS = 2_000;
+const NATS_MAX_PING_OUT = 2;
+const NATS_RECONNECT_TIME_WAIT_MS = 1_000;
+const NATS_RECONNECT_JITTER_MS = 250;
+export function buildNatsConnectionOptions(args) {
+    return {
+        servers: args.servers,
+        ...(args.token ? { token: args.token } : {}),
+        pingInterval: NATS_PING_INTERVAL_MS,
+        maxPingOut: NATS_MAX_PING_OUT,
+        maxReconnectAttempts: -1,
+        reconnectTimeWait: NATS_RECONNECT_TIME_WAIT_MS,
+        reconnectJitter: NATS_RECONNECT_JITTER_MS,
+        reconnectJitterTLS: NATS_RECONNECT_JITTER_MS,
+    };
+}
 export function normalizeNatsServers(value) {
     if (!Array.isArray(value)) {
         return [];
@@ -55,7 +71,7 @@ async function initJetStreamContext(args) {
     const stream = `DOER_AGENT_EVENTS_${sanitized}`;
     const subject = `doer.agent.events.${sanitized}`;
     const durable = `doer-agent-uploader-${sanitized}`;
-    const nc = await connect(args.token ? { servers: args.servers, token: args.token } : { servers: args.servers });
+    const nc = await connect(buildNatsConnectionOptions({ servers: args.servers, token: args.token }));
     const jsm = await nc.jetstreamManager();
     await ensureJetStreamInfra({ jsm, stream, subject, durable });
     void (async () => {

package/dist/agent-runtime-io.js

@@ -1,9 +1,19 @@
-export async function postJson(url, body) {
-    const res = await fetch(url, {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify(body),
-    });
+export async function postJson(url, body, options = {}) {
+    let res;
+    try {
+        res = await fetch(url, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify(body),
+            ...(options.timeoutMs ? { signal: AbortSignal.timeout(options.timeoutMs) } : {}),
+        });
+    }
+    catch (error) {
+        if (options.timeoutMs && error instanceof Error && error.name === "TimeoutError") {
+            throw new Error(`request timed out after ${options.timeoutMs}ms`);
+        }
+        throw error;
+    }
     const text = await res.text();
     let data = {};
     if (text) {
@@ -104,9 +114,22 @@ export function createEventPersistenceHelpers(args) {
     };
 }
 export async function heartbeatAgentSession(args) {
-    await args.nc.flush();
+    let timeout;
+    try {
+        await Promise.race([
+            args.nc.flush(),
+            new Promise((_, reject) => {
+                timeout = setTimeout(() => reject(new Error(`nats flush timed out after ${args.timeoutMs}ms`)), args.timeoutMs);
+            }),
+        ]);
+    }
+    finally {
+        if (timeout) {
+            clearTimeout(timeout);
+        }
+    }
     await args.postJson(`${args.serverBaseUrl}/api/agent/heartbeat`, {
         userId: args.userId,
         agentToken: args.agentToken,
-    });
+    }, { timeoutMs: args.timeoutMs });
 }

package/dist/agent-settings.js

@@ -172,7 +172,7 @@ function normalizeMcpServerName(value) {
     if (!trimmed || !/^[A-Za-z0-9_-]+$/.test(trimmed)) {
         return null;
     }
-    if (trimmed === "doer_daemon" || trimmed === "doer_mobile") {
+    if (trimmed === "doer_daemon" || trimmed === "doer_mobile" || trimmed === "doer_threads") {
         return null;
     }
     return trimmed;
@@ -185,14 +185,38 @@ function normalizeStringArray(value) {
         .map((item) => (typeof item === "string" ? item.replace(/\r/g, "") : null))
         .filter((item) => item !== null && item.trim().length > 0);
 }
+function normalizeMcpHeaderEntries(value) {
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    const entries = [];
+    const seenKeys = new Set();
+    for (const item of value) {
+        if (!item || typeof item !== "object" || Array.isArray(item)) {
+            continue;
+        }
+        const raw = item;
+        const key = typeof raw.key === "string" ? raw.key.trim() : "";
+        if (!key || typeof raw.value !== "string" || seenKeys.has(key)) {
+            continue;
+        }
+        seenKeys.add(key);
+        entries.push({ key, value: raw.value.replace(/\r/g, "") });
+    }
+    return entries;
+}
 function normalizeAgentMcpServer(value) {
     if (!value || typeof value !== "object" || Array.isArray(value)) {
         return null;
     }
     const raw = value;
     const name = normalizeMcpServerName(raw.name);
+    const transport = raw.transport === "streamable_http" || (typeof raw.url === "string" && raw.url.trim())
+        ? "streamable_http"
+        : "stdio";
     const command = typeof raw.command === "string" ? raw.command.trim() : "";
-    if (!name || !command) {
+    const url = typeof raw.url === "string" ? raw.url.trim() : "";
+    if (!name || (transport === "stdio" ? !command : !url)) {
         return null;
     }
     const env = [];
@@ -208,9 +232,14 @@ function normalizeAgentMcpServer(value) {
     }
     return {
         name,
+        transport,
         command,
         args: normalizeStringArray(raw.args),
         env,
+        url,
+        bearerTokenEnvVar: typeof raw.bearerTokenEnvVar === "string" ? raw.bearerTokenEnvVar.trim() : "",
+        httpHeaders: normalizeMcpHeaderEntries(raw.httpHeaders),
+        envHttpHeaders: normalizeMcpHeaderEntries(raw.envHttpHeaders),
         enabled: raw.enabled !== false,
     };
 }
@@ -386,12 +415,17 @@ export async function toAgentSettingsPublic(args) {
         mcp: {
             servers: args.config.mcp.servers.map((server) => ({
                 name: server.name,
+                transport: server.transport,
                 command: server.command,
                 args: [...server.args],
                 env: server.env.map((variable) => ({
                     key: variable.key,
                     value: variable.value,
                 })),
+                url: server.url,
+                bearerTokenEnvVar: server.bearerTokenEnvVar,
+                httpHeaders: server.httpHeaders.map((header) => ({ ...header })),
+                envHttpHeaders: server.envHttpHeaders.map((header) => ({ ...header })),
                 enabled: server.enabled,
             })),
         },

package/dist/agent.js

@@ -28,7 +28,8 @@ const AGENT_PROJECT_DIR = path.join(AGENT_MODULE_DIR, "..");
 const AGENT_PACKAGE_JSON_PATH = path.join(AGENT_PROJECT_DIR, "package.json");
 const BUNDLED_SKILLS_ROOT = path.join(AGENT_PROJECT_DIR, "runtime", "skills");
 const HEARTBEAT_INTERVAL_MS = 5_000;
-const HEARTBEAT_FAILURE_THRESHOLD = 3;
+const HEARTBEAT_FAILURE_THRESHOLD = 2;
+const HEARTBEAT_REQUEST_TIMEOUT_MS = 3_000;
 const codexAppEventCodec = StringCodec();
 let activeTaskLogContext = null;
 let workspaceRootOverride = null;
@@ -187,6 +188,7 @@ const eventPersistenceHelpers = createEventPersistenceHelpers({
 const heartbeatSession = async (args) => {
     await heartbeatAgentSession({
         ...args,
+        timeoutMs: HEARTBEAT_REQUEST_TIMEOUT_MS,
         postJson,
     });
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "doer-agent",
-  "version": "0.9.0",
+  "version": "0.9.2",
   "description": "Reverse-polling agent runtime for doer",
   "type": "module",
   "main": "dist/agent.js",