@agentgrader/agent-openrouter 1.0.0

package/dist/index.d.ts

@@ -0,0 +1,13 @@
+import { AgentAdapter, StepEvent, AgentResult } from '@agentgrader/core';
+
+declare class OpenRouterAgentAdapter implements AgentAdapter {
+    readonly name = "openrouter";
+    solve(input: {
+        prompt: string;
+        sandbox: any;
+        config: any;
+        onStep: (step: StepEvent) => void;
+    }): Promise<AgentResult>;
+}
+
+export { OpenRouterAgentAdapter };

package/dist/index.js

@@ -0,0 +1,186 @@
+import { tool, experimental_createMCPClient, generateText } from 'ai';
+import { Experimental_StdioMCPTransport } from 'ai/mcp-stdio';
+import { createOpenAI } from '@ai-sdk/openai';
+import { z } from 'zod';
+
+// src/index.ts
+var OpenRouterAgentAdapter = class {
+  name = "openrouter";
+  async solve(input) {
+    const { prompt, sandbox, config, onStep } = input;
+    const apiKey = process.env.OPENROUTER_API_KEY || process.env.OPENAI_API_KEY || "mock-key";
+    const baseURL = process.env.OPENROUTER_API_KEY ? "https://openrouter.ai/api/v1" : void 0;
+    const client = createOpenAI({
+      baseURL,
+      apiKey,
+      headers: {
+        "HTTP-Referer": "https://github.com/agentgrader/agr",
+        "X-Title": "Agentgrader"
+      }
+    });
+    const modelName = config.model || "gpt-4o-mini";
+    const model = client(modelName);
+    let submitted = false;
+    let stepIndex = 0;
+    const localTools = {
+      executeCommand: tool({
+        description: "Execute a terminal bash command inside the sandbox container.",
+        parameters: z.object({
+          command: z.string()
+        }),
+        execute: async ({ command }) => {
+          const res = await sandbox.exec(command);
+          return {
+            stdout: res.stdout,
+            stderr: res.stderr,
+            exitCode: res.exitCode
+          };
+        }
+      }),
+      readFile: tool({
+        description: "Read the content of a file in the sandbox workspace.",
+        parameters: z.object({
+          path: z.string()
+        }),
+        execute: async ({ path }) => {
+          try {
+            const content = await sandbox.readFile(path);
+            return { content };
+          } catch (err) {
+            return { error: err.message };
+          }
+        }
+      }),
+      writeFile: tool({
+        description: "Write content to a file in the sandbox workspace.",
+        parameters: z.object({
+          path: z.string(),
+          content: z.string()
+        }),
+        execute: async ({ path, content }) => {
+          try {
+            await sandbox.writeFile(path, content);
+            return { success: true };
+          } catch (err) {
+            return { error: err.message };
+          }
+        }
+      }),
+      submit: tool({
+        description: "Submit the solution when the task is fully completed and verified.",
+        parameters: z.object({
+          summary: z.string().describe("A summary of changes made.")
+        }),
+        execute: async ({ summary }) => {
+          submitted = true;
+          return { message: "Solution submitted successfully." };
+        }
+      })
+    };
+    const mcpClients = [];
+    const mcpTools = {};
+    const mcpServers = config.mcp_servers ?? {};
+    for (const [serverName, serverConfig] of Object.entries(mcpServers)) {
+      try {
+        const transport = "command" in serverConfig ? new Experimental_StdioMCPTransport({
+          command: serverConfig.command,
+          args: serverConfig.args,
+          env: serverConfig.env
+        }) : (
+          // note: the installed AI SDK version only supports "sse" as a
+          // remote transport type, regardless of the configured `type`
+          { type: "sse", url: serverConfig.url, headers: serverConfig.headers }
+        );
+        const client2 = await experimental_createMCPClient({ transport });
+        mcpClients.push(client2);
+        const serverTools = await client2.tools();
+        for (const [toolName, toolDef] of Object.entries(serverTools)) {
+          mcpTools[`${serverName}_${toolName}`] = toolDef;
+        }
+      } catch (err) {
+        console.error(`Failed to connect to MCP server "${serverName}": ${err.message}`);
+      }
+    }
+    const tools = { ...localTools, ...mcpTools };
+    const getPricing = (model2) => {
+      const name = model2.toLowerCase();
+      if (name.includes("claude-3-5-sonnet")) {
+        return { input: 3 / 1e6, output: 15 / 1e6 };
+      }
+      if (name.includes("gpt-4o")) {
+        return { input: 5 / 1e6, output: 15 / 1e6 };
+      }
+      if (name.includes("mini") || name.includes("flash")) {
+        return { input: 0.15 / 1e6, output: 0.6 / 1e6 };
+      }
+      return { input: 2 / 1e6, output: 10 / 1e6 };
+    };
+    const pricing = getPricing(modelName);
+    try {
+      await generateText({
+        model,
+        maxSteps: config.max_steps || 30,
+        tools,
+        system: config.system_prompt || "You are an expert software engineering agent. Solve the coding task in the sandbox. Use tools to inspect, modify, and run tests. Call 'submit' when done.",
+        prompt,
+        experimental_telemetry: { isEnabled: true },
+        onStepFinish: ({ text, toolCalls, toolResults, usage }) => {
+          const promptTokens = usage?.promptTokens || 0;
+          const completionTokens = usage?.completionTokens || 0;
+          const stepCost = promptTokens * pricing.input + completionTokens * pricing.output;
+          if (text) {
+            onStep({
+              index: stepIndex++,
+              kind: "message",
+              tokensIn: promptTokens,
+              tokensOut: completionTokens,
+              costUsd: stepCost,
+              timestamp: Date.now(),
+              content: text
+            });
+          }
+          for (const tc of toolCalls) {
+            onStep({
+              index: stepIndex++,
+              kind: "tool_call",
+              tool: tc.toolName,
+              tokensIn: 0,
+              tokensOut: 0,
+              costUsd: 0,
+              timestamp: Date.now(),
+              content: JSON.stringify(tc.args)
+            });
+          }
+          for (const tr of toolResults) {
+            onStep({
+              index: stepIndex++,
+              kind: "tool_result",
+              tool: tr.toolName,
+              tokensIn: 0,
+              tokensOut: 0,
+              costUsd: 0,
+              timestamp: Date.now(),
+              content: JSON.stringify(tr.result)
+            });
+          }
+        }
+      });
+    } catch (err) {
+      console.error(`Error in generateText agent loop: ${err.message}`);
+    } finally {
+      for (const client2 of mcpClients) {
+        try {
+          await client2.close();
+        } catch (e) {
+        }
+      }
+    }
+    const finalDiff = await sandbox.gitDiff();
+    return {
+      finished: submitted,
+      finalDiff
+    };
+  }
+};
+
+export { OpenRouterAgentAdapter };

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "@agentgrader/agent-openrouter",
+  "version": "1.0.0",
+  "description": "OpenRouter/AI SDK ReAct agent adapter for the Agentgrader framework",
+  "license": "MIT",
+  "type": "module",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsup src/index.ts --format esm --dts --clean --treeshake",
+    "build:watch": "tsup src/index.ts --format esm --dts --watch"
+  },
+  "dependencies": {
+    "@ai-sdk/openai": "^1.1.0",
+    "@agentgrader/core": "workspace:*",
+    "ai": "^4.1.0",
+    "zod": "^3.23.8"
+  },
+  "devDependencies": {
+    "tsup": "^8.5.1"
+  },
+  "peerDependencies": {
+    "@agentgrader/core": "^1.0.0"
+  }
+}