u-foo 2.3.10 → 2.3.11

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "u-foo",
-  "version": "2.3.10",
+  "version": "2.3.11",
   "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/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,
 };

package/src/agent/internalRunner.js

@@ -7,14 +7,8 @@ const { runCliAgent } = require("./cliRunner");
 const { normalizeCliOutput } = require("./normalizeOutput");
 const { createActivityStatePublisher } = require("./activityStatePublisher");
 const { loadConfig, normalizeCodexInternalThreadMode } = require("../config");
-const {
-  createCodexThreadProvider,
-  defaultCodexTransportStreamFactory,
-} = require("./codexThreadProvider");
-const {
-  createClaudeThreadProvider,
-  defaultClaudeTransportStreamFactory,
-} = require("./claudeThreadProvider");
+const { createCodexThreadProvider } = require("./codexThreadProvider");
+const { createClaudeThreadProvider } = require("./claudeThreadProvider");
 const { resolveClaudeUpstreamCredentials } = require("./credentials/claude");
 const { buildUpstreamAuthFromCredential } = require("./credentials");
 const { listToolsForCallerTier, CALLER_TIERS } = require("../tools");
@@ -131,6 +125,73 @@ function drainQueue(queueFile) {
   return content.split(/\r?\n/).filter(Boolean);
 }
 
+function parseAgentViewRawInput(message) {
+  if (typeof message !== "string" || !message.trim()) return null;
+  try {
+    const parsed = JSON.parse(message);
+    if (parsed && parsed.raw === true && typeof parsed.data === "string") {
+      return parsed.data;
+    }
+  } catch {
+    // Not a raw agent-view envelope.
+  }
+  return null;
+}
+
+function createInteractiveInputSession({ write = () => {} } = {}) {
+  let buffer = "";
+
+  function writePrompt() {
+    write("> ");
+  }
+
+  function handleRaw(data) {
+    const submissions = [];
+    const text = String(data || "");
+    for (const char of text) {
+      if (char === "\r" || char === "\n") {
+        const submitted = buffer.trim();
+        buffer = "";
+        write("\r\n");
+        if (submitted) submissions.push(submitted);
+        else writePrompt();
+        continue;
+      }
+
+      if (char === "\u0003") {
+        buffer = "";
+        write("^C\r\n");
+        writePrompt();
+        continue;
+      }
+
+      if (char === "\u007f" || char === "\b") {
+        if (buffer.length > 0) {
+          buffer = buffer.slice(0, -1);
+          write("\b \b");
+        }
+        continue;
+      }
+
+      if (char >= " " && char !== "\u007f") {
+        buffer += char;
+        write(char);
+      }
+    }
+    return submissions;
+  }
+
+  return {
+    handleRaw,
+    writePrompt,
+    writeResponsePrompt: () => {
+      write("\r\n");
+      writePrompt();
+    },
+    getBuffer: () => buffer,
+  };
+}
+
 async function handleEvent(
   projectRoot,
   agentType,
@@ -259,6 +320,9 @@ async function handleThreadedEvent({
     const plainReplyParts = [];
     for await (const event of threadRuntime.thread.runStreamed(prompt, {})) {
       if (!event || typeof event !== "object") continue;
+      if (typeof threadRuntime.syncProviderSessionId === "function") {
+        threadRuntime.syncProviderSessionId();
+      }
       if (event.type === "text_delta" && event.delta) {
         if (streamToPublisher) {
           emitStreamDelta(event.delta);
@@ -269,6 +333,9 @@ async function handleThreadedEvent({
         throw new Error(event.error || `thread turn failed for ${agentType}`);
       }
     }
+    if (typeof threadRuntime.syncProviderSessionId === "function") {
+      threadRuntime.syncProviderSessionId();
+    }
 
     if (streamToPublisher) {
       busSender.enqueue(
@@ -420,15 +487,47 @@ function buildClaudeAuthProvider(projectRoot) {
   };
 }
 
-function createThreadRuntime({ projectRoot, provider, model, extraArgs = [], subscriber = "" }) {
+function persistProviderSessionId(projectRoot, subscriber, providerSessionId) {
+  const id = String(providerSessionId || "").trim();
+  if (!projectRoot || !subscriber || !id) return false;
+  try {
+    const agentsFile = getUfooPaths(projectRoot).agentsFile;
+    const parsed = fs.existsSync(agentsFile)
+      ? JSON.parse(fs.readFileSync(agentsFile, "utf8"))
+      : {};
+    if (!parsed.agents || typeof parsed.agents !== "object") return false;
+    if (!parsed.agents[subscriber] || typeof parsed.agents[subscriber] !== "object") return false;
+    if (parsed.agents[subscriber].provider_session_id === id) return false;
+    parsed.agents[subscriber].provider_session_id = id;
+    parsed.agents[subscriber].provider_session_updated_at = new Date().toISOString();
+    fs.writeFileSync(agentsFile, `${JSON.stringify(parsed, null, 2)}\n`);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function createThreadRuntime({ projectRoot, provider, model, extraArgs = [], subscriber = "", providerSessionId = "" }) {
   const disabledRuntime = {
     enabled: false,
     thread: null,
     toolRuntime: { enabled: false, mode: "disabled", tools: [] },
     close: async () => {},
     rebuildThread: async () => {},
+    syncProviderSessionId: () => false,
   };
 
+  const initialProviderSessionId = String(providerSessionId || "").trim();
+  let savedProviderSessionId = initialProviderSessionId;
+
+  function rememberProviderSessionId(thread) {
+    const id = String(thread && thread.id ? thread.id : "").trim();
+    if (!id || id === savedProviderSessionId) return false;
+    const changed = persistProviderSessionId(projectRoot, subscriber, id);
+    if (changed) savedProviderSessionId = id;
+    return changed;
+  }
+
   if (provider === "codex-cli") {
     if (getCodexThreadMode(projectRoot) !== "api") {
       return disabledRuntime;
@@ -444,9 +543,10 @@ function createThreadRuntime({ projectRoot, provider, model, extraArgs = [], sub
         cwd: projectRoot,
         extraArgs,
         tools: toolRuntime.tools,
-        streamFactory: defaultCodexTransportStreamFactory,
       });
-      let thread = providerInstance.startThread();
+      let thread = initialProviderSessionId
+        ? providerInstance.resumeThread(initialProviderSessionId)
+        : providerInstance.startThread();
 
       return {
         enabled: true,
@@ -454,6 +554,9 @@ function createThreadRuntime({ projectRoot, provider, model, extraArgs = [], sub
         get thread() {
           return thread;
         },
+        syncProviderSessionId() {
+          return rememberProviderSessionId(thread);
+        },
         async rebuildThread() {
           if (thread && typeof thread.close === "function") {
             await thread.close();
@@ -463,9 +566,10 @@ function createThreadRuntime({ projectRoot, provider, model, extraArgs = [], sub
             cwd: projectRoot,
             extraArgs,
             tools: toolRuntime.tools,
-            streamFactory: defaultCodexTransportStreamFactory,
           });
-          thread = providerInstance.startThread();
+          thread = savedProviderSessionId
+            ? providerInstance.resumeThread(savedProviderSessionId)
+            : providerInstance.startThread();
         },
         async close() {
           if (thread && typeof thread.close === "function") {
@@ -482,33 +586,40 @@ function createThreadRuntime({ projectRoot, provider, model, extraArgs = [], sub
     if (getClaudeThreadMode() !== "api") {
       return disabledRuntime;
     }
-    if (typeof createClaudeThreadProvider !== "function" || typeof resolveClaudeUpstreamCredentials !== "function") {
+    if (typeof createClaudeThreadProvider !== "function") {
       return disabledRuntime;
     }
 
     try {
       let providerInstance = createClaudeThreadProvider({
         model,
-        authProvider: buildClaudeAuthProvider(projectRoot),
-        streamFactory: defaultClaudeTransportStreamFactory,
+        cwd: projectRoot,
+        extraArgs,
       });
-      let thread = providerInstance.startThread();
+      let thread = initialProviderSessionId
+        ? providerInstance.resumeThread(initialProviderSessionId)
+        : providerInstance.startThread();
 
       return {
         enabled: true,
         get thread() {
           return thread;
         },
+        syncProviderSessionId() {
+          return rememberProviderSessionId(thread);
+        },
         async rebuildThread() {
           if (thread && typeof thread.close === "function") {
             await thread.close();
           }
           providerInstance = createClaudeThreadProvider({
             model,
-            authProvider: buildClaudeAuthProvider(projectRoot),
-            streamFactory: defaultClaudeTransportStreamFactory,
+            cwd: projectRoot,
+            extraArgs,
           });
-          thread = providerInstance.startThread();
+          thread = savedProviderSessionId
+            ? providerInstance.resumeThread(savedProviderSessionId)
+            : providerInstance.startThread();
         },
         async close() {
           if (thread && typeof thread.close === "function") {
@@ -538,12 +649,14 @@ async function runInternalRunner({ projectRoot, agentType = "codex", extraArgs =
   const provider = normalizedAgentType === "codex" ? "codex-cli" : "claude-cli";
   const model = process.env.UFOO_AGENT_MODEL || "";
   const busSender = createBusSender(projectRoot, subscriber);
+  const interactiveSessions = new Map();
   const threadRuntime = createThreadRuntime({
     projectRoot,
     provider,
     model,
     extraArgs,
     subscriber,
+    providerSessionId: process.env.UFOO_PROVIDER_SESSION_ID || "",
   });
 
   // Session state management for CLI continuity
@@ -586,6 +699,18 @@ async function runInternalRunner({ projectRoot, agentType = "codex", extraArgs =
     activityPublisher.publish(state);
   }
 
+  function getInteractiveSession(publisher) {
+    const key = String(publisher || "unknown");
+    if (interactiveSessions.has(key)) return interactiveSessions.get(key);
+    const session = createInteractiveInputSession({
+      write: (delta) => {
+        busSender.enqueue(key, JSON.stringify({ stream: true, delta: String(delta || "") }));
+      },
+    });
+    interactiveSessions.set(key, session);
+    return session;
+  }
+
   setActivityState("ready");
 
   // 心跳更新函数
@@ -615,7 +740,6 @@ async function runInternalRunner({ projectRoot, agentType = "codex", extraArgs =
       try {
         const lines = drainQueue(queueFile);
         if (lines.length > 0) {
-          setActivityState("working");
           const events = [];
           for (const line of lines) {
             try {
@@ -625,7 +749,33 @@ async function runInternalRunner({ projectRoot, agentType = "codex", extraArgs =
             }
           }
 
+          const runnableEvents = [];
           for (const evt of events) {
+            const rawInput = parseAgentViewRawInput(evt && evt.data ? evt.data.message : "");
+            if (rawInput === null) {
+              runnableEvents.push(evt);
+              continue;
+            }
+
+            const session = getInteractiveSession(evt.publisher || "unknown");
+            const submissions = session.handleRaw(rawInput);
+            for (const message of submissions) {
+              runnableEvents.push({
+                ...evt,
+                __agentViewRaw: true,
+                data: {
+                  ...(evt.data || {}),
+                  message,
+                },
+              });
+            }
+          }
+
+          if (runnableEvents.length > 0) {
+            setActivityState("working");
+          }
+
+          for (const evt of runnableEvents) {
             // eslint-disable-next-line no-await-in-loop
             await handleEvent(
               projectRoot,
@@ -640,6 +790,9 @@ async function runInternalRunner({ projectRoot, agentType = "codex", extraArgs =
               extraArgs,
               threadRuntime
             );
+            if (evt.__agentViewRaw) {
+              getInteractiveSession(evt.publisher || "unknown").writeResponsePrompt();
+            }
           }
 
           // Persist CLI session state after processing (only if changed and for claude)
@@ -659,7 +812,10 @@ async function runInternalRunner({ projectRoot, agentType = "codex", extraArgs =
           // 处理消息后更新心跳
           updateHeartbeat();
           lastHeartbeat = now;
-          setActivityState("idle");
+          if (runnableEvents.length > 0) {
+            setActivityState("idle");
+          }
+          await busSender.flush();
         }
       } finally {
         processing = false;
@@ -684,4 +840,7 @@ module.exports = {
   getClaudeThreadMode,
   buildClaudeAuthProvider,
   shouldFallbackToLegacyThreadProvider,
+  parseAgentViewRawInput,
+  createInteractiveInputSession,
+  persistProviderSessionId,
 };

package/src/agent/ptyRunner.js

@@ -116,11 +116,6 @@ function computeInjectedSubmitDelayMs(agentType, text) {
   return delayMs;
 }
 
-function buildPrompt(text, marker) {
-  if (!marker) return text;
-  return `${text}\n\n请在完成后输出以下标记（单独一行）：\n${marker}\n`;
-}
-
 function resolveCommand(agentType, extraArgs = []) {
   const normalizedAgent = String(agentType || "").trim().toLowerCase();
   const extra = Array.isArray(extraArgs) ? extraArgs : [];
@@ -172,9 +167,11 @@ async function runPtyRunner({ projectRoot, agentType = "codex", extraArgs = [] }
     UFOO_INTERNAL_PTY: "1",
   };
 
+  const idleMs = Number.parseInt(process.env.UFOO_INTERNAL_PTY_IDLE_MS || "", 10) || 30000;
   const eventBus = new EventBus(projectRoot);
   const activityDetector = new ActivityDetector(agentType, {
     mode: "internal-pty",
+    quietWindowMs: idleMs,
   });
   const agentsFilePath = getUfooPaths(projectRoot).agentsFile;
 
@@ -184,15 +181,11 @@ async function runPtyRunner({ projectRoot, agentType = "codex", extraArgs = [] }
   let ptyReady = false;
   let readyTimer = null;
   let currentPublisher = "";
-  let currentMarker = "";
   let pendingOutput = [];
   let outputBuffer = "";
   let flushTimer = null;
   let idleTimer = null;
   let watchdogTimer = null;
-  let suppressEcho = false;
-  let echoMarker = "";
-  let suppressTimer = null;
   let ptyProcess = null;
   let restartCount = 0;
   let lastSpawnTime = 0;
@@ -205,14 +198,11 @@ async function runPtyRunner({ projectRoot, agentType = "codex", extraArgs = [] }
   const injectServer = setupInjectServer();
   initScreenBuffer(80, 24);
   const maxChunk = 2000;
-  const idleMs = 30000;
   const watchdogMs = 120000;
   const maxQueue = 200;
   let sendQueue = Promise.resolve();
   const streamPublisherCache = new Map();
   const DROP_LINE_PATTERNS = [
-    /__UFOO_DONE_/,
-    /请在完成后输出以下标记/,
     /context left/i,
     /esc to interrupt/i,
     /for shortcuts/i,
@@ -660,8 +650,7 @@ async function runPtyRunner({ projectRoot, agentType = "codex", extraArgs = [] }
       detail: snap.detail,
     });
     // Quiet-window detector may classify IDLE sooner than stream fallback timer.
-    // Release queue only when no explicit marker is being awaited.
-    if (newState === "idle" && busy && !currentMarker && !suppressEcho) {
+    if (newState === "idle" && busy) {
       if (idleTimer) {
         clearTimeout(idleTimer);
         idleTimer = null;
@@ -696,49 +685,6 @@ async function runPtyRunner({ projectRoot, agentType = "codex", extraArgs = [] }
       if (!clean) return;
       outputBuffer += clean;
       activityDetector.processOutput(clean);
-      if (suppressEcho) {
-        if (echoMarker && outputBuffer.includes(echoMarker)) {
-          const idx = outputBuffer.indexOf(echoMarker);
-          outputBuffer = outputBuffer.slice(idx + echoMarker.length);
-          outputBuffer = outputBuffer.replace(/^\n+/, "");
-          suppressEcho = false;
-          currentMarker = echoMarker;
-          echoMarker = "";
-          if (suppressTimer) {
-            clearTimeout(suppressTimer);
-            suppressTimer = null;
-          }
-        } else {
-          return;
-        }
-      }
-      if (currentMarker) {
-        const idx = outputBuffer.indexOf(currentMarker);
-        if (idx !== -1) {
-          const before = outputBuffer.slice(0, idx);
-          outputBuffer = "";
-          if (before) {
-            deliverChunk(before);
-          }
-          if (currentPublisher) {
-            completePublisherResponse("marker");
-          }
-          currentMarker = "";
-          busy = false;
-          activityDetector.markIdle();
-          currentPublisher = "";
-          if (watchdogTimer) {
-            clearTimeout(watchdogTimer);
-            watchdogTimer = null;
-          }
-          if (idleTimer) {
-            clearTimeout(idleTimer);
-            idleTimer = null;
-          }
-          processQueue();
-          return;
-        }
-      }
       scheduleFlush();
       // Ready detection: during TUI startup, reset the quiet timer on each output.
       // Once output stops for READY_QUIET_MS, the TUI is considered initialized.
@@ -805,7 +751,6 @@ async function runPtyRunner({ projectRoot, agentType = "codex", extraArgs = [] }
       busy = false;
       activityDetector.markIdle();
       currentPublisher = "";
-      currentMarker = "";
 
       // If stop() was called, let the runner exit
       if (!running) return;
@@ -940,11 +885,6 @@ async function runPtyRunner({ projectRoot, agentType = "codex", extraArgs = [] }
     busy = true;
     activityDetector.markWorking();
     currentPublisher = next.publisher;
-    currentMarker = next.marker || "";
-    if (suppressTimer) {
-      clearTimeout(suppressTimer);
-      suppressTimer = null;
-    }
     flushPending();
     if (next.text) {
       if (next.raw) {
@@ -952,30 +892,16 @@ async function runPtyRunner({ projectRoot, agentType = "codex", extraArgs = [] }
       } else {
         // Write text first, then send Enter separately.
         // Codex Ink TUI requires text and submit key as separate writes.
-        // IMPORTANT: Defer marker detection until after Enter is sent,
-        // because the prompt echo (TextInput display) contains the marker text.
-        const prompt = buildPrompt(next.text, currentMarker);
-        const savedMarker = currentMarker;
-        suppressEcho = true;
-        echoMarker = savedMarker;
-        currentMarker = ""; // Disable marker detection during prompt echo & formatted display
-        ptyProcess.write(prompt);
+        ptyProcess.write(next.text);
         setTimeout(() => {
           if (ptyProcess && ptyAlive) {
+            // Drop the local TUI input echo from any forwarded stream output.
             outputBuffer = "";
             const isClaude = agentType === "claude-code";
             if (isClaude) {
               // Claude Code: send CR directly without ESC.
               // ESC before CR is interpreted as Alt+Enter (newline).
               ptyProcess.write("\r");
-              suppressTimer = setTimeout(() => {
-                suppressTimer = null;
-                if (!suppressEcho) return;
-                suppressEcho = false;
-                echoMarker = "";
-                currentMarker = savedMarker;
-                outputBuffer = "";
-              }, 1500);
             } else {
               // Codex/others: ESC dismisses autocomplete, then CR submits.
               ptyProcess.write("\x1b");
@@ -983,14 +909,6 @@ async function runPtyRunner({ projectRoot, agentType = "codex", extraArgs = [] }
                 if (ptyProcess && ptyAlive) {
                   ptyProcess.write("\r");
                 }
-                suppressTimer = setTimeout(() => {
-                  suppressTimer = null;
-                  if (!suppressEcho) return;
-                  suppressEcho = false;
-                  echoMarker = "";
-                  currentMarker = savedMarker;
-                  outputBuffer = "";
-                }, 1500);
               }, 100);
             }
           }
@@ -1001,13 +919,12 @@ async function runPtyRunner({ projectRoot, agentType = "codex", extraArgs = [] }
     watchdogTimer = setTimeout(() => {
       watchdogTimer = null;
       if (!busy) return;
-      const timeoutNote = `[internal-pty] marker timeout; restarting PTY`;
+      const timeoutNote = `[internal-pty] task timeout; restarting PTY`;
       if (currentPublisher) {
         completePublisherResponse("timeout", timeoutNote);
       }
       logNote(timeoutNote);
-      restartPty("marker timeout");
-      currentMarker = "";
+      restartPty("task timeout");
       busy = false;
       activityDetector.markIdle();
       currentPublisher = "";
@@ -1058,11 +975,10 @@ async function runPtyRunner({ projectRoot, agentType = "codex", extraArgs = [] }
         if (messageQueue.length >= maxQueue) {
           messageQueue.shift();
         }
-        const marker = raw ? "" : `__UFOO_DONE_${Date.now()}_${Math.random().toString(16).slice(2)}__`;
         const publisher = typeof evt.publisher === "object" && evt.publisher
           ? (evt.publisher.subscriber || evt.publisher.nickname || "unknown")
           : (evt.publisher || "unknown");
-        messageQueue.push({ publisher, raw, text, marker });
+        messageQueue.push({ publisher, raw, text });
       }
     }
     processQueue();

package/src/chat/agentViewController.js

@@ -126,7 +126,10 @@ function createAgentViewController(options = {}) {
 
     agentInputSuppressUntil = now() + 300;
     agentViewUsesBus = Boolean(options.useBus);
-    if (!agentViewUsesBus) {
+    if (agentViewUsesBus) {
+      const label = getAgentLabel(agentId);
+      processStdout.write(`ufoo internal · ${label}\r\n\r\n> `);
+    } else {
       const sockPath = getInjectSockPath(agentId);
       connectAgentOutput(sockPath);
       connectAgentInput(sockPath);

package/src/chat/dashboardKeyController.js

@@ -57,6 +57,11 @@ function createDashboardKeyController(options = {}) {
     return Boolean(caps && caps.supportsSocketProtocol);
   }
 
+  function supportsInternalQueue(agentId) {
+    const caps = getAgentCapabilities(agentId);
+    return Boolean(caps && caps.supportsInternalQueueLoop);
+  }
+
   function withAgentInputFocus() {
     state.focusMode = "input";
     state.agentOutputSuppressed = false;
@@ -73,7 +78,7 @@ function createDashboardKeyController(options = {}) {
 
   function switchAgentView(agentId) {
     withAgentInputFocus();
-    enterAgentView(agentId);
+    enterAgentView(agentId, { useBus: supportsInternalQueue(agentId) && !supportsSocket(agentId) });
   }
 
   function exitAgentDashboardToInput() {
@@ -154,7 +159,7 @@ function createDashboardKeyController(options = {}) {
           } else {
             withAgentInputFocus();
             state.selectedAgentIndex = nextIndex + 1;
-            enterAgentView(nextAgent);
+            enterAgentView(nextAgent, { useBus: supportsInternalQueue(nextAgent) && !supportsSocket(nextAgent) });
           }
         } else {
           exitAgentView();
@@ -511,6 +516,16 @@ function createDashboardKeyController(options = {}) {
           enterAgentView(agentId);
           return true;
         }
+
+        if (supportsInternalQueue(agentId)) {
+          clearTargetAgent();
+          state.focusMode = "input";
+          state.dashboardView = "agents";
+          state.selectedAgentIndex = -1;
+          setScreenGrabKeys(false);
+          enterAgentView(agentId, { useBus: true });
+          return true;
+        }
       }
 
       exitDashboardMode(false);