u-foo 1.9.7 → 2.1.0

package/bin/ufoo.js

@@ -29,13 +29,15 @@ async function main() {
   }
   if (cmd === "agent-runner") {
     const agentType = argv[1] || "codex";
-    await runInternalRunner({ projectRoot: process.cwd(), agentType });
+    const extraArgs = argv.slice(2);
+    await runInternalRunner({ projectRoot: process.cwd(), agentType, extraArgs });
     return;
   }
   if (cmd === "agent-pty-runner") {
     const agentType = argv[1] || "codex";
+    const extraArgs = argv.slice(2);
     try {
-      await runPtyRunner({ projectRoot: process.cwd(), agentType });
+      await runPtyRunner({ projectRoot: process.cwd(), agentType, extraArgs });
     } catch (err) {
       const normalized = String(agentType || "").trim().toLowerCase();
       if (normalized === "ufoo" || normalized === "ucode" || normalized === "ufoo-code") {
@@ -44,7 +46,7 @@ async function main() {
       // Fallback to headless runner if PTY is unavailable
       // eslint-disable-next-line no-console
       console.error(`[pty-runner] ${err.message || err}. Falling back to headless internal runner.`);
-      await runInternalRunner({ projectRoot: process.cwd(), agentType });
+      await runInternalRunner({ projectRoot: process.cwd(), agentType, extraArgs });
     }
     return;
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "u-foo",
-  "version": "1.9.7",
+  "version": "2.1.0",
   "description": "Multi-Agent Workspace Protocol. Just add u. claude → uclaude, codex → ucodex.",
   "license": "SEE LICENSE IN LICENSE",
   "homepage": "https://ufoo.dev",
@@ -20,9 +20,7 @@
     "uclaude": "bin/uclaude.js",
     "ucodex": "bin/ucodex.js",
     "ucode": "bin/ucode.js",
-    "ucode-core": "bin/ucode-core.js",
-    "ufoo-assistant-agent": "bin/ufoo-assistant-agent.js",
-    "ufoo-engine": "bin/ufoo-engine.js"
+    "ucode-core": "bin/ucode-core.js"
   },
   "files": [
     "bin/",

package/src/agent/claudeEventTranslator.js

@@ -0,0 +1,267 @@
+"use strict";
+
+function toObject(value) {
+  return value && typeof value === "object" ? value : {};
+}
+
+function toArray(value) {
+  return Array.isArray(value) ? value : [];
+}
+
+function safeStringify(value) {
+  if (typeof value === "string") return value;
+  if (value === undefined) return "";
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return "";
+  }
+}
+
+function parseJsonArgs(raw = "") {
+  const text = String(raw || "").trim();
+  if (!text) return {};
+  try {
+    const parsed = JSON.parse(text);
+    return parsed && typeof parsed === "object" ? parsed : {};
+  } catch {
+    return { __raw: text };
+  }
+}
+
+function toNonNegativeInt(value) {
+  const num = Number(value);
+  if (!Number.isFinite(num) || num < 0) return 0;
+  return Math.floor(num);
+}
+
+function normalizeClaudeUsage(usage = null) {
+  if (!usage || typeof usage !== "object") return null;
+  const item = toObject(usage);
+  return {
+    ...item,
+    input_tokens: toNonNegativeInt(item.input_tokens),
+    output_tokens: toNonNegativeInt(item.output_tokens),
+    cache_creation_tokens: toNonNegativeInt(
+      item.cache_creation_tokens
+        || item.cache_creation_input_tokens
+        || (item.cache_creation && item.cache_creation.input_tokens)
+    ),
+    cache_read_tokens: toNonNegativeInt(
+      item.cache_read_tokens
+        || item.cache_read_input_tokens
+        || (item.cache_read && item.cache_read.input_tokens)
+    ),
+  };
+}
+
+function createClaudeEventState(seed = {}) {
+  return {
+    turnId: String(seed.turnId || ""),
+    threadId: String(seed.threadId || ""),
+    usage: null,
+    stopReason: "",
+    contentBlocks: new Map(),
+    assistantBlocks: [],
+  };
+}
+
+function normalizeClaudeContentBlock(block = {}) {
+  const item = toObject(block);
+  const type = String(item.type || "").trim();
+  if (!type) return [];
+
+  if (type === "text") {
+    return [{
+      type: "text_delta",
+      delta: String(item.text || ""),
+      itemType: "text",
+    }];
+  }
+
+  if (type === "tool_use") {
+    return [{
+      type: "tool_call",
+      toolCallId: String(item.id || item.tool_use_id || ""),
+      name: String(item.name || ""),
+      args: toObject(item.input),
+    }];
+  }
+
+  if (type === "tool_result") {
+    return [{
+      type: "tool_result",
+      toolCallId: String(item.tool_use_id || item.id || ""),
+      output: Object.prototype.hasOwnProperty.call(item, "content") ? item.content : item.output,
+      is_error: item.is_error === true,
+    }];
+  }
+
+  return [];
+}
+
+function normalizeClaudeMessage(message = {}) {
+  const item = toObject(message);
+  const turnId = String(item.id || item.turn_id || "");
+  const usage = normalizeClaudeUsage(item.usage || null);
+  const events = [];
+  if (turnId) {
+    events.push({ type: "turn_started", turnId });
+  }
+  for (const block of toArray(item.content)) {
+    events.push(...normalizeClaudeContentBlock(block));
+  }
+  if (usage) {
+    events.push({ type: "usage", turnId, usage });
+  }
+  events.push({
+    type: "turn_completed",
+    turnId,
+    usage,
+    stopReason: String(item.stop_reason || ""),
+  });
+  return events;
+}
+
+function appendAssistantBlock(state, block) {
+  if (!block || typeof block !== "object") return;
+  state.assistantBlocks.push(block);
+}
+
+function getContentBlockState(state, index) {
+  const key = Number.isFinite(Number(index)) ? Number(index) : -1;
+  if (!state.contentBlocks.has(key)) {
+    state.contentBlocks.set(key, {
+      type: "",
+      text: "",
+      toolCallId: "",
+      name: "",
+      jsonText: "",
+    });
+  }
+  return state.contentBlocks.get(key);
+}
+
+function normalizeClaudeEvent(event = {}, state = createClaudeEventState()) {
+  const item = toObject(event);
+  const type = String(item.type || "").trim();
+  if (!type) return [];
+
+  if (type === "message_start") {
+    const message = toObject(item.message);
+    state.turnId = String(message.id || state.turnId || "");
+    state.usage = normalizeClaudeUsage(message.usage || state.usage || null);
+    return [{
+      type: "turn_started",
+      turnId: state.turnId,
+    }];
+  }
+
+  if (type === "content_block_start") {
+    const block = toObject(item.content_block);
+    const blockState = getContentBlockState(state, item.index);
+    blockState.type = String(block.type || "").trim();
+    if (blockState.type === "text") {
+      blockState.text = String(block.text || "");
+      if (blockState.text) {
+        appendAssistantBlock(state, { type: "text", text: blockState.text });
+      }
+    }
+    if (blockState.type === "tool_use") {
+      blockState.toolCallId = String(block.id || block.tool_use_id || "");
+      blockState.name = String(block.name || "");
+      blockState.jsonText = safeStringify(block.input || "");
+    }
+    return [];
+  }
+
+  if (type === "content_block_delta") {
+    const delta = toObject(item.delta);
+    const deltaType = String(delta.type || "").trim();
+    const blockState = getContentBlockState(state, item.index);
+    if (deltaType === "text_delta") {
+      const text = String(delta.text || "");
+      if (!text) return [];
+      blockState.text += text;
+      if (state.assistantBlocks.length > 0) {
+        const last = state.assistantBlocks[state.assistantBlocks.length - 1];
+        if (last && last.type === "text") {
+          last.text = `${String(last.text || "")}${text}`;
+        } else {
+          appendAssistantBlock(state, { type: "text", text });
+        }
+      } else {
+        appendAssistantBlock(state, { type: "text", text });
+      }
+      return [{
+        type: "text_delta",
+        delta: text,
+        itemType: "text",
+      }];
+    }
+    if (deltaType === "input_json_delta") {
+      blockState.jsonText += String(delta.partial_json || "");
+    }
+    return [];
+  }
+
+  if (type === "content_block_stop") {
+    const blockState = getContentBlockState(state, item.index);
+    state.contentBlocks.delete(Number.isFinite(Number(item.index)) ? Number(item.index) : -1);
+    if (blockState.type !== "tool_use") return [];
+    const args = parseJsonArgs(blockState.jsonText);
+    const assistantBlock = {
+      type: "tool_use",
+      id: blockState.toolCallId,
+      name: blockState.name,
+      input: args,
+    };
+    appendAssistantBlock(state, assistantBlock);
+    return [{
+      type: "tool_call",
+      toolCallId: blockState.toolCallId,
+      name: blockState.name,
+      args,
+    }];
+  }
+
+  if (type === "message_delta") {
+    const usage = normalizeClaudeUsage(item.usage || null);
+    if (usage) state.usage = usage;
+    const delta = toObject(item.delta);
+    if (delta.stop_reason) state.stopReason = String(delta.stop_reason || "");
+    return usage ? [{
+      type: "usage",
+      turnId: state.turnId,
+      usage,
+    }] : [];
+  }
+
+  if (type === "message_stop") {
+    return [{
+      type: "turn_completed",
+      turnId: state.turnId,
+      usage: state.usage,
+      stopReason: state.stopReason,
+    }];
+  }
+
+  if (type === "error") {
+    const error = toObject(item.error);
+    return [{
+      type: "turn_failed",
+      turnId: state.turnId,
+      error: String(error.message || item.message || "claude stream failed"),
+    }];
+  }
+
+  return [];
+}
+
+module.exports = {
+  createClaudeEventState,
+  normalizeClaudeContentBlock,
+  normalizeClaudeEvent,
+  normalizeClaudeMessage,
+  normalizeClaudeUsage,
+};

package/src/agent/claudeOauthTokenReader.js

@@ -0,0 +1,52 @@
+"use strict";
+
+const {
+  ClaudeUpstreamCredentialResolver,
+  DEFAULT_REFRESH_WINDOW_MS,
+  resolveClaudeOauthPaths,
+  parseClaudeOauthFile,
+  serializeClaudeOauthToken,
+  classifyTokenState,
+  withLockFile,
+  atomicWriteJson,
+} = require("./credentials/claude");
+const { toLegacyResolvedAuth } = require("./credentials");
+
+class ClaudeOauthTokenReader {
+  constructor(options = {}) {
+    this.resolver = new ClaudeUpstreamCredentialResolver(options);
+  }
+
+  resolvePaths() {
+    return this.resolver.resolvePaths();
+  }
+
+  readTokenFile() {
+    return this.resolver.readTokenFile();
+  }
+
+  buildResolvedAuth(tokenRecord) {
+    return toLegacyResolvedAuth(this.resolver.buildResolvedCredential(tokenRecord));
+  }
+
+  async refreshIfNeeded(initialRecord) {
+    const descriptor = await this.resolver.refreshIfNeeded(initialRecord);
+    return toLegacyResolvedAuth(descriptor);
+  }
+
+  async resolveAuth() {
+    const descriptor = await this.resolver.resolveCredentials();
+    return toLegacyResolvedAuth(descriptor);
+  }
+}
+
+module.exports = {
+  ClaudeOauthTokenReader,
+  DEFAULT_REFRESH_WINDOW_MS,
+  resolveClaudeOauthPaths,
+  parseClaudeOauthFile,
+  serializeClaudeOauthToken,
+  classifyTokenState,
+  withLockFile,
+  atomicWriteJson,
+};

package/src/agent/claudeThreadProvider.js

@@ -0,0 +1,343 @@
+"use strict";
+
+const {
+  createClaudeEventState,
+  normalizeClaudeEvent,
+} = require("./claudeEventTranslator");
+const { redactUfooEvent } = require("../providerapi/redactor");
+const { sendUpstreamRequest } = require("./upstreamTransport");
+
+const CACHE_CONTROL = Object.freeze({ type: "ephemeral" });
+
+function createThreadId() {
+  return `claude-thread-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
+}
+
+function resolveAnthropicSdk() {
+  try {
+    // Optional dependency during Phase 1b seam work.
+    // eslint-disable-next-line global-require, import/no-extraneous-dependencies
+    return require("@anthropic-ai/sdk");
+  } catch (err) {
+    const error = new Error("Claude API seam enabled but @anthropic-ai/sdk is not installed");
+    error.code = "ANTHROPIC_SDK_UNAVAILABLE";
+    error.cause = err;
+    throw error;
+  }
+}
+
+async function defaultClaudeAuthProvider() {
+  const apiKey = String(process.env.ANTHROPIC_API_KEY || "").trim();
+  if (!apiKey) {
+    const error = new Error("Claude API seam requires an authProvider or ANTHROPIC_API_KEY");
+    error.code = "CLAUDE_AUTH_UNAVAILABLE";
+    throw error;
+  }
+  return { apiKey };
+}
+
+function defaultClaudeClientFactory({ sdk, auth = {} }) {
+  if (auth.client) return auth.client;
+  const Anthropic = sdk && (sdk.Anthropic || sdk.default || sdk);
+  if (!Anthropic) {
+    throw new Error("Anthropic SDK seam missing Anthropic client constructor");
+  }
+  const options = {};
+  if (auth.apiKey) options.apiKey = auth.apiKey;
+  if (auth.baseUrl) options.baseURL = auth.baseUrl;
+  if (auth.headers && typeof auth.headers === "object") {
+    options.defaultHeaders = { ...auth.headers };
+  }
+  return new Anthropic(options);
+}
+
+function defaultClaudeStreamFactory({ client, request }) {
+  if (!client || !client.messages || typeof client.messages.create !== "function") {
+    throw new Error("Claude API seam requires client.messages.create");
+  }
+  return client.messages.create({
+    ...request,
+    stream: true,
+  });
+}
+
+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,
+  });
+  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 = {}) {
+  const item = tool && typeof tool === "object" ? tool : {};
+  return {
+    name: String(item.name || "").trim(),
+    description: String(item.description || "").trim(),
+    input_schema: item.input_schema || item.inputSchema || { type: "object", properties: {} },
+  };
+}
+
+function normalizeMessageInput(input) {
+  if (typeof input === "string") {
+    return {
+      role: "user",
+      content: [{ type: "text", text: input }],
+    };
+  }
+  if (Array.isArray(input)) {
+    return {
+      role: "user",
+      content: input,
+    };
+  }
+  if (input && typeof input === "object" && input.role && input.content) {
+    return {
+      role: String(input.role),
+      content: Array.isArray(input.content) ? input.content : [input.content],
+    };
+  }
+  return {
+    role: "user",
+    content: [{ type: "text", text: String(input || "") }],
+  };
+}
+
+function normalizeContentBlocks(content) {
+  if (Array.isArray(content)) return content.filter((item) => item && typeof item === "object");
+  if (content && typeof content === "object") return [content];
+  return [{ type: "text", text: String(content || "") }];
+}
+
+function withCacheControlOnLastBlock(content) {
+  const blocks = normalizeContentBlocks(content).map((block) => ({ ...block }));
+  if (blocks.length === 0) return blocks;
+  const lastIndex = blocks.length - 1;
+  blocks[lastIndex] = {
+    ...blocks[lastIndex],
+    cache_control: { ...CACHE_CONTROL },
+  };
+  return blocks;
+}
+
+function buildClaudeSystemBlocks(opts = {}) {
+  const blocks = [];
+  const staticText = String(opts.staticText || opts.systemPrompt || opts.system || "").trim();
+  const semistaticText = String(opts.semistaticText || opts.sessionPrompt || "").trim();
+  const dynamicText = String(opts.dynamicText || "").trim();
+
+  if (staticText) {
+    blocks.push({
+      type: "text",
+      text: staticText,
+      cache_control: { ...CACHE_CONTROL },
+    });
+  }
+  if (semistaticText) {
+    blocks.push({
+      type: "text",
+      text: semistaticText,
+      cache_control: { ...CACHE_CONTROL },
+    });
+  }
+  if (dynamicText) {
+    blocks.push({
+      type: "text",
+      text: dynamicText,
+    });
+  }
+
+  return blocks;
+}
+
+function buildClaudeRequestMessages(history = [], userMessage) {
+  const prior = Array.isArray(history) ? history : [];
+  const messages = prior.map((message) => ({
+    role: String(message && message.role ? message.role : "user"),
+    content: withCacheControlOnLastBlock(message && message.content ? message.content : []),
+  }));
+  messages.push(userMessage);
+  return messages;
+}
+
+function buildClaudeRequest({
+  model,
+  maxTokens,
+  messages = [],
+  userMessage,
+  tools = [],
+  promptCache = {},
+}) {
+  const request = {
+    model,
+    max_tokens: maxTokens,
+    messages: buildClaudeRequestMessages(messages, userMessage),
+  };
+  const system = buildClaudeSystemBlocks(promptCache);
+  if (system.length > 0) request.system = system;
+  if (tools.length > 0) request.tools = tools;
+  return request;
+}
+
+function createAssistantMessageFromState(state) {
+  return {
+    role: "assistant",
+    content: Array.isArray(state.assistantBlocks) ? state.assistantBlocks.slice() : [],
+  };
+}
+
+function shouldRetryClaudeStream(err, attempt) {
+  if (attempt >= 1) return false;
+  const code = String((err && err.code) || "").trim().toUpperCase();
+  if (code === "ABORT_ERR" || code === "ECONNRESET" || code === "ETIMEDOUT") return true;
+  const message = String((err && err.message) || "").toLowerCase();
+  return message.includes("stream") || message.includes("network") || message.includes("disconnect");
+}
+
+class ClaudeApiThread {
+  constructor({
+    model = "",
+    authProvider = defaultClaudeAuthProvider,
+    clientFactory = defaultClaudeClientFactory,
+    streamFactory = defaultClaudeStreamFactory,
+    sdk,
+    maxTokens = 4096,
+  } = {}) {
+    this.id = "";
+    this.model = model;
+    this.authProvider = authProvider;
+    this.clientFactory = clientFactory;
+    this.streamFactory = streamFactory;
+    this.sdk = sdk;
+    this.maxTokens = maxTokens;
+    this.messages = [];
+  }
+
+  async *runStreamed(input, opts = {}) {
+    if (!this.id) this.id = createThreadId();
+    const userMessage = normalizeMessageInput(input);
+    const requestMessages = this.messages.slice();
+    const tools = Array.isArray(opts.tools) ? opts.tools.map(normalizeToolDefinition).filter((tool) => tool.name) : [];
+    const request = buildClaudeRequest({
+      model: this.model,
+      maxTokens: Number.isFinite(Number(opts.maxTokens)) ? Number(opts.maxTokens) : this.maxTokens,
+      messages: requestMessages,
+      userMessage,
+      tools,
+      promptCache: opts.promptCache || {},
+    });
+
+    yield redactUfooEvent({ type: "thread_started", threadId: this.id });
+
+    const auth = await this.authProvider({ threadId: this.id, model: this.model });
+    const client = this.clientFactory({
+      sdk: this.sdk || resolveAnthropicSdk(),
+      auth,
+      model: this.model,
+    });
+
+    let lastError = null;
+    for (let attempt = 0; attempt < 2; attempt += 1) {
+      const state = createClaudeEventState({ threadId: this.id });
+      try {
+        const stream = await this.streamFactory({
+          client,
+          request,
+          auth,
+          attempt,
+        });
+        for await (const rawEvent of stream) {
+          const events = normalizeClaudeEvent(rawEvent, state);
+          for (const event of events) {
+            if (event && typeof event === "object") {
+              yield redactUfooEvent(event);
+            }
+          }
+        }
+        this.messages = requestMessages.concat([userMessage, createAssistantMessageFromState(state)]);
+        return;
+      } catch (err) {
+        lastError = err;
+        if (!shouldRetryClaudeStream(err, attempt)) {
+          throw err;
+        }
+        // TODO(phase-1b-iii): if retry-after-partial-stream appears in practice,
+        // add replay/dedupe before claude runner cutover. This slice retries only once.
+      }
+    }
+
+    throw lastError || new Error("Claude stream failed");
+  }
+
+  async close() {
+    return undefined;
+  }
+}
+
+class ClaudeThreadProvider {
+  constructor(options = {}) {
+    this.options = { ...options };
+  }
+
+  startThread() {
+    return new ClaudeApiThread(this.options);
+  }
+
+  resumeThread(threadId = "") {
+    const thread = this.startThread();
+    thread.id = String(threadId || "").trim();
+    return thread;
+  }
+}
+
+function createClaudeThreadProvider(options = {}) {
+  return new ClaudeThreadProvider(options);
+}
+
+module.exports = {
+  buildClaudeRequest,
+  buildClaudeRequestMessages,
+  buildClaudeSystemBlocks,
+  ClaudeApiThread,
+  ClaudeThreadProvider,
+  createClaudeThreadProvider,
+  defaultClaudeAuthProvider,
+  defaultClaudeClientFactory,
+  defaultClaudeStreamFactory,
+  defaultClaudeTransportStreamFactory,
+  normalizeMessageInput,
+  normalizeToolDefinition,
+  resolveAnthropicSdk,
+  withCacheControlOnLastBlock,
+};