opencode-claude-max-proxy 1.10.1 → 1.11.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-claude-max-proxy",
-  "version": "1.10.1",
+  "version": "1.11.0",
   "description": "Use your Claude Max subscription with OpenCode via proxy server",
   "type": "module",
   "main": "./src/proxy/server.ts",
@@ -32,7 +32,9 @@
     "bin/",
     "src/proxy/",
     "src/logger.ts",
-    "README.md"
+    "src/mcpTools.ts",
+    "README.md",
+    "src/plugin/"
   ],
   "keywords": [
     "opencode",

package/src/mcpTools.ts

@@ -0,0 +1,185 @@
+import { createSdkMcpServer, tool } from "@anthropic-ai/claude-agent-sdk"
+import { z } from "zod"
+import * as fs from "node:fs/promises"
+import * as path from "node:path"
+import { exec } from "node:child_process"
+import { promisify } from "node:util"
+import { glob as globLib } from "glob"
+
+const execAsync = promisify(exec)
+
+const getCwd = () => process.env.CLAUDE_PROXY_WORKDIR || process.cwd()
+
+export const opencodeMcpServer = createSdkMcpServer({
+  name: "opencode",
+  version: "1.0.0",
+  tools: [
+    tool(
+      "read",
+      "Read the contents of a file at the specified path",
+      {
+        path: z.string().describe("Absolute or relative path to the file"),
+        encoding: z.string().optional().describe("File encoding, defaults to utf-8")
+      },
+      async (args) => {
+        try {
+          const filePath = path.isAbsolute(args.path) 
+            ? args.path 
+            : path.resolve(getCwd(), args.path)
+          const content = await fs.readFile(filePath, (args.encoding || "utf-8") as BufferEncoding)
+          return {
+            content: [{ type: "text", text: content }]
+          }
+        } catch (error) {
+          return {
+            content: [{ type: "text", text: `Error reading file: ${error instanceof Error ? error.message : String(error)}` }],
+            isError: true
+          }
+        }
+      }
+    ),
+    
+    tool(
+      "write",
+      "Write content to a file, creating directories if needed",
+      {
+        path: z.string().describe("Path to write to"),
+        content: z.string().describe("Content to write")
+      },
+      async (args) => {
+        try {
+          const filePath = path.isAbsolute(args.path)
+            ? args.path
+            : path.resolve(getCwd(), args.path)
+          await fs.mkdir(path.dirname(filePath), { recursive: true })
+          await fs.writeFile(filePath, args.content, "utf-8")
+          return {
+            content: [{ type: "text", text: `Successfully wrote to ${args.path}` }]
+          }
+        } catch (error) {
+          return {
+            content: [{ type: "text", text: `Error writing file: ${error instanceof Error ? error.message : String(error)}` }],
+            isError: true
+          }
+        }
+      }
+    ),
+    
+    tool(
+      "edit",
+      "Edit a file by replacing oldString with newString",
+      {
+        path: z.string().describe("Path to the file to edit"),
+        oldString: z.string().describe("The text to replace"),
+        newString: z.string().describe("The replacement text")
+      },
+      async (args) => {
+        try {
+          const filePath = path.isAbsolute(args.path)
+            ? args.path
+            : path.resolve(getCwd(), args.path)
+          const content = await fs.readFile(filePath, "utf-8")
+          if (!content.includes(args.oldString)) {
+            return {
+              content: [{ type: "text", text: `Error: oldString not found in file` }],
+              isError: true
+            }
+          }
+          const newContent = content.replace(args.oldString, args.newString)
+          await fs.writeFile(filePath, newContent, "utf-8")
+          return {
+            content: [{ type: "text", text: `Successfully edited ${args.path}` }]
+          }
+        } catch (error) {
+          return {
+            content: [{ type: "text", text: `Error editing file: ${error instanceof Error ? error.message : String(error)}` }],
+            isError: true
+          }
+        }
+      }
+    ),
+    
+    tool(
+      "bash",
+      "Execute a bash command and return the output",
+      {
+        command: z.string().describe("The command to execute"),
+        cwd: z.string().optional().describe("Working directory for the command")
+      },
+      async (args) => {
+        try {
+          const options = { 
+            cwd: args.cwd || getCwd(),
+            timeout: 120000
+          }
+          const { stdout, stderr } = await execAsync(args.command, options)
+          const output = stdout || stderr || "(no output)"
+          return {
+            content: [{ type: "text", text: output }]
+          }
+        } catch (error: unknown) {
+          const execError = error as { stdout?: string; stderr?: string; message?: string }
+          const output = execError.stdout || execError.stderr || execError.message || String(error)
+          return {
+            content: [{ type: "text", text: output }],
+            isError: true
+          }
+        }
+      }
+    ),
+    
+    tool(
+      "glob",
+      "Find files matching a glob pattern",
+      {
+        pattern: z.string().describe("Glob pattern like **/*.ts"),
+        cwd: z.string().optional().describe("Base directory for the search")
+      },
+      async (args) => {
+        try {
+          const files = await globLib(args.pattern, {
+            cwd: args.cwd || getCwd(),
+            nodir: true,
+            ignore: ["**/node_modules/**", "**/.git/**"]
+          })
+          return {
+            content: [{ type: "text", text: files.join("\n") || "(no matches)" }]
+          }
+        } catch (error) {
+          return {
+            content: [{ type: "text", text: `Error: ${error instanceof Error ? error.message : String(error)}` }],
+            isError: true
+          }
+        }
+      }
+    ),
+    
+    tool(
+      "grep",
+      "Search for a pattern in files",
+      {
+        pattern: z.string().describe("Regex pattern to search for"),
+        path: z.string().optional().describe("Directory or file to search in"),
+        include: z.string().optional().describe("File pattern to include, e.g., *.ts")
+      },
+      async (args) => {
+        try {
+          const searchPath = args.path || getCwd()
+          const includePattern = args.include || "*"
+          
+          let cmd = `grep -rn --include="${includePattern}" "${args.pattern}" "${searchPath}" 2>/dev/null || true`
+          const { stdout } = await execAsync(cmd, { maxBuffer: 10 * 1024 * 1024 })
+          
+          return {
+            content: [{ type: "text", text: stdout || "(no matches)" }]
+          }
+        } catch (error) {
+          return {
+            content: [{ type: "text", text: `Error: ${error instanceof Error ? error.message : String(error)}` }],
+            isError: true
+          }
+        }
+      }
+    )
+  ]
+})

package/src/plugin/claude-max-headers.ts

@@ -0,0 +1,52 @@
+/**
+ * OpenCode plugin that injects session tracking headers into Anthropic API requests.
+ *
+ * This enables the claude-max-proxy to reliably track sessions and resume
+ * Claude Agent SDK conversations instead of starting fresh every time.
+ *
+ * Installation:
+ *   Add to your opencode.json:
+ *     { "plugin": ["./path/to/claude-max-headers.ts"] }
+ *
+ *   Or copy to your project's .opencode/plugin/ directory.
+ *
+ * What it does:
+ *   Adds x-opencode-session and x-opencode-request headers to requests
+ *   sent to the Anthropic provider. The proxy uses these to map OpenCode
+ *   sessions to Claude SDK sessions for conversation resumption.
+ *
+ * Without this plugin:
+ *   The proxy falls back to fingerprint-based session matching (hashing
+ *   the first user message). This works but is less reliable.
+ */
+
+type ChatHeadersHook = (
+  incoming: {
+    sessionID: string
+    agent: any
+    model: { providerID: string }
+    provider: any
+    message: { id: string }
+  },
+  output: { headers: Record<string, string> }
+) => Promise<void>
+
+type PluginHooks = {
+  "chat.headers"?: ChatHeadersHook
+}
+
+type PluginFn = (input: any) => Promise<PluginHooks>
+
+export const ClaudeMaxHeadersPlugin: PluginFn = async (_input) => {
+  return {
+    "chat.headers": async (incoming, output) => {
+      // Only inject headers for Anthropic provider requests
+      if (incoming.model.providerID !== "anthropic") return
+
+      output.headers["x-opencode-session"] = incoming.sessionID
+      output.headers["x-opencode-request"] = incoming.message.id
+    },
+  }
+}
+
+export default ClaudeMaxHeadersPlugin

package/src/proxy/server.ts

@@ -415,34 +415,118 @@ export function createProxyServer(config: Partial<ProxyConfig> = {}) {
 
 
 
-      // When resuming, only send the last user message (SDK already has history)
-      const messagesToConvert = isResume
-        ? getLastUserMessage(body.messages || [])
-        : body.messages
-
-      // Convert messages to a text prompt, preserving all content types
-      const conversationParts = messagesToConvert
-        ?.map((m: { role: string; content: string | Array<{ type: string; text?: string; content?: string; tool_use_id?: string; name?: string; input?: unknown; id?: string }> }) => {
-          const role = m.role === "assistant" ? "Assistant" : "Human"
-          let content: string
+      // When resuming, only send new messages the SDK doesn't have.
+      const allMessages = body.messages || []
+      let messagesToConvert: typeof allMessages
+
+      if (isResume && cachedSession) {
+        const knownCount = cachedSession.messageCount || 0
+        if (knownCount > 0 && knownCount < allMessages.length) {
+          messagesToConvert = allMessages.slice(knownCount)
+        } else {
+          messagesToConvert = getLastUserMessage(allMessages)
+        }
+      } else {
+        messagesToConvert = allMessages
+      }
+
+      // Check if any messages contain multimodal content (images, documents, files)
+      const MULTIMODAL_TYPES = new Set(["image", "document", "file"])
+      const hasMultimodal = messagesToConvert?.some((m: any) =>
+        Array.isArray(m.content) && m.content.some((b: any) => MULTIMODAL_TYPES.has(b.type))
+      )
+
+      // Strip cache_control from content blocks — the SDK manages its own caching
+      // and OpenCode's ttl='1h' blocks conflict with the SDK's ttl='5m' blocks
+      function stripCacheControl(content: any): any {
+        if (!Array.isArray(content)) return content
+        return content.map((block: any) => {
+          if (block.cache_control) {
+            const { cache_control, ...rest } = block
+            return rest
+          }
+          return block
+        })
+      }
+
+      // Build the prompt — either structured (multimodal) or text
+      let prompt: string | AsyncIterable<any>
+
+      if (hasMultimodal) {
+        // Structured messages preserve image/document/file blocks for Claude to see.
+        // The SDK only accepts role:"user" in SDKUserMessage, so assistant messages
+        // are converted to text summaries wrapped as user messages.
+        const structured = messagesToConvert.map((m: any) => {
+          if (m.role === "user") {
+            return {
+              type: "user" as const,
+              message: { role: "user" as const, content: stripCacheControl(m.content) },
+              parent_tool_use_id: null,
+            }
+          }
+          // Convert assistant/tool messages to text summary
+          let text: string
           if (typeof m.content === "string") {
-            content = m.content
+            text = `[Assistant: ${m.content}]`
           } else if (Array.isArray(m.content)) {
-            content = m.content
-              .map((block: any) => {
-                if (block.type === "text" && block.text) return block.text
-                if (block.type === "tool_use") return `[Tool Use: ${block.name}(${JSON.stringify(block.input)})]`
-                if (block.type === "tool_result") return `[Tool Result for ${block.tool_use_id}: ${typeof block.content === "string" ? block.content : JSON.stringify(block.content)}]`
-                return ""
-              })
-              .filter(Boolean)
-              .join("\n")
+            text = m.content.map((b: any) => {
+              if (b.type === "text" && b.text) return `[Assistant: ${b.text}]`
+              if (b.type === "tool_use") return `[Tool Use: ${b.name}(${JSON.stringify(b.input)})]`
+              if (b.type === "tool_result") return `[Tool Result: ${typeof b.content === "string" ? b.content : JSON.stringify(b.content)}]`
+              return ""
+            }).filter(Boolean).join("\n")
           } else {
-            content = String(m.content)
+            text = `[Assistant: ${String(m.content)}]`
+          }
+          return {
+            type: "user" as const,
+            message: { role: "user" as const, content: text },
+            parent_tool_use_id: null,
           }
-          return `${role}: ${content}`
         })
-        .join("\n\n") || ""
+
+        // Prepend system context as a text message
+        if (systemContext) {
+          structured.unshift({
+            type: "user" as const,
+            message: { role: "user", content: systemContext },
+            parent_tool_use_id: null,
+          })
+        }
+
+        prompt = (async function* () { for (const msg of structured) yield msg })()
+      } else {
+        // Text prompt — convert messages to string
+        const conversationParts = messagesToConvert
+          ?.map((m: { role: string; content: string | Array<{ type: string; text?: string; content?: string; tool_use_id?: string; name?: string; input?: unknown; id?: string }> }) => {
+            const role = m.role === "assistant" ? "Assistant" : "Human"
+            let content: string
+            if (typeof m.content === "string") {
+              content = m.content
+            } else if (Array.isArray(m.content)) {
+              content = m.content
+                .map((block: any) => {
+                  if (block.type === "text" && block.text) return block.text
+                  if (block.type === "tool_use") return `[Tool Use: ${block.name}(${JSON.stringify(block.input)})]`
+                  if (block.type === "tool_result") return `[Tool Result for ${block.tool_use_id}: ${typeof block.content === "string" ? block.content : JSON.stringify(block.content)}]`
+                  if (block.type === "image") return "[Image attached]"
+                  if (block.type === "document") return "[Document attached]"
+                  if (block.type === "file") return "[File attached]"
+                  return ""
+                })
+                .filter(Boolean)
+                .join("\n")
+            } else {
+              content = String(m.content)
+            }
+            return `${role}: ${content}`
+          })
+          .join("\n\n") || ""
+
+        prompt = systemContext
+          ? `${systemContext}\n\n${conversationParts}`
+          : conversationParts
+      }
 
       // --- Passthrough mode ---
       // When enabled, ALL tool execution is forwarded to OpenCode instead of
@@ -499,10 +583,7 @@ export function createProxyServer(config: Partial<ProxyConfig> = {}) {
             }
           : undefined
 
-      // Combine system context with conversation
-      const prompt = systemContext
-        ? `${systemContext}\n\n${conversationParts}`
-        : conversationParts
+
 
         if (!stream) {
           const contentBlocks: Array<Record<string, unknown>> = []
@@ -1034,6 +1115,12 @@ export function createProxyServer(config: Partial<ProxyConfig> = {}) {
     }
   })
 
+  // Catch-all: log unhandled requests
+  app.all("*", (c) => {
+    console.error(`[PROXY] UNHANDLED ${c.req.method} ${c.req.url}`)
+    return c.json({ error: { type: "not_found", message: `Endpoint not supported: ${c.req.method} ${new URL(c.req.url).pathname}` } }, 404)
+  })
+
   return { app, config: finalConfig }
 }