withruntime 0.3.1 → 0.5.0

package/dist/ai/index.js

@@ -0,0 +1,38 @@
+/** Runtime sandbox tools for the Vercel AI SDK, and for Mastra, whose agents
+ * take AI SDK tools as they are:
+ *
+ *   import { generateText, stepCountIs } from "ai";
+ *   import { Sandbox } from "withruntime";
+ *   import { runtimeTools } from "withruntime/ai";
+ *
+ *   await using sbx = await Sandbox.create();
+ *   await generateText({ model, tools: runtimeTools(sbx), stopWhen: stepCountIs(10), prompt });
+ *
+ * Needs the `ai` package (version 5 or newer) beside this one. */
+import { jsonSchema, tool } from "ai";
+import { sandboxTools, } from "../tools/index.js";
+export function runtimeTools(sandbox, options = {}) {
+    const [exec, read, write, list] = sandboxTools(sandbox, options);
+    return {
+        runtime_exec: tool({
+            description: exec.description,
+            inputSchema: jsonSchema(exec.inputSchema),
+            execute: (input) => exec.execute(input),
+        }),
+        runtime_read_file: tool({
+            description: read.description,
+            inputSchema: jsonSchema(read.inputSchema),
+            execute: (input) => read.execute(input),
+        }),
+        runtime_write_file: tool({
+            description: write.description,
+            inputSchema: jsonSchema(write.inputSchema),
+            execute: (input) => write.execute(input),
+        }),
+        runtime_list_files: tool({
+            description: list.description,
+            inputSchema: jsonSchema(list.inputSchema),
+            execute: (input) => list.execute(input),
+        }),
+    };
+}

package/dist/claude-agent-sdk/index.d.ts

@@ -0,0 +1,7 @@
+import type { Sandbox } from "../sandbox.js";
+import { type SandboxToolOptions } from "../tools/index.js";
+export type { SandboxToolOptions } from "../tools/index.js";
+/** The tools' names as the Claude Agent SDK sees them, for `allowedTools`. */
+export declare const RUNTIME_TOOL_NAMES: string[];
+/** An MCP server named "runtime" whose four tools act on `sandbox`. */
+export declare function runtimeMcpServer(sandbox: Sandbox, options?: SandboxToolOptions): import("@anthropic-ai/claude-agent-sdk").McpSdkServerConfigWithInstance;

package/dist/claude-agent-sdk/index.js

@@ -0,0 +1,65 @@
+/** Runtime sandbox tools for the Claude Agent SDK, as an in-process MCP server:
+ *
+ *   import { query } from "@anthropic-ai/claude-agent-sdk";
+ *   import { Sandbox } from "withruntime";
+ *   import { runtimeMcpServer, RUNTIME_TOOL_NAMES } from "withruntime/claude-agent-sdk";
+ *
+ *   await using sbx = await Sandbox.create();
+ *   query({ prompt, options: {
+ *     mcpServers: { runtime: runtimeMcpServer(sbx) },
+ *     allowedTools: RUNTIME_TOOL_NAMES,
+ *     disallowedTools: ["Bash", "Read", "Write", "Edit"], // keep work off this machine
+ *   } });
+ *
+ * Needs `@anthropic-ai/claude-agent-sdk` and `zod` beside this one. For an agent
+ * that should create and manage sandboxes itself, connect Runtime's own MCP
+ * server instead: `npx -y withruntime mcp`. */
+import { createSdkMcpServer, tool } from "@anthropic-ai/claude-agent-sdk";
+import { z } from "zod";
+import { sandboxTools } from "../tools/index.js";
+/** The tools' names as the Claude Agent SDK sees them, for `allowedTools`. */
+export const RUNTIME_TOOL_NAMES = [
+    "mcp__runtime__runtime_exec",
+    "mcp__runtime__runtime_read_file",
+    "mcp__runtime__runtime_write_file",
+    "mcp__runtime__runtime_list_files",
+];
+const text = (value) => ({
+    content: [
+        { type: "text", text: typeof value === "string" ? value : JSON.stringify(value) },
+    ],
+});
+/** An MCP server named "runtime" whose four tools act on `sandbox`. */
+export function runtimeMcpServer(sandbox, options = {}) {
+    const [exec, read, write, list] = sandboxTools(sandbox, options);
+    return createSdkMcpServer({
+        name: "runtime",
+        version: "1.0.0",
+        tools: [
+            tool(exec.name, exec.description, {
+                command: z.string().min(1).describe(exec.inputSchema.properties.command.description),
+                cwd: z.string().optional().describe(exec.inputSchema.properties.cwd.description),
+                timeoutSeconds: z
+                    .number()
+                    .int()
+                    .min(1)
+                    .optional()
+                    .describe(exec.inputSchema.properties.timeoutSeconds.description),
+            }, async (input) => text(await exec.execute(input))),
+            tool(read.name, read.description, { path: z.string().describe(read.inputSchema.properties.path.description) }, async (input) => text(await read.execute(input))),
+            tool(write.name, write.description, {
+                path: z.string().describe(write.inputSchema.properties.path.description),
+                content: z.string().describe(write.inputSchema.properties.content.description),
+            }, async (input) => text(await write.execute(input))),
+            tool(list.name, list.description, {
+                path: z.string().optional().describe(list.inputSchema.properties.path.description),
+                depth: z
+                    .number()
+                    .int()
+                    .min(1)
+                    .optional()
+                    .describe(list.inputSchema.properties.depth.description),
+            }, async (input) => text(await list.execute(input))),
+        ],
+    });
+}

package/dist/cli.d.ts

@@ -5,5 +5,11 @@ type Out = {
     error: (text: string) => void;
 };
 export declare function run(argv: string[], env?: NodeJS.ProcessEnv, out?: Out): Promise<number>;
+export declare function secretsCommand(argv: string[], env: NodeJS.ProcessEnv, out: Out, 
+/** Tests give the value here; the CLI reads standard input. */
+read?: () => Promise<string>): Promise<number>;
+export declare function imageCommand(argv: string[], env: NodeJS.ProcessEnv, out: Out, 
+/** Tests give the registry secret here; the CLI reads standard input. */
+read?: () => Promise<string>): Promise<number>;
 export declare function describeError(error: unknown, json: boolean): string;
 export {};