@every-app/sdk 0.3.0-rc.8 → 0.3.0

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"}

package/dist/server/fromMcpTools.js

@@ -1,192 +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 { TOOL_NAME_PATTERN } from "../internal/index.js";
-import { ToolError, toolResult, } from "./tools.js";
-const JSON_SCHEMA_TARGET = "draft-2020-12";
-/**
- * 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 function fromMcpTools(tools, options = {}) {
-    const out = {};
-    for (const tool of tools) {
-        const problem = (message) => new TypeError(`fromMcpTools: tool "${tool?.name}" ${message}`);
-        if (!tool || typeof tool.name !== "string") {
-            throw new TypeError("fromMcpTools: every tool needs a name");
-        }
-        if (!TOOL_NAME_PATTERN.test(tool.name)) {
-            throw problem("must be named in lowercase snake_case: a letter, then letters, digits or _ (at most 48 characters); rename it in the list");
-        }
-        if (Object.prototype.hasOwnProperty.call(out, tool.name)) {
-            throw problem("is listed twice");
-        }
-        if (typeof tool.handler !== "function") {
-            throw problem("needs a handler function");
-        }
-        const output = tool.outputSchema === undefined
-            ? undefined
-            : toToolSchema(tool.outputSchema, problem);
-        const annotations = tool.annotations ?? {};
-        const title = tool.title ?? annotations.title;
-        out[tool.name] = {
-            ...(title !== undefined ? { title } : {}),
-            description: tool.description?.trim() ? tool.description : tool.name,
-            risk: options.risk?.(tool) ?? defaultRisk(annotations),
-            input: toToolSchema(tool.inputSchema ?? {}, problem),
-            ...(output ? { output } : {}),
-            ...(annotations.idempotentHint !== undefined
-                ? { idempotent: annotations.idempotentHint }
-                : {}),
-            ...(annotations.openWorldHint !== undefined
-                ? { openWorld: annotations.openWorldHint }
-                : {}),
-            handler: async (args, context) => {
-                const extra = options.context
-                    ? await options.context(context)
-                    : context;
-                const result = await tool.handler(args, extra);
-                return fromCallToolResult(result);
-            },
-        };
-    }
-    return out;
-}
-function defaultRisk(annotations) {
-    if (annotations.readOnlyHint === true)
-        return "read";
-    return annotations.destructiveHint === true ? "destructive" : "write";
-}
-function fromCallToolResult(result) {
-    if (!isRecord(result)) {
-        throw new Error("the MCP tool did not return a CallToolResult");
-    }
-    const text = (Array.isArray(result.content) ? result.content : [])
-        .flatMap((part) => isRecord(part) && part.type === "text" && typeof part.text === "string"
-        ? [part.text]
-        : [])
-        .join("\n\n");
-    if (result.isError === true)
-        throw new ToolError(text || "The tool failed.");
-    const structured = result.structuredContent;
-    if (isRecord(structured) && !Array.isArray(structured)) {
-        return toolResult({ text, structured });
-    }
-    return text;
-}
-function isRecord(value) {
-    return typeof value === "object" && value !== null;
-}
-function isStandardWithJson(value) {
-    if (!isRecord(value))
-        return false;
-    const standard = value["~standard"];
-    return (isRecord(standard) &&
-        typeof standard.validate === "function" &&
-        isRecord(standard.jsonSchema));
-}
-function isPlainToolSchema(value) {
-    return isRecord(value.jsonSchema) && typeof value.validate === "function";
-}
-function toToolSchema(schema, problem) {
-    if (!isRecord(schema) || Array.isArray(schema)) {
-        throw problem("has a schema that is not an object");
-    }
-    if (isStandardWithJson(schema) || isPlainToolSchema(schema)) {
-        return schema;
-    }
-    if ("~standard" in schema) {
-        throw problem("has a schema that doesn't convert to JSON Schema (zod >= 4.2 does)");
-    }
-    const values = Object.values(schema);
-    if (values.every((value) => isRecord(value) && "~standard" in value)) {
-        if (!values.every(isStandardWithJson)) {
-            throw problem("has a raw shape whose fields don't convert to JSON Schema (zod >= 4.2 does)");
-        }
-        return rawShapeSchema(schema);
-    }
-    return jsonSchemaOnly(schema);
-}
-/** A plain JSON Schema: described as is; any object passes. */
-function jsonSchemaOnly(jsonSchema) {
-    return {
-        jsonSchema,
-        validate: (value) => isRecord(value) && !Array.isArray(value)
-            ? { value }
-            : { issues: [{ message: "Expected an object" }] },
-    };
-}
-/**
- * `{ key: schema }` as an object schema, the way `McpServer` wraps one in
- * `z.object()`: unknown keys are dropped, and a field is optional when its
- * schema accepts `undefined`.
- */
-function rawShapeSchema(shape) {
-    const properties = {};
-    const required = [];
-    for (const [key, field] of Object.entries(shape)) {
-        const { $schema: _, ...property } = field["~standard"].jsonSchema.input({
-            target: JSON_SCHEMA_TARGET,
-        });
-        properties[key] = property;
-        const absent = field["~standard"].validate(undefined);
-        // An async validator can't be asked here; call the field required.
-        if (absent instanceof Promise || absent.issues)
-            required.push(key);
-    }
-    return {
-        jsonSchema: {
-            type: "object",
-            properties,
-            ...(required.length > 0 ? { required } : {}),
-        },
-        validate: async (value) => {
-            if (!isRecord(value) || Array.isArray(value)) {
-                return { issues: [{ message: "Expected an object" }] };
-            }
-            const parsed = {};
-            const issues = [];
-            for (const [key, field] of Object.entries(shape)) {
-                const result = await field["~standard"].validate(value[key]);
-                if (result.issues) {
-                    for (const issue of result.issues) {
-                        issues.push({
-                            message: issue.message,
-                            path: [
-                                key,
-                                ...(issue.path ?? []).map((segment) => typeof segment === "object" ? segment.key : segment),
-                            ],
-                        });
-                    }
-                }
-                else if (key in value || result.value !== undefined) {
-                    parsed[key] = result.value;
-                }
-            }
-            return issues.length > 0 ? { issues } : { value: parsed };
-        },
-    };
-}