@useactor/core 0.1.0 → 0.2.3

package/dist/runtime/runtime-tool-execution.js

@@ -0,0 +1,733 @@
+import { createTaskProgressEvent, createToolCallEvent, createToolResultEvent, } from "../events/events.js";
+import { classifyShellSandboxProfile } from "../tools/local-tools.js";
+const googleWorkspaceWriteToolNames = new Set([
+    "google_drive_create_folder",
+    "google_drive_create_text_file",
+    "google_drive_rename_file",
+    "google_drive_move_file",
+    "google_drive_trash_file",
+    "google_docs_create",
+    "google_docs_append_text",
+    "google_docs_replace_text",
+    "google_sheets_create",
+    "google_sheets_update_range",
+    "google_sheets_append_rows",
+    "google_sheets_clear_range",
+    "google_sheets_add_sheet",
+    "google_sheets_rename_sheet",
+    "google_sheets_delete_sheet",
+    "google_sheets_format_range",
+    "google_sheets_batch_update",
+    "google_slides_create",
+    "google_slides_create_slide",
+    "google_slides_delete_object",
+    "google_slides_create_text_box",
+    "google_slides_replace_text",
+    "google_slides_create_image",
+    "google_slides_create_shape",
+    "google_slides_create_table",
+    "google_slides_update_text_style",
+    "google_slides_update_shape_style",
+    "google_slides_batch_update",
+]);
+export async function handleToolCall(input) {
+    const target = extractPermissionTarget(input.toolName, input.input);
+    const sandboxProfile = inferSandboxProfile(input.toolName, input.input);
+    const descriptor = {
+        toolId: input.toolName,
+        action: "call",
+        reason: `Model requested tool ${input.toolName}.`,
+        riskLevel: inferToolRiskLevel(input.toolName),
+        ...(sandboxProfile ? { sandboxProfile } : {}),
+        ...(target ? { target } : {}),
+        preview: JSON.stringify(input.input),
+        availableDecisions: getAvailableApprovalDecisions(input.toolName, target),
+    };
+    const tool = input.toolRegistry?.getTool(input.toolName);
+    if (!tool) {
+        const message = `Tool unavailable: ${input.toolName}`;
+        input.emit(createToolResultEvent(input.context, {
+            toolCallId: input.toolCallId,
+            toolId: input.toolName,
+            status: "error",
+            durationMs: 0,
+            summary: message,
+        }));
+        return { content: message };
+    }
+    if (input.toolName === "task" && input.executeSubagentTask) {
+        input.emit(createToolCallEvent(input.context, input.toolCallId, descriptor));
+        return executeSubagentTaskTool({
+            input: input.input,
+            context: input.context,
+            toolCallId: input.toolCallId,
+            toolName: input.toolName,
+            executeSubagentTask: input.executeSubagentTask,
+            emit: input.emit,
+        });
+    }
+    const executeTool = () => {
+        const startedAt = Date.now();
+        const context = {
+            ...input.context,
+            timestamp: new Date().toISOString(),
+        };
+        return tool
+            .executor(input.input, {
+            sessionId: input.context.sessionId,
+            runId: input.context.runId,
+            ...(input.project ? { project: input.project } : {}),
+        })
+            .then((result) => {
+            emitTaskProgressIfPresent({
+                context,
+                toolCallId: input.toolCallId,
+                toolName: input.toolName,
+                result,
+                emit: input.emit,
+            });
+            input.emit(createToolResultEvent(context, {
+                toolCallId: input.toolCallId,
+                toolId: input.toolName,
+                status: "success",
+                durationMs: Date.now() - startedAt,
+                ...summarizeToolResult(descriptor, result),
+            }));
+            return result;
+        })
+            .catch((error) => {
+            const message = safeErrorMessage(error);
+            input.emit(createToolResultEvent(context, {
+                toolCallId: input.toolCallId,
+                toolId: input.toolName,
+                status: "error",
+                durationMs: Date.now() - startedAt,
+                summary: message,
+            }));
+            return { content: `Tool failed: ${message}` };
+        });
+    };
+    if (tool.permissionPolicy === "never" || tool.permissionPolicy === "always") {
+        input.emit(createToolCallEvent(input.context, input.toolCallId, descriptor));
+        return executeTool();
+    }
+    const permissionRequest = input.project
+        ? {
+            projectId: input.project.id,
+            sessionId: input.context.sessionId,
+            toolId: input.toolName,
+            action: "call",
+            ...(target ? { target } : {}),
+        }
+        : undefined;
+    const pendingRequest = {
+        runId: input.context.runId,
+        sessionId: input.context.sessionId,
+        requestId: input.toolCallId,
+        descriptor,
+        ...(permissionRequest ? { permissionRequest } : {}),
+        context: input.context,
+    };
+    const grantResult = await input.lifecycle.executeWithMatchingGrant(pendingRequest, () => {
+        input.emit(createToolCallEvent(input.context, input.toolCallId, descriptor));
+        return executeTool();
+    });
+    if (grantResult) {
+        return grantResult.toolResult;
+    }
+    const pending = input.lifecycle.requestToolExecution(pendingRequest, executeTool);
+    input.emit(pending.event);
+    const decisionResult = await pending.result;
+    if (decisionResult.status === "unknown_request") {
+        return { content: "Tool request could not be resolved." };
+    }
+    input.emit(decisionResult.event);
+    if (decisionResult.status === "denied") {
+        return { content: "Tool request denied by the user." };
+    }
+    if (decisionResult.status === "redirected") {
+        return {
+            content: `Tool request redirected by the user: ${decisionResult.instruction}`,
+        };
+    }
+    return decisionResult.toolResult;
+}
+async function executeSubagentTaskTool(input) {
+    const startedAt = Date.now();
+    const context = {
+        ...input.context,
+        timestamp: new Date().toISOString(),
+    };
+    try {
+        const taskInput = parseRuntimeSubagentTaskInput(input.input);
+        const result = await input.executeSubagentTask(taskInput);
+        input.emit(createToolResultEvent(context, {
+            toolCallId: input.toolCallId,
+            toolId: input.toolName,
+            status: "success",
+            durationMs: Date.now() - startedAt,
+            summary: result.content.slice(0, 200),
+            metadata: {
+                subagent: true,
+                ...(result.metadata
+                    ? Object.fromEntries(Object.entries(result.metadata).filter((entry) => ["string", "number", "boolean"].includes(typeof entry[1]) || entry[1] === null))
+                    : {}),
+            },
+        }));
+        return result;
+    }
+    catch (error) {
+        const message = safeErrorMessage(error);
+        input.emit(createToolResultEvent(context, {
+            toolCallId: input.toolCallId,
+            toolId: input.toolName,
+            status: "error",
+            durationMs: Date.now() - startedAt,
+            summary: message,
+        }));
+        return { content: `Tool failed: ${message}` };
+    }
+}
+function parseRuntimeSubagentTaskInput(input) {
+    if (!input || typeof input !== "object" || Array.isArray(input)) {
+        throw new Error("Subagent task input must be an object.");
+    }
+    const record = input;
+    if (typeof record.task !== "string" || !record.task.trim()) {
+        throw new Error("Subagent task is required.");
+    }
+    return {
+        task: record.task,
+        ...(typeof record.context === "string" && record.context.trim()
+            ? { context: record.context }
+            : {}),
+    };
+}
+function inferSandboxProfile(toolName, input) {
+    if (toolName !== "bash" ||
+        !input ||
+        typeof input !== "object" ||
+        Array.isArray(input)) {
+        return undefined;
+    }
+    const command = input.command;
+    return typeof command === "string" && command.trim()
+        ? classifyShellSandboxProfile(command)
+        : undefined;
+}
+function extractPermissionTarget(toolName, input) {
+    if (!input || typeof input !== "object" || Array.isArray(input)) {
+        return undefined;
+    }
+    const record = input;
+    if (toolName === "bash" && typeof record.command === "string") {
+        const prefix = deriveCommandPrefix(record.command);
+        if (prefix.length > 0) {
+            return `command-prefix:${JSON.stringify(prefix)}`;
+        }
+    }
+    if (toolName.startsWith("google_drive_")) {
+        const driveTarget = extractGoogleDrivePermissionTarget(toolName, record);
+        if (driveTarget) {
+            return driveTarget;
+        }
+    }
+    if (toolName.startsWith("google_docs_")) {
+        const docsTarget = extractGoogleDocsPermissionTarget(toolName, record);
+        if (docsTarget) {
+            return docsTarget;
+        }
+    }
+    if (toolName.startsWith("google_sheets_")) {
+        const sheetsTarget = extractGoogleSheetsPermissionTarget(toolName, record);
+        if (sheetsTarget) {
+            return sheetsTarget;
+        }
+    }
+    if (toolName.startsWith("google_slides_")) {
+        const slidesTarget = extractGoogleSlidesPermissionTarget(toolName, record);
+        if (slidesTarget) {
+            return slidesTarget;
+        }
+    }
+    if (typeof record.path === "string" && record.path.trim()) {
+        return record.path.trim();
+    }
+    if (typeof record.target === "string" && record.target.trim()) {
+        return record.target.trim();
+    }
+    if (Array.isArray(record.args) && record.args.length > 0) {
+        const args = record.args
+            .map((value) => String(value).trim())
+            .filter(Boolean);
+        if (args.length > 0) {
+            return `args:${JSON.stringify(args)}`;
+        }
+    }
+    return undefined;
+}
+function getAvailableApprovalDecisions(toolName, target) {
+    return (toolName === "bash" && target?.startsWith("command-prefix:")) ||
+        (googleWorkspaceWriteToolNames.has(toolName) && target)
+        ? ["allow_once", "allow_session", "allow_always", "redirect"]
+        : ["allow_once", "redirect"];
+}
+function extractGoogleDrivePermissionTarget(toolName, record) {
+    if (toolName === "google_drive_create_folder" ||
+        toolName === "google_drive_create_text_file") {
+        return typeof record.parentId === "string" && record.parentId.trim()
+            ? `google-drive:folder:${record.parentId.trim()}`
+            : "google-drive:root";
+    }
+    if (typeof record.fileId === "string" && record.fileId.trim()) {
+        return `google-drive:file:${record.fileId.trim()}`;
+    }
+    return undefined;
+}
+function extractGoogleDocsPermissionTarget(toolName, record) {
+    if (toolName === "google_docs_create") {
+        return "google-docs:create";
+    }
+    if (typeof record.documentId === "string" && record.documentId.trim()) {
+        return `google-docs:document:${record.documentId.trim()}`;
+    }
+    return undefined;
+}
+function extractGoogleSheetsPermissionTarget(toolName, record) {
+    if (toolName === "google_sheets_create") {
+        return "google-sheets:create";
+    }
+    if (typeof record.spreadsheetId === "string" && record.spreadsheetId.trim()) {
+        return `google-sheets:spreadsheet:${record.spreadsheetId.trim()}`;
+    }
+    return undefined;
+}
+function extractGoogleSlidesPermissionTarget(toolName, record) {
+    if (toolName === "google_slides_create") {
+        return "google-slides:create";
+    }
+    if (typeof record.presentationId === "string" && record.presentationId.trim()) {
+        return `google-slides:presentation:${record.presentationId.trim()}`;
+    }
+    return undefined;
+}
+function deriveCommandPrefix(command) {
+    const firstSegment = firstShellCommandSegment(command);
+    return splitShellWords(firstSegment);
+}
+function firstShellCommandSegment(command) {
+    let quote;
+    let escaped = false;
+    for (let index = 0; index < command.length; index += 1) {
+        const char = command[index];
+        if (escaped) {
+            escaped = false;
+            continue;
+        }
+        if (char === "\\") {
+            escaped = true;
+            continue;
+        }
+        if (quote) {
+            if (char === quote)
+                quote = undefined;
+            continue;
+        }
+        if (char === "'" || char === '"') {
+            quote = char;
+            continue;
+        }
+        const next = command[index + 1];
+        if (char === ";" || char === "|" || char === "&" || char === "\n") {
+            if (char === "&" && next !== "&") {
+                continue;
+            }
+            return command.slice(0, index).trim();
+        }
+    }
+    return command.trim();
+}
+function splitShellWords(command) {
+    const words = [];
+    let current = "";
+    let quote;
+    let escaped = false;
+    for (const char of command) {
+        if (escaped) {
+            current += char;
+            escaped = false;
+            continue;
+        }
+        if (char === "\\") {
+            escaped = true;
+            continue;
+        }
+        if (quote) {
+            if (char === quote) {
+                quote = undefined;
+            }
+            else {
+                current += char;
+            }
+            continue;
+        }
+        if (char === "'" || char === '"') {
+            quote = char;
+            continue;
+        }
+        if (/\s/.test(char)) {
+            if (current) {
+                words.push(current);
+                current = "";
+            }
+            continue;
+        }
+        current += char;
+    }
+    if (current) {
+        words.push(current);
+    }
+    return words;
+}
+function inferToolRiskLevel(toolName) {
+    return toolName === "bash" ||
+        toolName === "write" ||
+        toolName === "edit" ||
+        toolName === "write_file" ||
+        toolName === "edit_file" ||
+        toolName === "document_apply_operations"
+        ? "destructive"
+        : "normal";
+}
+function safeErrorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+function summarizeToolResult(tool, result) {
+    const parsed = parseJsonRecord(result.content);
+    const metadata = compactMetadata(result.metadata);
+    if (tool.toolId === "read" || tool.toolId === "read_file") {
+        const content = typeof parsed?.content === "string" ? parsed.content : "";
+        return {
+            summary: `Read ${tool.target ?? readString(parsed, "relativePath") ?? "file"}`,
+            metadata: {
+                ...(metadata ?? {}),
+                bytes: Buffer.byteLength(content, "utf8"),
+                lines: content.length ? content.split("\n").length : 0,
+            },
+        };
+    }
+    if (tool.toolId === "list" || tool.toolId === "list_files") {
+        const files = Array.isArray(parsed?.files) ? parsed.files : [];
+        return {
+            summary: `Listed ${files.length} item(s)`,
+            metadata: {
+                ...(metadata ?? {}),
+                count: files.length,
+                ...(typeof parsed?.truncated === "boolean"
+                    ? { truncated: parsed.truncated }
+                    : {}),
+            },
+        };
+    }
+    if (tool.toolId === "grep" || tool.toolId === "ripgrep") {
+        const matches = Array.isArray(parsed?.matches) ? parsed.matches : [];
+        return {
+            summary: `Found ${matches.length} match(es)`,
+            metadata: {
+                ...(metadata ?? {}),
+                count: matches.length,
+                ...(typeof parsed?.truncated === "boolean"
+                    ? { truncated: parsed.truncated }
+                    : {}),
+            },
+        };
+    }
+    if (tool.toolId === "glob") {
+        const files = Array.isArray(parsed?.files) ? parsed.files : [];
+        return {
+            summary: `Found ${files.length} file(s)`,
+            metadata: {
+                ...(metadata ?? {}),
+                count: files.length,
+                ...(typeof parsed?.truncated === "boolean"
+                    ? { truncated: parsed.truncated }
+                    : {}),
+            },
+        };
+    }
+    if (tool.toolId === "write" || tool.toolId === "write_file") {
+        return {
+            summary: `Wrote ${tool.target ?? readString(parsed, "relativePath") ?? "file"}`,
+            ...(metadata ? { metadata } : {}),
+        };
+    }
+    if (tool.toolId === "edit" || tool.toolId === "edit_file") {
+        return {
+            summary: `Edited ${tool.target ?? readString(parsed, "relativePath") ?? "file"}`,
+            ...(metadata ? { metadata } : {}),
+        };
+    }
+    if (tool.toolId === "document_inspect") {
+        return {
+            summary: `Inspected ${readString(parsed, "path") ?? "document"}`,
+            ...(metadata ? { metadata } : {}),
+        };
+    }
+    if (tool.toolId === "document_apply_operations") {
+        return {
+            summary: `Edited ${readString(parsed, "outputPath") ?? tool.target ?? "document"}`,
+            ...(metadata ? { metadata } : {}),
+        };
+    }
+    if (tool.toolId === "bash") {
+        const exitCode = readNumber(parsed, "exitCode") ?? readNumber(metadata, "exitCode");
+        return {
+            summary: `Exited ${exitCode ?? 0}`,
+            metadata: {
+                ...(metadata ?? {}),
+                ...(exitCode !== undefined ? { exitCode } : {}),
+            },
+        };
+    }
+    if (tool.toolId === "update_plan") {
+        const plan = Array.isArray(parsed?.plan) ? parsed.plan : [];
+        return {
+            summary: `Updated ${plan.length} plan item(s)`,
+            ...(metadata ? { metadata } : {}),
+        };
+    }
+    if (tool.toolId === "project_app_defaults") {
+        return {
+            summary: "Updated project app defaults",
+            ...(metadata ? { metadata } : {}),
+        };
+    }
+    if (tool.toolId.startsWith("google_")) {
+        return summarizeGoogleWorkspaceToolResult(tool, parsed, metadata);
+    }
+    return {
+        ...(metadata ? { metadata } : {}),
+    };
+}
+function summarizeGoogleWorkspaceToolResult(tool, parsed, metadata) {
+    if (tool.toolId === "google_workspace_status") {
+        const capabilities = readStringArray(parsed, "capabilities");
+        return {
+            summary: capabilities.length
+                ? `Connected · ${capabilities.map(capitalizeWord).join(", ")}`
+                : "Connected",
+            ...(metadata ? { metadata } : {}),
+        };
+    }
+    if (tool.toolId === "google_drive_search") {
+        const files = readArray(parsed, "files");
+        return {
+            summary: `Found ${files.length} file(s)`,
+            metadata: {
+                ...(metadata ?? {}),
+                count: files.length,
+                ...(typeof parsed?.nextPageToken === "string"
+                    ? { hasMore: true }
+                    : {}),
+            },
+        };
+    }
+    if (tool.toolId === "google_drive_export_text" ||
+        tool.toolId === "google_drive_get_metadata") {
+        const file = readRecord(parsed, "file");
+        const name = readString(file, "name") ?? "file";
+        return {
+            summary: tool.toolId === "google_drive_export_text"
+                ? `Exported ${name}`
+                : `Read metadata for ${name}`,
+            ...(metadata ? { metadata } : {}),
+        };
+    }
+    if (tool.toolId.startsWith("google_drive_")) {
+        const file = readRecord(parsed, "file");
+        const name = readString(file, "name") ?? tool.target ?? "file";
+        return {
+            summary: `${googleDriveMutationVerb(tool.toolId)} ${name}`,
+            ...(metadata ? { metadata } : {}),
+        };
+    }
+    if (tool.toolId === "google_sheets_get_metadata") {
+        const sheets = readArray(parsed, "sheets");
+        const title = readString(parsed, "title") ?? "spreadsheet";
+        return {
+            summary: `Read metadata for ${title} · ${sheets.length} sheet(s)`,
+            ...(metadata ? { metadata } : {}),
+        };
+    }
+    if (tool.toolId === "google_sheets_read_range") {
+        const values = readArray(parsed, "values");
+        const range = readString(parsed, "range") ?? "range";
+        return {
+            summary: `Read ${values.length} row(s) from ${range}`,
+            metadata: { ...(metadata ?? {}), rows: values.length },
+        };
+    }
+    if (tool.toolId === "google_sheets_search_values") {
+        const matches = readArray(parsed, "matches");
+        return {
+            summary: `Found ${matches.length} match(es)`,
+            metadata: { ...(metadata ?? {}), count: matches.length },
+        };
+    }
+    if (tool.toolId === "google_sheets_create") {
+        return {
+            summary: `Created spreadsheet ${readString(parsed, "title") ?? ""}`.trim(),
+            ...(metadata ? { metadata } : {}),
+        };
+    }
+    if (tool.toolId.startsWith("google_sheets_")) {
+        const cells = readNumber(parsed, "updatedCells");
+        const replies = readArray(parsed, "replies");
+        return {
+            summary: cells !== undefined
+                ? `Updated ${cells} cell(s)`
+                : replies.length > 0
+                    ? `Applied ${replies.length} sheet update(s)`
+                    : "Updated spreadsheet",
+            ...(metadata ? { metadata } : {}),
+        };
+    }
+    if (tool.toolId.startsWith("google_docs_")) {
+        const target = readString(parsed, "title") ?? readString(parsed, "documentId") ?? "document";
+        return {
+            summary: `${googleDocsVerb(tool.toolId)} ${target}`,
+            ...(metadata ? { metadata } : {}),
+        };
+    }
+    if (tool.toolId === "google_slides_get_metadata" ||
+        tool.toolId === "google_slides_read_text") {
+        const slideCount = readNumber(parsed, "slideCount") ?? readArray(parsed, "slides").length;
+        const title = readString(parsed, "title") ?? "presentation";
+        return {
+            summary: `Read ${title} · ${slideCount} slide(s)`,
+            ...(metadata ? { metadata } : {}),
+        };
+    }
+    if (tool.toolId === "google_slides_create") {
+        return {
+            summary: `Created presentation ${readString(parsed, "title") ?? ""}`.trim(),
+            ...(metadata ? { metadata } : {}),
+        };
+    }
+    if (tool.toolId.startsWith("google_slides_")) {
+        const replies = readArray(parsed, "replies");
+        return {
+            summary: `Applied ${replies.length} slide update(s)`,
+            ...(metadata ? { metadata } : {}),
+        };
+    }
+    return {
+        summary: "Ran Google Workspace tool",
+        ...(metadata ? { metadata } : {}),
+    };
+}
+function googleDriveMutationVerb(toolId) {
+    if (toolId.includes("create"))
+        return "Created";
+    if (toolId.includes("rename"))
+        return "Renamed";
+    if (toolId.includes("move"))
+        return "Moved";
+    if (toolId.includes("trash"))
+        return "Trashed";
+    return "Updated";
+}
+function googleDocsVerb(toolId) {
+    if (toolId === "google_docs_create")
+        return "Created document";
+    if (toolId === "google_docs_append_text")
+        return "Appended to";
+    if (toolId === "google_docs_replace_text")
+        return "Updated";
+    return "Updated";
+}
+function readRecord(record, key) {
+    const value = record?.[key];
+    return value && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : undefined;
+}
+function readArray(record, key) {
+    const value = record?.[key];
+    return Array.isArray(value) ? value : [];
+}
+function readStringArray(record, key) {
+    return readArray(record, key).filter((value) => typeof value === "string" && Boolean(value));
+}
+function capitalizeWord(value) {
+    return value.charAt(0).toUpperCase() + value.slice(1);
+}
+function emitTaskProgressIfPresent(input) {
+    if (input.toolName !== "update_plan") {
+        return;
+    }
+    const parsed = parseJsonRecord(input.result.content);
+    const rawPlan = parsed?.plan;
+    if (!Array.isArray(rawPlan)) {
+        return;
+    }
+    const plan = rawPlan.flatMap((item) => {
+        if (!item || typeof item !== "object" || Array.isArray(item))
+            return [];
+        const record = item;
+        const step = record.step;
+        const status = record.status;
+        if (typeof step !== "string" ||
+            !step.trim() ||
+            !isTaskProgressStatus(status)) {
+            return [];
+        }
+        return [{ step: step.trim(), status }];
+    });
+    if (plan.length === 0) {
+        return;
+    }
+    const explanation = readString(parsed, "explanation");
+    input.emit(createTaskProgressEvent(input.context, {
+        toolCallId: input.toolCallId,
+        plan,
+        ...(explanation ? { explanation } : {}),
+    }));
+}
+function isTaskProgressStatus(value) {
+    return value === "pending" || value === "in_progress" || value === "completed";
+}
+function parseJsonRecord(value) {
+    try {
+        const parsed = JSON.parse(value);
+        return parsed && typeof parsed === "object" && !Array.isArray(parsed)
+            ? parsed
+            : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function compactMetadata(metadata) {
+    if (!metadata)
+        return undefined;
+    const compacted = {};
+    for (const [key, value] of Object.entries(metadata)) {
+        if (typeof value === "string" ||
+            typeof value === "number" ||
+            typeof value === "boolean" ||
+            value === null) {
+            compacted[key] = value;
+        }
+    }
+    return Object.keys(compacted).length ? compacted : undefined;
+}
+function readString(record, key) {
+    const value = record?.[key];
+    return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}
+function readNumber(record, key) {
+    const value = record?.[key];
+    return typeof value === "number" ? value : undefined;
+}
+//# sourceMappingURL=runtime-tool-execution.js.map