@juspay/neurolink 9.65.2 → 9.66.0

package/dist/cli/commands/proxy.js

@@ -234,6 +234,122 @@ async function clearClaudeProxySettings(expectedBaseUrl) {
     fs.writeFileSync(CLAUDE_SETTINGS_PATH, JSON.stringify(settings, null, 2));
     return hadBaseUrl || hadToolSearch;
 }
+// =============================================================================
+// OPENCODE AUTO-CONFIGURATION
+// =============================================================================
+function getOpenCodeConfigDir() {
+    if (process.platform === "darwin") {
+        return join(homedir(), "Library", "Application Support", "opencode");
+    }
+    // Linux/other: XDG_CONFIG_HOME or ~/.config
+    return join(process.env.XDG_CONFIG_HOME || join(homedir(), ".config"), "opencode");
+}
+const OPENCODE_CONFIG_PATH = join(getOpenCodeConfigDir(), "opencode.json");
+/**
+ * Key under which we persist the snapshot of the user's pre-existing
+ * `provider.neurolink` config inside `opencode.json` itself. Persisting (rather
+ * than relying on in-process state) means restoration still works even if the
+ * proxy crashes or shutdown handlers run in a different process.
+ *
+ * Mirrors the Claude pattern (`__proxy_original_env` inside Claude's settings).
+ */
+const OPENCODE_ORIGINAL_KEY = "__proxy_original_neurolink";
+async function setOpenCodeProxySettings(baseUrl, proxyKey) {
+    const fs = await import("fs");
+    const configDir = getOpenCodeConfigDir();
+    try {
+        fs.accessSync(configDir);
+    }
+    catch {
+        // OpenCode not installed — config directory does not exist, skip silently
+        return;
+    }
+    let config;
+    try {
+        config = JSON.parse(fs.readFileSync(OPENCODE_CONFIG_PATH, "utf8"));
+    }
+    catch {
+        // file missing/invalid — create fresh config object
+        config = { provider: {} };
+    }
+    const provider = (config.provider ?? {});
+    // Persist a snapshot of the user's pre-existing provider.neurolink — but
+    // only the first time we touch the file. Subsequent set() calls must NOT
+    // overwrite the snapshot (otherwise after the proxy writes its own block,
+    // the next set() would store the proxy's block as the "original" and
+    // permanently lose the user's real config on the next clear()).
+    if (!(OPENCODE_ORIGINAL_KEY in config)) {
+        config[OPENCODE_ORIGINAL_KEY] =
+            "neurolink" in provider
+                ? JSON.parse(JSON.stringify(provider.neurolink))
+                : null;
+    }
+    provider.neurolink = {
+        id: "neurolink",
+        name: "NeuroLink Proxy",
+        npm: "@ai-sdk/openai-compatible",
+        env: [],
+        models: {},
+        options: {
+            baseURL: baseUrl,
+            apiKey: proxyKey || "neurolink-proxy",
+        },
+    };
+    config.provider = provider;
+    fs.writeFileSync(OPENCODE_CONFIG_PATH, JSON.stringify(config, null, 2));
+}
+async function clearOpenCodeProxySettings(expectedBaseUrl) {
+    const fs = await import("fs");
+    let config;
+    try {
+        config = JSON.parse(fs.readFileSync(OPENCODE_CONFIG_PATH, "utf8"));
+    }
+    catch {
+        return false;
+    }
+    const provider = config.provider;
+    if (!provider || !("neurolink" in provider)) {
+        return false;
+    }
+    // Check if our proxy URL matches before removing
+    const existing = provider.neurolink;
+    if (expectedBaseUrl && existing) {
+        const options = existing.options;
+        if (options && typeof options.baseURL === "string") {
+            if (options.baseURL !== expectedBaseUrl) {
+                // User configured a different URL; do not clobber
+                return false;
+            }
+        }
+    }
+    const hadNeurolink = "neurolink" in provider;
+    // Restore from the snapshot persisted at first set(), regardless of process
+    // identity. Only delete provider.neurolink when the snapshot says the user
+    // explicitly had no entry before — never on an "undefined" snapshot, since
+    // that would mean the snapshot was lost and we cannot prove the entry is ours.
+    if (OPENCODE_ORIGINAL_KEY in config) {
+        const snapshot = config[OPENCODE_ORIGINAL_KEY];
+        if (snapshot === null) {
+            // User had no provider.neurolink before the proxy started — safe to remove.
+            delete provider.neurolink;
+        }
+        else {
+            provider.neurolink = snapshot;
+        }
+        delete config[OPENCODE_ORIGINAL_KEY];
+    }
+    else {
+        // No snapshot present — refuse to delete to avoid destroying a config
+        // the proxy may not own (e.g. a user wrote their own `neurolink` block
+        // before the snapshot key was introduced, or this is being cleared from
+        // a process that never ran set()).
+        logger.debug("[proxy] OpenCode clear: no original-provider snapshot found, leaving provider.neurolink intact");
+        return false;
+    }
+    config.provider = provider;
+    fs.writeFileSync(OPENCODE_CONFIG_PATH, JSON.stringify(config, null, 2));
+    return hadNeurolink;
+}
 async function isProxyHealthy(host, port, timeoutMs) {
     try {
         const response = await fetch(`http://${host}:${port}/health`, {
@@ -533,9 +649,10 @@ function printProxyBanner(url, strategy) {
     logger.always(`  ${chalk.bold("PID:")}        ${chalk.cyan(process.pid)}`);
     logger.always("");
     logger.always(chalk.bold("Endpoints:"));
-    logger.always(`  ${chalk.blue("POST")} /v1/messages  — Proxy to Anthropic`);
-    logger.always(`  ${chalk.green("GET")}  /health       — Health check`);
-    logger.always(`  ${chalk.green("GET")}  /status       — Detailed status`);
+    logger.always(`  ${chalk.blue("POST")} /v1/messages         — Claude proxy (Anthropic format)`);
+    logger.always(`  ${chalk.blue("POST")} /v1/chat/completions — OpenAI-compatible proxy`);
+    logger.always(`  ${chalk.green("GET")}  /health              — Health check`);
+    logger.always(`  ${chalk.green("GET")}  /status              — Detailed status`);
     logger.always("");
     logger.always(chalk.bold("Set in Claude Code:"));
     logger.always(`  ${chalk.cyan(`ANTHROPIC_BASE_URL=${url}`)}`);
@@ -706,6 +823,7 @@ async function resolveBootPrimaryAccountKey(primaryEmail) {
 }
 async function createProxyStartApp(params) {
     const { createClaudeProxyRoutes } = await import("../../lib/server/routes/claudeProxyRoutes.js");
+    const { createOpenAIProxyRoutes } = await import("../../lib/server/routes/openaiProxyRoutes.js");
     const { Hono } = await import("hono");
     const app = new Hono();
     const readiness = createProxyReadinessState();
@@ -724,7 +842,9 @@ async function createProxyStartApp(params) {
         }, 502);
     });
     const routeGroup = createClaudeProxyRoutes(params.modelRouter, "", params.strategy, params.passthrough, params.primaryAccountKey);
-    for (const route of routeGroup.routes) {
+    const openaiRouteGroup = createOpenAIProxyRoutes(params.modelRouter, "", params.port);
+    const allProxyRoutes = [...routeGroup.routes, ...openaiRouteGroup.routes];
+    for (const route of allProxyRoutes) {
         const method = route.method.toLowerCase();
         app[method](route.path, async (c) => {
             const emptyBody = {};
@@ -1025,6 +1145,13 @@ function registerProxyShutdownHandlers(params) {
             catch {
                 // non-fatal
             }
+            try {
+                const shutdownHost = params.host === "0.0.0.0" ? "localhost" : params.host;
+                await clearOpenCodeProxySettings(`http://${shutdownHost}:${params.port}/v1`);
+            }
+            catch {
+                // non-fatal
+            }
         }
         try {
             params.server.close?.();
@@ -1114,6 +1241,15 @@ async function startProxyRuntime(params) {
             logger.debug("[proxy] Failed to auto-configure Claude Code: " +
                 (error instanceof Error ? error.message : String(error)));
         }
+        try {
+            await setOpenCodeProxySettings(`${url}/v1`);
+            logger.always(chalk.green("  ✓ Auto-configured OpenCode settings"));
+            logger.always(chalk.dim("    Restart OpenCode to connect through proxy"));
+        }
+        catch (error) {
+            logger.debug("[proxy] Failed to auto-configure OpenCode: " +
+                (error instanceof Error ? error.message : String(error)));
+        }
     }
     else {
         logger.always(chalk.dim("  ⊘ Dev mode: skipping client auto-configuration"));
@@ -1808,6 +1944,12 @@ export const proxyGuardCommand = {
         }
         // Restart failed or launchd not installed — clean up Claude settings
         const cleared = await clearClaudeProxySettings(expectedBaseUrl);
+        try {
+            await clearOpenCodeProxySettings(`${expectedBaseUrl}/v1`);
+        }
+        catch {
+            // non-fatal
+        }
         const state = loadProxyState();
         if (state &&
             state.host === host &&
@@ -1916,9 +2058,16 @@ export const proxySetupCommand = {
                 console.info(chalk.green("  ✓ Claude Code configured"));
             }
             catch (e) {
-                console.info(chalk.yellow(`  ⚠ Could not auto-configure: ${e instanceof Error ? e.message : String(e)}`));
+                console.info(chalk.yellow(`  ⚠ Could not auto-configure Claude Code: ${e instanceof Error ? e.message : String(e)}`));
                 console.info(chalk.yellow(`  Set manually: ANTHROPIC_BASE_URL=${url}`));
             }
+            try {
+                await setOpenCodeProxySettings(`${url}/v1`);
+                console.info(chalk.green("  ✓ OpenCode configured"));
+            }
+            catch (e) {
+                console.info(chalk.yellow(`  ⚠ Could not auto-configure OpenCode: ${e instanceof Error ? e.message : String(e)}`));
+            }
             // Done!
             console.info("");
             console.info(chalk.bold.green("Setup complete!"));

package/dist/lib/proxy/modelRouter.d.ts

@@ -1,4 +1,4 @@
-import type { FallbackEntry, ProxyRoutingConfig, RouteResult } from "../types/index.js";
+import type { FallbackEntry, ModelMapping, ProxyRoutingConfig, RouteResult } from "../types/index.js";
 export declare class ModelRouter {
     private readonly mappings;
     private readonly passthrough;
@@ -7,4 +7,8 @@ export declare class ModelRouter {
     resolve(requestedModel: string): RouteResult;
     isClaudeTarget(requestedModel: string): boolean;
     getFallbackChain(): FallbackEntry[];
+    /** Return the raw model mapping entries (used by /v1/models). */
+    getModelMappings(): ModelMapping[];
+    /** Return models configured for passthrough (used by /v1/models). */
+    getPassthroughModels(): string[];
 }

package/dist/lib/proxy/modelRouter.js

@@ -29,5 +29,13 @@ export class ModelRouter {
     getFallbackChain() {
         return this.fallback;
     }
+    /** Return the raw model mapping entries (used by /v1/models). */
+    getModelMappings() {
+        return Array.from(this.mappings.values());
+    }
+    /** Return models configured for passthrough (used by /v1/models). */
+    getPassthroughModels() {
+        return Array.from(this.passthrough);
+    }
 }
 //# sourceMappingURL=modelRouter.js.map

package/dist/lib/proxy/openaiFormat.d.ts

@@ -0,0 +1,137 @@
+/**
+ * OpenAI Chat Completions API format conversion layer.
+ *
+ * Provides a request parser (OpenAI -> NeuroLink), a response serializer
+ * (NeuroLink -> OpenAI), a streaming SSE state machine, and an error
+ * envelope helper.  Together they allow NeuroLink to act as a
+ * drop-in OpenAI API proxy.
+ *
+ * Reference: https://platform.openai.com/docs/api-reference/chat/create
+ */
+import type { ClaudeRequest, ClaudeResponse, InternalResult, OpenAICompletionRequest, OpenAICompletionResponse, OpenAIErrorResponse, ParsedOpenAIRequest, StreamLifecycleState } from "../types/index.js";
+/** Generate a unique chat completion ID in the OpenAI format. */
+export declare function generateChatCompletionId(): string;
+/** Generate an OpenAI-format tool call ID (`call_` + random chars). */
+export declare function generateOpenAIToolCallId(): string;
+/**
+ * Parse an incoming OpenAI Chat Completions request into an intermediate
+ * representation consumable by NeuroLink's generate/stream pipeline.
+ *
+ * Handles:
+ * - System prompt extraction from system messages
+ * - Message flattening (text + image parts)
+ * - Tool definition conversion
+ * - tool_choice mapping
+ * - top_p, temperature, max_tokens pass-through
+ */
+export declare function parseOpenAIRequest(body: OpenAICompletionRequest): ParsedOpenAIRequest;
+/**
+ * Serialize a NeuroLink GenerateResult into an OpenAI Chat Completions response.
+ */
+export declare function serializeOpenAIResponse(result: InternalResult, requestModel: string): OpenAICompletionResponse;
+/**
+ * Build an OpenAI-compatible error envelope.
+ */
+export declare function buildOpenAIError(status: number, message: string): OpenAIErrorResponse;
+/**
+ * Format a single OpenAI SSE frame.
+ * OpenAI uses only `data:` lines (no `event:` prefix unlike Claude).
+ */
+export declare function formatOpenAISSE(data: unknown): string;
+/**
+ * Stateful SSE serializer that emits a well-formed OpenAI streaming response.
+ *
+ * Tracks lifecycle state (`idle` -> `streaming` -> `done`) and the current
+ * tool call index for multi-tool streaming.
+ *
+ * Usage:
+ * ```ts
+ * const sse = new OpenAIStreamSerializer(requestModel);
+ *
+ * // Start the stream
+ * yield* sse.start();
+ *
+ * // Text deltas
+ * for await (const chunk of textStream) {
+ *   yield* sse.pushDelta(chunk);
+ * }
+ *
+ * // Tool use
+ * yield* sse.pushToolUse(toolId, toolName, toolInput);
+ *
+ * // Finalize
+ * yield* sse.finish("stop", usage);
+ * ```
+ */
+export declare class OpenAIStreamSerializer {
+    private state;
+    private readonly id;
+    private readonly model;
+    private started;
+    private toolCallIndex;
+    constructor(model: string);
+    /** Current lifecycle state (exposed for testing). */
+    getState(): StreamLifecycleState;
+    private makeChunk;
+    /**
+     * Emit the opening frame with `role: "assistant"`.
+     */
+    start(): Generator<string>;
+    /**
+     * Push a text content delta.
+     */
+    pushDelta(text: string): Generator<string>;
+    /**
+     * Push the start of a tool call (id, name, empty arguments).
+     */
+    pushToolCallStart(id: string, name: string): Generator<string>;
+    /**
+     * Push an arguments delta for the current tool call.
+     */
+    pushToolCallArgDelta(index: number, argsChunk: string): Generator<string>;
+    /**
+     * Push a complete tool use: emits tool call start followed by chunked
+     * argument deltas (~100 chars per chunk).
+     */
+    pushToolUse(id: string, name: string, input: unknown): Generator<string>;
+    /**
+     * Finalize the stream: emit finish_reason chunk, then `data: [DONE]`.
+     */
+    finish(finishReason?: string, usage?: {
+        input: number;
+        output: number;
+        total: number;
+    }): Generator<string>;
+    /**
+     * Emit an error event.  Transitions to terminal ERROR state.
+     */
+    emitError(message: string): Generator<string>;
+}
+/**
+ * Convert an OpenAI Chat Completions request to a Claude Messages API request.
+ *
+ * Used by the OpenAI proxy endpoint to internally loopback requests targeting
+ * Claude models through the proxy's native /v1/messages passthrough path,
+ * so they benefit from OAuth account rotation, retry, SSE interception, etc.
+ */
+export declare function convertOpenAIToClaudeRequest(openai: OpenAICompletionRequest): ClaudeRequest;
+/**
+ * Convert a non-streaming Claude Messages response to an OpenAI Chat
+ * Completions response by bridging through {@link InternalResult}.
+ */
+export declare function convertClaudeToOpenAIResponse(claude: ClaudeResponse, requestModel: string): OpenAICompletionResponse;
+/**
+ * Create a TransformStream that parses Claude Messages API SSE events from
+ * the upstream response and re-emits them as OpenAI Chat Completions SSE
+ * frames.
+ *
+ * Handles the canonical Claude SSE event types:
+ *  - message_start       -> emits the opening `role: "assistant"` chunk
+ *  - content_block_start -> text block: no-op; tool_use block: emit tool call start
+ *  - content_block_delta -> text_delta: emit content delta;
+ *                           input_json_delta: emit tool call argument delta
+ *  - content_block_stop  -> no-op
+ *  - message_delta       -> captures stop_reason and output token usage
+ *  - message_stop        -> emits the final `finish_reason` chunk + `[DONE]`
+ */
+export declare function createClaudeToOpenAIStreamTransform(requestModel: string): TransformStream<Uint8Array, Uint8Array>;