@digitalocean/dots 1.18.0-beta.1 → 1.19.0

package/src/action-gateway/index.js

@@ -1,663 +0,0 @@
-import { FetchRequestAdapter } from "@microsoft/kiota-http-fetchlibrary";
-import { DigitalOceanApiKeyAuthenticationProvider } from "../dots/DigitalOceanApiKeyAuthenticationProvider.js";
-import { createDigitalOceanClient } from "../dots/digitalOceanClient.js";
-import { InferenceClient, } from "../inference-gen/InferenceClient.js";
-export const DEFAULT_API_BASE_URL = "https://api.digitalocean.com";
-export const SESSION_ID_HEADER = "X-Session-Id";
-export const ACTOR_ID_HEADER = "X-Actor-Id";
-export const MCP_PROTOCOL_VERSION = "2025-06-18";
-export const META_SEARCH = "action_search";
-export const META_INVOKE = "action_invoke";
-export const META_CODE = "action_code";
-export class GatewayError extends Error {
-    constructor(message, status, body) {
-        super(message);
-        this.status = status;
-        this.body = body;
-        this.name = "GatewayError";
-    }
-}
-function asObject(value) {
-    return value !== null && typeof value === "object" ? value : {};
-}
-function asArray(value) {
-    return Array.isArray(value) ? value : [];
-}
-function parseArguments(value) {
-    if (typeof value === "string") {
-        if (!value.trim())
-            return {};
-        return asObject(JSON.parse(value));
-    }
-    return asObject(value);
-}
-function stringifyResult(value) {
-    return typeof value === "string" ? value : JSON.stringify(value);
-}
-function simplifySchema(schema) {
-    const simplified = structuredClone(asObject(schema));
-    for (const key of ["oneOf", "allOf", "anyOf", "enum", "const", "not"]) {
-        delete simplified[key];
-    }
-    simplified.type ?? (simplified.type = "object");
-    if (simplified.type === "object")
-        simplified.properties ?? (simplified.properties = {});
-    return simplified;
-}
-function toolFields(tool) {
-    return {
-        name: tool.name,
-        description: tool.description ?? tool.title ?? "",
-        parameters: simplifySchema(tool.inputSchema),
-    };
-}
-export class ChatCompletionsProvider {
-    constructor() {
-        this.name = "chat.completions";
-    }
-    wrapTools(tools) {
-        return tools.map((tool) => ({ type: "function", function: toolFields(tool) }));
-    }
-    extractToolCalls(response) {
-        const choice = asObject(asArray(asObject(response).choices)[0]);
-        const message = asObject(choice.message);
-        return asArray(message.tool_calls).map((value) => {
-            const call = asObject(value);
-            const functionCall = asObject(call.function);
-            return {
-                callId: String(call.id ?? ""),
-                name: String(functionCall.name ?? ""),
-                arguments: parseArguments(functionCall.arguments),
-            };
-        });
-    }
-    formatToolResults(calls, results) {
-        return calls.map((call, index) => ({
-            role: "tool",
-            tool_call_id: call.callId,
-            content: stringifyResult(results[index]),
-        }));
-    }
-}
-export class MessagesProvider {
-    constructor() {
-        this.name = "messages";
-    }
-    wrapTools(tools) {
-        return tools.map((tool) => {
-            const fields = toolFields(tool);
-            return {
-                name: fields.name,
-                description: fields.description,
-                input_schema: fields.parameters,
-            };
-        });
-    }
-    extractToolCalls(response) {
-        return asArray(asObject(response).content)
-            .map(asObject)
-            .filter((block) => block.type === "tool_use")
-            .map((block) => ({
-            callId: String(block.id ?? ""),
-            name: String(block.name ?? ""),
-            arguments: parseArguments(block.input),
-        }));
-    }
-    formatToolResults(calls, results) {
-        if (calls.length === 0)
-            return [];
-        return [{
-                role: "user",
-                content: calls.map((call, index) => ({
-                    type: "tool_result",
-                    tool_use_id: call.callId,
-                    content: stringifyResult(results[index]),
-                })),
-            }];
-    }
-}
-export class ResponsesProvider {
-    constructor() {
-        this.name = "responses";
-    }
-    wrapTools(tools) {
-        return tools.map((tool) => ({ type: "function", ...toolFields(tool) }));
-    }
-    extractToolCalls(response) {
-        return asArray(asObject(response).output)
-            .map(asObject)
-            .filter((item) => item.type === "function_call")
-            .map((item) => ({
-            callId: String(item.call_id ?? item.id ?? ""),
-            name: String(item.name ?? ""),
-            arguments: parseArguments(item.arguments),
-        }));
-    }
-    formatToolResults(calls, results) {
-        return calls.map((call, index) => ({
-            type: "function_call_output",
-            call_id: call.callId,
-            output: stringifyResult(results[index]),
-        }));
-    }
-}
-function normalizeBaseURL(value) {
-    const url = value.trim().replace(/\/+$/, "");
-    return url.includes("://") ? url : `https://${url}`;
-}
-function externalSessionId(sessionUrn) {
-    return sessionUrn.split(":").at(-1) ?? sessionUrn;
-}
-function isLoopbackHost(hostname) {
-    return hostname === "localhost"
-        || hostname === "127.0.0.1"
-        || hostname === "[::1]"
-        || hostname.endsWith(".localhost");
-}
-/**
- * Gateway requests carry the DigitalOcean API token, so refuse an `mcpUrl` that
- * would put it on the wire in cleartext. Loopback endpoints stay usable for
- * local gateway development.
- */
-function assertTransportURL(mcpURL, payload) {
-    let url;
-    try {
-        url = new URL(mcpURL);
-    }
-    catch {
-        throw new GatewayError(`session create response returned an invalid mcpUrl: ${mcpURL}`, undefined, payload);
-    }
-    if (url.protocol === "https:")
-        return;
-    if (url.protocol === "http:" && isLoopbackHost(url.hostname))
-        return;
-    throw new GatewayError(`session create response returned a non-HTTPS mcpUrl: ${mcpURL}`, undefined, payload);
-}
-function normalizePermissions(permissions) {
-    const rules = (permissions?.rules ?? []).map((rule) => {
-        if (!rule.tool)
-            throw new Error("each permissions rule requires tool");
-        return {
-            tool: rule.tool,
-            action: rule.action ?? "allow",
-            ...(rule.match ? { match: rule.match } : {}),
-        };
-    });
-    return {
-        defaultAction: permissions?.defaultAction ?? permissions?.default_action ?? "ask",
-        rules,
-    };
-}
-function toSessionPolicy(policy) {
-    return {
-        defaultAction: policy.defaultAction,
-        rules: policy.rules.map((rule) => ({
-            tool: rule.tool,
-            action: rule.action,
-            ...(rule.match ? { match: { additionalData: rule.match } } : {}),
-        })),
-    };
-}
-function toSessionConfig(config) {
-    const { preloadTools, ...additionalData } = config;
-    return {
-        ...(preloadTools === undefined ? {} : { preloadTools: preloadTools }),
-        ...(Object.keys(additionalData).length === 0 ? {} : { additionalData }),
-    };
-}
-async function requestJSON(url, apiKey, init) {
-    const response = await fetch(url, {
-        ...init,
-        headers: {
-            ...(apiKey ? { Authorization: `Bearer ${apiKey}` } : {}),
-            Accept: "application/json",
-            "Content-Type": "application/json",
-            ...init.headers,
-        },
-    });
-    const text = await response.text();
-    let body;
-    try {
-        body = text ? JSON.parse(text) : undefined;
-    }
-    catch {
-        body = text;
-    }
-    if (!response.ok) {
-        const message = String(asObject(body).message ?? response.statusText ?? "request failed");
-        throw new GatewayError(message, response.status, body);
-    }
-    return body;
-}
-const META_TOOLS = [
-    {
-        name: META_SEARCH,
-        title: "Action Search",
-        description: "Discover catalog tools for one or more use cases.",
-        inputSchema: {
-            type: "object",
-            properties: {
-                queries: {
-                    type: "array",
-                    minItems: 1,
-                    maxItems: 5,
-                    items: {
-                        type: "object",
-                        properties: {
-                            use_case: { type: "string" },
-                            known_fields: { type: "string" },
-                        },
-                        required: ["use_case"],
-                    },
-                },
-                providers: { type: "array", items: { type: "string" } },
-                tags: { type: "array", items: { type: "string" } },
-                limit: { type: "integer" },
-            },
-            required: ["queries"],
-        },
-    },
-    {
-        name: META_INVOKE,
-        title: "Action Invoke",
-        description: "Invoke one to ten catalog tools in parallel.",
-        inputSchema: {
-            type: "object",
-            properties: {
-                tools: {
-                    type: "array",
-                    minItems: 1,
-                    maxItems: 10,
-                    items: {
-                        type: "object",
-                        properties: {
-                            tool: { type: "string" },
-                            tool_slug: { type: "string" },
-                            arguments: { type: "object" },
-                        },
-                    },
-                },
-                rationale: { type: "string", maxLength: 512 },
-            },
-            required: ["tools"],
-        },
-    },
-    {
-        name: META_CODE,
-        title: "Action Code",
-        description: "Run Python in an ephemeral sandbox.",
-        inputSchema: {
-            type: "object",
-            properties: {
-                code: { type: "string" },
-                code_to_execute: { type: "string" },
-                thought: { type: "string" },
-            },
-        },
-    },
-];
-class GatewayTransport {
-    constructor(apiKey, endpointURL, sessionUrn, actorId) {
-        this.apiKey = apiKey;
-        this.endpointURL = endpointURL;
-        this.actorId = actorId;
-        this.nextRequestId = 1;
-        this.sessionId = externalSessionId(sessionUrn);
-    }
-    async callTool(name, arguments_) {
-        const result = await this.rpc("tools/call", { name, arguments: arguments_ });
-        return unwrapMCPToolResult(result);
-    }
-    async listTools() {
-        const result = asObject(await this.rpc("tools/list"));
-        return asArray(result.tools);
-    }
-    async decideApproval(approvalId, decision) {
-        const normalizedApprovalId = approvalId.trim();
-        if (!normalizedApprovalId)
-            throw new Error("approvalId is required");
-        const origin = new URL(this.endpointURL).origin;
-        return requestJSON(`${origin}/approvals/${encodeURIComponent(normalizedApprovalId)}`, this.apiKey, {
-            method: "POST",
-            headers: {
-                [SESSION_ID_HEADER]: this.sessionId,
-                [ACTOR_ID_HEADER]: this.actorId,
-            },
-            body: JSON.stringify({ decision }),
-        });
-    }
-    async rpc(method, params) {
-        const response = await fetch(this.endpointURL, {
-            method: "POST",
-            headers: {
-                Authorization: `Bearer ${this.apiKey}`,
-                Accept: "application/json, text/event-stream",
-                "Content-Type": "application/json",
-                "MCP-Protocol-Version": MCP_PROTOCOL_VERSION,
-                [SESSION_ID_HEADER]: this.sessionId,
-                [ACTOR_ID_HEADER]: this.actorId,
-            },
-            body: JSON.stringify({
-                jsonrpc: "2.0",
-                id: this.nextRequestId++,
-                method,
-                ...(params === undefined ? {} : { params }),
-            }),
-        });
-        const text = await response.text();
-        const envelope = parseMCPEnvelope(text);
-        if (!response.ok) {
-            throw new GatewayError(String(asObject(envelope).message ?? response.statusText ?? "request failed"), response.status, envelope);
-        }
-        const error = asObject(asObject(envelope).error);
-        if (Object.keys(error).length > 0) {
-            throw new GatewayError(String(error.message ?? "MCP request failed"), undefined, error);
-        }
-        if (!("result" in asObject(envelope))) {
-            throw new GatewayError("MCP response is missing result", undefined, envelope);
-        }
-        return asObject(envelope).result;
-    }
-}
-function parseMCPEnvelope(text) {
-    if (!text.trim())
-        return undefined;
-    if (!text.split("\n").some((line) => line.startsWith("data:")))
-        return JSON.parse(text);
-    const events = text.split(/\r?\n\r?\n/);
-    for (const event of events) {
-        const data = event.split(/\r?\n/)
-            .filter((line) => line.startsWith("data:"))
-            .map((line) => line.slice(5).trimStart())
-            .join("\n");
-        if (!data)
-            continue;
-        const candidate = JSON.parse(data);
-        if ("result" in asObject(candidate) || "error" in asObject(candidate))
-            return candidate;
-    }
-    throw new GatewayError("MCP response did not contain a JSON-RPC result");
-}
-function unwrapMCPToolResult(payload) {
-    const result = asObject(payload);
-    if (result.isError) {
-        const structured = asObject(result.structuredContent);
-        const error = asObject(structured.error);
-        throw new GatewayError(String(error.message ?? contentText(result.content) ?? "tool call failed"), undefined, payload);
-    }
-    if ("structuredContent" in result)
-        return result.structuredContent;
-    const text = contentText(result.content);
-    if (text === undefined)
-        return payload;
-    try {
-        return JSON.parse(text);
-    }
-    catch {
-        return text;
-    }
-}
-function contentText(content) {
-    const text = asArray(content)
-        .map(asObject)
-        .filter((item) => item.type === "text" && typeof item.text === "string")
-        .map((item) => String(item.text))
-        .join("\n");
-    return text || undefined;
-}
-function unwrapToolResult(payload) {
-    const result = asObject(payload);
-    if (result.status && result.status !== "succeeded") {
-        const error = asObject(result.error);
-        throw new GatewayError(String(error.message ?? "tool call failed"), undefined, payload);
-    }
-    if ("output" in result) {
-        if (typeof result.output === "string") {
-            try {
-                return JSON.parse(result.output);
-            }
-            catch {
-                return result.output;
-            }
-        }
-        return result.output;
-    }
-    return payload;
-}
-function toolErrorResult(error) {
-    const body = asObject(error.body);
-    const structured = asObject(body.structuredContent);
-    const structuredError = asObject(structured.error);
-    const bodyError = asObject(body.error);
-    const details = Object.keys(structuredError).length > 0 ? structuredError : bodyError;
-    return {
-        error: Object.keys(details).length > 0
-            ? { ...details, message: details.message ?? error.message }
-            : { message: error.message },
-        ...(body._meta === undefined ? {} : { _meta: body._meta }),
-    };
-}
-function normalizeQueries(input) {
-    const queries = Array.isArray(input) ? input : [input];
-    if (queries.length < 1 || queries.length > 5) {
-        throw new Error("search accepts between 1 and 5 queries");
-    }
-    return queries.map((query) => typeof query === "string" ? { use_case: query } : query);
-}
-export class ToolsOperations {
-    constructor(transport, provider) {
-        this.transport = transport;
-        this.provider = provider;
-    }
-    async list(options = {}) {
-        if (!options.includeAll)
-            return structuredClone(META_TOOLS);
-        return this.transport.listTools();
-    }
-    async search(queries, options = {}) {
-        return this.transport.callTool(META_SEARCH, {
-            queries: normalizeQueries(queries),
-            ...(options.providers?.length ? { providers: options.providers } : {}),
-            ...(options.tags?.length ? { tags: options.tags } : {}),
-            ...(options.limit !== undefined ? { limit: options.limit } : {}),
-        });
-    }
-    async invoke(tools, options = {}) {
-        if (tools.length < 1 || tools.length > 10) {
-            throw new Error("invoke accepts between 1 and 10 tools");
-        }
-        const normalized = tools.map((tool) => {
-            const name = tool.tool ?? tool.toolSlug ?? tool.tool_slug;
-            if (!name)
-                throw new Error("each invoke entry requires tool");
-            return { tool: name, arguments: tool.arguments ?? {} };
-        });
-        return this.transport.callTool(META_INVOKE, {
-            tools: normalized,
-            ...(options.rationale ? { rationale: options.rationale } : {}),
-        });
-    }
-    async invokeOne(name, arguments_ = {}, options = {}) {
-        const envelope = asObject(await this.invoke([{ tool: name, arguments: arguments_ }], options));
-        const first = asObject(asArray(envelope.results)[0]);
-        if (Object.keys(first).length === 0)
-            throw new GatewayError(`invoke of ${name} returned no results`);
-        return unwrapToolResult(first.result ?? first);
-    }
-    async definitions(options = {}) {
-        let catalog;
-        if (options.search !== undefined) {
-            catalog = flattenSearchResults(await this.search(options.search, options));
-        }
-        else {
-            catalog = await this.list({ includeAll: options.includeAll || Boolean(options.names?.length) });
-        }
-        if (options.names?.length) {
-            const names = new Set(options.names);
-            catalog = catalog.filter((tool) => names.has(tool.name));
-            const missing = options.names.filter((name) => !catalog.some((tool) => tool.name === name));
-            if (missing.length)
-                throw new Error(`tools not found in catalog: ${missing.join(", ")}`);
-        }
-        return this.provider.wrapTools(catalog);
-    }
-}
-function flattenSearchResults(payload) {
-    const found = new Map();
-    for (const group of asArray(asObject(payload).results)) {
-        for (const match of asArray(asObject(group).results)) {
-            const tool = asObject(match);
-            if (tool.name && !found.has(tool.name))
-                found.set(tool.name, tool);
-        }
-    }
-    return [...found.values()];
-}
-export class CodeOperations {
-    constructor(transport) {
-        this.transport = transport;
-    }
-    async execute(code, options = {}) {
-        if (!code.trim())
-            throw new Error("code is empty");
-        return this.transport.callTool(META_CODE, {
-            code,
-            ...(options.thought ? { thought: options.thought } : {}),
-        });
-    }
-}
-export class Session {
-    constructor(sessionUrn, actorId, name, policy, mcpURL, provider, transport, raw, selectedTools) {
-        this.sessionUrn = sessionUrn;
-        this.actorId = actorId;
-        this.name = name;
-        this.policy = policy;
-        this.mcpURL = mcpURL;
-        this.provider = provider;
-        this.raw = raw;
-        this.selectedTools = selectedTools;
-        this.id = externalSessionId(sessionUrn);
-        this.transport = transport;
-        this.toolsOperations = new ToolsOperations(transport, provider);
-        this.code = new CodeOperations(transport);
-    }
-    get url() {
-        return this.mcpURL;
-    }
-    approve(approvalId) {
-        return this.transport.decideApproval(approvalId, "approve");
-    }
-    deny(approvalId) {
-        return this.transport.decideApproval(approvalId, "deny");
-    }
-    tools(options = {}) {
-        return this.toolsOperations.definitions(options);
-    }
-    async handleToolCalls(response, options = {}) {
-        const calls = this.provider.extractToolCalls(response);
-        const results = await this.executeToolCalls(calls, options);
-        return this.provider.formatToolResults(calls, results);
-    }
-    async executeToolCalls(calls, options = {}) {
-        return Promise.all(calls.map(async (call) => {
-            try {
-                if (call.name === META_SEARCH)
-                    return await this.toolsOperations.search(asArray(call.arguments.queries), call.arguments);
-                if (call.name === META_INVOKE)
-                    return await this.toolsOperations.invoke(asArray(call.arguments.tools), {
-                        rationale: String(call.arguments.rationale ?? options.rationale ?? "") || undefined,
-                    });
-                if (call.name === META_CODE) {
-                    const code = String(call.arguments.code ?? call.arguments.code_to_execute ?? "");
-                    return await this.code.execute(code, { thought: String(call.arguments.thought ?? "") || undefined });
-                }
-                return await this.toolsOperations.invokeOne(call.name, call.arguments, options);
-            }
-            catch (error) {
-                if (error instanceof GatewayError)
-                    return toolErrorResult(error);
-                throw error;
-            }
-        }));
-    }
-}
-export class SessionsOperations {
-    constructor(apiKey, provider, sessionsApi) {
-        this.apiKey = apiKey;
-        this.provider = provider;
-        this.sessionsApi = sessionsApi;
-    }
-    async create(options) {
-        const actorId = options.actorId?.trim();
-        if (!actorId)
-            throw new Error("actorId is required");
-        const suffix = Math.random().toString(16).slice(2, 10);
-        const name = options.name ?? `dots-session-${suffix}`;
-        const policy = normalizePermissions(options.permissions);
-        if (options.tools !== undefined && !Array.isArray(options.tools)) {
-            throw new TypeError("tools must be an array of tool references");
-        }
-        const body = {
-            actorId,
-            name,
-            policy: toSessionPolicy(policy),
-            ...(options.tools === undefined ? {} : { tools: options.tools }),
-            ...(options.config === undefined ? {} : { config: toSessionConfig(options.config) }),
-        };
-        const payload = await this.sessionsApi.post(body);
-        const raw = asObject(payload?.session);
-        const sessionUrn = String(payload?.session?.sessionUrn ?? "");
-        if (!sessionUrn)
-            throw new GatewayError("session create response is missing sessionUrn", undefined, payload);
-        const mcpURL = String(payload?.mcpUrl ?? "");
-        if (!mcpURL)
-            throw new GatewayError("session create response is missing mcpUrl", undefined, payload);
-        assertTransportURL(mcpURL, payload);
-        const selectedTools = (payload?.tools ?? []).map(String);
-        const transport = new GatewayTransport(this.apiKey, mcpURL, sessionUrn, actorId);
-        return new Session(sessionUrn, actorId, String(raw.name ?? name), policy, mcpURL, this.provider, transport, raw, selectedTools);
-    }
-}
-export class ActionGatewayClient extends InferenceClient {
-    constructor(options) {
-        super(options);
-        const apiKey = options.apiKey?.trim();
-        if (!apiKey)
-            throw new Error("apiKey is required");
-        const apiBaseURL = normalizeBaseURL(options.apiBaseURL ?? DEFAULT_API_BASE_URL);
-        this.provider = options.provider ?? new ChatCompletionsProvider();
-        const authProvider = new DigitalOceanApiKeyAuthenticationProvider(apiKey);
-        const adapter = new FetchRequestAdapter(authProvider);
-        adapter.baseUrl = apiBaseURL;
-        const publicApi = createDigitalOceanClient(adapter).v2.actionGateway;
-        this.sessionsApi = publicApi.sessions;
-        this.tools = publicApi.tools;
-        this.toolbelts = publicApi.toolbelts;
-        this.connections = publicApi.connections;
-        this.users = publicApi.users;
-        this.session = new SessionsOperations(apiKey, this.provider, this.sessionsApi);
-        this.sessions = this.session;
-    }
-    async createToolbelt(options) {
-        if (!Array.isArray(options.tools))
-            throw new TypeError("tools must be an array of tool names");
-        const body = {
-            name: options.name,
-            tools: options.tools,
-            version: options.version,
-            displayName: options.displayName,
-            description: options.description,
-        };
-        const response = await this.toolbelts.post(body);
-        const toolbelt = response?.toolbelt;
-        if (!toolbelt?.reference)
-            throw new GatewayError("toolbelt create response is missing reference");
-        return Object.defineProperty(toolbelt, "ref", {
-            configurable: true,
-            enumerable: true,
-            get: () => toolbelt.reference,
-        });
-    }
-}
-export { ActionGatewayClient as Client };
-export default ActionGatewayClient;