@rynfar/meridian 1.21.1

package/dist/cli.js

@@ -0,0 +1,46 @@
+#!/usr/bin/env node
+import {
+  __require,
+  startProxyServer
+} from "./cli-zyn4cqp2.js";
+
+// bin/cli.ts
+import { exec as execCallback } from "child_process";
+import { promisify } from "util";
+var exec = promisify(execCallback);
+process.on("uncaughtException", (err) => {
+  console.error(`[PROXY] Uncaught exception (recovered): ${err.message}`);
+});
+process.on("unhandledRejection", (reason) => {
+  console.error(`[PROXY] Unhandled rejection (recovered): ${reason instanceof Error ? reason.message : reason}`);
+});
+var port = parseInt(process.env.CLAUDE_PROXY_PORT || "3456", 10);
+var host = process.env.CLAUDE_PROXY_HOST || "127.0.0.1";
+var idleTimeoutSeconds = parseInt(process.env.CLAUDE_PROXY_IDLE_TIMEOUT_SECONDS || "120", 10);
+async function runCli(start = startProxyServer, runExec = exec) {
+  try {
+    const { stdout } = await runExec("claude auth status", { timeout: 5000 });
+    const auth = JSON.parse(stdout);
+    if (!auth.loggedIn) {
+      console.error("\x1B[31m✗ Not logged in to Claude.\x1B[0m Run: claude login");
+      process.exit(1);
+    }
+    if (auth.subscriptionType !== "max") {
+      console.error(`\x1B[33m⚠ Claude subscription: ${auth.subscriptionType || "unknown"} (Max recommended)\x1B[0m`);
+    }
+  } catch {
+    console.error("\x1B[33m⚠ Could not verify Claude auth status. If requests fail, run: claude login\x1B[0m");
+  }
+  const proxy = await start({ port, host, idleTimeoutSeconds });
+  proxy.server.on("error", (error) => {
+    if (error.code === "EADDRINUSE") {
+      process.exit(1);
+    }
+  });
+}
+if (__require.main == __require.module) {
+  await runCli();
+}
+export {
+  runCli
+};

package/dist/logger.d.ts

@@ -0,0 +1,5 @@
+type LogFields = Record<string, unknown>;
+export declare const withClaudeLogContext: <T>(context: LogFields, fn: () => T) => T;
+export declare const claudeLog: (event: string, extra?: LogFields) => void;
+export {};
+//# sourceMappingURL=logger.d.ts.map

package/dist/logger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logger.d.ts","sourceRoot":"","sources":["../src/logger.ts"],"names":[],"mappings":"AAEA,KAAK,SAAS,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;AAyDxC,eAAO,MAAM,oBAAoB,GAAI,CAAC,EAAE,SAAS,SAAS,EAAE,IAAI,MAAM,CAAC,KAAG,CAEzE,CAAA;AAED,eAAO,MAAM,SAAS,GAAI,OAAO,MAAM,EAAE,QAAQ,SAAS,SAQzD,CAAA"}

package/dist/mcpTools.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Create a fresh MCP server instance per request.
+ *
+ * SDK ≥0.2.81 enforces "one Protocol per transport connection". The internal
+ * McpServer holds a Protocol whose connect() throws if reused:
+ *   "Already connected to a transport. Call close() before connecting to a
+ *    new transport, or use a separate Protocol instance per connection."
+ *
+ * Each query() call connects its own transport to the MCP server, so sharing
+ * a singleton across requests triggers this guard on the second request.
+ * Creating a fresh instance avoids the conflict entirely — the same pattern
+ * used by createPassthroughMcpServer().
+ */
+export declare function createOpencodeMcpServer(): import("@anthropic-ai/claude-agent-sdk").McpSdkServerConfigWithInstance;
+//# sourceMappingURL=mcpTools.d.ts.map

package/dist/mcpTools.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mcpTools.d.ts","sourceRoot":"","sources":["../src/mcpTools.ts"],"names":[],"mappings":"AAYA;;;;;;;;;;;;GAYG;AACH,wBAAgB,uBAAuB,4EA8KtC"}

package/dist/proxy/adapter.d.ts

@@ -0,0 +1,78 @@
+/**
+ * Agent adapter interface.
+ *
+ * Abstracts agent-specific behavior so the proxy can work with
+ * different calling agents (OpenCode, Claude Code, custom agents).
+ */
+import type { Context } from "hono";
+/**
+ * An agent adapter provides agent-specific configuration to the proxy.
+ * The proxy calls these methods during request handling to determine
+ * how to interact with the calling agent.
+ */
+export interface AgentAdapter {
+    /** Human-readable name for logging */
+    readonly name: string;
+    /**
+     * Extract a session ID from the request.
+     * Returns undefined if the agent doesn't provide session tracking.
+     */
+    getSessionId(c: Context): string | undefined;
+    /**
+     * Extract the client's working directory from the request body.
+     * Returns undefined to fall back to CLAUDE_PROXY_WORKDIR or process.cwd().
+     */
+    extractWorkingDirectory(body: any): string | undefined;
+    /**
+     * Content normalization — convert message content to a stable string
+     * for hashing. Agents may send content in different formats.
+     */
+    normalizeContent(content: any): string;
+    /**
+     * SDK built-in tools to block (replaced by MCP equivalents).
+     * These are tools where the agent provides its own implementation.
+     */
+    getBlockedBuiltinTools(): readonly string[];
+    /**
+     * Claude Code SDK tools that have no equivalent in this agent.
+     * These are blocked to prevent Claude from calling tools the agent
+     * can't handle.
+     */
+    getAgentIncompatibleTools(): readonly string[];
+    /**
+     * The MCP server name used by this agent.
+     * Tools are registered as `mcp__{name}__{tool}`.
+     */
+    getMcpServerName(): string;
+    /**
+     * MCP tools that are allowed through the proxy's tool filter.
+     */
+    getAllowedMcpTools(): readonly string[];
+    /**
+     * Build SDK agent definitions from the request body.
+     * Returns agent name → AgentDefinition map for SDK subagent routing.
+     * Return empty object {} if the agent doesn't support subagent routing.
+     */
+    buildSdkAgents?(body: any, mcpToolNames: readonly string[]): Record<string, any>;
+    /**
+     * Build SDK hooks (e.g., PreToolUse) for this agent.
+     * Return undefined if no hooks are needed.
+     */
+    buildSdkHooks?(body: any, sdkAgents: Record<string, any>): any;
+    /**
+     * Build additional system context to append (e.g., agent name hints).
+     * Return empty string if nothing to add.
+     */
+    buildSystemContextAddendum?(body: any, sdkAgents: Record<string, any>): string;
+    /**
+     * Whether this agent uses passthrough mode for tool execution.
+     *
+     * In passthrough mode the proxy returns tool_use blocks to the calling
+     * agent for it to execute, rather than executing them internally via MCP.
+     *
+     * When undefined, falls back to the CLAUDE_PROXY_PASSTHROUGH env var.
+     * When defined, takes precedence over the env var for this agent.
+     */
+    usesPassthrough?(): boolean;
+}
+//# sourceMappingURL=adapter.d.ts.map

package/dist/proxy/adapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"adapter.d.ts","sourceRoot":"","sources":["../../src/proxy/adapter.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,MAAM,CAAA;AAEnC;;;;GAIG;AACH,MAAM,WAAW,YAAY;IAC3B,sCAAsC;IACtC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IAErB;;;OAGG;IACH,YAAY,CAAC,CAAC,EAAE,OAAO,GAAG,MAAM,GAAG,SAAS,CAAA;IAE5C;;;OAGG;IACH,uBAAuB,CAAC,IAAI,EAAE,GAAG,GAAG,MAAM,GAAG,SAAS,CAAA;IAEtD;;;OAGG;IACH,gBAAgB,CAAC,OAAO,EAAE,GAAG,GAAG,MAAM,CAAA;IAEtC;;;OAGG;IACH,sBAAsB,IAAI,SAAS,MAAM,EAAE,CAAA;IAE3C;;;;OAIG;IACH,yBAAyB,IAAI,SAAS,MAAM,EAAE,CAAA;IAE9C;;;OAGG;IACH,gBAAgB,IAAI,MAAM,CAAA;IAE1B;;OAEG;IACH,kBAAkB,IAAI,SAAS,MAAM,EAAE,CAAA;IAEvC;;;;OAIG;IACH,cAAc,CAAC,CAAC,IAAI,EAAE,GAAG,EAAE,YAAY,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAA;IAEhF;;;OAGG;IACH,aAAa,CAAC,CAAC,IAAI,EAAE,GAAG,EAAE,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,GAAG,CAAA;IAE9D;;;OAGG;IACH,0BAA0B,CAAC,CAAC,IAAI,EAAE,GAAG,EAAE,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,MAAM,CAAA;IAE9E;;;;;;;;OAQG;IACH,eAAe,CAAC,IAAI,OAAO,CAAA;CAC5B"}

package/dist/proxy/adapters/crush.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Crush (Charm) agent adapter.
+ *
+ * Provides Crush-specific behavior for session tracking, content normalization,
+ * and tool configuration.
+ *
+ * Crush connects via a provider entry in ~/.config/crush/crush.json using
+ * type "anthropic" with base_url pointing at this proxy. No special auth
+ * or BYOK mechanism — just a base_url override.
+ *
+ * Key characteristics:
+ * - User-Agent: Charm-Crush/<version>
+ * - Always streams (stream: true)
+ * - 19 lowercase tool names (bash, edit, write, grep, ls, etc.)
+ * - No session header: relies on fingerprint-based session cache
+ * - No CWD in request body: falls back to CLAUDE_PROXY_WORKDIR or process.cwd()
+ * - Manages its own tool execution loop: passthrough mode is appropriate
+ * - System prompt sent as a list in the `system` field (not embedded in messages)
+ */
+import type { AgentAdapter } from "../adapter";
+export declare const crushAdapter: AgentAdapter;
+//# sourceMappingURL=crush.d.ts.map

package/dist/proxy/adapters/crush.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"crush.d.ts","sourceRoot":"","sources":["../../../src/proxy/adapters/crush.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAGH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAA;AAe9C,eAAO,MAAM,YAAY,EAAE,YAkE1B,CAAA"}

package/dist/proxy/adapters/detect.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Agent adapter detection.
+ *
+ * Inspects the incoming request to select the appropriate AgentAdapter.
+ * Falls back to the OpenCode adapter for backward compatibility.
+ */
+import type { Context } from "hono";
+import type { AgentAdapter } from "../adapter";
+/**
+ * Detect which agent adapter to use based on request headers.
+ *
+ * Detection rules (evaluated in order):
+ * 1. User-Agent starts with "factory-cli/"  → Droid adapter
+ * 2. User-Agent starts with "Charm-Crush/"  → Crush adapter
+ * 3. Default                                → OpenCode adapter (backward compatible)
+ */
+export declare function detectAdapter(c: Context): AgentAdapter;
+//# sourceMappingURL=detect.d.ts.map

package/dist/proxy/adapters/detect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"detect.d.ts","sourceRoot":"","sources":["../../../src/proxy/adapters/detect.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,MAAM,CAAA;AACnC,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAA;AAK9C;;;;;;;GAOG;AACH,wBAAgB,aAAa,CAAC,CAAC,EAAE,OAAO,GAAG,YAAY,CAYtD"}

package/dist/proxy/adapters/droid.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Droid (Factory AI) agent adapter.
+ *
+ * Provides Droid-specific behavior for session tracking, working directory
+ * extraction, content normalization, and tool configuration.
+ *
+ * Authentication: Droid connects via BYOK (Bring Your Own Key) by setting
+ * provider="anthropic" and baseUrl pointing to this proxy in
+ * ~/.factory/settings.json customModels.
+ *
+ * Key differences from OpenCode:
+ * - No session header: relies on fingerprint-based session caching
+ * - CWD in <system-reminder> blocks inside user messages (not <env> in system)
+ * - No subagent routing: Droid manages its own subagents internally
+ * - MCP server name: "droid"
+ */
+import type { AgentAdapter } from "../adapter";
+export declare const droidAdapter: AgentAdapter;
+//# sourceMappingURL=droid.d.ts.map

package/dist/proxy/adapters/droid.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"droid.d.ts","sourceRoot":"","sources":["../../../src/proxy/adapters/droid.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAGH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAA;AAwC9C,eAAO,MAAM,YAAY,EAAE,YAuE1B,CAAA"}

package/dist/proxy/adapters/opencode.d.ts

@@ -0,0 +1,9 @@
+/**
+ * OpenCode agent adapter.
+ *
+ * Provides OpenCode-specific behavior for session tracking,
+ * working directory extraction, content normalization, and tool configuration.
+ */
+import type { AgentAdapter } from "../adapter";
+export declare const openCodeAdapter: AgentAdapter;
+//# sourceMappingURL=opencode.d.ts.map

package/dist/proxy/adapters/opencode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"opencode.d.ts","sourceRoot":"","sources":["../../../src/proxy/adapters/opencode.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAA;AAO9C,eAAO,MAAM,eAAe,EAAE,YA6E7B,CAAA"}

package/dist/proxy/agentDefs.d.ts

@@ -0,0 +1,51 @@
+/**
+ * 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 declare function parseAgentDescriptions(taskDescription: string): Map<string, string>;
+/**
+ * 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 declare function mapModelTier(model?: string): "sonnet" | "opus" | "opus[1m]" | "haiku" | "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 declare function buildAgentDefinitions(taskDescription: string, mcpToolNames?: string[]): Record<string, AgentDefinition>;
+//# sourceMappingURL=agentDefs.d.ts.map

package/dist/proxy/agentDefs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agentDefs.d.ts","sourceRoot":"","sources":["../../src/proxy/agentDefs.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,sCAAsC;AACtC,MAAM,WAAW,eAAe;IAC9B,WAAW,EAAE,MAAM,CAAA;IACnB,MAAM,EAAE,MAAM,CAAA;IACd,KAAK,CAAC,EAAE,QAAQ,GAAG,MAAM,GAAG,OAAO,GAAG,SAAS,CAAA;IAC/C,KAAK,CAAC,EAAE,MAAM,EAAE,CAAA;IAChB,eAAe,CAAC,EAAE,MAAM,EAAE,CAAA;CAC3B;AAED;;;;;;;GAOG;AACH,wBAAgB,sBAAsB,CAAC,eAAe,EAAE,MAAM,GAAG,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAcnF;AAED;;;;;;GAMG;AACH,wBAAgB,YAAY,CAAC,KAAK,CAAC,EAAE,MAAM,GAAG,QAAQ,GAAG,MAAM,GAAG,UAAU,GAAG,OAAO,GAAG,SAAS,CAOjG;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,qBAAqB,CACnC,eAAe,EAAE,MAAM,EACvB,YAAY,CAAC,EAAE,MAAM,EAAE,GACtB,MAAM,CAAC,MAAM,EAAE,eAAe,CAAC,CAejC"}

package/dist/proxy/agentMatch.d.ts

@@ -0,0 +1,18 @@
+/**
+ * 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
+ */
+export declare function fuzzyMatchAgentName(input: string, validAgents: string[]): string;
+//# sourceMappingURL=agentMatch.d.ts.map

package/dist/proxy/agentMatch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agentMatch.d.ts","sourceRoot":"","sources":["../../src/proxy/agentMatch.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAwCH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,EAAE,GAAG,MAAM,CAqChF"}

package/dist/proxy/errors.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Error classification for SDK errors.
+ * Maps raw error messages to structured HTTP error responses.
+ */
+export interface ClassifiedError {
+    status: number;
+    type: string;
+    message: string;
+}
+/**
+ * Detect specific SDK errors and return helpful messages to the client.
+ */
+export declare function classifyError(errMsg: string): ClassifiedError;
+/**
+ * Detect errors caused by stale session/message UUIDs.
+ * These happen when the upstream Claude session no longer contains
+ * the referenced message (expired, compacted server-side, etc.).
+ */
+export declare function isStaleSessionError(error: unknown): boolean;
+/**
+ * Quick check whether an error message indicates a rate limit.
+ * Used by server.ts to decide whether to retry with a smaller context window.
+ */
+export declare function isRateLimitError(errMsg: string): boolean;
+//# sourceMappingURL=errors.d.ts.map

package/dist/proxy/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../src/proxy/errors.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,MAAM,WAAW,eAAe;IAC9B,MAAM,EAAE,MAAM,CAAA;IACd,IAAI,EAAE,MAAM,CAAA;IACZ,OAAO,EAAE,MAAM,CAAA;CAChB;AAED;;GAEG;AACH,wBAAgB,aAAa,CAAC,MAAM,EAAE,MAAM,GAAG,eAAe,CAoF7D;AAED;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAG3D;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAGxD"}

package/dist/proxy/messages.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Message parsing and normalization utilities.
+ */
+/**
+ * Normalize message content to a string for hashing and comparison.
+ * Handles both string content and array content (Anthropic content blocks).
+ * Strips cache_control metadata to ensure hash stability across requests.
+ *
+ * NOTE: OpenCode sends content as a string on the first request but as
+ * an array on subsequent ones. This normalizer handles both formats.
+ * Other agents may behave differently — this will move to the adapter pattern.
+ */
+export declare function normalizeContent(content: any): string;
+/**
+ * Extract only the last user message (for session resume — SDK already has history).
+ */
+export declare function getLastUserMessage(messages: Array<{
+    role: string;
+    content: any;
+}>): Array<{
+    role: string;
+    content: any;
+}>;
+//# sourceMappingURL=messages.d.ts.map

package/dist/proxy/messages.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"messages.d.ts","sourceRoot":"","sources":["../../src/proxy/messages.ts"],"names":[],"mappings":"AAAA;;GAEG;AAcH;;;;;;;;GAQG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,GAAG,GAAG,MAAM,CAiBrD;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,KAAK,CAAC;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,GAAG,CAAA;CAAE,CAAC,GAAG,KAAK,CAAC;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,GAAG,CAAA;CAAE,CAAC,CAKzH"}

package/dist/proxy/models.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Model mapping and Claude executable resolution.
+ */
+export type ClaudeModel = "sonnet" | "sonnet[1m]" | "opus" | "opus[1m]" | "haiku";
+export interface ClaudeAuthStatus {
+    loggedIn?: boolean;
+    subscriptionType?: string;
+    email?: string;
+}
+export declare function mapModelToClaudeModel(model: string, subscriptionType?: string | null): ClaudeModel;
+/**
+ * Strip the [1m] suffix from a model, returning the base variant.
+ * Used for fallback when the 1M context window is rate-limited.
+ */
+export declare function stripExtendedContext(model: ClaudeModel): ClaudeModel;
+/**
+ * Check whether a model is using extended (1M) context.
+ */
+export declare function hasExtendedContext(model: ClaudeModel): boolean;
+export declare function getClaudeAuthStatusAsync(): Promise<ClaudeAuthStatus | null>;
+/**
+ * Resolve the Claude executable path asynchronously (non-blocking).
+ *
+ * Uses a three-tier cache:
+ * 1. cachedClaudePath — resolved path, returned immediately on subsequent calls
+ * 2. cachedClaudePathPromise — deduplicates concurrent calls during resolution
+ * 3. Falls through to resolution logic (SDK cli.js → system `which claude`)
+ *
+ * The promise is cleared in `finally` to allow retry on failure while
+ * cachedClaudePath prevents re-resolution on success.
+ */
+export declare function resolveClaudeExecutableAsync(): Promise<string>;
+/** Reset cached path — for testing only */
+export declare function resetCachedClaudePath(): void;
+/** Reset cached auth status — for testing only */
+export declare function resetCachedClaudeAuthStatus(): void;
+/** Expire the auth status cache without clearing lastKnownGoodAuthStatus — for testing only.
+ *  This simulates the TTL expiring so the next call re-executes `claude auth status`,
+ *  while preserving the "last known good" fallback state. */
+export declare function expireAuthStatusCache(): void;
+/**
+ * Check if an error is a "Controller is already closed" error.
+ * This happens when the client disconnects mid-stream.
+ */
+export declare function isClosedControllerError(error: unknown): boolean;
+//# sourceMappingURL=models.d.ts.map

package/dist/proxy/models.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"models.d.ts","sourceRoot":"","sources":["../../src/proxy/models.ts"],"names":[],"mappings":"AAAA;;GAEG;AAUH,MAAM,MAAM,WAAW,GAAG,QAAQ,GAAG,YAAY,GAAG,MAAM,GAAG,UAAU,GAAG,OAAO,CAAA;AACjF,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,EAAE,OAAO,CAAA;IAClB,gBAAgB,CAAC,EAAE,MAAM,CAAA;IACzB,KAAK,CAAC,EAAE,MAAM,CAAA;CACf;AA0BD,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,MAAM,EAAE,gBAAgB,CAAC,EAAE,MAAM,GAAG,IAAI,GAAG,WAAW,CAYlG;AAED;;;GAGG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,WAAW,GAAG,WAAW,CAIpE;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,WAAW,GAAG,OAAO,CAE9D;AAED,wBAAsB,wBAAwB,IAAI,OAAO,CAAC,gBAAgB,GAAG,IAAI,CAAC,CAkCjF;AAOD;;;;;;;;;;GAUG;AACH,wBAAsB,4BAA4B,IAAI,OAAO,CAAC,MAAM,CAAC,CAiCpE;AAED,2CAA2C;AAC3C,wBAAgB,qBAAqB,IAAI,IAAI,CAG5C;AAED,kDAAkD;AAClD,wBAAgB,2BAA2B,IAAI,IAAI,CAMlD;AAED;;6DAE6D;AAC7D,wBAAgB,qBAAqB,IAAI,IAAI,CAG5C;AAED;;;GAGG;AACH,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAG/D"}

package/dist/proxy/passthroughTools.d.ts

@@ -0,0 +1,30 @@
+/**
+ * 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.
+ */
+export declare const PASSTHROUGH_MCP_NAME = "oc";
+export declare const PASSTHROUGH_MCP_PREFIX = "mcp__oc__";
+/**
+ * Create an MCP server with tool definitions matching OpenCode's request.
+ */
+export declare function createPassthroughMcpServer(tools: Array<{
+    name: string;
+    description?: string;
+    input_schema?: any;
+}>): {
+    server: import("@anthropic-ai/claude-agent-sdk").McpSdkServerConfigWithInstance;
+    toolNames: string[];
+};
+/**
+ * Strip the MCP prefix from a tool name to get the OpenCode tool name.
+ * e.g., "mcp__oc__todowrite" → "todowrite"
+ */
+export declare function stripMcpPrefix(toolName: string): string;
+//# sourceMappingURL=passthroughTools.d.ts.map

package/dist/proxy/passthroughTools.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"passthroughTools.d.ts","sourceRoot":"","sources":["../../src/proxy/passthroughTools.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAKH,eAAO,MAAM,oBAAoB,OAAO,CAAA;AACxC,eAAO,MAAM,sBAAsB,cAAmC,CAAA;AAsCtE;;GAEG;AACH,wBAAgB,0BAA0B,CACxC,KAAK,EAAE,KAAK,CAAC;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,WAAW,CAAC,EAAE,MAAM,CAAC;IAAC,YAAY,CAAC,EAAE,GAAG,CAAA;CAAE,CAAC;;;EAsCzE;AAED;;;GAGG;AACH,wBAAgB,cAAc,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAKvD"}

package/dist/proxy/query.d.ts

@@ -0,0 +1,105 @@
+/**
+ * SDK query options builder.
+ *
+ * Centralizes the construction of query() options, eliminating duplication
+ * between the streaming and non-streaming paths in server.ts.
+ */
+import type { AgentAdapter } from "./adapter";
+import { createPassthroughMcpServer } from "./passthroughTools";
+export interface QueryContext {
+    /** The prompt to send (text or async iterable for multimodal) */
+    prompt: string | AsyncIterable<any>;
+    /** Resolved Claude model name */
+    model: string;
+    /** Client working directory */
+    workingDirectory: string;
+    /** System context text (may be empty) */
+    systemContext: string;
+    /** Path to Claude executable */
+    claudeExecutable: string;
+    /** Whether passthrough mode is enabled */
+    passthrough: boolean;
+    /** Whether this is a streaming request */
+    stream: boolean;
+    /** SDK agent definitions extracted from tool descriptions */
+    sdkAgents: Record<string, any>;
+    /** Passthrough MCP server (if passthrough mode + tools present) */
+    passthroughMcp?: ReturnType<typeof createPassthroughMcpServer>;
+    /** Cleaned environment variables (API keys stripped) */
+    cleanEnv: Record<string, string | undefined>;
+    /** SDK session ID for resume (if continuing a session) */
+    resumeSessionId?: string;
+    /** Whether this is an undo operation */
+    isUndo: boolean;
+    /** UUID to rollback to for undo operations */
+    undoRollbackUuid?: string;
+    /** SDK hooks (PreToolUse etc.) */
+    sdkHooks?: any;
+    /** The agent adapter providing tool configuration */
+    adapter: AgentAdapter;
+}
+/**
+ * Build the options object for the Claude Agent SDK query() call.
+ * This is called identically from both streaming and non-streaming paths,
+ * with the only difference being `includePartialMessages` for streaming.
+ */
+export declare function buildQueryOptions(ctx: QueryContext): {
+    prompt: string | AsyncIterable<any>;
+    options: {
+        hooks?: any;
+        resumeSessionAt?: string | undefined;
+        forkSession?: boolean | undefined;
+        resume?: string | undefined;
+        agents?: Record<string, any> | undefined;
+        plugins: never[];
+        env: {
+            ENABLE_TOOL_SEARCH: string;
+        };
+        allowedTools?: string[] | undefined;
+        mcpServers?: {
+            oc: import("@anthropic-ai/claude-agent-sdk").McpSdkServerConfigWithInstance;
+        } | undefined;
+        disallowedTools: string[];
+        systemPrompt?: {
+            type: "preset";
+            preset: "claude_code";
+            append: string;
+        } | undefined;
+        permissionMode: "bypassPermissions";
+        allowDangerouslySkipPermissions: boolean;
+        includePartialMessages?: boolean | undefined;
+        maxTurns: number;
+        cwd: string;
+        model: string;
+        pathToClaudeCodeExecutable: string;
+    } | {
+        hooks?: any;
+        resumeSessionAt?: string | undefined;
+        forkSession?: boolean | undefined;
+        resume?: string | undefined;
+        agents?: Record<string, any> | undefined;
+        plugins: never[];
+        env: {
+            ENABLE_TOOL_SEARCH: string;
+        };
+        disallowedTools: string[];
+        allowedTools: string[];
+        mcpServers: {
+            [x: string]: import("@anthropic-ai/claude-agent-sdk").McpSdkServerConfigWithInstance;
+            oc?: undefined;
+        };
+        systemPrompt?: {
+            type: "preset";
+            preset: "claude_code";
+            append: string;
+        } | undefined;
+        permissionMode: "bypassPermissions";
+        allowDangerouslySkipPermissions: boolean;
+        includePartialMessages?: boolean | undefined;
+        maxTurns: number;
+        cwd: string;
+        model: string;
+        pathToClaudeCodeExecutable: string;
+    };
+};
+//# sourceMappingURL=query.d.ts.map

package/dist/proxy/query.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"query.d.ts","sourceRoot":"","sources":["../../src/proxy/query.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,WAAW,CAAA;AAE7C,OAAO,EAAE,0BAA0B,EAAwB,MAAM,oBAAoB,CAAA;AAErF,MAAM,WAAW,YAAY;IAC3B,iEAAiE;IACjE,MAAM,EAAE,MAAM,GAAG,aAAa,CAAC,GAAG,CAAC,CAAA;IACnC,iCAAiC;IACjC,KAAK,EAAE,MAAM,CAAA;IACb,+BAA+B;IAC/B,gBAAgB,EAAE,MAAM,CAAA;IACxB,yCAAyC;IACzC,aAAa,EAAE,MAAM,CAAA;IACrB,gCAAgC;IAChC,gBAAgB,EAAE,MAAM,CAAA;IACxB,0CAA0C;IAC1C,WAAW,EAAE,OAAO,CAAA;IACpB,0CAA0C;IAC1C,MAAM,EAAE,OAAO,CAAA;IACf,6DAA6D;IAC7D,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAA;IAC9B,mEAAmE;IACnE,cAAc,CAAC,EAAE,UAAU,CAAC,OAAO,0BAA0B,CAAC,CAAA;IAC9D,wDAAwD;IACxD,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC,CAAA;IAC5C,0DAA0D;IAC1D,eAAe,CAAC,EAAE,MAAM,CAAA;IACxB,wCAAwC;IACxC,MAAM,EAAE,OAAO,CAAA;IACf,8CAA8C;IAC9C,gBAAgB,CAAC,EAAE,MAAM,CAAA;IACzB,kCAAkC;IAClC,QAAQ,CAAC,EAAE,GAAG,CAAA;IACd,qDAAqD;IACrD,OAAO,EAAE,YAAY,CAAA;CACtB;AAED;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA6ClD"}

package/dist/proxy/server.d.ts

@@ -0,0 +1,10 @@
+import type { ProxyConfig, ProxyInstance, ProxyServer } from "./types";
+export type { ProxyConfig, ProxyInstance, ProxyServer };
+import { computeLineageHash, hashMessage, computeMessageHashes, type LineageResult } from "./session/lineage";
+import { clearSessionCache, getMaxSessionsLimit } from "./session/cache";
+export { computeLineageHash, hashMessage, computeMessageHashes };
+export { clearSessionCache, getMaxSessionsLimit };
+export type { LineageResult };
+export declare function createProxyServer(config?: Partial<ProxyConfig>): ProxyServer;
+export declare function startProxyServer(config?: Partial<ProxyConfig>): Promise<ProxyInstance>;
+//# sourceMappingURL=server.d.ts.map

package/dist/proxy/server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../../src/proxy/server.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,WAAW,EAAE,aAAa,EAAE,WAAW,EAAE,MAAM,SAAS,CAAA;AACtE,YAAY,EAAE,WAAW,EAAE,aAAa,EAAE,WAAW,EAAE,CAAA;AAgBvD,OAAO,EACL,kBAAkB,EAClB,WAAW,EACX,oBAAoB,EACpB,KAAK,aAAa,EACnB,MAAM,mBAAmB,CAAA;AAG1B,OAAO,EAA+B,iBAAiB,EAAE,mBAAmB,EAAgB,MAAM,iBAAiB,CAAA;AAEnH,OAAO,EAAE,kBAAkB,EAAE,WAAW,EAAE,oBAAoB,EAAE,CAAA;AAChE,OAAO,EAAE,iBAAiB,EAAE,mBAAmB,EAAE,CAAA;AACjD,YAAY,EAAE,aAAa,EAAE,CAAA;AAyF7B,wBAAgB,iBAAiB,CAAC,MAAM,GAAE,OAAO,CAAC,WAAW,CAAM,GAAG,WAAW,CAulChF;AAED,wBAAsB,gBAAgB,CAAC,MAAM,GAAE,OAAO,CAAC,WAAW,CAAM,GAAG,OAAO,CAAC,aAAa,CAAC,CA0ChG"}

package/dist/proxy/session/cache.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Session cache management.
+ *
+ * Manages in-memory LRU caches for session and fingerprint lookups,
+ * coordinates with the shared file store for cross-proxy session resume.
+ */
+import { type LineageResult } from "./lineage";
+export declare function getMaxSessionsLimit(): number;
+/** Clear all session caches (used in tests).
+ *  Re-reads MERIDIAN_MAX_SESSIONS / CLAUDE_PROXY_MAX_SESSIONS so tests can override the limit. */
+export declare function clearSessionCache(): void;
+/** Evict a stale session from all caches and the shared store.
+ *  Used when a resume/undo fails because the upstream Claude session is gone. */
+export declare function evictSession(sessionId: string | undefined, workingDirectory?: string, messages?: Array<{
+    role: string;
+    content: any;
+}>): void;
+/** Look up a cached session by header or fingerprint.
+ *  Returns a LineageResult that classifies the mutation and includes the
+ *  session state needed for the correct SDK action. */
+export declare function lookupSession(sessionId: string | undefined, messages: Array<{
+    role: string;
+    content: any;
+}>, workingDirectory?: string): LineageResult;
+/** Store a session mapping with lineage hash and SDK UUIDs for divergence detection.
+ *  @param sdkMessageUuids — per-message SDK assistant UUIDs (null for user messages).
+ *    If provided, merged with any previously stored UUIDs to build a complete map. */
+export declare function storeSession(sessionId: string | undefined, messages: Array<{
+    role: string;
+    content: any;
+}>, claudeSessionId: string, workingDirectory?: string, sdkMessageUuids?: Array<string | null>): void;
+//# sourceMappingURL=cache.d.ts.map

package/dist/proxy/session/cache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cache.d.ts","sourceRoot":"","sources":["../../../src/proxy/session/cache.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAKH,OAAO,EAKL,KAAK,aAAa,EACnB,MAAM,WAAW,CAAA;AAMlB,wBAAgB,mBAAmB,IAAI,MAAM,CAW5C;AAqCD;kGACkG;AAClG,wBAAgB,iBAAiB,SAYhC;AAED;iFACiF;AACjF,wBAAgB,YAAY,CAC1B,SAAS,EAAE,MAAM,GAAG,SAAS,EAC7B,gBAAgB,CAAC,EAAE,MAAM,EACzB,QAAQ,CAAC,EAAE,KAAK,CAAC;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,GAAG,CAAA;CAAE,CAAC,GAC/C,IAAI,CAoBN;AAUD;;uDAEuD;AACvD,wBAAgB,aAAa,CAC3B,SAAS,EAAE,MAAM,GAAG,SAAS,EAC7B,QAAQ,EAAE,KAAK,CAAC;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,GAAG,CAAA;CAAE,CAAC,EAC/C,gBAAgB,CAAC,EAAE,MAAM,GACxB,aAAa,CAqDf;AAED;;sFAEsF;AACtF,wBAAgB,YAAY,CAC1B,SAAS,EAAE,MAAM,GAAG,SAAS,EAC7B,QAAQ,EAAE,KAAK,CAAC;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,GAAG,CAAA;CAAE,CAAC,EAC/C,eAAe,EAAE,MAAM,EACvB,gBAAgB,CAAC,EAAE,MAAM,EACzB,eAAe,CAAC,EAAE,KAAK,CAAC,MAAM,GAAG,IAAI,CAAC,QAoBvC"}