@juspay/neurolink 9.30.0 → 9.31.0

package/dist/lib/server/adapters/honoAdapter.js

@@ -313,35 +313,101 @@ export class HonoServerAdapter extends BaseServerAdapter {
                     typeof result === "object" &&
                     Symbol.asyncIterator in result) {
                     for await (const chunk of result) {
+                        // Transform raw provider chunks into StreamEvent format
+                        // The client SDK expects { type, content, timestamp, ... } objects
+                        const streamEvent = this.toStreamEvent(chunk);
                         await stream.writeSSE({
-                            data: JSON.stringify(chunk),
-                            event: "message",
+                            data: JSON.stringify(streamEvent),
                         });
                     }
                 }
+                else if (result && isErrorResponse(result)) {
+                    // Error result, send as error event
+                    const errorResult = result;
+                    const statusCode = errorResult.httpStatus ?? 500;
+                    await stream.writeSSE({
+                        data: JSON.stringify({
+                            type: "error",
+                            error: {
+                                code: errorResult.error?.code ?? "STREAM_ERROR",
+                                message: errorResult.error?.message ?? "Stream error",
+                                status: statusCode,
+                            },
+                            timestamp: Date.now(),
+                        }),
+                    });
+                }
                 else {
-                    // Single result, send as complete event
+                    // Single result, normalize into a StreamEvent so the client can
+                    // match on the `type` field via handleEvent()
+                    const streamEvent = this.toStreamEvent(result);
                     await stream.writeSSE({
-                        data: JSON.stringify(result),
-                        event: "complete",
+                        data: JSON.stringify(streamEvent),
                     });
                 }
-                // Send done event
+                // Send [DONE] signal that the client SDK expects
                 await stream.writeSSE({
-                    data: "",
-                    event: "done",
+                    data: "[DONE]",
                 });
             }
             catch (error) {
                 await stream.writeSSE({
                     data: JSON.stringify({
-                        error: error instanceof Error ? error.message : "Stream error",
+                        type: "error",
+                        error: {
+                            code: "STREAM_ERROR",
+                            message: error instanceof Error ? error.message : "Stream error",
+                            status: 500,
+                        },
+                        timestamp: Date.now(),
                     }),
-                    event: "error",
+                });
+                // Still send [DONE] after error so the client terminates cleanly
+                await stream.writeSSE({
+                    data: "[DONE]",
                 });
             }
         });
     }
+    /**
+     * Transform a raw provider chunk into a StreamEvent
+     * Provider chunks are typically { content: string } objects;
+     * the client SDK expects { type: "text", content: string, timestamp: number }
+     */
+    toStreamEvent(chunk) {
+        // Already a StreamEvent (has a type field)
+        if (chunk &&
+            typeof chunk === "object" &&
+            "type" in chunk &&
+            typeof chunk.type === "string") {
+            return {
+                ...chunk,
+                timestamp: chunk.timestamp ?? Date.now(),
+            };
+        }
+        // Raw text chunk from provider: { content: string }
+        if (chunk && typeof chunk === "object" && "content" in chunk) {
+            return {
+                type: "text",
+                content: String(chunk.content),
+                timestamp: Date.now(),
+            };
+        }
+        // String chunk
+        if (typeof chunk === "string") {
+            return {
+                type: "text",
+                content: chunk,
+                timestamp: Date.now(),
+            };
+        }
+        // Unknown shape — wrap as metadata event (StreamEventType has no "data" variant)
+        return {
+            type: "metadata",
+            metadata: chunk,
+            timestamp: Date.now(),
+        };
+    }
     /**
      * Register middleware with Hono
      */

package/dist/lib/server/middleware/cache.js

@@ -247,6 +247,9 @@ export class LRUCache {
         this.accessOrder.push(key);
     }
 }
+// ============================================
+// Response Cache Store (Synchronous)
+// ============================================
 /**
  * Synchronous response cache store with TTL support
  *

package/dist/lib/server/routes/claudeProxyRoutes.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Claude-Compatible Proxy Routes
+ *
+ * Exposes Anthropic-compatible /v1/messages, /v1/models, and /v1/messages/count_tokens
+ * endpoints. ALL requests are routed through ctx.neurolink.generate() / ctx.neurolink.stream()
+ * -- no direct HTTP calls to Anthropic.
+ *
+ * An optional ModelRouter can remap incoming model names to different
+ * provider/model pairs (e.g. "claude-sonnet-4-20250514" -> vertex/gemini-2.5-pro).
+ * Without a router, models are passed through to the Anthropic provider.
+ */
+import type { RouteGroup } from "../types.js";
+import type { ModelRouter } from "../../proxy/modelRouter.js";
+export type { ClaudeProxyDeps } from "../../types/index.js";
+/**
+ * Create Claude-compatible proxy routes.
+ *
+ * Every request flows through ctx.neurolink.generate() or ctx.neurolink.stream().
+ * No direct fetch() calls to api.anthropic.com.
+ *
+ * @param modelRouter - Optional model router for remapping model names.
+ * @param basePath    - Base path prefix (default: "" since Claude API uses /v1/...).
+ * @returns RouteGroup with Claude-compatible endpoints.
+ */
+export declare function createClaudeProxyRoutes(modelRouter?: ModelRouter, basePath?: string, accountStrategy?: "round-robin" | "fill-first"): RouteGroup;
+type ParsedClaudeError = {
+    errorType?: string;
+    message?: string;
+};
+/**
+ * Parse a Claude error payload when available.
+ */
+export declare function parseClaudeErrorBody(errBody: string): ParsedClaudeError;
+/**
+ * Detect malformed request errors that should not trigger account/provider failover.
+ */
+export declare function isInvalidRequestError(status: number, errBody: string): boolean;
+/**
+ * Detect transient upstream failures that should trigger account/provider failover.
+ *
+ * Includes Cloudflare 52x statuses and Anthropic 400/api_error wrappers that
+ * carry transient HTML responses (e.g. 520 pages) inside `error.message`.
+ */
+export declare function isTransientHttpFailure(status: number, errBody: string): boolean;