opencode-claude-max-proxy 1.0.2 → 1.8.0

package/src/logger.ts

@@ -1,10 +1,72 @@
+import { AsyncLocalStorage } from "node:async_hooks"
+
+type LogFields = Record<string, unknown>
+
+const contextStore = new AsyncLocalStorage<LogFields>()
+
 const shouldLog = () => process.env["OPENCODE_CLAUDE_PROVIDER_DEBUG"]
+const shouldLogStreamDebug = () => process.env["OPENCODE_CLAUDE_PROVIDER_STREAM_DEBUG"]
 
-export const claudeLog = (message: string, extra?: Record<string, unknown>) => {
-  if (!shouldLog()) return
-  const parts = ["[opencode-claude-code-provider]", message]
-  if (extra && Object.keys(extra).length > 0) {
-    parts.push(JSON.stringify(extra))
+const isVerboseStreamEvent = (event: string): boolean => {
+  return event.startsWith("stream.") || event === "response.empty_stream"
+}
+
+const REDACTED_KEYS = new Set([
+  "authorization",
+  "cookie",
+  "x-api-key",
+  "apiKey",
+  "apikey",
+  "prompt",
+  "messages",
+  "content"
+])
+
+const sanitize = (value: unknown): unknown => {
+  if (value === null || value === undefined) return value
+
+  if (typeof value === "string") {
+    if (value.length > 512) {
+      return `${value.slice(0, 512)}... [truncated=${value.length}]`
+    }
+    return value
+  }
+
+  if (Array.isArray(value)) {
+    return value.map(sanitize)
   }
-  console.debug(parts.join(" "))
+
+  if (typeof value === "object") {
+    const out: Record<string, unknown> = {}
+    for (const [k, v] of Object.entries(value as Record<string, unknown>)) {
+      if (REDACTED_KEYS.has(k)) {
+        if (typeof v === "string") {
+          out[k] = `[redacted len=${v.length}]`
+        } else if (Array.isArray(v)) {
+          out[k] = `[redacted array len=${v.length}]`
+        } else {
+          out[k] = "[redacted]"
+        }
+      } else {
+        out[k] = sanitize(v)
+      }
+    }
+    return out
+  }
+
+  return value
+}
+
+export const withClaudeLogContext = <T>(context: LogFields, fn: () => T): T => {
+  return contextStore.run(context, fn)
+}
+
+export const claudeLog = (event: string, extra?: LogFields) => {
+  if (!shouldLog()) return
+  if (isVerboseStreamEvent(event) && !shouldLogStreamDebug()) return
+
+  const context = contextStore.getStore() || {}
+  const payload = sanitize({ ts: new Date().toISOString(), event, ...context, ...(extra || {}) })
+
+  console.debug(`[opencode-claude-code-provider] ${JSON.stringify(payload)}`)
 }

package/src/proxy/agentDefs.ts

@@ -0,0 +1,102 @@
+/**
+ * Extract SDK AgentDefinition objects from OpenCode's Task tool description.
+ *
+ * OpenCode (via oh-my-opencode or other frameworks) sends a Task tool with
+ * descriptions of each available agent. We parse these and convert them into
+ * Claude Agent SDK `AgentDefinition` objects so the SDK's native Task handler
+ * routes to properly-configured subagents.
+ *
+ * This means whatever agents the user configures in their framework
+ * automatically become available as SDK subagents — with descriptions,
+ * model tiers, and tool access.
+ */
+
+/** SDK-compatible agent definition */
+export interface AgentDefinition {
+  description: string
+  prompt: string
+  model?: "sonnet" | "opus" | "haiku" | "inherit"
+  tools?: string[]
+  disallowedTools?: string[]
+}
+
+/**
+ * Parse agent entries from the Task tool description text.
+ *
+ * Expected format (from OpenCode):
+ *   - agent-name: Description of what the agent does
+ *
+ * @returns Map of agent name → description
+ */
+export function parseAgentDescriptions(taskDescription: string): Map<string, string> {
+  const agents = new Map<string, string>()
+
+  const agentSection = taskDescription.match(
+    /Available agent types.*?:\n((?:- [\w][\w-]*:.*\n?)+)/s
+  )
+  if (!agentSection) return agents
+
+  const entries = agentSection[1]!.matchAll(/^- ([\w][\w-]*):\s*(.+)/gm)
+  for (const match of entries) {
+    agents.set(match[1]!, match[2]!.trim())
+  }
+
+  return agents
+}
+
+/**
+ * Map an OpenCode model string to an SDK model tier.
+ *
+ * The SDK only accepts 'sonnet' | 'opus' | 'haiku' | 'inherit'.
+ * We map based on the model name pattern, defaulting to 'inherit'
+ * for non-Anthropic models (they'll use the parent session's model).
+ */
+export function mapModelTier(model?: string): "sonnet" | "opus" | "haiku" | "inherit" {
+  if (!model) return "inherit"
+  const lower = model.toLowerCase()
+  if (lower.includes("opus")) return "opus"
+  if (lower.includes("haiku")) return "haiku"
+  if (lower.includes("sonnet")) return "sonnet"
+  return "inherit"
+}
+
+/**
+ * Build SDK AgentDefinition objects from the Task tool description.
+ *
+ * Each agent gets:
+ * - description: from the Task tool text (user-configured)
+ * - prompt: instructional prompt incorporating the description
+ * - model: 'inherit' (uses parent session model — all requests go through our proxy)
+ * - tools: undefined (inherit all tools from parent)
+ *
+ * @param taskDescription - The full Task tool description text from OpenCode
+ * @param mcpToolNames - Optional list of MCP tool names to make available to agents
+ */
+export function buildAgentDefinitions(
+  taskDescription: string,
+  mcpToolNames?: string[]
+): Record<string, AgentDefinition> {
+  const descriptions = parseAgentDescriptions(taskDescription)
+  const agents: Record<string, AgentDefinition> = {}
+
+  for (const [name, description] of descriptions) {
+    agents[name] = {
+      description,
+      prompt: buildAgentPrompt(name, description),
+      model: "inherit",
+      // Give agents access to MCP tools if provided
+      ...(mcpToolNames?.length ? { tools: [...mcpToolNames] } : {}),
+    }
+  }
+
+  return agents
+}
+
+/**
+ * Build a system prompt for an agent based on its name and description.
+ */
+function buildAgentPrompt(name: string, description: string): string {
+  return `You are the "${name}" agent. ${description}
+
+Focus on your specific role and complete the task thoroughly. Return a clear, concise result.`
+}

package/src/proxy/agentMatch.ts

@@ -0,0 +1,93 @@
+/**
+ * Fuzzy matching for agent names.
+ *
+ * When Claude sends an invalid subagent_type, this tries to map it
+ * to the closest valid agent name. This is deterministic string matching,
+ * not LLM guessing.
+ *
+ * Matching priority:
+ * 1. Exact match (case-insensitive)
+ * 2. Known aliases (e.g., "general-purpose" → "general")
+ * 3. Prefix match (e.g., "lib" → "librarian")
+ * 4. Substring match (e.g., "junior" → "sisyphus-junior")
+ * 5. Suffix-stripped match (e.g., "explore-agent" → "explore")
+ * 6. Semantic aliases (e.g., "search" → "explore")
+ * 7. Fallback: return lowercased original
+ */
+
+// Known aliases for common SDK mistakes
+const KNOWN_ALIASES: Record<string, string> = {
+  "general-purpose": "general",
+  "default": "general",
+  "code-reviewer": "oracle",
+  "reviewer": "oracle",
+  "code-review": "oracle",
+  "review": "oracle",
+  "consultation": "oracle",
+  "analyzer": "oracle",
+  "debugger": "oracle",
+  "search": "explore",
+  "grep": "explore",
+  "find": "explore",
+  "codebase-search": "explore",
+  "research": "librarian",
+  "docs": "librarian",
+  "documentation": "librarian",
+  "lookup": "librarian",
+  "reference": "librarian",
+  "consult": "oracle",
+  "architect": "oracle",
+  "image-analyzer": "multimodal-looker",
+  "image": "multimodal-looker",
+  "pdf": "multimodal-looker",
+  "visual": "multimodal-looker",
+  "planner": "plan",
+  "planning": "plan",
+  "builder": "build",
+  "coder": "build",
+  "developer": "build",
+  "writer": "build",
+  "executor": "build",
+}
+
+// Common suffixes to strip
+const STRIP_SUFFIXES = ["-agent", "-tool", "-worker", "-task", " agent", " tool"]
+
+export function fuzzyMatchAgentName(input: string, validAgents: string[]): string {
+  if (!input) return input
+  if (validAgents.length === 0) return input.toLowerCase()
+
+  const lowered = input.toLowerCase()
+
+  // 1. Exact match (case-insensitive)
+  const exact = validAgents.find(a => a.toLowerCase() === lowered)
+  if (exact) return exact
+
+  // 2. Known aliases
+  const alias = KNOWN_ALIASES[lowered]
+  if (alias && validAgents.includes(alias)) return alias
+
+  // 3. Prefix match
+  const prefixMatch = validAgents.find(a => a.toLowerCase().startsWith(lowered))
+  if (prefixMatch) return prefixMatch
+
+  // 4. Substring match
+  const substringMatch = validAgents.find(a => a.toLowerCase().includes(lowered))
+  if (substringMatch) return substringMatch
+
+  // 5. Suffix-stripped match
+  for (const suffix of STRIP_SUFFIXES) {
+    if (lowered.endsWith(suffix)) {
+      const stripped = lowered.slice(0, -suffix.length)
+      const strippedMatch = validAgents.find(a => a.toLowerCase() === stripped)
+      if (strippedMatch) return strippedMatch
+    }
+  }
+
+  // 6. Reverse substring (input contains a valid agent name)
+  const reverseMatch = validAgents.find(a => lowered.includes(a.toLowerCase()))
+  if (reverseMatch) return reverseMatch
+
+  // 7. Fallback
+  return lowered
+}

package/src/proxy/passthroughTools.ts

@@ -0,0 +1,108 @@
+/**
+ * Dynamic MCP tool registration for passthrough mode.
+ *
+ * In passthrough mode, OpenCode's tools need to be real callable tools
+ * (not just text descriptions in the prompt). We create an MCP server
+ * that registers each tool from OpenCode's request with the exact
+ * name and schema, so Claude generates proper tool_use blocks.
+ *
+ * Tool handlers are no-ops — the PreToolUse hook blocks execution.
+ * We just need the definitions so Claude can call them.
+ */
+
+import { createSdkMcpServer } from "@anthropic-ai/claude-agent-sdk"
+import { z } from "zod"
+
+export const PASSTHROUGH_MCP_NAME = "oc"
+export const PASSTHROUGH_MCP_PREFIX = `mcp__${PASSTHROUGH_MCP_NAME}__`
+
+/**
+ * Convert a JSON Schema object to a Zod schema (simplified).
+ * Handles the common types OpenCode sends. Falls back to z.any() for complex types.
+ */
+function jsonSchemaToZod(schema: any): z.ZodTypeAny {
+  if (!schema || typeof schema !== "object") return z.any()
+
+  if (schema.type === "string") {
+    let s = z.string()
+    if (schema.description) s = s.describe(schema.description)
+    if (schema.enum) return z.enum(schema.enum as [string, ...string[]])
+    return s
+  }
+  if (schema.type === "number" || schema.type === "integer") {
+    let n = z.number()
+    if (schema.description) n = n.describe(schema.description)
+    return n
+  }
+  if (schema.type === "boolean") return z.boolean()
+  if (schema.type === "array") {
+    const items = schema.items ? jsonSchemaToZod(schema.items) : z.any()
+    return z.array(items)
+  }
+  if (schema.type === "object" && schema.properties) {
+    const shape: Record<string, z.ZodTypeAny> = {}
+    const required = new Set(schema.required || [])
+    for (const [key, propSchema] of Object.entries(schema.properties)) {
+      const zodProp = jsonSchemaToZod(propSchema as any)
+      shape[key] = required.has(key) ? zodProp : zodProp.optional()
+    }
+    return z.object(shape)
+  }
+
+  return z.any()
+}
+
+/**
+ * Create an MCP server with tool definitions matching OpenCode's request.
+ */
+export function createPassthroughMcpServer(
+  tools: Array<{ name: string; description?: string; input_schema?: any }>
+) {
+  const server = createSdkMcpServer({ name: PASSTHROUGH_MCP_NAME })
+  const toolNames: string[] = []
+
+  for (const tool of tools) {
+    try {
+      // Convert OpenCode's JSON Schema to Zod for MCP registration
+      const zodSchema = tool.input_schema?.properties
+        ? jsonSchemaToZod(tool.input_schema)
+        : z.object({})
+
+      // The raw shape for the tool() call needs to be a record of Zod types
+      const shape: Record<string, z.ZodTypeAny> =
+        zodSchema instanceof z.ZodObject
+          ? (zodSchema as any).shape
+          : { input: z.any() }
+
+      server.instance.tool(
+        tool.name,
+        tool.description || tool.name,
+        shape,
+        async () => ({ content: [{ type: "text" as const, text: "passthrough" }] })
+      )
+      toolNames.push(`${PASSTHROUGH_MCP_PREFIX}${tool.name}`)
+    } catch {
+      // If schema conversion fails, register with permissive schema
+      server.instance.tool(
+        tool.name,
+        tool.description || tool.name,
+        { input: z.string().optional() },
+        async () => ({ content: [{ type: "text" as const, text: "passthrough" }] })
+      )
+      toolNames.push(`${PASSTHROUGH_MCP_PREFIX}${tool.name}`)
+    }
+  }
+
+  return { server, toolNames }
+}
+
+/**
+ * Strip the MCP prefix from a tool name to get the OpenCode tool name.
+ * e.g., "mcp__oc__todowrite" → "todowrite"
+ */
+export function stripMcpPrefix(toolName: string): string {
+  if (toolName.startsWith(PASSTHROUGH_MCP_PREFIX)) {
+    return toolName.slice(PASSTHROUGH_MCP_PREFIX.length)
+  }
+  return toolName
+}