@every-app/sdk 0.3.0-rc.11 → 0.3.0-rc.12

package/dist/server/aiBinding.js

@@ -1,294 +0,0 @@
-/**
- * `gatewayAiBinding(env)`: the Gateway's AI providers as a Workers AI
- * binding, for code written against `env.AI.run(model, inputs, options)`.
- *
- * An app on Every App needs no `ai` binding of its own to call models: the
- * Gateway holds the keys, counts the calls and keeps the app to `ai.models`.
- * Code that already calls `env.AI.run()` (upstream code a port keeps, the
- * Agents SDK, `workers-ai-provider`) gets this object in its place:
- *
- *   const AI = gatewayAiBinding(env, { for: request });
- *   await AI.run("@cf/meta/llama-3.1-8b-instruct-fast", { messages });
- *
- * Each `run()` becomes an OpenAI-compatible call on the provider's route
- * through the Gateway (`createGatewayFetch`): text generation (`messages`
- * or `prompt`) on its chat completions route, text embeddings (`text`) on
- * its embeddings route, answered in Workers AI's shapes (`{ response,
- * tool_calls, usage }`, `{ shape, data }`, or a stream of `data:
- * {"response": …}` events with `stream: true`). In local development
- * without a Gateway, the developer's own key in `.dev.vars` is used, as
- * `createGatewayFetch` does (WORKERS_AI_API_TOKEN and CLOUDFLARE_ACCOUNT_ID
- * for Workers AI).
- */
-import { AI_DEFAULT_MODEL, AI_DEFAULT_PROVIDER, AI_DEFAULT_ROUTES, ConfigurationError, devAiProvider, } from "../internal/index.js";
-import { BINDING_ORIGIN, createGatewayFetch } from "./gatewayFetch.js";
-import { GatewayRefusalError, gatewayRefusal } from "./refusal.js";
-/**
- * A Workers AI binding (`Ai`) over the Gateway: pass it where code takes
- * `env.AI`. `run()` covers text generation (messages or prompt; tools;
- * `stream: true`; `returnRawResponse`, which returns the provider's
- * OpenAI-shaped `Response`) and text embeddings; the binding's other
- * methods (`gateway()`, `autorag()`, `models()`, `toMarkdown()`, …) and
- * other tasks (images, audio, batches, websockets) throw
- * `ConfigurationError`. `options.gateway` is ignored: the Gateway's
- * operator decides whether calls go through Cloudflare AI Gateway
- * (`everyapp ai gateway on`).
- *
- * Errors are thrown as a binding throws them: `GatewayRefusalError` when
- * the Gateway refused (`ai_provider_not_configured`, `model_not_allowed`,
- * …), `ConfigurationError` where createGatewayFetch throws one (no binding
- * and no dev key), and an `Error` naming the status when the provider
- * answered with an error. Nothing is checked when the binding is made, so
- * making one per request costs nothing.
- */
-export function gatewayAiBinding(env, options = {}) {
-    const provider = options.provider ?? "workers-ai";
-    async function run(model, inputs, runOptions = {}) {
-        if (runOptions.websocket) {
-            throw unsupported("run() with websocket: true");
-        }
-        if (!inputs || typeof inputs !== "object") {
-            throw unsupported("run() without an inputs object");
-        }
-        if (Array.isArray(inputs["requests"])) {
-            throw unsupported("run() with a batch of requests");
-        }
-        const embedding = !("messages" in inputs) && !("prompt" in inputs) && "text" in inputs;
-        if (!embedding && !("messages" in inputs) && !("prompt" in inputs)) {
-            throw unsupported("run() for anything but text generation (messages or prompt) and text embeddings (text)");
-        }
-        const url = `${BINDING_ORIGIN}/api/ai/${provider}${routeOf(provider, embedding ? "embeddings" : "chat")}`;
-        const sent = modelToSend(provider, model, options.models);
-        const body = embedding
-            ? { model: sent, input: inputs["text"] }
-            : chatBody(sent, inputs);
-        const gatewayFetch = createGatewayFetch({
-            env,
-            for: options.for,
-        });
-        const response = await gatewayFetch(url, {
-            method: "POST",
-            headers: { "content-type": "application/json" },
-            body: JSON.stringify(body),
-            ...(runOptions.signal ? { signal: runOptions.signal } : {}),
-        });
-        if (runOptions.returnRawResponse)
-            return response;
-        await throwIfFailed(response, provider);
-        if (embedding)
-            return embeddingOutput(await response.json());
-        if (inputs["stream"] === true) {
-            if (!response.body)
-                return new ReadableStream();
-            return response.body.pipeThrough(toWorkersAiStream());
-        }
-        return textOutput(await response.json());
-    }
-    const notHere = (method) => () => {
-        throw unsupported(`env.AI.${method}()`);
-    };
-    const binding = {
-        aiGatewayLogId: null,
-        run,
-        gateway: notHere("gateway"),
-        autorag: notHere("autorag"),
-        aiSearch: notHere("aiSearch"),
-        websearch: notHere("websearch"),
-        models: notHere("models"),
-        toMarkdown: notHere("toMarkdown"),
-    };
-    // `Ai` is the app's own Workers types' class (it changes with each
-    // version); the object above is its working subset, the rest throwing.
-    return binding;
-}
-function unsupported(what) {
-    return new ConfigurationError(`${what} isn't available through the Every App gateway; call the provider's routes with createGatewayFetch() instead.`);
-}
-/** The provider's path for a chat or an embeddings call, under `/api/ai/<provider>`. */
-function routeOf(provider, kind) {
-    if (provider === AI_DEFAULT_PROVIDER)
-        return AI_DEFAULT_ROUTES[kind];
-    const spec = devAiProvider(provider);
-    if (!spec) {
-        throw new ConfigurationError(`gatewayAiBinding: ${JSON.stringify(provider)} is not an AI provider of the catalog.`);
-    }
-    const route = spec[kind];
-    if (!route) {
-        throw new ConfigurationError(`gatewayAiBinding: ${provider} has no OpenAI-compatible ${kind === "chat" ? "chat completions" : "embeddings"} route.`);
-    }
-    return route.path;
-}
-function modelToSend(provider, model, models) {
-    const mapped = models && Object.hasOwn(models, model) ? models[model] : null;
-    if (mapped)
-        return mapped;
-    if (provider === AI_DEFAULT_PROVIDER && model.startsWith("@cf/")) {
-        return AI_DEFAULT_MODEL;
-    }
-    return model;
-}
-/**
- * Workers AI's text generation inputs as a chat completions body: `prompt`
- * as one user message, legacy tools (`{ name, description, parameters }`)
- * as OpenAI's, everything else (max_tokens, temperature, response_format,
- * stream, …) as it is. Never adds `stream_options` (Workers AI refuses it
- * on a call that doesn't stream).
- */
-function chatBody(model, inputs) {
-    const { prompt, messages, tools, raw: _raw, lora: _lora, ...rest } = inputs;
-    const body = {
-        ...rest,
-        model,
-        messages: messages ??
-            (typeof prompt === "string" ? [{ role: "user", content: prompt }] : []),
-    };
-    if (Array.isArray(tools))
-        body["tools"] = tools.map(openAiTool);
-    return body;
-}
-function openAiTool(tool) {
-    if (!isRecord(tool) || "function" in tool)
-        return tool;
-    const { name, description, parameters } = tool;
-    return {
-        type: "function",
-        function: {
-            name,
-            ...(description === undefined ? {} : { description }),
-            ...(parameters === undefined ? {} : { parameters }),
-        },
-    };
-}
-async function throwIfFailed(response, provider) {
-    if (response.ok)
-        return;
-    const refusal = await gatewayRefusal(response.clone());
-    if (refusal)
-        throw new GatewayRefusalError(refusal);
-    const text = await response.text().catch(() => "");
-    throw new Error(`AI (${provider}) answered ${response.status}${text ? `: ${text.slice(0, 500)}` : ""}`);
-}
-/** A chat completion as Workers AI answers text generation. */
-function textOutput(body) {
-    const choice = firstChoice(body);
-    const message = isRecord(choice?.["message"]) ? choice["message"] : {};
-    const toolCalls = workersAiToolCalls(message["tool_calls"]);
-    const usage = isRecord(body) ? body["usage"] : undefined;
-    return {
-        // Workers AI may send an all-digit reply as a JSON number.
-        response: textOf(message["content"]),
-        ...(toolCalls ? { tool_calls: toolCalls } : {}),
-        ...(isRecord(usage) ? { usage } : {}),
-    };
-}
-/**
- * OpenAI tool calls as both forms Workers AI answers with: the legacy
- * `{ name, arguments }` (arguments parsed) and the OpenAI-shaped
- * `{ id, type, function }`.
- */
-function workersAiToolCalls(calls) {
-    if (!Array.isArray(calls) || calls.length === 0)
-        return undefined;
-    return calls.filter(isRecord).map((call) => {
-        const fn = isRecord(call["function"]) ? call["function"] : {};
-        const args = fn["arguments"];
-        return {
-            ...(call["id"] === undefined ? {} : { id: call["id"] }),
-            type: "function",
-            function: { name: fn["name"], arguments: args },
-            name: fn["name"],
-            arguments: typeof args === "string" ? parsedOr(args) : args,
-        };
-    });
-}
-/** Embeddings as Workers AI answers them: `{ shape: [rows, dimensions], data }`. */
-function embeddingOutput(body) {
-    const rows = isRecord(body) && Array.isArray(body["data"]) ? body["data"] : [];
-    const data = rows
-        .filter(isRecord)
-        .sort((a, b) => Number(a["index"] ?? 0) - Number(b["index"] ?? 0))
-        .map((row) => Array.isArray(row["embedding"]) ? row["embedding"] : []);
-    return { shape: [data.length, data[0]?.length ?? 0], data };
-}
-/**
- * An OpenAI chat completions event stream as Workers AI streams text:
- * one `data: {"response": "<token>"}` event per chunk with text (tool call
- * deltas and usage alongside), then `data: [DONE]`.
- */
-function toWorkersAiStream() {
-    const decoder = new TextDecoder();
-    const encoder = new TextEncoder();
-    let pending = "";
-    const convert = (line) => {
-        const match = /^data:[ ]?(.*?)\r?$/s.exec(line);
-        if (!match)
-            return "";
-        const data = match[1].trim();
-        if (data === "[DONE]")
-            return "data: [DONE]\n\n";
-        let chunk;
-        try {
-            chunk = JSON.parse(data);
-        }
-        catch {
-            return "";
-        }
-        const choice = firstChoice(chunk);
-        const delta = isRecord(choice?.["delta"]) ? choice["delta"] : {};
-        const usage = isRecord(chunk) ? chunk["usage"] : undefined;
-        const toolCalls = Array.isArray(delta["tool_calls"])
-            ? delta["tool_calls"]
-            : undefined;
-        const event = {
-            response: textOf(delta["content"]),
-            ...(toolCalls ? { tool_calls: toolCalls } : {}),
-            ...(isRecord(usage) ? { usage } : {}),
-        };
-        if (!event.response && !toolCalls && !isRecord(usage))
-            return "";
-        return `data: ${JSON.stringify(event)}\n\n`;
-    };
-    return new TransformStream({
-        transform(bytes, controller) {
-            pending += decoder.decode(bytes, { stream: true });
-            const end = pending.lastIndexOf("\n");
-            if (end === -1)
-                return;
-            const lines = pending.slice(0, end).split("\n");
-            pending = pending.slice(end + 1);
-            const out = lines.map(convert).join("");
-            if (out)
-                controller.enqueue(encoder.encode(out));
-        },
-        flush(controller) {
-            pending += decoder.decode();
-            const out = convert(pending);
-            if (out)
-                controller.enqueue(encoder.encode(out));
-        },
-    });
-}
-function firstChoice(body) {
-    if (!isRecord(body) || !Array.isArray(body["choices"]))
-        return undefined;
-    const choice = body["choices"][0];
-    return isRecord(choice) ? choice : undefined;
-}
-function textOf(content) {
-    if (typeof content === "string")
-        return content;
-    if (typeof content === "number")
-        return String(content);
-    return "";
-}
-function parsedOr(text) {
-    try {
-        return JSON.parse(text);
-    }
-    catch {
-        return text;
-    }
-}
-function isRecord(value) {
-    return typeof value === "object" && value !== null && !Array.isArray(value);
-}

package/dist/server/emailBinding.d.ts

@@ -1,72 +0,0 @@
-/**
- * `gatewayEmailBinding(env)`: the Gateway's `email` capability as a
- * `send_email` binding, for code written against `env.EMAIL.send(message)`.
- *
- * An app on Every App binds no `send_email` of its own: the Gateway sends
- * with its sender, checks `from` against the installation's senders and
- * keeps the mail budgets. Code that already calls `env.EMAIL.send()` gets
- * this object in its place:
- *
- *   const EMAIL = gatewayEmailBinding(env, { for: request });
- *   await EMAIL.send({ from, to, subject, text });
- *
- * Each `send()` is a `sendEmail()` (the manifest lists `capabilities: {
- * email: { access: "write" } }`), so local development works the same way:
- * checked and printed, or sent with the developer's own Email Sending
- * account (EMAIL_REST_API_TOKEN, CLOUDFLARE_ACCOUNT_ID, EMAIL_FROM).
- */
-import { type SendEmailMessage } from "../internal/index.js";
-import type { GatewayCallFor } from "./attribution.js";
-export interface GatewayEmailBindingOptions {
-    /**
-     * Whom the mail is for: the inbound request, or `{ background: true,
-     * organizationId }` (sendEmail's `for`).
-     */
-    for?: GatewayCallFor;
-}
-/** `name <email>` or a bare address, as the binding takes them. */
-type BindingAddress = string | {
-    email: string;
-    name?: string;
-};
-type BindingRecipients = BindingAddress | BindingAddress[];
-/** The structured message `send_email`'s `send()` takes (`EmailMessageBuilder`). */
-export interface GatewayEmailBindingMessage {
-    from: BindingAddress;
-    to?: BindingRecipients;
-    cc?: BindingRecipients;
-    bcc?: BindingRecipients;
-    subject: string;
-    replyTo?: BindingAddress;
-    headers?: Record<string, string>;
-    text?: string;
-    html?: string;
-    attachments?: {
-        disposition?: "inline" | "attachment";
-        contentId?: string;
-        filename: string;
-        type: string;
-        content: string | ArrayBuffer | ArrayBufferView;
-    }[];
-}
-/**
- * A `send_email` binding (`SendEmail`) over the Gateway: pass it where code
- * takes `env.EMAIL`. `send()` takes the structured message (`from`, `to`,
- * `cc`, `bcc`, `subject`, `text`, `html`, `replyTo`, `headers`,
- * `attachments`) and resolves `{ messageId }`. A raw MIME `EmailMessage`
- * (`new EmailMessage(from, to, raw)`) is refused with `GatewayRefusalError`
- * `email_invalid_message`: the Gateway takes structured mail only.
- *
- * Errors are sendEmail()'s: `GatewayRefusalError` with the Gateway's code
- * (`email_sender_not_allowed`, `email_budget_exhausted`,
- * `integration_not_configured`, …) and `ConfigurationError` with neither a
- * binding nor `everyapp dev`. Nothing is checked when the binding is made.
- */
-export declare function gatewayEmailBinding(env: object, options?: GatewayEmailBindingOptions): SendEmail;
-/**
- * The binding's message as sendEmail()'s: recipients as bare addresses,
- * `from` and `replyTo` with their display names, attachments base64.
- */
-export declare function toSendEmailMessage(message: unknown): SendEmailMessage;
-export {};
-//# sourceMappingURL=emailBinding.d.ts.map

package/dist/server/emailBinding.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"emailBinding.d.ts","sourceRoot":"","sources":["../../src/server/emailBinding.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AACH,OAAO,EAGL,KAAK,gBAAgB,EACtB,MAAM,sBAAsB,CAAC;AAC9B,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAIvD,MAAM,WAAW,0BAA0B;IACzC;;;OAGG;IACH,GAAG,CAAC,EAAE,cAAc,CAAC;CACtB;AAED,mEAAmE;AACnE,KAAK,cAAc,GAAG,MAAM,GAAG;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC;AAChE,KAAK,iBAAiB,GAAG,cAAc,GAAG,cAAc,EAAE,CAAC;AAE3D,oFAAoF;AACpF,MAAM,WAAW,0BAA0B;IACzC,IAAI,EAAE,cAAc,CAAC;IACrB,EAAE,CAAC,EAAE,iBAAiB,CAAC;IACvB,EAAE,CAAC,EAAE,iBAAiB,CAAC;IACvB,GAAG,CAAC,EAAE,iBAAiB,CAAC;IACxB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,CAAC,EAAE,cAAc,CAAC;IACzB,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACjC,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,WAAW,CAAC,EAAE;QACZ,WAAW,CAAC,EAAE,QAAQ,GAAG,YAAY,CAAC;QACtC,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB,QAAQ,EAAE,MAAM,CAAC;QACjB,IAAI,EAAE,MAAM,CAAC;QACb,OAAO,EAAE,MAAM,GAAG,WAAW,GAAG,eAAe,CAAC;KACjD,EAAE,CAAC;CACL;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,mBAAmB,CACjC,GAAG,EAAE,MAAM,EACX,OAAO,GAAE,0BAA+B,GACvC,SAAS,CAcX;AAED;;;GAGG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,OAAO,GAAG,gBAAgB,CA6BrE"}

package/dist/server/emailBinding.js

@@ -1,124 +0,0 @@
-/**
- * `gatewayEmailBinding(env)`: the Gateway's `email` capability as a
- * `send_email` binding, for code written against `env.EMAIL.send(message)`.
- *
- * An app on Every App binds no `send_email` of its own: the Gateway sends
- * with its sender, checks `from` against the installation's senders and
- * keeps the mail budgets. Code that already calls `env.EMAIL.send()` gets
- * this object in its place:
- *
- *   const EMAIL = gatewayEmailBinding(env, { for: request });
- *   await EMAIL.send({ from, to, subject, text });
- *
- * Each `send()` is a `sendEmail()` (the manifest lists `capabilities: {
- * email: { access: "write" } }`), so local development works the same way:
- * checked and printed, or sent with the developer's own Email Sending
- * account (EMAIL_REST_API_TOKEN, CLOUDFLARE_ACCOUNT_ID, EMAIL_FROM).
- */
-import { ConfigurationError, } from "../internal/index.js";
-import { GatewayRefusalError } from "./refusal.js";
-import { sendEmail } from "./sendEmail.js";
-/**
- * A `send_email` binding (`SendEmail`) over the Gateway: pass it where code
- * takes `env.EMAIL`. `send()` takes the structured message (`from`, `to`,
- * `cc`, `bcc`, `subject`, `text`, `html`, `replyTo`, `headers`,
- * `attachments`) and resolves `{ messageId }`. A raw MIME `EmailMessage`
- * (`new EmailMessage(from, to, raw)`) is refused with `GatewayRefusalError`
- * `email_invalid_message`: the Gateway takes structured mail only.
- *
- * Errors are sendEmail()'s: `GatewayRefusalError` with the Gateway's code
- * (`email_sender_not_allowed`, `email_budget_exhausted`,
- * `integration_not_configured`, …) and `ConfigurationError` with neither a
- * binding nor `everyapp dev`. Nothing is checked when the binding is made.
- */
-export function gatewayEmailBinding(env, options = {}) {
-    const binding = {
-        async send(message) {
-            const result = await sendEmail({
-                env,
-                ...(options.for === undefined ? {} : { for: options.for }),
-                message: toSendEmailMessage(message),
-            });
-            return { messageId: result.messageId ?? "" };
-        },
-    };
-    // `SendEmail` is the app's own Workers types' interface, whose `send()`
-    // overloads change with the version; this `send()` takes both forms.
-    return binding;
-}
-/**
- * The binding's message as sendEmail()'s: recipients as bare addresses,
- * `from` and `replyTo` with their display names, attachments base64.
- */
-export function toSendEmailMessage(message) {
-    if (!message || typeof message !== "object") {
-        throw new ConfigurationError("EMAIL.send() takes a message object.");
-    }
-    if (!("subject" in message)) {
-        throw new GatewayRefusalError({
-            status: 400,
-            code: "email_invalid_message",
-            message: "Raw MIME messages can't be sent through the Every App gateway; send a structured message ({ from, to, subject, text or html }).",
-        });
-    }
-    const m = message;
-    return {
-        to: addresses(m.to) ?? [],
-        ...(m.cc === undefined ? {} : { cc: addresses(m.cc) }),
-        ...(m.bcc === undefined ? {} : { bcc: addresses(m.bcc) }),
-        subject: m.subject,
-        ...(m.text ? { text: m.text } : {}),
-        ...(m.html ? { html: m.html } : {}),
-        from: named(m.from),
-        ...(m.replyTo ? { replyTo: named(m.replyTo) } : {}),
-        ...(m.headers && Object.keys(m.headers).length > 0
-            ? { headers: m.headers }
-            : {}),
-        ...(m.attachments?.length
-            ? { attachments: m.attachments.map(attachment) }
-            : {}),
-    };
-}
-/**
- * One attachment in the Gateway's shape. An inline part without a content
- * id can't be referenced (and the Gateway refuses it), so it goes as an
- * ordinary attachment.
- */
-function attachment(a) {
-    const contentId = a.contentId?.trim();
-    return {
-        filename: a.filename,
-        contentType: a.type,
-        content: base64(a.content),
-        ...(a.disposition === "inline" && contentId
-            ? { disposition: "inline", contentId }
-            : {}),
-    };
-}
-function named(address) {
-    if (typeof address === "string")
-        return { address };
-    return {
-        address: address.email,
-        ...(address.name?.trim() ? { name: address.name } : {}),
-    };
-}
-function addresses(recipients) {
-    if (recipients === undefined)
-        return undefined;
-    const of = (a) => (typeof a === "string" ? a : a.email);
-    return Array.isArray(recipients) ? recipients.map(of) : of(recipients);
-}
-/** Strings are taken as base64 already, as the binding takes them; bytes are encoded. */
-function base64(content) {
-    if (typeof content === "string")
-        return content;
-    const bytes = content instanceof ArrayBuffer
-        ? new Uint8Array(content)
-        : new Uint8Array(content.buffer, content.byteOffset, content.byteLength);
-    let binary = "";
-    for (let i = 0; i < bytes.length; i += 0x8000) {
-        binary += String.fromCharCode(...bytes.subarray(i, i + 0x8000));
-    }
-    return btoa(binary);
-}

package/dist/server/fromMcpTools.d.ts

@@ -1,89 +0,0 @@
-/**
- * `fromMcpTools()` — an app's existing MCP tools as `defineTools()` entries.
- *
- *   const tools: McpToolLike[] = [];
- *   registerMyTools((name, config, handler) =>
- *     tools.push({ name, ...config, handler }),
- *   );
- *   export default everyApp(handler, {
- *     tools: defineTools(fromMcpTools(tools), { instructions }),
- *   });
- *
- * Takes the shape `McpServer.registerTool(name, config, handler)` is called
- * with (or what a low-level server's `tools/list` returns, plus a handler),
- * structurally: the SDK takes no dependency on `@modelcontextprotocol/sdk`,
- * and a live `McpServer` keeps its registry private, so the app hands over
- * the list it registers from.
- */
-import { type ToolRisk } from "../internal/index.js";
-import { type StandardSchemaWithJSON, type ToolContext, type ToolDefinition, type ToolSchema } from "./tools.js";
-/** MCP tool annotations (all hints); only these are read. */
-export interface McpToolAnnotationsLike {
-    title?: string;
-    readOnlyHint?: boolean;
-    destructiveHint?: boolean;
-    idempotentHint?: boolean;
-    openWorldHint?: boolean;
-}
-/** An MCP `CallToolResult`, structurally. */
-export interface McpToolResultLike {
-    content?: ReadonlyArray<{
-        readonly type: string;
-    }>;
-    structuredContent?: unknown;
-    isError?: boolean;
-}
-/**
- * A tool schema as MCP servers write one: a {@link ToolSchema} (a full zod
- * object, `{ jsonSchema, validate }`), a raw shape of Standard Schemas
- * (`{ query: z.string() }`, what `McpServer.registerTool` takes), or a plain
- * JSON Schema object (a low-level server's `tools/list`), which is described
- * but not validated: the handler checks its own arguments, as it did before.
- */
-export type McpToolSchemaLike = ToolSchema | Readonly<Record<string, StandardSchemaWithJSON>> | Readonly<Record<string, unknown>>;
-/** One MCP tool: `registerTool`'s name, config and handler, flattened. */
-export interface McpToolLike<TExtra = ToolContext> {
-    name: string;
-    title?: string;
-    description?: string;
-    /** Omitted: the tool takes no arguments. */
-    inputSchema?: McpToolSchemaLike;
-    outputSchema?: McpToolSchemaLike;
-    annotations?: McpToolAnnotationsLike;
-    /**
-     * Called with the validated arguments and the value of
-     * {@link FromMcpToolsOptions.context} (the call's {@link ToolContext} by
-     * default). Return a `CallToolResult`; throw {@link ToolError} for a message
-     * the model may read.
-     */
-    handler: (args: never, extra: TExtra) => McpToolResultLike | Promise<McpToolResultLike>;
-}
-export interface FromMcpToolsOptions<TExtra = ToolContext> {
-    /**
-     * What each handler gets as its second argument, built per call from the
-     * verified caller (`user`, `env`, `request`, `callId`). Default: the
-     * {@link ToolContext} itself.
-     */
-    context?: (context: ToolContext) => TExtra | Promise<TExtra>;
-    /**
-     * A tool's risk, overriding the default for the tools it returns a risk
-     * for. Default: `readOnlyHint: true` is `read`, `destructiveHint: true`
-     * is `destructive`, anything else `write`.
-     */
-    risk?: (tool: McpToolLike<TExtra>) => ToolRisk | undefined;
-}
-/**
- * Adapt MCP tools into `defineTools()` entries, keyed by tool name, to spread
- * beside the app's own: `defineTools({ ...fromMcpTools(list), my_tool })`.
- *
- * - `title`, `description` (the name when absent), `idempotentHint` and
- *   `openWorldHint` carry over; risk as {@link FromMcpToolsOptions.risk}.
- * - A result's text blocks, joined by a blank line, are what the model
- *   reads; `structuredContent` is sent as structured content (checked
- *   against `outputSchema` when there is one). Other blocks are dropped.
- * - `isError: true` becomes a {@link ToolError} with the result's text.
- *
- * Names must already be lowercase snake_case; `defineTools()` checks them.
- */
-export declare function fromMcpTools<TExtra = ToolContext>(tools: Iterable<McpToolLike<TExtra>>, options?: FromMcpToolsOptions<TExtra>): Record<string, ToolDefinition>;
-//# sourceMappingURL=fromMcpTools.d.ts.map

package/dist/server/fromMcpTools.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"fromMcpTools.d.ts","sourceRoot":"","sources":["../../src/server/fromMcpTools.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AACH,OAAO,EAAqB,KAAK,QAAQ,EAAE,MAAM,sBAAsB,CAAC;AACxE,OAAO,EAGL,KAAK,sBAAsB,EAC3B,KAAK,WAAW,EAChB,KAAK,cAAc,EACnB,KAAK,UAAU,EAChB,MAAM,YAAY,CAAC;AAIpB,6DAA6D;AAC7D,MAAM,WAAW,sBAAsB;IACrC,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,aAAa,CAAC,EAAE,OAAO,CAAC;CACzB;AAED,6CAA6C;AAC7C,MAAM,WAAW,iBAAiB;IAChC,OAAO,CAAC,EAAE,aAAa,CAAC;QAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IACnD,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAC5B,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB;AAED;;;;;;GAMG;AACH,MAAM,MAAM,iBAAiB,GACzB,UAAU,GACV,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,sBAAsB,CAAC,CAAC,GAChD,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;AAEtC,0EAA0E;AAC1E,MAAM,WAAW,WAAW,CAAC,MAAM,GAAG,WAAW;IAC/C,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,4CAA4C;IAC5C,WAAW,CAAC,EAAE,iBAAiB,CAAC;IAChC,YAAY,CAAC,EAAE,iBAAiB,CAAC;IACjC,WAAW,CAAC,EAAE,sBAAsB,CAAC;IACrC;;;;;OAKG;IACH,OAAO,EAAE,CACP,IAAI,EAAE,KAAK,EACX,KAAK,EAAE,MAAM,KACV,iBAAiB,GAAG,OAAO,CAAC,iBAAiB,CAAC,CAAC;CACrD;AAED,MAAM,WAAW,mBAAmB,CAAC,MAAM,GAAG,WAAW;IACvD;;;;OAIG;IACH,OAAO,CAAC,EAAE,CAAC,OAAO,EAAE,WAAW,KAAK,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;IAC7D;;;;OAIG;IACH,IAAI,CAAC,EAAE,CAAC,IAAI,EAAE,WAAW,CAAC,MAAM,CAAC,KAAK,QAAQ,GAAG,SAAS,CAAC;CAC5D;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,YAAY,CAAC,MAAM,GAAG,WAAW,EAC/C,KAAK,EAAE,QAAQ,CAAC,WAAW,CAAC,MAAM,CAAC,CAAC,EACpC,OAAO,GAAE,mBAAmB,CAAC,MAAM,CAAM,GACxC,MAAM,CAAC,MAAM,EAAE,cAAc,CAAC,CA+ChC"}