@dogpile/sdk 0.3.0 → 0.3.1

package/dist/runtime/tools.js

@@ -1,81 +1,9 @@
 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 };
-}
+import { normalizeRuntimeToolAdapterError } from "./tools/built-in.js";
+// Re-export the public surface from the split modules so the
+// `@dogpile/sdk/runtime/tools` subpath stays stable.
+export { builtInDogpileToolIdentity, builtInDogpileToolInputSchema, builtInDogpileToolPermissions, createCodeExecToolAdapter, createWebSearchToolAdapter, normalizeBuiltInDogpileTool, normalizeBuiltInDogpileTools, normalizeRuntimeToolAdapterError, validateBuiltInDogpileToolInput } from "./tools/built-in.js";
+export { normalizeVercelAITool, normalizeVercelAITools } from "./tools/vercel-ai.js";
 /**
  * Create the shared runtime tool executor used by every first-party protocol.
  *
@@ -206,36 +134,6 @@ function runtimeToolPermissionManifest(permission) {
         ...(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,
@@ -263,8 +161,8 @@ async function executeRuntimeTool(tool, identity, input, context) {
             }
         };
     }
-    const validation = validateRuntimeToolInput(tool, input);
-    if (validation.type === "invalid") {
+    const validation = tool.validateInput?.(input);
+    if (validation?.type === "invalid") {
         return {
             type: "error",
             toolCallId: context.toolCallId,
@@ -296,12 +194,6 @@ async function executeRuntimeTool(tool, identity, input, context) {
         };
     }
 }
-function validateRuntimeToolInput(tool, input) {
-    if (typeof tool.validateInput !== "function") {
-        return { type: "valid" };
-    }
-    return tool.validateInput(input);
-}
 function mergeToolMetadata(base, request) {
     return {
         ...(base ?? {}),
@@ -311,659 +203,4 @@ function mergeToolMetadata(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