u-foo 1.9.8 → 2.2.0

package/src/agent/cliRunner.js

@@ -1,24 +1,12 @@
 const { spawn } = require("child_process");
 const { randomUUID } = require("crypto");
-const { DEFAULT_ASSISTANT_TIMEOUT_MS } = require("../assistant/constants");
+
+const DEFAULT_CLI_TIMEOUT_MS = 600000;
 
 const ROUTER_JSON_SCHEMA = JSON.stringify({
   type: "object",
   properties: {
     reply: { type: "string" },
-    assistant_call: {
-      type: "object",
-      properties: {
-        kind: { type: "string", enum: ["explore", "bash", "mixed"] },
-        task: { type: "string" },
-        context: { type: "string" },
-        expect: { type: "string" },
-        provider: { type: "string" },
-        model: { type: "string" },
-        timeout_ms: { type: "integer" },
-      },
-      required: ["task"],
-    },
     dispatch: {
       type: "array",
       items: {
@@ -622,7 +610,7 @@ async function runCliAgent(params) {
       cwd: params.cwd,
       env,
       input: stdin,
-      timeoutMs: params.timeoutMs || DEFAULT_ASSISTANT_TIMEOUT_MS,
+      timeoutMs: params.timeoutMs || DEFAULT_CLI_TIMEOUT_MS,
       onStdout: codexParser ? (chunk) => codexParser.onChunk(chunk) : null,
       signal: params.signal,
     });
@@ -685,7 +673,7 @@ async function runCliAgent(params) {
           cwd: params.cwd,
           env,
           input: retryStdin,
-          timeoutMs: params.timeoutMs || DEFAULT_ASSISTANT_TIMEOUT_MS,
+          timeoutMs: params.timeoutMs || DEFAULT_CLI_TIMEOUT_MS,
           onStdout: retryParser ? (chunk) => retryParser.onChunk(chunk) : null,
           signal: params.signal,
         });

package/src/agent/codexEventTranslator.js

@@ -0,0 +1,78 @@
+function getTextFromItem(item) {
+  if (!item || typeof item !== "object") return "";
+  if (typeof item.text === "string") return item.text;
+  if (item.item && typeof item.item.text === "string") return item.item.text;
+  if (Array.isArray(item.content)) {
+    return item.content
+      .map((entry) => (entry && typeof entry.text === "string" ? entry.text : ""))
+      .join("");
+  }
+  return "";
+}
+
+function normalizeCodexEvent(event = {}) {
+  const type = String(event.type || "").trim();
+  if (!type) return null;
+
+  if (type === "thread.started") {
+    return { type: "thread_started", threadId: event.thread_id || event.threadId || "" };
+  }
+
+  if (type === "turn.started") {
+    return { type: "turn_started", turnId: event.turn_id || event.turnId || "" };
+  }
+
+  if (type === "turn.completed") {
+    return {
+      type: "turn_completed",
+      turnId: event.turn_id || event.turnId || "",
+      usage: event.usage || null,
+    };
+  }
+
+  if (type === "turn.failed") {
+    const error = event.error || {};
+    return {
+      type: "turn_failed",
+      turnId: event.turn_id || event.turnId || "",
+      error: typeof error.message === "string" ? error.message : String(error || "turn failed"),
+    };
+  }
+
+  if (type === "item.completed") {
+    const item = event.item || {};
+    const itemType = String(item.type || "").trim();
+    const text = getTextFromItem(item);
+
+    if (itemType === "message" || itemType === "assistant_message" || text) {
+      return {
+        type: "text_delta",
+        delta: text,
+        itemType,
+      };
+    }
+
+    if (itemType === "tool_call") {
+      return {
+        type: "tool_call",
+        name: item.name || "",
+        toolCallId: item.id || item.tool_call_id || "",
+        args: item.arguments || item.args || {},
+      };
+    }
+
+    if (itemType === "tool_result") {
+      return {
+        type: "tool_result",
+        toolCallId: item.tool_call_id || item.id || "",
+        output: item.output,
+      };
+    }
+  }
+
+  return null;
+}
+
+module.exports = {
+  normalizeCodexEvent,
+};

package/src/agent/codexThreadProvider.js

@@ -0,0 +1,181 @@
+const { normalizeCodexEvent } = require("./codexEventTranslator");
+const { redactUfooEvent } = require("../providerapi/redactor");
+const { sendUpstreamPrompt } = require("./upstreamTransport");
+
+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");
+  } catch (err) {
+    const error = new Error("Codex SDK seam enabled but @openai/codex-sdk is not installed");
+    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");
+  }
+  const { history, ...sdkOpts } = opts;
+  void history;
+  return sdk.runStreamed({
+    model,
+    cwd,
+    extraArgs,
+    threadId,
+    input,
+    ...sdkOpts,
+  });
+}
+
+function createThreadId() {
+  return `codex-thread-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
+}
+
+async function* defaultCodexTransportStreamFactory({
+  model,
+  cwd,
+  threadId = "",
+  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 = "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,
+  };
+}
+
+class CodexSdkThread {
+  constructor({
+    model = "",
+    cwd = "",
+    extraArgs = [],
+    streamFactory = defaultCodexStreamFactory,
+    sdk,
+    tools = [],
+  } = {}) {
+    this.id = "";
+    this.model = model;
+    this.cwd = cwd;
+    this.extraArgs = Array.isArray(extraArgs) ? extraArgs.slice() : [];
+    this.streamFactory = streamFactory;
+    this.sdk = sdk;
+    this.tools = Array.isArray(tools) ? tools.slice() : [];
+    this.messages = [];
+  }
+
+  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 stream = this.streamFactory({
+      sdk: this.sdk,
+      model: this.model,
+      cwd: this.cwd,
+      extraArgs: this.extraArgs,
+      threadId: this.id,
+      input,
+      opts: mergedOpts,
+    });
+    let outputText = "";
+    for await (const rawEvent of stream) {
+      const normalized = normalizeCodexEvent(rawEvent);
+      if (!normalized) continue;
+      if (normalized.type === "thread_started" && normalized.threadId) {
+        this.id = normalized.threadId;
+      }
+      if (normalized.type === "text_delta" && normalized.delta) {
+        outputText += normalized.delta;
+      }
+      yield redactUfooEvent(normalized);
+    }
+    this.messages.push({ role: "user", content: String(input || "") });
+    this.messages.push({ role: "assistant", content: outputText });
+  }
+
+  async close() {
+    return undefined;
+  }
+}
+
+class CodexThreadProvider {
+  constructor({
+    model = "",
+    cwd = "",
+    extraArgs = [],
+    streamFactory = defaultCodexStreamFactory,
+    sdk,
+    tools = [],
+  } = {}) {
+    this.model = model;
+    this.cwd = cwd;
+    this.extraArgs = Array.isArray(extraArgs) ? extraArgs.slice() : [];
+    this.streamFactory = streamFactory;
+    this.sdk = sdk || resolveCodexSdk();
+    this.tools = Array.isArray(tools) ? tools.slice() : [];
+  }
+
+  startThread() {
+    return new CodexSdkThread({
+      model: this.model,
+      cwd: this.cwd,
+      extraArgs: this.extraArgs,
+      streamFactory: this.streamFactory,
+      sdk: this.sdk,
+      tools: this.tools,
+    });
+  }
+
+  resumeThread(threadId = "") {
+    const thread = this.startThread();
+    thread.id = String(threadId || "").trim();
+    return thread;
+  }
+}
+
+function createCodexThreadProvider(options = {}) {
+  return new CodexThreadProvider(options);
+}
+
+module.exports = {
+  CodexSdkThread,
+  CodexThreadProvider,
+  createCodexThreadProvider,
+  defaultCodexStreamFactory,
+  defaultCodexTransportStreamFactory,
+  resolveCodexSdk,
+};

package/src/agent/controllerToolExecutor.js

@@ -0,0 +1,233 @@
+"use strict";
+
+const EventBus = require("../bus");
+const { dispatchMessageHandler } = require("../tools/handlers/dispatchMessage");
+const { ackBusHandler } = require("../tools/handlers/ackBus");
+
+function normalizeObjectArgs(value) {
+  if (!value) return {};
+  if (typeof value === "string") {
+    try {
+      const parsed = JSON.parse(value);
+      return parsed && typeof parsed === "object" ? parsed : {};
+    } catch {
+      return {};
+    }
+  }
+  return typeof value === "object" ? value : {};
+}
+
+function normalizePositiveInt(value, fallback) {
+  const num = Number.parseInt(value, 10);
+  if (Number.isFinite(num) && num > 0) return num;
+  return fallback;
+}
+
+function buildStructuredError(code, message, extra = {}) {
+  return {
+    code: String(code || "tool_error"),
+    message: String(message || "tool execution failed"),
+    ...extra,
+  };
+}
+
+function resolveDispatchTargets(ctx, target) {
+  if (typeof ctx.resolveDispatchTargets === "function") {
+    const resolved = ctx.resolveDispatchTargets(target);
+    if (Array.isArray(resolved) && resolved.length > 0) return resolved;
+  }
+
+  const eventBus = ctx.eventBus || new EventBus(ctx.projectRoot);
+  try {
+    if (typeof eventBus.ensureBus === "function") eventBus.ensureBus();
+    if (typeof eventBus.loadBusData === "function") eventBus.loadBusData();
+    const targets = eventBus.messageManager && typeof eventBus.messageManager.resolveTarget === "function"
+      ? eventBus.messageManager.resolveTarget(target)
+      : [];
+    if (Array.isArray(targets) && targets.length > 0) return targets;
+  } catch {
+    // fall through to conservative fallback
+  }
+
+  if (target.includes(":")) return [target];
+
+  throw buildStructuredError("invalid_target", `dispatch_message target not found: ${target}`);
+}
+
+async function handleDispatchMessage(ctx, args) {
+  const eventBus = typeof ctx.dispatchMessages === "function"
+    ? {
+      send: async (target, message, publisher, options = {}) => {
+        resolveDispatchTargets(ctx, target);
+        if (target !== "broadcast" && typeof ctx.markPending === "function") {
+          ctx.markPending(target);
+        }
+        await ctx.dispatchMessages(ctx.projectRoot, [{
+          target,
+          message,
+          injection_mode: options.injectionMode || "immediate",
+          source: options.source || publisher,
+        }]);
+        return { seq: 0, targets: [target] };
+      },
+      broadcast: async (message, publisher, options = {}) => {
+        await ctx.dispatchMessages(ctx.projectRoot, [{
+          target: "broadcast",
+          message,
+          injection_mode: options.injectionMode || "immediate",
+          source: options.source || publisher,
+        }]);
+        return { seq: 0, targets: ["broadcast"] };
+      },
+    }
+    : new EventBus(ctx.projectRoot);
+
+  const result = await dispatchMessageHandler({
+    projectRoot: ctx.projectRoot,
+    subscriber: ctx.subscriber,
+    eventBus,
+  }, args);
+
+  return {
+    dispatched: 1,
+    target: result.target,
+    injection_mode: result.mode,
+    source: result.source,
+  };
+}
+
+async function handleAckBus(ctx, args) {
+  const eventBus = typeof ctx.ackBus === "function"
+    ? {
+      ack: async (subscriber) => {
+        await ctx.ackBus(ctx.projectRoot, subscriber);
+        return 1;
+      },
+    }
+    : new EventBus(ctx.projectRoot);
+
+  const result = await ackBusHandler({
+    projectRoot: ctx.projectRoot,
+    subscriber: ctx.subscriber,
+    eventBus,
+  }, args);
+
+  return {
+    acknowledged: true,
+    subscriber: result.subscriber,
+  };
+}
+
+async function handleLaunchAgent(ctx, args) {
+  if (typeof ctx.handleOps !== "function") {
+    throw buildStructuredError("tool_unavailable", "launch_agent hook is unavailable");
+  }
+
+  const agent = String(args.agent || "").trim().toLowerCase();
+  if (!agent) {
+    throw buildStructuredError("invalid_arguments", "launch_agent requires agent");
+  }
+
+  const op = {
+    action: "launch",
+    agent,
+    count: normalizePositiveInt(args.count, 1),
+  };
+  if (args.nickname) op.nickname = String(args.nickname).trim();
+  if (args.prompt_profile) op.prompt_profile = String(args.prompt_profile).trim();
+  if (args.launch_scope) op.launch_scope = String(args.launch_scope).trim();
+  if (args.terminal_app) op.terminal_app = String(args.terminal_app).trim();
+
+  const opsResults = await ctx.handleOps(ctx.projectRoot, [op], ctx.processManager || null);
+  return {
+    operation: op,
+    ops_results: Array.isArray(opsResults) ? opsResults : [],
+  };
+}
+
+async function executeControllerTool(ctx, toolCall = {}) {
+  const observer = ctx.observer || { emit: () => {}, audit: () => {} };
+  const name = String(toolCall.name || "").trim();
+  const args = normalizeObjectArgs(toolCall.arguments);
+  const toolCallId = String(
+    toolCall.tool_call_id || toolCall.toolCallId || toolCall.id || `${Date.now().toString(36)}`
+  ).trim();
+  const turnId = String(toolCall.turn_id || toolCall.turnId || ctx.turnId || "").trim();
+
+  observer.emit("tool_call_started", {
+    tool_name: name,
+    tool_call_id: toolCallId,
+    turn_id: turnId,
+  });
+
+  try {
+    let result;
+    if (name === "dispatch_message") {
+      result = await handleDispatchMessage(ctx, args);
+    } else if (name === "ack_bus") {
+      result = await handleAckBus(ctx, args);
+    } else if (name === "launch_agent") {
+      result = await handleLaunchAgent(ctx, args);
+    } else {
+      throw buildStructuredError("unsupported_tool", `unsupported controller tool: ${name}`);
+    }
+
+    observer.emit("tool_call_finished", {
+      tool_name: name,
+      tool_call_id: toolCallId,
+      turn_id: turnId,
+      ok: true,
+    });
+    observer.audit({
+      source: "controller_loop",
+      kind: "tool_call",
+      tool_name: name,
+      tool_call_id: toolCallId,
+      turn_id: turnId,
+      ok: true,
+      result,
+    });
+
+    return {
+      ok: true,
+      name,
+      tool_call_id: toolCallId,
+      turn_id: turnId,
+      result,
+    };
+  } catch (err) {
+    const error = err && typeof err === "object" && err.code
+      ? err
+      : buildStructuredError("tool_execution_failed", err && err.message ? err.message : String(err || "tool failed"));
+
+    observer.emit("tool_call_finished", {
+      tool_name: name,
+      tool_call_id: toolCallId,
+      turn_id: turnId,
+      ok: false,
+      error_code: error.code,
+    });
+    observer.audit({
+      source: "controller_loop",
+      kind: "tool_call",
+      tool_name: name,
+      tool_call_id: toolCallId,
+      turn_id: turnId,
+      ok: false,
+      error,
+    });
+
+    return {
+      ok: false,
+      name,
+      tool_call_id: toolCallId,
+      turn_id: turnId,
+      error,
+    };
+  }
+}
+
+module.exports = {
+  buildStructuredError,
+  executeControllerTool,
+};