open-managed-agents 0.1.0

package/dist/src/control-plane/events/tool-persistence.js

@@ -0,0 +1,102 @@
+import { materializePersistedEvents } from "./persist.js";
+export function materializeToolPermissionUseRows(input) {
+    const useRows = materializePersistedEvents(input.workspaceId, input.sessionId, [
+        {
+            type: "agent.tool_use",
+            payload: {
+                name: input.event.name,
+                input: input.event.input,
+                evaluated_permission: input.event.evaluatedPermission,
+            },
+        },
+    ], input.now);
+    input.event.bindToolUseId(useRows[0].id, (reason) => {
+        input.onReleased(useRows[0].id, reason);
+    });
+    return useRows;
+}
+export function materializeMcpToolUseRows(input) {
+    const useRows = materializePersistedEvents(input.workspaceId, input.sessionId, [
+        {
+            type: "agent.mcp_tool_use",
+            payload: {
+                mcp_server_name: input.event.mcpServerName,
+                name: input.event.name,
+                input: input.event.input,
+                evaluated_permission: input.event.evaluatedPermission,
+                // Probe 47 wire parity: hosted emits null outside subagent threads.
+                session_thread_id: null,
+            },
+        },
+    ], input.now);
+    input.event.bindToolUseId(useRows[0].id, (reason) => {
+        input.onReleased(useRows[0].id, reason);
+    });
+    return useRows;
+}
+export function toolPermissionRuntimeChanges(input) {
+    return {
+        openedActions: input.evaluatedPermission === "ask"
+            ? [
+                {
+                    workspaceId: input.workspaceId,
+                    sessionId: input.sessionId,
+                    turnId: input.turnId,
+                    actionId: input.toolUseId,
+                    actionType: "tool_confirmation",
+                    now: input.now,
+                },
+            ]
+            : [],
+        turnStates: input.evaluatedPermission === "ask"
+            ? [
+                {
+                    workspaceId: input.workspaceId,
+                    sessionId: input.sessionId,
+                    turnId: input.turnId,
+                    ownerId: input.ownerId,
+                    ownerGeneration: input.ownerGeneration,
+                    state: "paused",
+                    now: input.now,
+                },
+            ]
+            : [
+                {
+                    workspaceId: input.workspaceId,
+                    sessionId: input.sessionId,
+                    turnId: input.turnId,
+                    ownerId: input.ownerId,
+                    ownerGeneration: input.ownerGeneration,
+                    state: "running",
+                    now: input.now,
+                },
+            ],
+    };
+}
+export function materializeMcpToolResultRows(input) {
+    return materializePersistedEvents(input.workspaceId, input.sessionId, [
+        {
+            type: "agent.mcp_tool_result",
+            payload: {
+                mcp_tool_use_id: input.event.mcpToolUseId,
+                content: input.event.content,
+                is_error: input.event.isError,
+            },
+        },
+    ], input.now);
+}
+export function materializeMcpConnectionFailedRows(input) {
+    return materializePersistedEvents(input.workspaceId, input.sessionId, [
+        {
+            type: "session.error",
+            payload: {
+                error: {
+                    type: input.event.errorType ?? "mcp_connection_failed_error",
+                    mcp_server_name: input.event.mcpServerName,
+                    message: input.event.message,
+                    retry_status: { type: input.event.retryStatus },
+                },
+            },
+        },
+    ], input.now);
+}

package/dist/src/control-plane/events/types.js

@@ -0,0 +1,21 @@
+export class RuntimeTurnOwnershipLostError extends Error {
+    turnId;
+    constructor(turnId) {
+        super(`Runtime turn ownership lost: ${turnId}`);
+        this.turnId = turnId;
+        this.name = "RuntimeTurnOwnershipLostError";
+    }
+}
+export class RuntimeUnsupportedSessionFileResourcesError extends Error {
+    constructor() {
+        super("Configured runtime does not support session file resources");
+    }
+}
+export function toManagedAgentsEvent(event) {
+    return {
+        id: event.id,
+        type: event.type,
+        processed_at: event.processed_at,
+        ...event.payload,
+    };
+}

package/dist/src/control-plane/files/routes.js

@@ -0,0 +1,121 @@
+import { Hono } from "hono";
+import { bodyLimit } from "hono/body-limit";
+import { File as NodeFile } from "node:buffer";
+import { invalidRequest, requestTooLarge, toApiErrorBody, } from "../errors.js";
+import { parseLimit } from "../http.js";
+import { workspaceIdFrom } from "../workspace.js";
+export const MAX_FILE_UPLOAD_REQUEST_BYTES = 24 * 1024 * 1024;
+export function filesRoutes(service, admission) {
+    const app = new Hono();
+    // 0113 D9: the upload slot must be reserved BEFORE bodyLimit. For requests
+    // without a content-length, Hono's bodyLimit eagerly reads the raw body
+    // into a wrapped stream, so a gate placed after it (or in the handler)
+    // admits up to 24 MiB of buffering per rejected request.
+    app.use("/", async (c, next) => {
+        if (c.req.method !== "POST" || admission === undefined) {
+            await next();
+            return;
+        }
+        const releaseUpload = admission.uploads.acquire(workspaceIdFrom(c));
+        try {
+            await next();
+        }
+        finally {
+            releaseUpload();
+        }
+    });
+    app.use("/", bodyLimit({
+        maxSize: MAX_FILE_UPLOAD_REQUEST_BYTES,
+        onError: (c) => {
+            const err = requestTooLarge();
+            return jsonError(toApiErrorBody(err, c.get("requestId")), err.status);
+        },
+    }));
+    app.post("/", async (c) => {
+        const body = await parseMultipartBody(c.req);
+        const file = body.file;
+        if (!isUploadedFile(file)) {
+            throw invalidRequest("`file` is required");
+        }
+        const uploaded = await service.upload(workspaceIdFrom(c), {
+            filename: file.name,
+            mimeType: file.type,
+            body: new Uint8Array(await file.arrayBuffer()),
+        });
+        return c.json(uploaded, 200);
+    });
+    app.get("/", async (c) => {
+        const limit = parseLimit(c.req.query("limit"));
+        const afterId = c.req.query("after_id") || undefined;
+        const beforeId = c.req.query("before_id") || undefined;
+        const scopeId = c.req.query("scope_id") || undefined;
+        return c.json(await service.list(workspaceIdFrom(c), {
+            limit,
+            afterId,
+            beforeId,
+            scopeId,
+        }), 200);
+    });
+    app.get("/:id", async (c) => {
+        return c.json(await service.retrieveMetadata(workspaceIdFrom(c), c.req.param("id")), 200);
+    });
+    app.get("/:id/content", async (c) => {
+        const download = await service.download(workspaceIdFrom(c), c.req.param("id"));
+        return new Response(asyncIterableToReadableStream(download.body), {
+            status: 200,
+            headers: {
+                "content-type": download.mimeType,
+                "content-length": String(download.sizeBytes),
+                "request-id": c.get("requestId"),
+            },
+        });
+    });
+    app.delete("/:id", async (c) => {
+        return c.json(await service.delete(workspaceIdFrom(c), c.req.param("id")), 200);
+    });
+    return app;
+}
+function isUploadedFile(value) {
+    return (value instanceof NodeFile ||
+        (typeof value === "object" &&
+            value !== null &&
+            "arrayBuffer" in value &&
+            typeof value.arrayBuffer === "function" &&
+            "name" in value &&
+            typeof value.name === "string" &&
+            "type" in value &&
+            typeof value.type === "string"));
+}
+async function parseMultipartBody(req) {
+    try {
+        return await req.parseBody();
+    }
+    catch (error) {
+        throw invalidRequest("Request body must be valid multipart/form-data", String(error));
+    }
+}
+function jsonError(body, status) {
+    return new Response(JSON.stringify(body), {
+        status,
+        headers: {
+            "content-type": "application/json; charset=UTF-8",
+            "request-id": body.request_id,
+        },
+    });
+}
+function asyncIterableToReadableStream(body) {
+    const iterator = body[Symbol.asyncIterator]();
+    return new ReadableStream({
+        async pull(controller) {
+            const next = await iterator.next();
+            if (next.done) {
+                controller.close();
+                return;
+            }
+            controller.enqueue(next.value);
+        },
+        async cancel(reason) {
+            await iterator.throw?.(reason);
+        },
+    });
+}

package/dist/src/control-plane/files/service.js

@@ -0,0 +1,65 @@
+import { invalidRequest, notFound } from "../errors.js";
+export class DefaultFileService {
+    storage;
+    constructor(storage) {
+        this.storage = storage;
+    }
+    async upload(workspaceId, input) {
+        const record = await this.storage.create(workspaceId, {
+            filename: normalizeFilename(input.filename),
+            mimeType: normalizeMimeType(input.mimeType),
+            body: input.body,
+        });
+        return record.metadata;
+    }
+    async retrieveMetadata(workspaceId, fileId) {
+        const record = await this.storage.retrieveMetadata(workspaceId, fileId);
+        if (!record) {
+            throw notFound(`File ${fileId} not found`);
+        }
+        return record.metadata;
+    }
+    async download(workspaceId, fileId) {
+        const metadata = await this.retrieveMetadata(workspaceId, fileId);
+        if (!metadata.downloadable) {
+            throw invalidRequest(`File '${fileId}' is not downloadable`);
+        }
+        const body = await this.storage.openBytes(workspaceId, fileId);
+        if (!body) {
+            throw notFound(`File ${fileId} not found`);
+        }
+        return {
+            filename: metadata.filename,
+            mimeType: metadata.mime_type,
+            sizeBytes: metadata.size_bytes,
+            body,
+        };
+    }
+    async delete(workspaceId, fileId) {
+        const deleted = await this.storage.delete(workspaceId, fileId);
+        if (!deleted) {
+            throw notFound(`File ${fileId} not found`);
+        }
+        return { id: fileId, type: "file_deleted" };
+    }
+    async list(workspaceId, opts = {}) {
+        const page = await this.storage.list(workspaceId, opts);
+        return {
+            data: page.data.map((record) => record.metadata),
+            has_more: page.has_more,
+            first_id: page.first_id,
+            last_id: page.last_id,
+        };
+    }
+}
+function normalizeFilename(filename) {
+    const trimmed = filename.trim();
+    if (trimmed.length === 0) {
+        throw invalidRequest("Uploaded file must include a filename");
+    }
+    return trimmed;
+}
+function normalizeMimeType(mimeType) {
+    const trimmed = mimeType.trim();
+    return trimmed.length === 0 ? "application/octet-stream" : trimmed;
+}

package/dist/src/control-plane/files/store-common.js

@@ -0,0 +1,87 @@
+import { createHash } from "node:crypto";
+import { invalidRequest } from "../errors.js";
+export function reusableOutput(stored, file, sizeBytes, sha256) {
+    if (!stored)
+        return undefined;
+    if (stored.sha256 !== sha256)
+        return undefined;
+    if (stored.metadata.size_bytes !== sizeBytes)
+        return undefined;
+    if (stored.metadata.filename !== file.filename)
+        return undefined;
+    return stored;
+}
+export async function consumeUploadBody(body, maxBytes, label) {
+    const hash = createHash("sha256");
+    const chunks = [];
+    let sizeBytes = 0;
+    for await (const chunk of chunksOf(body)) {
+        sizeBytes += chunk.byteLength;
+        if (sizeBytes > maxBytes) {
+            throw invalidRequest(`${label} exceeds the ${limitLabel(maxBytes)} per-file limit`);
+        }
+        hash.update(chunk);
+        chunks.push(chunk);
+    }
+    return {
+        bytes: concat(chunks, sizeBytes),
+        sizeBytes,
+        sha256: hash.digest("hex"),
+    };
+}
+export function validateOutputFilename(filename, maxBytes) {
+    const bytes = new TextEncoder().encode(filename).byteLength;
+    if (bytes === 0) {
+        throw invalidRequest("Session output filename must not be empty");
+    }
+    if (filename.includes("/") || filename.includes("\\")) {
+        throw invalidRequest(`Session output filename must be a basename: ${filename}`);
+    }
+    if (bytes > maxBytes) {
+        throw invalidRequest(`Session output filename exceeds the ${maxBytes} byte limit`);
+    }
+}
+async function* chunksOf(body) {
+    if (body instanceof Uint8Array) {
+        yield body;
+        return;
+    }
+    for await (const chunk of body) {
+        yield chunk;
+    }
+}
+function concat(chunks, totalLength) {
+    const out = new Uint8Array(totalLength);
+    let offset = 0;
+    for (const chunk of chunks) {
+        out.set(chunk, offset);
+        offset += chunk.byteLength;
+    }
+    return out;
+}
+export function normalizeLimit(limit) {
+    if (limit === undefined)
+        return 20;
+    if (!Number.isSafeInteger(limit) || limit <= 0)
+        return 20;
+    return Math.min(limit, 1000);
+}
+export function limitLabel(bytes) {
+    if (bytes % (1024 * 1024) === 0)
+        return `${bytes / (1024 * 1024)} MiB`;
+    return `${bytes} bytes`;
+}
+export function toRecord(stored) {
+    return {
+        workspace_id: stored.workspace_id,
+        storage_key: stored.storage_key,
+        sha256: stored.sha256,
+        metadata: { ...stored.metadata },
+    };
+}
+export function compareRecords(a, b) {
+    return compareId(a.metadata.id, b.metadata.id);
+}
+export function compareId(a, b) {
+    return a.localeCompare(b);
+}