cclaw-cli 0.49.0 → 0.51.0

package/dist/eval/tools/index.js

@@ -1,35 +0,0 @@
-/**
- * Registry of sandbox-confined tools used by the with-tools agent (agent/workflow mode).
- *
- * The registry order defines the advertised schema order in the
- * function-calling payload. Keeping it stable means judges reading
- * generated traces can rely on predictable tool descriptions.
- */
-import { globTool } from "./glob.js";
-import { grepTool } from "./grep.js";
-import { readTool } from "./read.js";
-import { writeTool } from "./write.js";
-export { truncatePayload } from "./types.js";
-export const BUILTIN_TOOLS = [readTool, writeTool, globTool, grepTool];
-/** Build a lookup for the agent loop. */
-export function toolsByName(tools = BUILTIN_TOOLS) {
-    const map = new Map();
-    for (const tool of tools) {
-        if (map.has(tool.descriptor.name)) {
-            throw new Error(`duplicate tool name: ${tool.descriptor.name}`);
-        }
-        map.set(tool.descriptor.name, tool);
-    }
-    return map;
-}
-/** Shape a tool list for OpenAI-style `tools[]` in the chat request. */
-export function toolsForRequest(tools = BUILTIN_TOOLS) {
-    return tools.map((tool) => ({
-        type: "function",
-        function: {
-            name: tool.descriptor.name,
-            description: tool.descriptor.description,
-            parameters: tool.descriptor.parameters
-        }
-    }));
-}

package/dist/eval/tools/read.d.ts

@@ -1,2 +0,0 @@
-import { type SandboxTool } from "./types.js";
-export declare const readTool: SandboxTool;

package/dist/eval/tools/read.js

@@ -1,122 +0,0 @@
-import fs from "node:fs/promises";
-import { SandboxEscapeError } from "../sandbox.js";
-import { parseArgs, requireString, optionalNumber, truncatePayload } from "./types.js";
-const DESCRIPTION = "Read a UTF-8 text file from the sandbox. Returns the file contents. " +
-    "Supports optional 1-indexed `offset` and `limit` to read a slice.";
-export const readTool = {
-    descriptor: {
-        name: "read_file",
-        description: DESCRIPTION,
-        parameters: {
-            type: "object",
-            additionalProperties: false,
-            required: ["path"],
-            properties: {
-                path: {
-                    type: "string",
-                    description: "Path relative to the sandbox root."
-                },
-                offset: {
-                    type: "integer",
-                    minimum: 1,
-                    description: "1-indexed start line (inclusive)."
-                },
-                limit: {
-                    type: "integer",
-                    minimum: 1,
-                    description: "Maximum number of lines to return."
-                }
-            }
-        }
-    },
-    async invoke(rawArgs, ctx) {
-        let args;
-        try {
-            args = parseArgs(rawArgs);
-        }
-        catch (err) {
-            return { ok: false, name: this.descriptor.name, error: err.message };
-        }
-        let relPath;
-        try {
-            relPath = requireString(args, "path");
-        }
-        catch (err) {
-            return { ok: false, name: this.descriptor.name, error: err.message };
-        }
-        let offset;
-        let limit;
-        try {
-            offset = optionalNumber(args, "offset");
-            limit = optionalNumber(args, "limit");
-        }
-        catch (err) {
-            return {
-                ok: false,
-                name: this.descriptor.name,
-                error: err.message
-            };
-        }
-        if (offset !== undefined && (!Number.isInteger(offset) || offset < 1)) {
-            return {
-                ok: false,
-                name: this.descriptor.name,
-                error: '"offset" must be a positive integer'
-            };
-        }
-        if (limit !== undefined && (!Number.isInteger(limit) || limit < 1)) {
-            return {
-                ok: false,
-                name: this.descriptor.name,
-                error: '"limit" must be a positive integer'
-            };
-        }
-        let abs;
-        try {
-            abs = await ctx.sandbox.resolve(relPath);
-        }
-        catch (err) {
-            const denied = err instanceof SandboxEscapeError ? relPath : undefined;
-            return {
-                ok: false,
-                name: this.descriptor.name,
-                error: err.message,
-                details: denied ? { deniedPath: denied } : undefined
-            };
-        }
-        let raw;
-        try {
-            raw = await fs.readFile(abs, "utf8");
-        }
-        catch (err) {
-            return {
-                ok: false,
-                name: this.descriptor.name,
-                error: `read failed: ${err.message}`,
-                details: { path: relPath }
-            };
-        }
-        let content = raw;
-        let effectiveLines;
-        if (offset !== undefined || limit !== undefined) {
-            const lines = raw.split(/\r?\n/);
-            const start = Math.max(0, (offset ?? 1) - 1);
-            const end = limit !== undefined ? Math.min(lines.length, start + limit) : lines.length;
-            const slice = lines.slice(start, end);
-            content = slice.join("\n");
-            effectiveLines = slice.length;
-        }
-        const truncated = truncatePayload(content, ctx.maxResultBytes);
-        return {
-            ok: true,
-            name: this.descriptor.name,
-            content: truncated,
-            details: {
-                path: relPath,
-                bytes: Buffer.byteLength(truncated, "utf8"),
-                truncated: truncated !== content,
-                ...(effectiveLines !== undefined ? { lines: effectiveLines } : {})
-            }
-        };
-    }
-};

package/dist/eval/tools/types.d.ts

@@ -1,49 +0,0 @@
-/**
- * Shared types for sandbox-confined tools (agent/workflow mode).
- *
- * Tools are plain async functions: they take validated arguments and a
- * sandbox handle and return a structured result. The runner serializes
- * results for the model as JSON; the `SandboxTool.invoke` wrapper keeps
- * both the raw structured output (for tests/metrics) and the stringified
- * model-facing payload.
- */
-import type { Sandbox } from "../sandbox.js";
-export interface ToolDescriptor {
-    /** Name the model calls (must match the function-calling schema). */
-    name: string;
-    /** Human-readable prompt shown to the model. */
-    description: string;
-    /** JSON schema shipped with the OpenAI-style `tools[]` array. */
-    parameters: Record<string, unknown>;
-}
-export interface ToolContext {
-    sandbox: Sandbox;
-    /**
-     * Maximum bytes the tool may return in `content`. Results longer than
-     * this are truncated with a trailing marker so the model sees the
-     * cutoff.
-     */
-    maxResultBytes: number;
-}
-export interface ToolSuccess {
-    ok: true;
-    name: string;
-    content: string;
-    details?: Record<string, unknown>;
-}
-export interface ToolFailure {
-    ok: false;
-    name: string;
-    error: string;
-    details?: Record<string, unknown>;
-}
-export type ToolResult = ToolSuccess | ToolFailure;
-export interface SandboxTool {
-    descriptor: ToolDescriptor;
-    invoke(rawArgs: string, ctx: ToolContext): Promise<ToolResult>;
-}
-/** Truncate a result payload to `maxBytes` with a visible cutoff marker. */
-export declare function truncatePayload(payload: string, maxBytes: number): string;
-export declare function parseArgs(raw: string): Record<string, unknown>;
-export declare function requireString(args: Record<string, unknown>, key: string): string;
-export declare function optionalNumber(args: Record<string, unknown>, key: string): number | undefined;

package/dist/eval/tools/types.js

@@ -1,41 +0,0 @@
-/** Truncate a result payload to `maxBytes` with a visible cutoff marker. */
-export function truncatePayload(payload, maxBytes) {
-    if (Buffer.byteLength(payload, "utf8") <= maxBytes)
-        return payload;
-    const marker = "\n…[truncated by cclaw sandbox]";
-    const budget = Math.max(0, maxBytes - Buffer.byteLength(marker, "utf8"));
-    const buf = Buffer.from(payload, "utf8").subarray(0, budget);
-    return `${buf.toString("utf8")}${marker}`;
-}
-export function parseArgs(raw) {
-    if (typeof raw !== "string" || raw.trim() === "") {
-        throw new Error("tool arguments missing");
-    }
-    let parsed;
-    try {
-        parsed = JSON.parse(raw);
-    }
-    catch (err) {
-        throw new Error(`tool arguments are not valid JSON: ${err.message}`);
-    }
-    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
-        throw new Error("tool arguments must be a JSON object");
-    }
-    return parsed;
-}
-export function requireString(args, key) {
-    const value = args[key];
-    if (typeof value !== "string" || value.length === 0) {
-        throw new Error(`"${key}" must be a non-empty string`);
-    }
-    return value;
-}
-export function optionalNumber(args, key) {
-    const value = args[key];
-    if (value === undefined || value === null)
-        return undefined;
-    if (typeof value !== "number" || !Number.isFinite(value)) {
-        throw new Error(`"${key}" must be a finite number`);
-    }
-    return value;
-}

package/dist/eval/tools/write.d.ts

@@ -1,2 +0,0 @@
-import { type SandboxTool } from "./types.js";
-export declare const writeTool: SandboxTool;

package/dist/eval/tools/write.js

@@ -1,92 +0,0 @@
-import fs from "node:fs/promises";
-import path from "node:path";
-import { SandboxEscapeError } from "../sandbox.js";
-import { parseArgs, requireString, truncatePayload } from "./types.js";
-const DESCRIPTION = "Write a UTF-8 text file inside the sandbox. Creates parent directories " +
-    "as needed. Overwrites existing files. Only paths inside the sandbox " +
-    "are accepted.";
-export const writeTool = {
-    descriptor: {
-        name: "write_file",
-        description: DESCRIPTION,
-        parameters: {
-            type: "object",
-            additionalProperties: false,
-            required: ["path", "content"],
-            properties: {
-                path: {
-                    type: "string",
-                    description: "Path relative to the sandbox root."
-                },
-                content: {
-                    type: "string",
-                    description: "UTF-8 contents to write."
-                }
-            }
-        }
-    },
-    async invoke(rawArgs, ctx) {
-        let args;
-        try {
-            args = parseArgs(rawArgs);
-        }
-        catch (err) {
-            return { ok: false, name: this.descriptor.name, error: err.message };
-        }
-        let relPath;
-        try {
-            relPath = requireString(args, "path");
-        }
-        catch (err) {
-            return { ok: false, name: this.descriptor.name, error: err.message };
-        }
-        const rawContent = args.content;
-        if (typeof rawContent !== "string") {
-            return {
-                ok: false,
-                name: this.descriptor.name,
-                error: '"content" must be a string'
-            };
-        }
-        const payloadBytes = Buffer.byteLength(rawContent, "utf8");
-        if (payloadBytes > ctx.maxResultBytes * 4) {
-            return {
-                ok: false,
-                name: this.descriptor.name,
-                error: `"content" exceeds per-invocation ceiling (${payloadBytes} bytes).`
-            };
-        }
-        let abs;
-        try {
-            abs = await ctx.sandbox.resolve(relPath, { allowMissing: true });
-        }
-        catch (err) {
-            const denied = err instanceof SandboxEscapeError ? relPath : undefined;
-            return {
-                ok: false,
-                name: this.descriptor.name,
-                error: err.message,
-                details: denied ? { deniedPath: denied } : undefined
-            };
-        }
-        try {
-            await fs.mkdir(path.dirname(abs), { recursive: true });
-            await fs.writeFile(abs, rawContent, "utf8");
-        }
-        catch (err) {
-            return {
-                ok: false,
-                name: this.descriptor.name,
-                error: `write failed: ${err.message}`,
-                details: { path: relPath }
-            };
-        }
-        const summary = `wrote ${payloadBytes} byte(s) to ${relPath}`;
-        return {
-            ok: true,
-            name: this.descriptor.name,
-            content: truncatePayload(summary, ctx.maxResultBytes),
-            details: { path: relPath, bytes: payloadBytes }
-        };
-    }
-};