@evalview/node 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 EvalView Contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,97 @@
+# @evalview/node
+
+Drop-in Node.js/Next.js middleware for [EvalView](https://github.com/hidai25/eval-view) testing framework.
+
+## Installation
+
+```bash
+npm install @evalview/node
+```
+
+## Quick Start
+
+### Next.js App Router
+
+```typescript
+// app/api/evalview/route.ts
+import { createEvalViewMiddleware } from '@evalview/node';
+
+export const POST = createEvalViewMiddleware({
+  targetEndpoint: '/api/unifiedchat',  // Your agent's endpoint
+});
+```
+
+### Express.js
+
+```javascript
+const { createEvalViewMiddleware } = require('@evalview/node');
+
+app.post('/api/evalview', createEvalViewMiddleware({
+  targetEndpoint: '/api/your-agent',
+}));
+```
+
+## Configuration
+
+```typescript
+createEvalViewMiddleware({
+  // Required: Endpoint to forward requests to
+  targetEndpoint: '/api/unifiedchat',
+
+  // Optional: Default user ID for test requests (defaults to 'evalview-test-user')
+  // Use an existing user ID from your database
+  defaultUserId: 'your-dev-user-id',
+
+  // Optional: Dynamic user ID resolution
+  // Useful for creating users on-the-fly or looking up existing ones
+  getUserId: async (req) => {
+    // Example: Look up or create user
+    const user = await findOrCreateUser('test@example.com');
+    return user.id;
+  },
+
+  // Optional: Transform EvalView request to your API format
+  transformRequest: (req) => ({
+    message: req.query,
+    userId: req.context?.userId, // Automatically set by middleware
+    // ... your custom mapping
+  }),
+
+  // Optional: Parse your API response to EvalView format
+  parseResponse: (responseText, startTime) => ({
+    session_id: `session-${startTime}`,
+    output: '...',
+    steps: [...],
+    cost: 0.05,
+    latency: Date.now() - startTime,
+  }),
+
+  // Optional: Base URL for requests
+  baseUrl: process.env.API_BASE_URL,
+});
+```
+
+## Default Behavior
+
+Works out-of-the-box with Tapescope-style APIs that:
+- Accept: `{ message, userId, conversationId, route, history }`
+- Return: NDJSON stream with `tool_call` and `message_complete` events
+
+## Testing
+
+Point EvalView CLI to your endpoint:
+
+```yaml
+# .evalview/config.yaml
+adapter: http
+endpoint: http://localhost:3000/api/evalview
+```
+
+Then run tests:
+```bash
+evalview run
+```
+
+## License
+
+MIT

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * @evalview/node
+ *
+ * Drop-in Node.js middleware for EvalView testing framework
+ */
+export { createEvalViewMiddleware, type EvalViewRequest, type EvalViewResponse, type EvalViewStep, type MiddlewareConfig, } from './middleware';

package/dist/index.js

@@ -0,0 +1,10 @@
+"use strict";
+/**
+ * @evalview/node
+ *
+ * Drop-in Node.js middleware for EvalView testing framework
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createEvalViewMiddleware = void 0;
+var middleware_1 = require("./middleware");
+Object.defineProperty(exports, "createEvalViewMiddleware", { enumerable: true, get: function () { return middleware_1.createEvalViewMiddleware; } });

package/dist/middleware.d.ts

@@ -0,0 +1,65 @@
+/**
+ * EvalView Middleware for Node.js/Next.js
+ *
+ * Drop-in middleware that translates EvalView standard format
+ * to your agent's API format and back.
+ *
+ * Usage:
+ *   import { createEvalViewMiddleware } from '@evalview/node'
+ *
+ *   app.post('/api/evalview', createEvalViewMiddleware({
+ *     targetEndpoint: '/api/unifiedchat',
+ *     parseResponse: (ndjson) => ({ output, steps, cost, latency })
+ *   }))
+ */
+export interface EvalViewRequest {
+    query: string;
+    context?: {
+        route?: string;
+        userId?: string;
+        conversationId?: string;
+        history?: any[];
+        [key: string]: any;
+    };
+    enable_tracing?: boolean;
+}
+export interface EvalViewStep {
+    id: string;
+    name: string;
+    tool: string;
+    parameters: any;
+    output?: any;
+    success: boolean;
+    latency?: number;
+    cost?: number;
+    tokens?: number;
+}
+export interface EvalViewResponse {
+    session_id: string;
+    output: string;
+    steps: EvalViewStep[];
+    cost: number;
+    latency: number;
+    tokens?: number;
+}
+export interface MiddlewareConfig {
+    /** Endpoint to forward requests to (e.g., '/api/unifiedchat') */
+    targetEndpoint: string;
+    /** Optional: Transform EvalView request to your API format */
+    transformRequest?: (req: EvalViewRequest) => any;
+    /** Optional: Parse your API response to EvalView format */
+    parseResponse?: (responseText: string, startTime: number) => EvalViewResponse;
+    /** Optional: Base URL for requests (defaults to current host) */
+    baseUrl?: string;
+    /** Optional: Default user ID for test requests (defaults to 'evalview-test-user') */
+    defaultUserId?: string;
+    /** Optional: Function to get/create user ID dynamically */
+    getUserId?: (req: EvalViewRequest) => string | Promise<string>;
+}
+/**
+ * Create EvalView middleware handler
+ *
+ * @param config - Middleware configuration
+ * @returns Request handler function
+ */
+export declare function createEvalViewMiddleware(config: MiddlewareConfig): (req: any) => Promise<import("undici-types").Response>;

package/dist/middleware.js

@@ -0,0 +1,183 @@
+"use strict";
+/**
+ * EvalView Middleware for Node.js/Next.js
+ *
+ * Drop-in middleware that translates EvalView standard format
+ * to your agent's API format and back.
+ *
+ * Usage:
+ *   import { createEvalViewMiddleware } from '@evalview/node'
+ *
+ *   app.post('/api/evalview', createEvalViewMiddleware({
+ *     targetEndpoint: '/api/unifiedchat',
+ *     parseResponse: (ndjson) => ({ output, steps, cost, latency })
+ *   }))
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createEvalViewMiddleware = createEvalViewMiddleware;
+const DEBUG = process.env.EVALVIEW_DEBUG === 'true';
+/**
+ * Default Tapescope request transformer
+ */
+function defaultTransformRequest(req) {
+    const timestamp = Date.now();
+    return {
+        message: req.query,
+        userId: req.context?.userId, // Set by middleware
+        conversationId: req.context?.conversationId || `eval-${timestamp}`,
+        route: req.context?.route || 'orchestrator',
+        history: req.context?.history || [],
+    };
+}
+/**
+ * Default Tapescope NDJSON response parser
+ * Handles both pure NDJSON and SSE format (with "data: " prefix)
+ */
+function defaultParseResponse(ndjsonText, startTime) {
+    const lines = ndjsonText.trim().split('\n');
+    const events = lines
+        .filter(line => line.trim())
+        .map(line => {
+        try {
+            // Strip SSE "data: " prefix if present
+            const jsonLine = line.startsWith('data: ') ? line.slice(6) : line;
+            return JSON.parse(jsonLine);
+        }
+        catch (e) {
+            return null;
+        }
+    })
+        .filter(Boolean);
+    const steps = [];
+    let finalOutput = '';
+    let totalCost = 0;
+    let totalTokens = 0;
+    const sessionId = `session-${startTime}`;
+    for (const event of events) {
+        const eventType = event.type;
+        // Capture tool calls as steps
+        if (eventType === 'tool_call') {
+            steps.push({
+                id: `step-${steps.length}`,
+                name: event.tool || 'unknown',
+                tool: event.tool || 'unknown',
+                parameters: event.params || {},
+                output: event.result,
+                success: true,
+                latency: 0,
+                cost: 0,
+            });
+        }
+        // Capture final message
+        if (eventType === 'message_complete') {
+            finalOutput = event.final?.text || '';
+            totalCost = event.data?.metadata?.cost || 0;
+            // Add synthesis step if present
+            if (event.tool) {
+                steps.push({
+                    id: `step-${steps.length}`,
+                    name: event.tool,
+                    tool: event.tool,
+                    parameters: {},
+                    success: event.ok || false,
+                    latency: 0,
+                    cost: totalCost,
+                });
+            }
+        }
+        // Accumulate streaming text (fallback if final not set)
+        if (eventType === 'text_delta' && !finalOutput) {
+            finalOutput += event.delta || '';
+        }
+    }
+    const endTime = Date.now();
+    const latency = endTime - startTime;
+    return {
+        session_id: sessionId,
+        output: finalOutput,
+        steps,
+        cost: totalCost,
+        latency,
+        tokens: totalTokens,
+    };
+}
+/**
+ * Create EvalView middleware handler
+ *
+ * @param config - Middleware configuration
+ * @returns Request handler function
+ */
+function createEvalViewMiddleware(config) {
+    const { targetEndpoint, transformRequest = defaultTransformRequest, parseResponse = defaultParseResponse, baseUrl, defaultUserId = 'evalview-test-user', getUserId, } = config;
+    return async function evalViewHandler(req) {
+        const startTime = Date.now();
+        try {
+            // Parse EvalView request (Next.js App Router)
+            const evalViewReq = await req.json();
+            // Resolve user ID (priority: context.userId > getUserId() > defaultUserId)
+            if (!evalViewReq.context) {
+                evalViewReq.context = {};
+            }
+            if (!evalViewReq.context.userId) {
+                evalViewReq.context.userId = getUserId
+                    ? await getUserId(evalViewReq)
+                    : defaultUserId;
+            }
+            if (DEBUG)
+                console.log('[EvalView] Received request:', {
+                    query: evalViewReq.query,
+                    route: evalViewReq.context?.route,
+                });
+            // Transform to target API format
+            const targetReq = transformRequest(evalViewReq);
+            if (DEBUG)
+                console.log('[EvalView] Calling target endpoint:', targetEndpoint);
+            // Determine base URL
+            const host = req.headers?.get?.('host') || req.headers?.host || 'localhost:3000';
+            const requestBaseUrl = baseUrl || `http://${host}`;
+            // Call target endpoint
+            const response = await fetch(`${requestBaseUrl}${targetEndpoint}`, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify(targetReq),
+            });
+            if (!response.ok) {
+                throw new Error(`Target endpoint failed: ${response.status} ${response.statusText}`);
+            }
+            // Get response text
+            const responseText = await response.text();
+            if (DEBUG)
+                console.log('[EvalView] Received response, parsing...');
+            // Parse and translate response
+            const evalViewRes = parseResponse(responseText, startTime);
+            if (DEBUG)
+                console.log('[EvalView] Translated response:', {
+                    steps: evalViewRes.steps.length,
+                    outputLength: evalViewRes.output.length,
+                    cost: evalViewRes.cost,
+                    latency: evalViewRes.latency,
+                });
+            // Return JSON response (Next.js App Router format)
+            return new Response(JSON.stringify(evalViewRes), {
+                status: 200,
+                headers: { 'Content-Type': 'application/json' },
+            });
+        }
+        catch (error) {
+            console.error('[EvalView] Error:', error);
+            return new Response(JSON.stringify({
+                error: error.message || 'EvalView middleware failed',
+                session_id: `error-${startTime}`,
+                output: '',
+                steps: [],
+                cost: 0,
+                latency: Date.now() - startTime,
+            }), {
+                status: 500,
+                headers: { 'Content-Type': 'application/json' },
+            });
+        }
+    };
+}

package/package.json

@@ -0,0 +1,65 @@
+{
+  "name": "@evalview/node",
+  "version": "0.1.0",
+  "description": "Drop-in Node.js middleware for EvalView testing framework",
+  "main": "dist/index.js",
+  "module": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.js"
+    },
+    "./middleware": {
+      "types": "./dist/middleware.d.ts",
+      "import": "./dist/middleware.js",
+      "require": "./dist/middleware.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "clean": "rm -rf dist",
+    "prepublishOnly": "npm run clean && npm run build"
+  },
+  "keywords": [
+    "evalview",
+    "testing",
+    "ai-agents",
+    "middleware",
+    "llm",
+    "evaluation"
+  ],
+  "author": "EvalView",
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/hidai25/eval-view.git",
+    "directory": "sdks/node"
+  },
+  "bugs": {
+    "url": "https://github.com/hidai25/eval-view/issues"
+  },
+  "homepage": "https://github.com/hidai25/eval-view/tree/main/sdks/node#readme",
+  "engines": {
+    "node": ">=16.0.0"
+  },
+  "peerDependencies": {
+    "next": ">=13.0.0"
+  },
+  "peerDependenciesMeta": {
+    "next": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "typescript": "^5.0.0"
+  }
+}