@dogpile/sdk 0.1.0

package/dist/runtime/tools.js

@@ -0,0 +1,969 @@
+import { validateRuntimeToolRegistrations } from "./validation.js";
+const webSearchIdentity = {
+    id: "dogpile.tools.webSearch",
+    namespace: "dogpile",
+    name: "webSearch",
+    version: "1.0.0",
+    description: "Search the web through a caller-provided fetch-compatible search adapter."
+};
+const codeExecIdentity = {
+    id: "dogpile.tools.codeExec",
+    namespace: "dogpile",
+    name: "codeExec",
+    version: "1.0.0",
+    description: "Execute code through a caller-provided sandbox adapter."
+};
+const webSearchInputSchema = {
+    kind: "json-schema",
+    description: "Web search query and optional result cap.",
+    schema: {
+        type: "object",
+        properties: {
+            query: { type: "string" },
+            maxResults: { type: "number", minimum: 1 }
+        },
+        required: ["query"],
+        additionalProperties: false
+    }
+};
+const codeExecInputSchema = {
+    kind: "json-schema",
+    description: "Code snippet plus language and optional timeout.",
+    schema: {
+        type: "object",
+        properties: {
+            language: {
+                type: "string",
+                enum: ["javascript", "typescript", "python", "bash", "shell"]
+            },
+            code: { type: "string" },
+            timeoutMs: { type: "number", minimum: 1 }
+        },
+        required: ["language", "code"],
+        additionalProperties: false
+    }
+};
+const webSearchPermissions = [
+    {
+        kind: "network",
+        allowPrivateNetwork: false
+    }
+];
+const codeExecPermissions = [
+    {
+        kind: "code-execution",
+        sandbox: "caller-provided",
+        languages: ["javascript", "typescript", "python", "bash", "shell"],
+        allowNetwork: false
+    }
+];
+const codeExecLanguages = ["javascript", "typescript", "python", "bash", "shell"];
+export function builtInDogpileToolIdentity(name) {
+    return name === "webSearch" ? webSearchIdentity : codeExecIdentity;
+}
+export function builtInDogpileToolInputSchema(name) {
+    return name === "webSearch" ? webSearchInputSchema : codeExecInputSchema;
+}
+/**
+ * Return the default permission declarations for one built-in tool name.
+ */
+export function builtInDogpileToolPermissions(name) {
+    return name === "webSearch" ? webSearchPermissions : codeExecPermissions;
+}
+export function validateBuiltInDogpileToolInput(name, input) {
+    const issues = name === "webSearch"
+        ? validateWebSearchInput(input)
+        : validateCodeExecInput(input);
+    return issues.length === 0 ? { type: "valid" } : { type: "invalid", issues };
+}
+/**
+ * Create the shared runtime tool executor used by every first-party protocol.
+ *
+ * @remarks
+ * The executor owns call id generation, read-only trace context construction,
+ * adapter validation, error normalization, and matched `tool-call` /
+ * `tool-result` events. Protocols only supply a normalized
+ * {@link RuntimeToolExecutionRequest}, which keeps tool execution independent
+ * of Coordinator, Sequential, Broadcast, or Shared control flow.
+ */
+export function createRuntimeToolExecutor(options) {
+    validateRuntimeToolRegistrations(options.tools);
+    const tools = Array.from(options.tools);
+    let callCount = 0;
+    return {
+        tools,
+        async execute(request) {
+            const tool = tools.find((candidate) => candidate.identity.id === request.toolId);
+            const identity = tool?.identity ?? {
+                id: request.toolId,
+                name: request.toolId
+            };
+            const callIndex = callCount;
+            callCount += 1;
+            const toolCallId = request.toolCallId ?? options.makeToolCallId?.(identity, callIndex) ?? defaultToolCallId(options.runId, callIndex);
+            const context = createExecutionContext(options, request, toolCallId);
+            options.emit?.({
+                type: "tool-call",
+                runId: options.runId,
+                at: new Date().toISOString(),
+                toolCallId,
+                tool: identity,
+                input: request.input,
+                ...(request.agentId ? { agentId: request.agentId } : {}),
+                ...(request.role ? { role: request.role } : {})
+            });
+            const result = await executeRuntimeTool(tool, identity, request.input, context);
+            options.emit?.({
+                type: "tool-result",
+                runId: options.runId,
+                at: new Date().toISOString(),
+                toolCallId,
+                tool: identity,
+                result,
+                ...(request.agentId ? { agentId: request.agentId } : {}),
+                ...(request.role ? { role: request.role } : {})
+            });
+            return result;
+        }
+    };
+}
+/**
+ * Return a JSON-serializable manifest for tools visible to a protocol run.
+ */
+export function runtimeToolManifest(tools) {
+    return tools.map((tool) => {
+        const inputSchema = {
+            kind: tool.inputSchema.kind,
+            schema: tool.inputSchema.schema,
+            ...(tool.inputSchema.description ? { description: tool.inputSchema.description } : {})
+        };
+        return {
+            identity: runtimeToolIdentityManifest(tool.identity),
+            inputSchema,
+            permissions: Array.from(tool.permissions ?? []).map(runtimeToolPermissionManifest)
+        };
+    });
+}
+/**
+ * Return request metadata that makes runtime tools visible to provider
+ * adapters, or an empty object when no tools are available.
+ */
+export function runtimeToolAvailability(tools) {
+    const manifest = runtimeToolManifest(tools);
+    return manifest.length > 0 ? { tools: manifest } : {};
+}
+/**
+ * Execute normalized tool requests returned by a provider response.
+ */
+export async function executeModelResponseToolRequests(options) {
+    const toolCalls = [];
+    for (const request of options.response.toolRequests ?? []) {
+        const result = await options.executor.execute({
+            ...request,
+            agentId: request.agentId ?? options.agentId,
+            role: request.role ?? options.role,
+            turn: request.turn ?? options.turn,
+            metadata: mergeToolMetadata(options.metadata, request.metadata)
+        });
+        toolCalls.push({
+            toolCallId: result.toolCallId,
+            tool: result.tool,
+            input: request.input,
+            result
+        });
+    }
+    return toolCalls;
+}
+function runtimeToolIdentityManifest(identity) {
+    return {
+        id: identity.id,
+        name: identity.name,
+        ...(identity.namespace ? { namespace: identity.namespace } : {}),
+        ...(identity.version ? { version: identity.version } : {}),
+        ...(identity.description ? { description: identity.description } : {})
+    };
+}
+function runtimeToolPermissionManifest(permission) {
+    if (permission.kind === "network") {
+        return {
+            kind: permission.kind,
+            ...(permission.allowHosts ? { allowHosts: Array.from(permission.allowHosts) } : {}),
+            ...(permission.allowPrivateNetwork === undefined ? {} : { allowPrivateNetwork: permission.allowPrivateNetwork })
+        };
+    }
+    if (permission.kind === "code-execution") {
+        return {
+            kind: permission.kind,
+            sandbox: permission.sandbox,
+            ...(permission.languages ? { languages: Array.from(permission.languages) } : {}),
+            ...(permission.allowNetwork === undefined ? {} : { allowNetwork: permission.allowNetwork })
+        };
+    }
+    return {
+        kind: permission.kind,
+        name: permission.name,
+        ...(permission.description ? { description: permission.description } : {}),
+        ...(permission.metadata ? { metadata: permission.metadata } : {})
+    };
+}
+function validateCodeExecAdapterInput(input, options) {
+    const issues = [...validateCodeExecInput(input)];
+    const languages = options.languages ?? codeExecLanguages;
+    if (typeof input.language === "string" && isCodeExecLanguage(input.language) && !languages.includes(input.language)) {
+        issues.push({
+            code: "invalid-value",
+            path: "language",
+            message: "codeExec.language is not enabled for this adapter.",
+            detail: {
+                allowed: Array.from(languages)
+            }
+        });
+    }
+    const effectiveTimeoutMs = input.timeoutMs ?? options.defaultTimeoutMs;
+    if (effectiveTimeoutMs !== undefined &&
+        options.maxTimeoutMs !== undefined &&
+        Number.isFinite(effectiveTimeoutMs) &&
+        Number.isFinite(options.maxTimeoutMs) &&
+        effectiveTimeoutMs > options.maxTimeoutMs) {
+        issues.push({
+            code: "out-of-range",
+            path: input.timeoutMs === undefined ? "defaultTimeoutMs" : "timeoutMs",
+            message: `codeExec.timeoutMs must be less than or equal to ${options.maxTimeoutMs}.`,
+            detail: {
+                maximum: options.maxTimeoutMs
+            }
+        });
+    }
+    return issues.length === 0 ? { type: "valid" } : { type: "invalid", issues };
+}
+function createExecutionContext(options, request, toolCallId) {
+    return {
+        runId: options.runId,
+        toolCallId,
+        protocol: options.protocol,
+        tier: options.tier,
+        ...(request.agentId ? { agentId: request.agentId } : {}),
+        ...(request.role ? { role: request.role } : {}),
+        ...(request.turn !== undefined ? { turn: request.turn } : {}),
+        ...(options.getTrace ? { trace: options.getTrace() } : {}),
+        ...(request.abortSignal ?? options.abortSignal ? { abortSignal: request.abortSignal ?? options.abortSignal } : {}),
+        ...(options.metadata || request.metadata ? { metadata: mergeToolMetadata(options.metadata, request.metadata) } : {})
+    };
+}
+async function executeRuntimeTool(tool, identity, input, context) {
+    if (!tool) {
+        return {
+            type: "error",
+            toolCallId: context.toolCallId,
+            tool: identity,
+            error: {
+                code: "unavailable",
+                message: `Runtime tool "${identity.id}" is not registered.`,
+                retryable: false
+            }
+        };
+    }
+    const validation = validateRuntimeToolInput(tool, input);
+    if (validation.type === "invalid") {
+        return {
+            type: "error",
+            toolCallId: context.toolCallId,
+            tool: identity,
+            error: {
+                code: "invalid-input",
+                message: "Runtime tool input failed validation.",
+                retryable: false,
+                detail: {
+                    issues: validation.issues.map((issue) => ({
+                        code: issue.code,
+                        path: issue.path,
+                        message: issue.message,
+                        ...(issue.detail ? { detail: issue.detail } : {})
+                    }))
+                }
+            }
+        };
+    }
+    try {
+        return await tool.execute(input, context);
+    }
+    catch (error) {
+        return {
+            type: "error",
+            toolCallId: context.toolCallId,
+            tool: identity,
+            error: normalizeRuntimeToolAdapterError(error)
+        };
+    }
+}
+function validateRuntimeToolInput(tool, input) {
+    if (typeof tool.validateInput !== "function") {
+        return { type: "valid" };
+    }
+    return tool.validateInput(input);
+}
+function mergeToolMetadata(base, request) {
+    return {
+        ...(base ?? {}),
+        ...(request ?? {})
+    };
+}
+function defaultToolCallId(runId, callIndex) {
+    return `${runId}:tool-${callIndex + 1}`;
+}
+/**
+ * Convert an unknown adapter failure into Dogpile's serializable error data.
+ */
+export function normalizeRuntimeToolAdapterError(error) {
+    if (isRuntimeToolAdapterError(error)) {
+        return error;
+    }
+    if (error instanceof DOMException && error.name === "AbortError") {
+        return {
+            code: "aborted",
+            message: error.message || "Tool execution was aborted.",
+            retryable: true,
+            detail: {
+                name: error.name
+            }
+        };
+    }
+    if (error instanceof Error) {
+        return {
+            code: "backend-error",
+            message: error.message,
+            retryable: false,
+            detail: {
+                name: error.name
+            }
+        };
+    }
+    return {
+        code: "unknown",
+        message: "Tool execution failed with a non-Error value.",
+        retryable: false,
+        detail: {
+            valueType: typeof error
+        }
+    };
+}
+/**
+ * Create Dogpile's built-in fetch-based web search adapter.
+ *
+ * @remarks
+ * The adapter is backend-neutral: by default it sends a GET request with
+ * `q` and `limit` query parameters, then accepts either `{ results: [...] }`
+ * or a bare array of result objects from the response JSON. Callers can replace
+ * request construction or response parsing for a specific search API while
+ * keeping Dogpile's shared runtime tool contract, identity, permissions, input
+ * validation, and serializable errors.
+ */
+export function createWebSearchToolAdapter(options) {
+    const identity = mergeIdentity(webSearchIdentity, options.identity);
+    return normalizeBuiltInDogpileTool({
+        name: "webSearch",
+        ...(options.identity ? { identity: options.identity } : {}),
+        ...(options.permissions ? { permissions: options.permissions } : {}),
+        async execute(input, context) {
+            const fetchImplementation = options.fetch ?? globalThis.fetch;
+            if (!fetchImplementation) {
+                return {
+                    type: "error",
+                    toolCallId: context.toolCallId,
+                    tool: identity,
+                    error: {
+                        code: "unavailable",
+                        message: "No fetch implementation is available for webSearch.",
+                        retryable: false
+                    }
+                };
+            }
+            const request = options.buildRequest
+                ? options.buildRequest(input, context)
+                : defaultWebSearchRequest(options, input, context);
+            const response = await fetchImplementation(request.url, {
+                ...request.init,
+                ...(context.abortSignal ? { signal: context.abortSignal } : {})
+            });
+            if (!response.ok) {
+                throw {
+                    code: response.status >= 500 ? "unavailable" : "backend-error",
+                    message: `Web search backend returned HTTP ${response.status}.`,
+                    retryable: response.status === 408 || response.status === 429 || response.status >= 500,
+                    detail: {
+                        status: response.status,
+                        statusText: response.statusText
+                    }
+                };
+            }
+            const output = options.parseResponse
+                ? await options.parseResponse(response, input, context)
+                : await defaultWebSearchResponseParser(response);
+            return {
+                type: "success",
+                toolCallId: context.toolCallId,
+                tool: identity,
+                output
+            };
+        }
+    });
+}
+/**
+ * Create Dogpile's built-in code execution adapter around a caller-owned sandbox.
+ *
+ * @remarks
+ * Dogpile core stays runtime-portable and never evaluates code itself. This
+ * adapter supplies the stable `codeExec` identity, schema, permissions,
+ * validation, timeout defaults, abort handling, and serializable errors while
+ * the host application owns the sandbox boundary.
+ */
+export function createCodeExecToolAdapter(options) {
+    const identity = mergeIdentity(codeExecIdentity, options.identity);
+    const permissions = options.permissions ??
+        codeExecPermissionsFor(options.languages ?? codeExecLanguages, options.allowNetwork ?? false);
+    const inputSchema = codeExecInputSchemaFor(options.languages ?? codeExecLanguages);
+    return {
+        identity,
+        inputSchema,
+        permissions,
+        validateInput: (input) => validateCodeExecAdapterInput(input, options),
+        async execute(input, context) {
+            const validation = validateCodeExecAdapterInput(input, options);
+            if (validation.type === "invalid") {
+                return {
+                    type: "error",
+                    toolCallId: context.toolCallId,
+                    tool: identity,
+                    error: {
+                        code: "invalid-input",
+                        message: "Invalid codeExec tool input.",
+                        retryable: false,
+                        detail: {
+                            issues: validation.issues
+                        }
+                    }
+                };
+            }
+            const timeoutMs = input.timeoutMs ?? options.defaultTimeoutMs;
+            const executionInput = timeoutMs === undefined
+                ? input
+                : {
+                    ...input,
+                    timeoutMs
+                };
+            try {
+                const output = await executeSandboxWithPolicy(options.execute, executionInput, context, timeoutMs);
+                return {
+                    type: "success",
+                    toolCallId: context.toolCallId,
+                    tool: identity,
+                    output
+                };
+            }
+            catch (error) {
+                return {
+                    type: "error",
+                    toolCallId: context.toolCallId,
+                    tool: identity,
+                    error: normalizeRuntimeToolAdapterError(error)
+                };
+            }
+        }
+    };
+}
+export function normalizeBuiltInDogpileTool(definition) {
+    switch (definition.name) {
+        case "webSearch": {
+            const identity = mergeIdentity(webSearchIdentity, definition.identity);
+            const permissions = definition.permissions ?? webSearchPermissions;
+            const tool = {
+                identity,
+                inputSchema: definition.inputSchema ?? webSearchInputSchema,
+                permissions,
+                validateInput: (input) => validateBuiltInDogpileToolInput("webSearch", input),
+                execute: (input, context) => executeBuiltInTool(identity, definition.execute, input, context, "webSearch")
+            };
+            return tool;
+        }
+        case "codeExec": {
+            const identity = mergeIdentity(codeExecIdentity, definition.identity);
+            const permissions = definition.permissions ?? codeExecPermissions;
+            const tool = {
+                identity,
+                inputSchema: definition.inputSchema ?? codeExecInputSchema,
+                permissions,
+                validateInput: (input) => validateBuiltInDogpileToolInput("codeExec", input),
+                execute: (input, context) => executeBuiltInTool(identity, definition.execute, input, context, "codeExec")
+            };
+            return tool;
+        }
+    }
+}
+/**
+ * Normalize configured built-in Dogpile tool executors into runtime tools.
+ */
+export function normalizeBuiltInDogpileTools(tools) {
+    const normalized = [];
+    if (tools.webSearch) {
+        normalized.push(normalizeBuiltInDogpileTool(asWebSearchDefinition(tools.webSearch)));
+    }
+    if (tools.codeExec) {
+        normalized.push(normalizeBuiltInDogpileTool(asCodeExecDefinition(tools.codeExec)));
+    }
+    return normalized;
+}
+/**
+ * Normalize one Vercel AI SDK tool into Dogpile's shared runtime tool interface.
+ */
+export async function normalizeVercelAITool(definition) {
+    if (!definition.tool.execute) {
+        throw new Error(`Vercel AI tool "${definition.name}" must define execute() to run inside Dogpile.`);
+    }
+    const identity = vercelAIToolIdentity(definition);
+    const inputSchema = definition.inputSchema ?? (await vercelAIInputSchema(definition.tool, definition.name));
+    const execute = definition.tool.execute;
+    return {
+        identity,
+        inputSchema,
+        async execute(input, context) {
+            try {
+                const output = await resolveVercelAIToolOutput(execute(input, {
+                    toolCallId: context.toolCallId,
+                    messages: Array.from(definition.messages ?? []),
+                    ...(context.abortSignal ? { abortSignal: context.abortSignal } : {}),
+                    experimental_context: context
+                }));
+                return {
+                    type: "success",
+                    toolCallId: context.toolCallId,
+                    tool: identity,
+                    output
+                };
+            }
+            catch (error) {
+                return {
+                    type: "error",
+                    toolCallId: context.toolCallId,
+                    tool: identity,
+                    error: {
+                        code: "vercel-ai-tool-error",
+                        message: error instanceof Error ? error.message : "Vercel AI tool execution failed.",
+                        retryable: false,
+                        detail: errorDetail(error)
+                    }
+                };
+            }
+        }
+    };
+}
+/**
+ * Normalize a Vercel AI SDK tool set into runtime tools in caller-defined key order.
+ */
+export async function normalizeVercelAITools(tools, options = {}) {
+    return Promise.all(Object.entries(tools).map(([name, tool]) => {
+        const identity = removeUndefinedIdentityFields({
+            ...(options.namespace !== undefined ? { namespace: options.namespace } : {}),
+            ...(options.version !== undefined ? { version: options.version } : {}),
+            ...options.identity?.[name]
+        });
+        return normalizeVercelAITool({
+            name,
+            tool: asJsonRuntimeVercelAITool(tool),
+            ...(options.messages ? { messages: options.messages } : {}),
+            ...(identity ? { identity } : {})
+        });
+    }));
+}
+async function executeBuiltInTool(identity, execute, input, context, name) {
+    const validation = validateBuiltInDogpileToolInput(name, input);
+    if (validation.type === "invalid") {
+        return {
+            type: "error",
+            toolCallId: context.toolCallId,
+            tool: identity,
+            error: {
+                code: "invalid-input",
+                message: `Invalid ${name} tool input.`,
+                retryable: false,
+                detail: {
+                    issues: validation.issues
+                }
+            }
+        };
+    }
+    try {
+        return await execute(input, context);
+    }
+    catch (error) {
+        return {
+            type: "error",
+            toolCallId: context.toolCallId,
+            tool: identity,
+            error: normalizeRuntimeToolAdapterError(error)
+        };
+    }
+}
+function asWebSearchDefinition(tool) {
+    return typeof tool === "function" ? { name: "webSearch", execute: tool } : tool;
+}
+function asCodeExecDefinition(tool) {
+    return typeof tool === "function" ? { name: "codeExec", execute: tool } : tool;
+}
+function mergeIdentity(defaultIdentity, options) {
+    if (!options) {
+        return defaultIdentity;
+    }
+    return {
+        ...defaultIdentity,
+        ...(options.namespace !== undefined ? { namespace: options.namespace } : {}),
+        ...(options.version !== undefined ? { version: options.version } : {}),
+        ...(options.description !== undefined ? { description: options.description } : {})
+    };
+}
+async function vercelAIInputSchema(tool, name) {
+    const schema = await resolveCompatibleSchema(tool.inputSchema);
+    const jsonSchema = asJsonObject(schema, `Vercel AI tool "${name}" input schema`);
+    return {
+        kind: "json-schema",
+        schema: jsonSchema,
+        ...(tool.description ? { description: tool.description } : {})
+    };
+}
+async function resolveCompatibleSchema(schema) {
+    if (isJsonSchemaWrapper(schema)) {
+        return await schema.jsonSchema;
+    }
+    return schema;
+}
+function isJsonSchemaWrapper(schema) {
+    return typeof schema === "object" && schema !== null && "jsonSchema" in schema;
+}
+function vercelAIToolIdentity(definition) {
+    return {
+        id: definition.identity?.id ?? `vercel-ai.tools.${definition.name}`,
+        name: definition.name,
+        namespace: definition.identity?.namespace ?? "vercel-ai",
+        ...(definition.identity?.version ? { version: definition.identity.version } : {}),
+        ...(definition.identity?.description ?? definition.tool.description
+            ? { description: definition.identity?.description ?? definition.tool.description }
+            : {})
+    };
+}
+async function resolveVercelAIToolOutput(output) {
+    if (isAsyncIterable(output)) {
+        let lastOutput;
+        for await (const chunk of output) {
+            lastOutput = chunk;
+        }
+        if (lastOutput === undefined) {
+            throw new Error("Vercel AI tool async iterable completed without an output.");
+        }
+        return lastOutput;
+    }
+    return await output;
+}
+function isAsyncIterable(value) {
+    return typeof value === "object" && value !== null && Symbol.asyncIterator in value;
+}
+function asJsonObject(value, label) {
+    if (typeof value !== "object" || value === null || Array.isArray(value)) {
+        throw new Error(`${label} must resolve to a JSON object.`);
+    }
+    return value;
+}
+function errorDetail(error) {
+    if (error instanceof Error) {
+        return {
+            name: error.name
+        };
+    }
+    return {
+        valueType: typeof error
+    };
+}
+function defaultWebSearchRequest(options, input, _context) {
+    const url = new URL(String(options.endpoint));
+    url.searchParams.set("q", input.query);
+    url.searchParams.set("limit", String(input.maxResults ?? options.defaultMaxResults ?? 10));
+    return {
+        url,
+        init: {
+            method: "GET",
+            ...(options.headers ? { headers: options.headers } : {})
+        }
+    };
+}
+async function defaultWebSearchResponseParser(response) {
+    const payload = await response.json();
+    const resultValues = Array.isArray(payload)
+        ? payload
+        : isJsonObject(payload) && Array.isArray(payload.results)
+            ? payload.results
+            : undefined;
+    if (!resultValues) {
+        throw {
+            code: "backend-error",
+            message: "Web search backend response must contain a results array.",
+            retryable: false
+        };
+    }
+    return {
+        results: resultValues.map(normalizeWebSearchResult)
+    };
+}
+function codeExecPermissionsFor(languages, allowNetwork) {
+    return [
+        {
+            kind: "code-execution",
+            sandbox: "caller-provided",
+            languages,
+            allowNetwork
+        }
+    ];
+}
+function codeExecInputSchemaFor(languages) {
+    return {
+        kind: "json-schema",
+        ...(codeExecInputSchema.description ? { description: codeExecInputSchema.description } : {}),
+        schema: {
+            type: "object",
+            properties: {
+                language: {
+                    type: "string",
+                    enum: Array.from(languages)
+                },
+                code: { type: "string" },
+                timeoutMs: { type: "number", minimum: 1 }
+            },
+            required: ["language", "code"],
+            additionalProperties: false
+        }
+    };
+}
+async function executeSandboxWithPolicy(execute, input, context, timeoutMs) {
+    if (context.abortSignal?.aborted) {
+        throw {
+            code: "aborted",
+            message: "Code execution was aborted before the sandbox started.",
+            retryable: true
+        };
+    }
+    const execution = Promise.resolve().then(() => execute(input, context));
+    if (timeoutMs === undefined && context.abortSignal === undefined) {
+        return await execution;
+    }
+    return await new Promise((resolve, reject) => {
+        let timeoutId;
+        const cleanup = () => {
+            if (timeoutId !== undefined) {
+                clearTimeout(timeoutId);
+            }
+            context.abortSignal?.removeEventListener("abort", abortHandler);
+        };
+        const abortHandler = () => {
+            cleanup();
+            reject({
+                code: "aborted",
+                message: "Code execution was aborted.",
+                retryable: true
+            });
+        };
+        if (context.abortSignal) {
+            context.abortSignal.addEventListener("abort", abortHandler, { once: true });
+        }
+        if (timeoutMs !== undefined) {
+            timeoutId = setTimeout(() => {
+                cleanup();
+                reject({
+                    code: "timeout",
+                    message: `Code execution exceeded timeout of ${timeoutMs}ms.`,
+                    retryable: true,
+                    detail: {
+                        timeoutMs
+                    }
+                });
+            }, timeoutMs);
+        }
+        execution.then((output) => {
+            cleanup();
+            resolve(output);
+        }, (error) => {
+            cleanup();
+            reject(error);
+        });
+    });
+}
+function normalizeWebSearchResult(value) {
+    if (!isJsonObject(value)) {
+        throw {
+            code: "backend-error",
+            message: "Web search result must be a JSON object.",
+            retryable: false
+        };
+    }
+    const title = jsonString(value.title, "title");
+    const url = jsonString(value.url, "url");
+    const snippet = optionalJsonString(value.snippet, "snippet");
+    const metadata = optionalJsonObject(value.metadata, "metadata");
+    return {
+        title,
+        url,
+        ...(snippet !== undefined ? { snippet } : {}),
+        ...(metadata !== undefined ? { metadata } : {})
+    };
+}
+function jsonString(value, fieldName) {
+    if (typeof value !== "string" || value.trim().length === 0) {
+        throw {
+            code: "backend-error",
+            message: `Web search result ${fieldName} must be a non-empty string.`,
+            retryable: false
+        };
+    }
+    return value;
+}
+function optionalJsonString(value, fieldName) {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (typeof value !== "string") {
+        throw {
+            code: "backend-error",
+            message: `Web search result ${fieldName} must be a string when present.`,
+            retryable: false
+        };
+    }
+    return value;
+}
+function optionalJsonObject(value, fieldName) {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (!isJsonObject(value)) {
+        throw {
+            code: "backend-error",
+            message: `Web search result ${fieldName} must be a JSON object when present.`,
+            retryable: false
+        };
+    }
+    return value;
+}
+function isJsonObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function validateWebSearchInput(input) {
+    const issues = [];
+    if (typeof input.query !== "string") {
+        issues.push({
+            code: input.query === undefined ? "missing-field" : "invalid-type",
+            path: "query",
+            message: "webSearch.query must be a string."
+        });
+    }
+    else if (input.query.trim().length === 0) {
+        issues.push({
+            code: "invalid-value",
+            path: "query",
+            message: "webSearch.query must not be empty."
+        });
+    }
+    if (input.maxResults !== undefined) {
+        if (typeof input.maxResults !== "number" || !Number.isFinite(input.maxResults)) {
+            issues.push({
+                code: "invalid-type",
+                path: "maxResults",
+                message: "webSearch.maxResults must be a finite number."
+            });
+        }
+        else if (input.maxResults < 1) {
+            issues.push({
+                code: "out-of-range",
+                path: "maxResults",
+                message: "webSearch.maxResults must be greater than or equal to 1.",
+                detail: {
+                    minimum: 1
+                }
+            });
+        }
+    }
+    return issues;
+}
+function validateCodeExecInput(input) {
+    const issues = [];
+    if (typeof input.language !== "string") {
+        issues.push({
+            code: input.language === undefined ? "missing-field" : "invalid-type",
+            path: "language",
+            message: "codeExec.language must be a string."
+        });
+    }
+    else if (!isCodeExecLanguage(input.language)) {
+        issues.push({
+            code: "invalid-value",
+            path: "language",
+            message: "codeExec.language must be one of javascript, typescript, python, bash, or shell.",
+            detail: {
+                allowed: ["javascript", "typescript", "python", "bash", "shell"]
+            }
+        });
+    }
+    if (typeof input.code !== "string") {
+        issues.push({
+            code: input.code === undefined ? "missing-field" : "invalid-type",
+            path: "code",
+            message: "codeExec.code must be a string."
+        });
+    }
+    if (input.timeoutMs !== undefined) {
+        if (typeof input.timeoutMs !== "number" || !Number.isFinite(input.timeoutMs)) {
+            issues.push({
+                code: "invalid-type",
+                path: "timeoutMs",
+                message: "codeExec.timeoutMs must be a finite number."
+            });
+        }
+        else if (input.timeoutMs < 1) {
+            issues.push({
+                code: "out-of-range",
+                path: "timeoutMs",
+                message: "codeExec.timeoutMs must be greater than or equal to 1.",
+                detail: {
+                    minimum: 1
+                }
+            });
+        }
+    }
+    return issues;
+}
+function isCodeExecLanguage(value) {
+    return value === "javascript" || value === "typescript" || value === "python" || value === "bash" || value === "shell";
+}
+function isRuntimeToolAdapterError(error) {
+    if (typeof error !== "object" || error === null || !("code" in error) || !("message" in error)) {
+        return false;
+    }
+    const candidate = error;
+    return isRuntimeToolAdapterErrorCode(candidate.code) && typeof candidate.message === "string";
+}
+function isRuntimeToolAdapterErrorCode(value) {
+    return (value === "invalid-input" ||
+        value === "permission-denied" ||
+        value === "timeout" ||
+        value === "aborted" ||
+        value === "unavailable" ||
+        value === "backend-error" ||
+        value === "unknown");
+}
+function removeUndefinedIdentityFields(identity) {
+    const normalized = {
+        ...(identity.id !== undefined ? { id: identity.id } : {}),
+        ...(identity.namespace !== undefined ? { namespace: identity.namespace } : {}),
+        ...(identity.version !== undefined ? { version: identity.version } : {}),
+        ...(identity.description !== undefined ? { description: identity.description } : {})
+    };
+    return Object.keys(normalized).length > 0 ? normalized : undefined;
+}
+function asJsonRuntimeVercelAITool(tool) {
+    return tool;
+}
+//# sourceMappingURL=tools.js.map