u-foo 2.3.10 → 2.3.12

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "u-foo",
-  "version": "2.3.10",
+  "version": "2.3.12",
   "description": "Multi-Agent Workspace Protocol. Just add u. claude → uclaude, codex → ucodex.",
   "license": "SEE LICENSE IN LICENSE",
   "homepage": "https://ufoo.dev",
@@ -45,6 +45,8 @@
     "bench:global-switch": "node scripts/global-chat-switch-benchmark.js"
   },
   "dependencies": {
+    "@anthropic-ai/claude-agent-sdk": "^0.2.138",
+    "@openai/codex-sdk": "^0.130.0",
     "blessed": "^0.1.81",
     "chalk": "^4.1.2",
     "commander": "^13.1.0",

package/src/agent/activityStateWriter.js

@@ -1,4 +1,6 @@
 const fs = require("fs");
+const { readJSON, writeJSON } = require("../bus/utils");
+const { appendAgentRegistryDiagnostic } = require("../ufoo/agentRegistryDiagnostics");
 
 /**
  * Centralized helper for writing activity_state to all-agents.json.
@@ -12,8 +14,17 @@ function writeActivityState(agentsFilePath, subscriber, state, options = {}) {
   const { since, force = false } = options;
   try {
     if (!agentsFilePath || !fs.existsSync(agentsFilePath)) return false;
-    const data = JSON.parse(fs.readFileSync(agentsFilePath, "utf8"));
-    if (!data.agents || !data.agents[subscriber]) return false;
+    const data = readJSON(agentsFilePath, null);
+    if (!data) return false;
+    if (!data.agents || !data.agents[subscriber]) {
+      appendAgentRegistryDiagnostic(agentsFilePath, "activity_state_subscriber_missing", {
+        source: "agent.activityStateWriter.writeActivityState",
+        subscriber,
+        state,
+        known_ids: Object.keys(data.agents || {}).sort(),
+      });
+      return false;
+    }
 
     const current = data.agents[subscriber].activity_state;
 
@@ -30,7 +41,7 @@ function writeActivityState(agentsFilePath, subscriber, state, options = {}) {
     data.agents[subscriber].activity_since = since
       ? new Date(since).toISOString()
       : new Date().toISOString();
-    fs.writeFileSync(agentsFilePath, JSON.stringify(data, null, 2));
+    writeJSON(agentsFilePath, data);
     return true;
   } catch {
     return false;

package/src/agent/claudeThreadProvider.js

@@ -3,9 +3,10 @@
 const {
   createClaudeEventState,
   normalizeClaudeEvent,
+  normalizeClaudeMessage,
+  normalizeClaudeUsage,
 } = require("./claudeEventTranslator");
 const { redactUfooEvent } = require("../providerapi/redactor");
-const { sendUpstreamRequest } = require("./upstreamTransport");
 
 const CACHE_CONTROL = Object.freeze({ type: "ephemeral" });
 
@@ -26,6 +27,25 @@ function resolveAnthropicSdk() {
   }
 }
 
+async function resolveClaudeAgentSdk() {
+  try {
+    return await import("@anthropic-ai/claude-agent-sdk");
+  } catch (err) {
+    const error = new Error("Claude Agent SDK mode requires @anthropic-ai/claude-agent-sdk");
+    error.code = "CLAUDE_AGENT_SDK_UNAVAILABLE";
+    error.cause = err;
+    throw error;
+  }
+}
+
+function resolveClaudeAgentQuery(sdk) {
+  const query = sdk && (sdk.query || (sdk.default && sdk.default.query));
+  if (typeof query !== "function") {
+    throw new Error("Claude Agent SDK module does not export query");
+  }
+  return query;
+}
+
 async function defaultClaudeAuthProvider() {
   const apiKey = String(process.env.ANTHROPIC_API_KEY || "").trim();
   if (!apiKey) {
@@ -61,43 +81,12 @@ function defaultClaudeStreamFactory({ client, request }) {
   });
 }
 
-async function* defaultClaudeTransportStreamFactory({ request, auth = {}, model = "", attempt = 0 }) {
-  const runtime = {
-    provider: "claude",
-    transport: "anthropic-messages",
-    model: String(model || request.model || "").trim(),
-    baseUrl: String(auth.baseUrl || process.env.ANTHROPIC_BASE_URL || "https://api.anthropic.com/v1").trim(),
-    auth,
-    credentialSource: auth.apiKey ? "thread-auth" : "thread-headers",
-  };
-  const result = await sendUpstreamRequest({
-    runtime,
-    request,
-    timeoutMs: Number.isFinite(Number(request.timeout_ms)) ? Number(request.timeout_ms) : 120000,
+function defaultClaudeAgentStreamFactory({ sdk, input, options }) {
+  const query = resolveClaudeAgentQuery(sdk);
+  return query({
+    prompt: String(input || ""),
+    options,
   });
-  if (!result.ok) {
-    const err = new Error(result.error || "Claude upstream request failed");
-    err.code = "CLAUDE_UPSTREAM_FAILED";
-    err.attempt = attempt;
-    throw err;
-  }
-
-  yield {
-    type: "message_start",
-    message: {
-      id: `msg-${Date.now().toString(36)}`,
-      usage: result.usage || undefined,
-    },
-  };
-  yield {
-    type: "content_block_delta",
-    index: 0,
-    delta: {
-      type: "text_delta",
-      text: String(result.output || ""),
-    },
-  };
-  yield { type: "message_stop" };
 }
 
 function normalizeToolDefinition(tool = {}) {
@@ -217,6 +206,74 @@ function createAssistantMessageFromState(state) {
   };
 }
 
+function extraArgsToObject(extraArgs = []) {
+  const result = {};
+  if (!Array.isArray(extraArgs)) return result;
+  for (let i = 0; i < extraArgs.length; i += 1) {
+    const raw = String(extraArgs[i] || "");
+    if (!raw.startsWith("--")) continue;
+    const key = raw.replace(/^--+/, "");
+    if (!key) continue;
+    const next = i + 1 < extraArgs.length ? String(extraArgs[i + 1] || "") : "";
+    if (!next || next.startsWith("--")) {
+      result[key] = null;
+      continue;
+    }
+    result[key] = next;
+    i += 1;
+  }
+  return result;
+}
+
+function buildClaudeAgentOptions({
+  model = "",
+  cwd = "",
+  threadId = "",
+  extraArgs = [],
+  agentOptions = {},
+  opts = {},
+} = {}) {
+  const options = {
+    ...agentOptions,
+    ...(opts && typeof opts.agentOptions === "object" ? opts.agentOptions : {}),
+  };
+  if (model && options.model === undefined) options.model = model;
+  if (cwd && options.cwd === undefined) options.cwd = cwd;
+  if (options.includePartialMessages === undefined) options.includePartialMessages = true;
+  if (options.extraArgs === undefined) {
+    const converted = extraArgsToObject(extraArgs);
+    if (Object.keys(converted).length > 0) options.extraArgs = converted;
+  }
+  if (threadId && !options.resume && !options.continue && !options.sessionId) {
+    options.resume = threadId;
+  }
+  if (opts && opts.abortController && options.abortController === undefined) {
+    options.abortController = opts.abortController;
+  }
+  if (opts && opts.signal && options.abortController === undefined) {
+    const controller = new AbortController();
+    opts.signal.addEventListener("abort", () => controller.abort(opts.signal.reason), { once: true });
+    options.abortController = controller;
+  }
+  return options;
+}
+
+function messageTextFromContent(content = []) {
+  if (!Array.isArray(content)) return "";
+  return content
+    .map((block) => (block && block.type === "text" ? String(block.text || "") : ""))
+    .join("");
+}
+
+function resultErrorMessage(message = {}) {
+  if (Array.isArray(message.errors) && message.errors.length > 0) {
+    return message.errors.map((item) => String(item || "")).filter(Boolean).join("\n");
+  }
+  if (typeof message.result === "string" && message.result) return message.result;
+  if (message.subtype) return String(message.subtype);
+  return "Claude Agent SDK query failed";
+}
+
 function shouldRetryClaudeStream(err, attempt) {
   if (attempt >= 1) return false;
   const code = String((err && err.code) || "").trim().toUpperCase();
@@ -228,23 +285,132 @@ function shouldRetryClaudeStream(err, attempt) {
 class ClaudeApiThread {
   constructor({
     model = "",
+    cwd = "",
+    extraArgs = [],
     authProvider = defaultClaudeAuthProvider,
     clientFactory = defaultClaudeClientFactory,
-    streamFactory = defaultClaudeStreamFactory,
+    streamFactory = defaultClaudeAgentStreamFactory,
     sdk,
+    agentOptions = {},
     maxTokens = 4096,
   } = {}) {
     this.id = "";
     this.model = model;
+    this.cwd = cwd;
+    this.extraArgs = Array.isArray(extraArgs) ? extraArgs.slice() : [];
     this.authProvider = authProvider;
     this.clientFactory = clientFactory;
     this.streamFactory = streamFactory;
     this.sdk = sdk;
+    this.agentOptions = { ...agentOptions };
     this.maxTokens = maxTokens;
     this.messages = [];
   }
 
   async *runStreamed(input, opts = {}) {
+    if (this.streamFactory === defaultClaudeAgentStreamFactory) {
+      yield* this.runAgentSdkStreamed(input, opts);
+      return;
+    }
+    yield* this.runMessagesStreamed(input, opts);
+  }
+
+  async *runAgentSdkStreamed(input, opts = {}) {
+    if (!this.sdk) {
+      this.sdk = await resolveClaudeAgentSdk();
+    }
+    const options = buildClaudeAgentOptions({
+      model: this.model,
+      cwd: this.cwd,
+      threadId: this.id,
+      extraArgs: this.extraArgs,
+      agentOptions: this.agentOptions,
+      opts,
+    });
+    const stream = await this.streamFactory({
+      sdk: this.sdk,
+      input,
+      options,
+      model: this.model,
+      cwd: this.cwd,
+      threadId: this.id,
+      opts,
+    });
+    const state = createClaudeEventState({ threadId: this.id });
+    let threadStarted = false;
+    let sawStreamEvents = false;
+    let sawText = false;
+    let sawTurnCompleted = false;
+
+    const emitThreadStarted = function* emitThreadStarted(self, sessionId = "") {
+      const nextId = String(sessionId || self.id || "").trim();
+      if (nextId) self.id = nextId;
+      if (!threadStarted && self.id) {
+        threadStarted = true;
+        yield redactUfooEvent({ type: "thread_started", threadId: self.id });
+      }
+    };
+
+    for await (const message of stream) {
+      if (!message || typeof message !== "object") continue;
+      const sessionId = String(message.session_id || message.sessionId || "").trim();
+      for (const event of emitThreadStarted(this, sessionId)) yield event;
+
+      if (message.type === "stream_event") {
+        sawStreamEvents = true;
+        const events = normalizeClaudeEvent(message.event || {}, state);
+        for (const event of events) {
+          if (!event || typeof event !== "object") continue;
+          if (event.type === "text_delta" && event.delta) sawText = true;
+          if (event.type === "turn_completed") sawTurnCompleted = true;
+          yield redactUfooEvent(event);
+        }
+        continue;
+      }
+
+      if (message.type === "assistant") {
+        if (sawStreamEvents) continue;
+        const events = normalizeClaudeMessage(message.message || {});
+        for (const event of events) {
+          if (!event || typeof event !== "object") continue;
+          if (event.type === "text_delta" && event.delta) sawText = true;
+          if (event.type === "turn_completed") sawTurnCompleted = true;
+          yield redactUfooEvent(event);
+        }
+        continue;
+      }
+
+      if (message.type === "result") {
+        if (message.is_error) {
+          yield redactUfooEvent({
+            type: "turn_failed",
+            turnId: state.turnId || message.uuid || "",
+            error: resultErrorMessage(message),
+          });
+          continue;
+        }
+        if (!sawText && typeof message.result === "string" && message.result) {
+          sawText = true;
+          yield redactUfooEvent({
+            type: "text_delta",
+            delta: message.result,
+            itemType: "text",
+          });
+        }
+        if (!sawTurnCompleted) {
+          sawTurnCompleted = true;
+          yield redactUfooEvent({
+            type: "turn_completed",
+            turnId: state.turnId || message.uuid || "",
+            usage: normalizeClaudeUsage(message.usage || null),
+            stopReason: String(message.stop_reason || ""),
+          });
+        }
+      }
+    }
+  }
+
+  async *runMessagesStreamed(input, opts = {}) {
     if (!this.id) this.id = createThreadId();
     const userMessage = normalizeMessageInput(input);
     const requestMessages = this.messages.slice();
@@ -332,12 +498,15 @@ module.exports = {
   ClaudeApiThread,
   ClaudeThreadProvider,
   createClaudeThreadProvider,
+  buildClaudeAgentOptions,
   defaultClaudeAuthProvider,
+  defaultClaudeAgentStreamFactory,
   defaultClaudeClientFactory,
   defaultClaudeStreamFactory,
-  defaultClaudeTransportStreamFactory,
+  extraArgsToObject,
   normalizeMessageInput,
   normalizeToolDefinition,
+  resolveClaudeAgentSdk,
   resolveAnthropicSdk,
   withCacheControlOnLastBlock,
 };

package/src/agent/codexThreadProvider.js

@@ -1,80 +1,79 @@
 const { normalizeCodexEvent } = require("./codexEventTranslator");
 const { redactUfooEvent } = require("../providerapi/redactor");
-const { sendUpstreamPrompt } = require("./upstreamTransport");
 
-function resolveCodexSdk() {
+async function resolveCodexSdk() {
   try {
-    // Optional dependency during Phase 1a seam work.
-    // eslint-disable-next-line global-require, import/no-extraneous-dependencies
-    return require("@openai/codex-sdk");
+    return await import("@openai/codex-sdk");
   } catch (err) {
-    const error = new Error("Codex SDK seam enabled but @openai/codex-sdk is not installed");
+    const error = new Error("Codex SDK mode requires @openai/codex-sdk");
     error.code = "CODEX_SDK_UNAVAILABLE";
     error.cause = err;
     throw error;
   }
 }
 
-function defaultCodexStreamFactory({
-  sdk,
-  model,
-  cwd,
-  extraArgs = [],
-  threadId = "",
-  input,
-  opts = {},
-}) {
-  if (!sdk || typeof sdk.runStreamed !== "function") {
-    throw new Error("Codex SDK seam requires runStreamed support");
+function resolveCodexConstructor(sdk) {
+  const Codex = sdk && (sdk.Codex || (sdk.default && sdk.default.Codex) || sdk.default);
+  if (typeof Codex !== "function") {
+    throw new Error("Codex SDK module does not export Codex");
   }
-  const { history, ...sdkOpts } = opts;
-  void history;
-  return sdk.runStreamed({
-    model,
-    cwd,
-    extraArgs,
-    threadId,
-    input,
-    ...sdkOpts,
-  });
+  return Codex;
 }
 
-function createThreadId() {
-  return `codex-thread-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
+function buildCodexOptions({ codexOptions = {} } = {}) {
+  return { ...codexOptions };
 }
 
-async function* defaultCodexTransportStreamFactory({
-  model,
-  cwd,
-  threadId = "",
+function buildThreadOptions({
+  model = "",
+  cwd = "",
+  threadOptions = {},
+} = {}) {
+  const options = { ...threadOptions };
+  if (model && options.model === undefined) {
+    options.model = model;
+  }
+  if (cwd && options.workingDirectory === undefined) {
+    options.workingDirectory = cwd;
+  }
+  if (options.skipGitRepoCheck === undefined) {
+    options.skipGitRepoCheck = true;
+  }
+  if (options.sandboxMode === undefined) {
+    options.sandboxMode = "workspace-write";
+  }
+  return options;
+}
+
+function buildTurnOptions(opts = {}) {
+  const {
+    history,
+    tools,
+    timeoutMs,
+    ...turnOptions
+  } = opts || {};
+  void history;
+  void tools;
+  void timeoutMs;
+  return turnOptions;
+}
+
+async function* defaultCodexStreamFactory({
+  thread,
   input,
   opts = {},
 }) {
-  const nextThreadId = String(threadId || "").trim() || createThreadId();
-  const result = await sendUpstreamPrompt({
-    projectRoot: cwd,
-    provider: "codex",
-    model,
-    prompt: String(input || ""),
-    messages: Array.isArray(opts.history) ? opts.history : [],
-    timeoutMs: Number.isFinite(Number(opts.timeoutMs)) ? Number(opts.timeoutMs) : 120000,
-  });
-  if (!result.ok) {
-    const err = new Error(result.error || "Codex upstream request failed");
-    err.code = result.errorCode || "CODEX_UPSTREAM_FAILED";
-    throw err;
-  }
-
-  yield { type: "thread.started", thread_id: nextThreadId };
-  yield {
-    type: "item.completed",
-    item: { type: "message", text: String(result.output || "") },
-  };
-  yield {
-    type: "turn.completed",
-    turn_id: `turn-${Date.now().toString(36)}`,
-    usage: result.usage || null,
-  };
+  if (!thread || typeof thread.runStreamed !== "function") {
+    throw new Error("Codex SDK thread requires runStreamed support");
+  }
+  const streamed = await thread.runStreamed(String(input || ""), buildTurnOptions(opts));
+  const events = streamed && streamed.events ? streamed.events : streamed;
+  if (!events || typeof events[Symbol.asyncIterator] !== "function") {
+    throw new Error("Codex SDK runStreamed did not return an async event stream");
+  }
+  for await (const event of events) {
+    yield event;
+  }
 }
 
 class CodexSdkThread {
@@ -84,26 +83,67 @@ class CodexSdkThread {
     extraArgs = [],
     streamFactory = defaultCodexStreamFactory,
     sdk,
+    codexClient,
+    sdkThread,
+    threadId = "",
     tools = [],
+    codexOptions = {},
+    threadOptions = {},
   } = {}) {
-    this.id = "";
+    this.id = String(threadId || "").trim();
     this.model = model;
     this.cwd = cwd;
     this.extraArgs = Array.isArray(extraArgs) ? extraArgs.slice() : [];
     this.streamFactory = streamFactory;
     this.sdk = sdk;
+    this.codexClient = codexClient || null;
+    this.sdkThread = sdkThread || null;
     this.tools = Array.isArray(tools) ? tools.slice() : [];
+    this.codexOptions = buildCodexOptions({ codexOptions });
+    this.threadOptions = { ...threadOptions };
     this.messages = [];
   }
 
+  async getCodexClient() {
+    if (this.codexClient) return this.codexClient;
+    if (!this.sdk) {
+      this.sdk = await resolveCodexSdk();
+    }
+    const Codex = resolveCodexConstructor(this.sdk);
+    this.codexClient = new Codex(this.codexOptions);
+    return this.codexClient;
+  }
+
+  async getSdkThread() {
+    if (this.sdkThread) return this.sdkThread;
+    const client = await this.getCodexClient();
+    const options = buildThreadOptions({
+      model: this.model,
+      cwd: this.cwd,
+      threadOptions: this.threadOptions,
+    });
+    this.sdkThread = this.id && typeof client.resumeThread === "function"
+      ? client.resumeThread(this.id, options)
+      : client.startThread(options);
+    if (this.sdkThread && this.sdkThread.id) {
+      this.id = this.sdkThread.id;
+    }
+    return this.sdkThread;
+  }
+
   async *runStreamed(input, opts = {}) {
     const mergedOpts = { ...opts };
     if (this.tools.length > 0 && !Array.isArray(mergedOpts.tools)) {
       mergedOpts.tools = this.tools.slice();
     }
     mergedOpts.history = this.messages.slice();
+    const sdkThread = this.streamFactory === defaultCodexStreamFactory
+      ? await this.getSdkThread()
+      : this.sdkThread;
     const stream = this.streamFactory({
       sdk: this.sdk,
+      thread: sdkThread,
+      codexClient: this.codexClient,
       model: this.model,
       cwd: this.cwd,
       extraArgs: this.extraArgs,
@@ -123,6 +163,9 @@ class CodexSdkThread {
       }
       yield redactUfooEvent(normalized);
     }
+    if (sdkThread && sdkThread.id) {
+      this.id = sdkThread.id;
+    }
     this.messages.push({ role: "user", content: String(input || "") });
     this.messages.push({ role: "assistant", content: outputText });
   }
@@ -139,14 +182,20 @@ class CodexThreadProvider {
     extraArgs = [],
     streamFactory = defaultCodexStreamFactory,
     sdk,
+    codexClient,
     tools = [],
+    codexOptions = {},
+    threadOptions = {},
   } = {}) {
     this.model = model;
     this.cwd = cwd;
     this.extraArgs = Array.isArray(extraArgs) ? extraArgs.slice() : [];
     this.streamFactory = streamFactory;
-    this.sdk = sdk || (streamFactory === defaultCodexStreamFactory ? resolveCodexSdk() : null);
+    this.sdk = sdk || null;
+    this.codexClient = codexClient || null;
     this.tools = Array.isArray(tools) ? tools.slice() : [];
+    this.codexOptions = buildCodexOptions({ codexOptions });
+    this.threadOptions = { ...threadOptions };
   }
 
   startThread() {
@@ -156,14 +205,26 @@ class CodexThreadProvider {
       extraArgs: this.extraArgs,
       streamFactory: this.streamFactory,
       sdk: this.sdk,
+      codexClient: this.codexClient,
       tools: this.tools,
+      codexOptions: this.codexOptions,
+      threadOptions: this.threadOptions,
     });
   }
 
   resumeThread(threadId = "") {
-    const thread = this.startThread();
-    thread.id = String(threadId || "").trim();
-    return thread;
+    return new CodexSdkThread({
+      model: this.model,
+      cwd: this.cwd,
+      extraArgs: this.extraArgs,
+      streamFactory: this.streamFactory,
+      sdk: this.sdk,
+      codexClient: this.codexClient,
+      threadId,
+      tools: this.tools,
+      codexOptions: this.codexOptions,
+      threadOptions: this.threadOptions,
+    });
   }
 }
 
@@ -175,7 +236,7 @@ module.exports = {
   CodexSdkThread,
   CodexThreadProvider,
   createCodexThreadProvider,
+  buildThreadOptions,
   defaultCodexStreamFactory,
-  defaultCodexTransportStreamFactory,
   resolveCodexSdk,
 };