mumucc 0.4.4 → 0.4.10

package/src/services/api/officialClaudeBridge.ts

@@ -0,0 +1,480 @@
+import { randomUUID } from 'crypto'
+import { existsSync } from 'fs'
+import { unlink, writeFile } from 'fs/promises'
+import { homedir } from 'os'
+import { join } from 'path'
+
+import { execa } from 'execa'
+import { getSessionId } from 'src/bootstrap/state.js'
+import type { Message } from 'src/types/message.js'
+import { has1mContext } from 'src/utils/context.js'
+import { getCwd } from 'src/utils/cwd.js'
+import { logForDebugging } from 'src/utils/debug.js'
+import { safeParseJSON } from 'src/utils/json.js'
+import {
+  createAssistantMessage,
+  extractTextContent,
+  getContentText,
+} from 'src/utils/messages.js'
+import { getCanonicalName, type ModelName } from 'src/utils/model/model.js'
+import {
+  isExternalPermissionMode,
+  toExternalPermissionMode,
+  type PermissionMode,
+} from 'src/utils/permissions/PermissionMode.js'
+import { generateTempFilePath } from 'src/utils/tempfile.js'
+
+const MAX_MAIN_THREAD_CONTEXT_MESSAGES = 24
+const MAX_MAIN_THREAD_CONTEXT_CHARS = 64_000
+const MAX_AGENT_CONTEXT_MESSAGES = 12
+const MAX_AGENT_CONTEXT_CHARS = 24_000
+
+type BridgeStreamEvent = {
+  type?: string
+  subtype?: string
+  result?: string
+  is_error?: boolean
+  error?: unknown
+  session_id?: string
+  message?: {
+    role?: string
+    content?: readonly { readonly type: string }[]
+  }
+}
+
+type OfficialClaudeBridgeSession = {
+  modelArg: string
+  officialSessionId: string
+}
+
+const officialClaudeSessions = new Map<string, OfficialClaudeBridgeSession>()
+
+/**
+ * Resolve the official Claude CLI binary.
+ */
+function getOfficialClaudeCommand(): string {
+  if (process.env.MUMUCC_OFFICIAL_CLAUDE_COMMAND) {
+    return process.env.MUMUCC_OFFICIAL_CLAUDE_COMMAND
+  }
+  const defaultPath = join(homedir(), '.local', 'bin', 'claude')
+  return existsSync(defaultPath) ? defaultPath : 'claude'
+}
+
+/**
+ * Map mumucc model names to official Claude CLI aliases.
+ */
+export function getOfficialClaudeBridgeModelArg(model: ModelName): string | null {
+  const canonical = getCanonicalName(model)
+  const suffix = has1mContext(model) ? '[1m]' : ''
+
+  if (canonical.includes('haiku')) return 'haiku'
+  if (canonical.includes('sonnet')) return `sonnet${suffix}`
+  if (canonical.includes('opus')) return `opus${suffix}`
+  return null
+}
+
+/**
+ * Whether this model should be executed by the official Claude CLI.
+ */
+export function shouldUseOfficialClaudeBridge(model: ModelName): boolean {
+  return getOfficialClaudeBridgeModelArg(model) !== null
+}
+
+export function isDisabledOfficialClaudeModel(model: ModelName): boolean {
+  return getOfficialClaudeBridgeModelArg(model) !== null
+}
+
+function truncateForBridge(text: string, limit: number): string {
+  if (text.length <= limit) return text
+  return `${text.slice(0, limit)}\n...[truncated]`
+}
+
+function summarizeMessage(message: Message): string | null {
+  switch (message.type) {
+    case 'user': {
+      const text = getContentText(message.message.content)
+      return text ? `User:\n${text}` : null
+    }
+    case 'assistant': {
+      const text = extractTextContent(message.message.content, '\n').trim()
+      return text ? `Assistant:\n${text}` : null
+    }
+    case 'attachment': {
+      const attachment = (message as { attachment?: { content?: unknown } })
+        .attachment
+      if (!attachment) return null
+      if (typeof attachment.content === 'string') {
+        return `Attachment:\n${attachment.content}`
+      }
+      if (Array.isArray(attachment.content)) {
+        const parts = attachment.content.filter(
+          (part): part is string => typeof part === 'string',
+        )
+        return parts.length > 0 ? `Attachment:\n${parts.join('\n')}` : null
+      }
+      return null
+    }
+    default:
+      return null
+  }
+}
+
+function buildTranscriptContext(
+  messages: Message[],
+  maxMessages: number,
+  maxChars: number,
+): string {
+  const recentMessages = messages
+    .slice(-maxMessages)
+    .map(summarizeMessage)
+    .filter((value): value is string => value !== null)
+
+  return truncateForBridge(recentMessages.join('\n\n'), maxChars)
+}
+
+function getLatestUserPrompt(messages: Message[]): string | null {
+  for (let i = messages.length - 1; i >= 0; i -= 1) {
+    const message = messages[i]
+    if (!message || message.type !== 'user') continue
+    const text = getContentText(message.message.content)
+    if (text) return text
+  }
+  return null
+}
+
+function buildMainThreadBootstrapPrompt(messages: Message[]): string {
+  const transcript = buildTranscriptContext(
+    messages,
+    MAX_MAIN_THREAD_CONTEXT_MESSAGES,
+    MAX_MAIN_THREAD_CONTEXT_CHARS,
+  )
+  const latestUserPrompt = getLatestUserPrompt(messages)
+
+  return [
+    'You are continuing a bridged mumucc main-thread session.',
+    'Treat the transcript below as the authoritative prior context from mumucc.',
+    transcript ? `Transcript:\n${transcript}` : null,
+    latestUserPrompt ? `Latest user request:\n${latestUserPrompt}` : null,
+    'Respond naturally to the latest user request. Use your normal Claude Code capabilities when needed.',
+  ]
+    .filter((value): value is string => value !== null)
+    .join('\n\n')
+}
+
+function buildMainThreadIncrementalPrompt(messages: Message[]): string {
+  const latestUserPrompt = getLatestUserPrompt(messages)
+  if (!latestUserPrompt) {
+    return buildMainThreadBootstrapPrompt(messages)
+  }
+  return [
+    'Continue the existing bridged mumucc session.',
+    `Latest user request:\n${latestUserPrompt}`,
+  ].join('\n\n')
+}
+
+function buildAgentPrompt({
+  agentType,
+  description,
+  messages,
+}: {
+  agentType: string
+  description?: string
+  messages: Message[]
+}): string {
+  const context = buildTranscriptContext(
+    messages,
+    MAX_AGENT_CONTEXT_MESSAGES,
+    MAX_AGENT_CONTEXT_CHARS,
+  )
+
+  return [
+    `You are executing as the "${agentType}" worker inside mumucc.`,
+    description ? `Task description: ${description}` : null,
+    context ? `Conversation context:\n${context}` : null,
+    'Complete the task using your normal Claude Code capabilities and return only your final response for the parent agent.',
+  ]
+    .filter((value): value is string => value !== null)
+    .join('\n\n')
+}
+
+/**
+ * Build an environment that uses the user's real official Claude auth state
+ * instead of inheriting mumucc-specific shell mutations.
+ */
+function getBridgeEnv(): NodeJS.ProcessEnv {
+  const env = { ...process.env }
+  if (process.env.MUMUCC_OFFICIAL_CLAUDE_CONFIG_DIR) {
+    env.CLAUDE_CONFIG_DIR = process.env.MUMUCC_OFFICIAL_CLAUDE_CONFIG_DIR
+  } else {
+    delete env.CLAUDE_CONFIG_DIR
+  }
+
+  delete env.CLAUDE_CODE_TEAMMATE_COMMAND
+  delete env.CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS
+  delete env.CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC
+  delete env.CLAUDE_CODE_ATTRIBUTION_HEADER
+  delete env.CLAUDE_CODE_ATTRIBUTION_VERSION
+  delete env.ANTHROPIC_API_KEY
+  delete env.ANTHROPIC_AUTH_TOKEN
+  delete env.ANTHROPIC_BASE_URL
+  delete env.ANTHROPIC_CUSTOM_HEADERS
+  delete env.ENABLED_FEATURES
+
+  return env
+}
+
+/**
+ * The official Claude subprocess is hidden behind mumucc's UI, so any mode
+ * that might open an internal approval prompt would deadlock. Force the child
+ * into a non-interactive permission mode unless the caller explicitly asked
+ * for bypassPermissions.
+ */
+function getBridgePermissionMode(
+  permissionMode?: PermissionMode,
+): PermissionMode | undefined {
+  if (!permissionMode) return undefined
+  if (permissionMode === 'bypassPermissions') return permissionMode
+  return 'dontAsk'
+}
+
+function extractBridgeErrorText(event: BridgeStreamEvent): string | null {
+  if (typeof event.result === 'string' && event.result.trim()) {
+    return event.result.trim()
+  }
+  if (typeof event.error === 'string' && event.error.trim()) {
+    return event.error.trim()
+  }
+  return null
+}
+
+function parseOfficialClaudeStream(stdout: string): {
+  sessionId?: string
+  text: string
+} {
+  const events = stdout
+    .split(/\r?\n/)
+    .map(line => line.trim())
+    .filter(Boolean)
+    .map(line => safeParseJSON(line, false))
+    .filter(
+      (value): value is BridgeStreamEvent =>
+        typeof value === 'object' && value !== null,
+    )
+
+  let sessionId: string | undefined
+  let assistantText = ''
+  let resultText = ''
+
+  for (const event of events) {
+    if (!sessionId && typeof event.session_id === 'string') {
+      sessionId = event.session_id
+    }
+
+    if (
+      event.type === 'assistant' &&
+      event.message?.role === 'assistant' &&
+      Array.isArray(event.message.content)
+    ) {
+      const text = extractTextContent(event.message.content, '\n').trim()
+      if (text) assistantText = text
+    }
+
+    if (event.type === 'result') {
+      if (event.is_error) {
+        throw new Error(
+          extractBridgeErrorText(event) || 'Official Claude bridge failed',
+        )
+      }
+      if (typeof event.result === 'string' && event.result.trim()) {
+        resultText = event.result.trim()
+      }
+    }
+  }
+
+  const text = resultText || assistantText
+  if (!text) {
+    throw new Error('Official Claude bridge produced no final assistant text')
+  }
+
+  return { sessionId, text }
+}
+
+async function runOfficialClaudeCli({
+  model,
+  systemPrompt,
+  prompt,
+  permissionMode,
+  maxTurns,
+  resumeSessionId,
+  sessionId,
+}: {
+  model: ModelName
+  systemPrompt: string[]
+  prompt: string
+  permissionMode?: PermissionMode
+  maxTurns?: number
+  resumeSessionId?: string
+  sessionId?: string
+}) {
+  const modelArg = getOfficialClaudeBridgeModelArg(model)
+  if (!modelArg) {
+    throw new Error(`Official Claude bridge does not support model: ${model}`)
+  }
+
+  const systemPromptText = buildBridgeSystemPrompt(systemPrompt)
+  const systemPromptFile = systemPromptText
+    ? generateTempFilePath('mumucc-claude-bridge', '.md', {
+        contentHash: systemPromptText,
+      })
+    : null
+
+  if (systemPromptFile) {
+    await writeFile(systemPromptFile, systemPromptText, 'utf8')
+  }
+
+  try {
+    const args = [
+      '-p',
+      '--verbose',
+      '--output-format',
+      'stream-json',
+      '--model',
+      modelArg,
+    ]
+
+    if (resumeSessionId) {
+      args.push('--resume', resumeSessionId)
+    } else if (sessionId) {
+      args.push('--session-id', sessionId)
+    }
+
+    if (systemPromptFile) {
+      args.push('--append-system-prompt-file', systemPromptFile)
+    }
+    const bridgePermissionMode = getBridgePermissionMode(permissionMode)
+    if (
+      bridgePermissionMode &&
+      isExternalPermissionMode(bridgePermissionMode)
+    ) {
+      args.push(
+        '--permission-mode',
+        toExternalPermissionMode(bridgePermissionMode),
+      )
+    }
+    if (maxTurns !== undefined) {
+      args.push('--max-turns', String(maxTurns))
+    }
+
+    logForDebugging(
+      `[OfficialClaudeBridge] Running ${getOfficialClaudeCommand()} ${args.join(' ')} in ${getCwd()}`,
+    )
+
+    const result = await execa(getOfficialClaudeCommand(), args, {
+      cwd: getCwd(),
+      env: getBridgeEnv(),
+      input: prompt,
+      reject: false,
+      timeout: 10 * 60 * 1000,
+    })
+
+    if (result.exitCode !== 0) {
+      throw new Error(result.stderr.trim() || result.stdout.trim())
+    }
+
+    const parsed = parseOfficialClaudeStream(result.stdout)
+    return {
+      modelArg,
+      officialSessionId:
+        parsed.sessionId ?? resumeSessionId ?? sessionId ?? undefined,
+      text: parsed.text,
+    }
+  } finally {
+    if (systemPromptFile) {
+      await unlink(systemPromptFile).catch(() => {})
+    }
+  }
+}
+
+function buildBridgeSystemPrompt(systemPrompt: string[]): string {
+  const bridgePrompt = [
+    'You are running inside the official Claude CLI as the Claude execution backend for mumucc.',
+    'Stay focused on the current task and respond directly.',
+    'Do not mention the bridge unless the user explicitly asks about it.',
+    'Use your normal Claude Code capabilities when needed.',
+  ]
+
+  if (process.env.MUMUCC_INCLUDE_FULL_SYSTEM_PROMPT_IN_CLAUDE_BRIDGE === '1') {
+    const externalPrompt = truncateForBridge(systemPrompt.join('\n\n').trim(), 8_000)
+    if (externalPrompt) {
+      bridgePrompt.push(`Additional mumucc context:\n${externalPrompt}`)
+    }
+  }
+
+  return bridgePrompt.join('\n\n')
+}
+
+function isRecoverableResumeError(error: unknown): boolean {
+  const message = error instanceof Error ? error.message : String(error)
+  return (
+    message.includes('Failed to resume session') ||
+    message.includes('No conversation found') ||
+    message.includes('Session ID') ||
+    message.includes('already in use')
+  )
+}
+
+/**
+ * Execute a main-thread Claude turn through the official CLI. Uses a per-mumucc
+ * session sidecar when possible, and falls back to replaying context if the
+ * sidecar becomes invalid or the model changes.
+ */
+export async function runOfficialClaudeMainThreadBridge({
+  model,
+  systemPrompt,
+  messages,
+  permissionMode,
+  maxTurns,
+}: {
+  model: ModelName
+  systemPrompt: string[]
+  messages: Message[]
+  permissionMode?: PermissionMode
+  maxTurns?: number
+}) {
+  throw new Error('Anthropic official channel is disabled in this mumucc build')
+}
+
+/**
+ * Execute an agent turn through the official Claude CLI.
+ */
+export async function runOfficialClaudeAgentBridge({
+  agentType,
+  description,
+  model,
+  systemPrompt,
+  messages,
+  permissionMode,
+  maxTurns,
+}: {
+  agentType: string
+  description?: string
+  model: ModelName
+  systemPrompt: string[]
+  messages: Message[]
+  permissionMode?: PermissionMode
+  maxTurns?: number
+}) {
+  const result = await runOfficialClaudeCli({
+    model,
+    systemPrompt,
+    prompt: buildAgentPrompt({
+      agentType,
+      description,
+      messages,
+    }),
+    permissionMode,
+    maxTurns,
+  })
+
+  return createAssistantMessage({ content: result.text })
+}

package/src/services/api/openaiShim.ts

@@ -31,6 +31,7 @@ import {
   type ShimCreateParams,
 } from './codexShim.js'
 import {
+  isCodexBaseUrl,
   resolveCodexApiCredentials,
   resolveProviderRequest,
 } from './openaiProviderConfig.js'
@@ -561,6 +562,7 @@ class OpenAIShimMessages {
   private baseUrlOverride?: string
   private codexAccountIdOverride?: string
   private codexAuthPathOverride?: string
+  private transportOverride?: 'chat_completions' | 'codex_responses'
 
   constructor(
     defaultHeaders: Record<string, string>,
@@ -569,6 +571,7 @@ class OpenAIShimMessages {
       baseUrl?: string
       codexAccountId?: string
       codexAuthPath?: string
+      transportOverride?: 'chat_completions' | 'codex_responses'
     },
   ) {
     this.defaultHeaders = defaultHeaders
@@ -576,6 +579,7 @@ class OpenAIShimMessages {
     this.baseUrlOverride = options?.baseUrl
     this.codexAccountIdOverride = options?.codexAccountId
     this.codexAuthPathOverride = options?.codexAuthPath
+    this.transportOverride = options?.transportOverride
   }
 
   create(
@@ -596,6 +600,9 @@ class OpenAIShimMessages {
         model: params.model,
         baseUrl: self.baseUrlOverride,
       })
+      if (self.transportOverride) {
+        request.transport = self.transportOverride
+      }
       // Override base URL if provided via constructor
       if (self.baseUrlOverride) {
         request.baseUrl = self.baseUrlOverride.replace(/\/+$/, '')
@@ -660,7 +667,7 @@ class OpenAIShimMessages {
           `Codex auth is required for ${request.requestedModel}. Set CODEX_API_KEY${authHint}.`,
         )
       }
-      if (!effectiveCredentials.accountId) {
+      if (!effectiveCredentials.accountId && isCodexBaseUrl(request.baseUrl)) {
         throw new Error(
           'Codex auth is missing chatgpt_account_id. Re-login with the Codex CLI or set CHATGPT_ACCOUNT_ID/CODEX_ACCOUNT_ID.',
         )
@@ -855,6 +862,7 @@ class OpenAIShimBeta {
       baseUrl?: string
       codexAccountId?: string
       codexAuthPath?: string
+      transportOverride?: 'chat_completions' | 'codex_responses'
     },
   ) {
     this.messages = new OpenAIShimMessages(defaultHeaders, options)
@@ -876,6 +884,7 @@ export function createOpenAIShimClient(options: {
   baseUrl?: string
   codexAccountId?: string
   codexAuthPath?: string
+  transportOverride?: 'chat_completions' | 'codex_responses'
 }): unknown {
   // When Gemini provider is active, map Gemini env vars to OpenAI-compatible ones
   if (
@@ -899,6 +908,7 @@ export function createOpenAIShimClient(options: {
       baseUrl: options.baseUrl,
       codexAccountId: options.codexAccountId,
       codexAuthPath: options.codexAuthPath,
+      transportOverride: options.transportOverride,
     },
   )
 

package/src/state/AppStateStore.ts

@@ -110,6 +110,17 @@ export type AppState = DeepImmutable<{
   spinnerTip?: string
   // Agent name from --agent CLI flag or settings (for logo display)
   agent: string | undefined
+  // Runtime metadata for Agent tool invocations keyed by tool_use_id.
+  // Lets the UI show the actual selected agent type/color/model even when
+  // the raw tool input omitted subagent_type or model.
+  agentToolInvocations: Record<
+    string,
+    {
+      agentType: string
+      model: string
+      color?: AgentColorName
+    }
+  >
   // Assistant mode fully enabled (settings + GrowthBook gate + trust).
   // Single source of truth - computed once in main.tsx before option
   // mutation, consumers read this instead of re-calling isAssistantMode().
@@ -502,6 +513,7 @@ export function getDefaultAppState(): AppState {
       mode: initialMode,
     },
     agent: undefined,
+    agentToolInvocations: {},
     agentDefinitions: { activeAgents: [], allAgents: [] },
     fileHistory: {
       snapshots: [],

package/src/tools/AgentTool/AgentTool.tsx

@@ -323,6 +323,19 @@ export const AgentTool = buildTool({
         agentDef?.profile,
         profileParam,
       );
+      if (toolUseContext.toolUseId) {
+        rootSetAppState(state => ({
+          ...state,
+          agentToolInvocations: {
+            ...state.agentToolInvocations,
+            [toolUseContext.toolUseId]: {
+              agentType: subagent_type ?? GENERAL_PURPOSE_AGENT.agentType,
+              model: resolvedTeammateModel,
+              color: agentDef?.color,
+            },
+          },
+        }));
+      }
       const result = await spawnTeammate({
         name,
         prompt,
@@ -459,6 +472,19 @@ export const AgentTool = buildTool({
       selectedAgent.profile,
       isForkPath ? undefined : profileParam,
     );
+    if (toolUseContext.toolUseId) {
+      rootSetAppState(state => ({
+        ...state,
+        agentToolInvocations: {
+          ...state.agentToolInvocations,
+          [toolUseContext.toolUseId]: {
+            agentType: selectedAgent.agentType,
+            model: resolvedAgentModel,
+            color: selectedAgent.color,
+          },
+        },
+      }));
+    }
     logEvent('tengu_agent_tool_selected', {
       agent_type: selectedAgent.agentType as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
       model: resolvedAgentModel as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,

package/src/tools/AgentTool/officialClaudeBridge.ts

@@ -0,0 +1,5 @@
+export {
+  isDisabledOfficialClaudeModel,
+  shouldUseOfficialClaudeBridge,
+  runOfficialClaudeAgentBridge as runOfficialClaudeBridge,
+} from '../../services/api/officialClaudeBridge.js'

package/src/tools/AgentTool/runAgent.ts

@@ -56,7 +56,10 @@ import {
 import { registerFrontmatterHooks } from '../../utils/hooks/registerFrontmatterHooks.js'
 import { clearSessionHooks } from '../../utils/hooks/sessionHooks.js'
 import { executeSubagentStartHooks } from '../../utils/hooks.js'
-import { createUserMessage } from '../../utils/messages.js'
+import {
+  createAssistantAPIErrorMessage,
+  createUserMessage,
+} from '../../utils/messages.js'
 import { getAgentModel } from '../../utils/model/agent.js'
 import type { ModelAlias } from '../../utils/model/aliases.js'
 import {
@@ -82,6 +85,11 @@ import type { ContentReplacementState } from '../../utils/toolResultStorage.js'
 import { createAgentId } from '../../utils/uuid.js'
 import { resolveAgentTools } from './agentToolUtils.js'
 import { type AgentDefinition, isBuiltInAgent } from './loadAgentsDir.js'
+import {
+  isDisabledOfficialClaudeModel,
+  runOfficialClaudeBridge,
+  shouldUseOfficialClaudeBridge,
+} from './officialClaudeBridge.js'
 
 /**
  * Initialize agent-specific MCP servers
@@ -647,6 +655,9 @@ export async function* runAgent({
     }
   }
 
+  const shouldBridgeToOfficialClaude =
+    shouldUseOfficialClaudeBridge(resolvedAgentModel)
+
   // Initialize agent-specific MCP servers (additive to parent's servers)
   const {
     clients: mergedMcpClients,
@@ -747,6 +758,27 @@ export async function* runAgent({
   let lastRecordedUuid: UUID | null = initialMessages.at(-1)?.uuid ?? null
 
   try {
+    if (shouldBridgeToOfficialClaude) {
+      const bridgedMessage = await runOfficialClaudeBridge({
+        agentType: agentDefinition.agentType,
+        description,
+        model: resolvedAgentModel,
+        systemPrompt: agentSystemPrompt,
+        messages: initialMessages,
+        permissionMode: agentDefinition.permissionMode,
+        maxTurns: maxTurns ?? agentDefinition.maxTurns,
+      })
+      await recordSidechainTranscript(
+        [bridgedMessage],
+        agentId,
+        lastRecordedUuid,
+      ).catch(err =>
+        logForDebugging(`Failed to record sidechain transcript: ${err}`),
+      )
+      yield bridgedMessage
+      return
+    }
+
     for await (const message of query({
       messages: initialMessages,
       systemPrompt: agentSystemPrompt,