@every-app/sdk 0.3.0-rc.2 → 0.3.0-rc.4

package/dist/server/everyApp.js

@@ -14,10 +14,21 @@
  * `cloudflare.config.ts` imports from the Worker in dev).
  * It also answers the gateway's internal tools contract
  * (`/__everyapp/tools/*`) for the app's `defineTools()` catalog.
+ *
+ * Around the handler and around each tool call it opens the request
+ * context (context.ts): `currentUser()` reads the user anywhere below, and
+ * every call back to the Gateway is attributed to the request without a
+ * `for`. A deployed Worker is pinned to its organization
+ * (`EVERY_APP_ORG_ID`), and an identity for any other is refused on both
+ * paths. The response leaves without `Set-Cookie`: the perimeter strips
+ * every `Cookie` before a request reaches the app, so a cookie the app's
+ * framework sets could never come back, and one named like the Gateway's
+ * session cookie would lock the person out of the app host.
  */
-import { APP_ID_ENV, AUDIENCE_ENV, ConfigurationError, DEV_ENV, IdentityError, ISSUER_ENV, PUBLIC_KEYS_ENV, getIdentityFromRequest, } from "../internal/index.js";
+import { APP_ID_ENV, AUDIENCE_ENV, ConfigurationError, DEV_ENV, IdentityError, IDENTITY_HEADER, ISSUER_ENV, ORG_ID_ENV, PUBLIC_KEYS_ENV, getIdentityFromRequest, isAdmin, } from "../internal/index.js";
+import { currentUser, serveRequest } from "./context.js";
 import { handleToolsRequest } from "./toolsEndpoint.js";
-export { ConfigurationError, IdentityError };
+export { ConfigurationError, IdentityError, isAdmin };
 const requestIdentities = new WeakMap();
 function envValue(env, key) {
     if (!env || typeof env !== "object")
@@ -68,6 +79,17 @@ function audienceFor(env, config) {
         return appId;
     throw new ConfigurationError(`${AUDIENCE_ENV} is not set — the app's cloudflare.config.ts must declare it (everyAppWorker() does at deploy).`);
 }
+/**
+ * The organization a deployed Worker serves ({@link ORG_ID_ENV}), which an
+ * identity must name. Under the dev opt-in there is none to enforce: the
+ * stub gateway's one organization is the only one, and `everyapp dev
+ * --mode mirror` signs real organizations in.
+ */
+function pinnedOrganization(env, config) {
+    if (devIdentitiesAllowed(env, config))
+        return undefined;
+    return envValue(env, ORG_ID_ENV);
+}
 function unauthorized(message) {
     return Response.json({ error: "unauthenticated", message }, { status: 401 });
 }
@@ -77,6 +99,7 @@ function misconfigured(message) {
 function identityOptions(env, config, audience) {
     return {
         audience,
+        organizationId: pinnedOrganization(env, config),
         issuer: config.issuer ?? envValue(env, ISSUER_ENV),
         publicKeys: config.publicKeys,
         env: env,
@@ -91,15 +114,54 @@ async function resolveIdentity(request, env, config) {
 function rememberIdentity(request, identity) {
     requestIdentities.set(request, identity);
 }
+/**
+ * The user the request context already verified, when `request` carries
+ * the same identity token: a framework that rebuilds the request (TanStack
+ * Start's `getRequest()`, a Hono context) still gets the one verification.
+ */
+function contextUserFor(request) {
+    const headers = "headers" in request ? request.headers : request;
+    const token = headers.get(IDENTITY_HEADER);
+    if (!token)
+        return null;
+    const scoped = servedRequestToken();
+    return scoped && scoped.token === token ? scoped.user : null;
+}
+/**
+ * The served request's token and user, or null outside a request. Reads
+ * the context without throwing (currentUser() throws outside one).
+ */
+function servedRequestToken() {
+    let user;
+    try {
+        user = currentUser();
+    }
+    catch {
+        return null;
+    }
+    if (!user)
+        return null;
+    const served = servedRequests.get(user);
+    return served ? { token: served, user } : null;
+}
+// The identity token of each request everyApp() serves, by its user, so a
+// second read of the same token answers from the context.
+const servedRequests = new WeakMap();
 /**
  * Return the verified Every App user for this request, or null for a declared
- * public request. Uses the request cache first, then verifies the identity
- * headers from the app id and public keys configured in env.
+ * public request. `request` is the inbound `Request` or just its `Headers`
+ * (a framework that hands out headers alone needs no made-up Request).
+ * Answers from the request context or the per-request cache first, then
+ * verifies the identity headers from the audience and public keys in env.
+ * Inside a handler `everyApp()` serves, `currentUser()` is the shorter way.
  */
 export async function getEveryAppUser(request, env) {
     const cached = requestIdentities.get(request);
     if (cached)
         return cached.user;
+    const fromContext = contextUserFor(request);
+    if (fromContext)
+        return fromContext;
     const identity = await resolveIdentity(request, env, {
         keysEnvVar: PUBLIC_KEYS_ENV,
     });
@@ -125,6 +187,40 @@ export async function requireEveryAppUser(request, env) {
         throw error;
     }
 }
+/**
+ * The user of the request being served (`currentUser()`), or throw the
+ * same 401 JSON Response as `requireEveryAppUser()` on a public route.
+ * Outside a request (`withOrganization()` work, a handler not under
+ * `everyApp()`) it throws `RequestContextError`, as `currentUser()` does.
+ */
+export function requireCurrentUser() {
+    const user = currentUser();
+    if (!user) {
+        throw unauthorized("this request does not have an authenticated user");
+    }
+    return user;
+}
+/**
+ * `response` without `Set-Cookie`: the perimeter strips every `Cookie`
+ * before a request reaches the app, so no cookie the app sets ever comes
+ * back, and one named like the Gateway's session cookie locks the person
+ * out of the app host (the perimeter refuses a session cookie sent twice).
+ * A WebSocket handshake (101) passes as it is: it can't be rebuilt from
+ * its body, and the perimeter drops its cookies' `Domain`.
+ */
+function withoutCookies(response) {
+    if (response.status === 101 || !response.headers.has("set-cookie")) {
+        return response;
+    }
+    console.warn("[everyapp] Dropped a Set-Cookie header: the Gateway never sends an app's cookies back to it.");
+    const headers = new Headers(response.headers);
+    headers.delete("set-cookie");
+    return new Response(response.body, {
+        status: response.status,
+        statusText: response.statusText,
+        headers,
+    });
+}
 export function hasScope(user, scope) {
     return user.scopes.includes("*") || user.scopes.includes(scope);
 }
@@ -179,7 +275,12 @@ export function everyApp(handler, manifestOrOptions, legacyOptions = {}) {
                     return unauthorized(err.message);
                 throw err;
             }
-            return handler(request, env, ctx, identity.user);
+            const { user, expiresAt } = identity;
+            if (user) {
+                servedRequests.set(user, request.headers.get(IDENTITY_HEADER) ?? "");
+            }
+            const response = await serveRequest({ request, user, expiresAt }, () => handler(request, env, ctx, user));
+            return withoutCookies(response);
         },
     };
 }

package/dist/server/fromMcpTools.d.ts

@@ -0,0 +1,89 @@
+/**
+ * `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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,192 @@
+/**
+ * `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 };
+        },
+    };
+}

package/dist/server/gatewayFetch.d.ts

@@ -17,11 +17,13 @@ export interface GatewayFetchEnv {
 export interface CreateGatewayFetchOptions {
     env: GatewayFetchEnv;
     /**
-     * Whom the call is for: the inbound request (its user), or
-     * `{ background: true, organizationId }` for work no person started
-     * (crons, Workflows, queues). An organization's own app may omit it for
-     * background work, which is then the app's; a shared app's Worker must
-     * pass one or the other ({@link AttributionError}).
+     * Whom the call is for. Left out, the request `everyApp()` is serving
+     * (its user, while the identity is good) or the organization
+     * `withOrganization()` named; outside both, `RequestContextError`.
+     * Explicitly: the inbound request, or `{ background: true,
+     * organizationId }` for work no person started (crons, Workflows,
+     * queues). A shared app's Worker must end up with one or the other
+     * ({@link AttributionError}).
      */
     for?: GatewayCallFor;
 }
@@ -31,7 +33,7 @@ export interface CreateGatewayFetchOptions {
  * developer's own provider key from `.dev.vars` is a direct-provider
  * fallback when no binding exists.
  */
-export declare function createGatewayFetch({ env, for: target, }: CreateGatewayFetchOptions): typeof fetch;
+export declare function createGatewayFetch({ env, for: explicitTarget, }: CreateGatewayFetchOptions): typeof fetch;
 /** A copy of `source` aimed at `url`, streaming its body rather than buffering it. */
 export declare function streamingRequest(url: string, source: Request, headers: Headers): Request;
 //# sourceMappingURL=gatewayFetch.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"gatewayFetch.d.ts","sourceRoot":"","sources":["../../src/server/gatewayFetch.ts"],"names":[],"mappings":"AASA,OAAO,EAGL,KAAK,cAAc,EACpB,MAAM,kBAAkB,CAAC;AAE1B,eAAO,MAAM,cAAc,sCAAsC,CAAC;AAGlE,MAAM,WAAW,qBAAqB;IACpC,KAAK,CAAC,KAAK,EAAE,WAAW,GAAG,GAAG,EAAE,IAAI,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,QAAQ,CAAC,CAAC;CACxE;AAED,MAAM,WAAW,eAAe;IAC9B,iBAAiB,CAAC,EAAE,qBAAqB,CAAC;IAC1C,YAAY,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC;IAChC,kEAAkE;IAClE,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B,oFAAoF;IACpF,oBAAoB,CAAC,EAAE,MAAM,CAAC;IAC9B,qBAAqB,CAAC,EAAE,MAAM,CAAC;CAChC;AAED,MAAM,WAAW,yBAAyB;IACxC,GAAG,EAAE,eAAe,CAAC;IACrB;;;;;;OAMG;IACH,GAAG,CAAC,EAAE,cAAc,CAAC;CACtB;AAED;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,EACjC,GAAG,EACH,GAAG,EAAE,MAAM,GACZ,EAAE,yBAAyB,GAAG,OAAO,KAAK,CA8D1C;AAED,sFAAsF;AACtF,wBAAgB,gBAAgB,CAC9B,GAAG,EAAE,MAAM,EACX,MAAM,EAAE,OAAO,EACf,OAAO,EAAE,OAAO,GACf,OAAO,CAUT"}
+{"version":3,"file":"gatewayFetch.d.ts","sourceRoot":"","sources":["../../src/server/gatewayFetch.ts"],"names":[],"mappings":"AAaA,OAAO,EAGL,KAAK,cAAc,EACpB,MAAM,kBAAkB,CAAC;AAE1B,eAAO,MAAM,cAAc,sCAAsC,CAAC;AAGlE,MAAM,WAAW,qBAAqB;IACpC,KAAK,CAAC,KAAK,EAAE,WAAW,GAAG,GAAG,EAAE,IAAI,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,QAAQ,CAAC,CAAC;CACxE;AAED,MAAM,WAAW,eAAe;IAC9B,iBAAiB,CAAC,EAAE,qBAAqB,CAAC;IAC1C,YAAY,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC;IAChC,kEAAkE;IAClE,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B,oFAAoF;IACpF,oBAAoB,CAAC,EAAE,MAAM,CAAC;IAC9B,qBAAqB,CAAC,EAAE,MAAM,CAAC;CAChC;AAED,MAAM,WAAW,yBAAyB;IACxC,GAAG,EAAE,eAAe,CAAC;IACrB;;;;;;;;OAQG;IACH,GAAG,CAAC,EAAE,cAAc,CAAC;CACtB;AAED;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,EACjC,GAAG,EACH,GAAG,EAAE,cAAc,GACpB,EAAE,yBAAyB,GAAG,OAAO,KAAK,CAuE1C;AAwCD,sFAAsF;AACtF,wBAAgB,gBAAgB,CAC9B,GAAG,EAAE,MAAM,EACX,MAAM,EAAE,OAAO,EACf,OAAO,EAAE,OAAO,GACf,OAAO,CAUT"}

package/dist/server/gatewayFetch.js

@@ -1,5 +1,5 @@
-import { aiProviderSettings, authorizationOf, ConfigurationError, DEV_AI_PROVIDERS, devAiProvider, joinProviderUrl, } from "../internal/index.js";
-import { applyAttribution, checkAttribution, } from "./attribution.js";
+import { AI_DEFAULT_MODEL, AI_DEFAULT_PROVIDER, AI_DEFAULT_ROUTES, aiProviderSettings, authorizationOf, ConfigurationError, DEV_AI_PROVIDERS, devAiProvider, joinProviderUrl, resolveAiDefault, } from "../internal/index.js";
+import { applyAttribution, attributionFor, } from "./attribution.js";
 export const BINDING_ORIGIN = "http://every-app-gateway.internal";
 const AI_PROXY_PREFIX = "/api/ai/";
 /**
@@ -8,8 +8,10 @@ const AI_PROXY_PREFIX = "/api/ai/";
  * developer's own provider key from `.dev.vars` is a direct-provider
  * fallback when no binding exists.
  */
-export function createGatewayFetch({ env, for: target, }) {
-    checkAttribution(env, target, "createGatewayFetch");
+export function createGatewayFetch({ env, for: explicitTarget, }) {
+    // Checked now, so a call nobody's fails where the fetch is made; and
+    // again per call, where an identity may since have neared its expiry.
+    attributionFor(env, explicitTarget, "createGatewayFetch");
     const binding = env.EVERY_APP_GATEWAY;
     const devProviders = env.EVERYAPP_DEV ? localProviders(env) : {};
     if (binding && typeof binding.fetch !== "function") {
@@ -19,6 +21,7 @@ export function createGatewayFetch({ env, for: target, }) {
         throw new ConfigurationError(`AI gateway unavailable: deploy with the EVERY_APP_GATEWAY binding, or set the provider's key (${listOf(Object.values(DEV_AI_PROVIDERS).map((spec) => settingsNames(spec, "with")), "or")}) in .dev.vars for direct local development.`);
     }
     return async (input, init) => {
+        const target = attributionFor(env, explicitTarget, "createGatewayFetch");
         const outbound = new Request(input, init);
         const headers = new Headers(outbound.headers);
         headers.delete("authorization");
@@ -28,7 +31,8 @@ export function createGatewayFetch({ env, for: target, }) {
             const bindingRequest = streamingRequest(`${BINDING_ORIGIN}${url.pathname}${url.search}`, outbound, headers);
             return binding.fetch(bindingRequest);
         }
-        const { provider, spec, path, search } = directProviderPath(outbound.url);
+        const direct = directProviderPath(outbound.url, env);
+        const { provider, spec, path, search } = direct;
         const dev = devProviders[provider];
         if (!dev) {
             throw new ConfigurationError(`Set ${settingsNames(spec)} in .dev.vars to call ${provider} in local development.`);
@@ -37,6 +41,11 @@ export function createGatewayFetch({ env, for: target, }) {
         if (!url)
             throw new ConfigurationError("Invalid provider proxy path.");
         applyAttribution(headers, undefined);
+        // The default route in dev: the model filled in as the gateway would.
+        let body = outbound;
+        if (direct.fillModel !== null) {
+            body = await withModel(outbound, direct.fillModel, headers);
+        }
         // The developer's key, put where the provider's entry says (a bearer
         // token for the three today), as the gateway would put its own.
         const auth = authorizationOf(spec.auth, { [spec.keyEnv]: dev.key });
@@ -46,11 +55,44 @@ export function createGatewayFetch({ env, for: target, }) {
         for (const [name, value] of Object.entries(auth?.query ?? {})) {
             url.searchParams.set(name, value);
         }
-        const response = await fetch(streamingRequest(url.toString(), outbound, headers));
+        const response = await fetch(streamingRequest(url.toString(), body, headers));
         // What the gateway does to the provider's answer, so dev behaves alike.
         return spec.normalizeResponse?.(path, response) ?? response;
     };
 }
+/**
+ * `source` with `model` put into its JSON body where the app named none
+ * or named `default`, as the gateway's default route does. A body that
+ * isn't a JSON object goes through as it is.
+ */
+async function withModel(source, model, headers) {
+    if (!canIncludeBody(source.method) || !source.body)
+        return source;
+    const text = await source.clone().text();
+    let payload;
+    try {
+        payload = JSON.parse(text);
+    }
+    catch {
+        return source;
+    }
+    if (!payload || typeof payload !== "object" || Array.isArray(payload)) {
+        return source;
+    }
+    const record = payload;
+    if (record["model"] === undefined ||
+        record["model"] === null ||
+        record["model"] === AI_DEFAULT_MODEL) {
+        record["model"] = model;
+    }
+    headers.delete("content-length");
+    return new Request(source.url, {
+        method: source.method,
+        headers,
+        body: JSON.stringify(record),
+        signal: source.signal,
+    });
+}
 /** A copy of `source` aimed at `url`, streaming its body rather than buffering it. */
 export function streamingRequest(url, source, headers) {
     const body = canIncludeBody(source.method) ? source.body : undefined;
@@ -82,19 +124,44 @@ function localProviders(env) {
     }
     return providers;
 }
-function directProviderPath(input) {
+function directProviderPath(input, env) {
     const incoming = new URL(input);
     const match = incoming.pathname.match(/^\/api\/ai\/([a-z][a-z0-9-]*)(\/.*)?$/);
-    const provider = match?.[1];
+    let provider = match?.[1];
+    let path = match?.[2] || "/";
+    let fillModel = null;
+    if (provider === AI_DEFAULT_PROVIDER) {
+        // The default in dev, by the gateway's rule on the developer's own
+        // `.dev.vars`: the first provider of the order with every setting set.
+        const values = env;
+        const resolution = resolveAiDefault({
+            choice: null,
+            isSet: (name) => typeof values[name] === "string" &&
+                values[name].trim().length > 0,
+        });
+        if (!resolution.configured) {
+            throw new ConfigurationError(`Set ${resolution.settings.join(" and ")} (or another model provider's key) in .dev.vars to call the default model in local development.`);
+        }
+        const route = path === AI_DEFAULT_ROUTES.chat
+            ? resolution.chat
+            : path === AI_DEFAULT_ROUTES.embeddings
+                ? resolution.embeddings
+                : undefined;
+        if (!route) {
+            throw new ConfigurationError(`The default model serves ${AI_DEFAULT_ROUTES.chat} and ${AI_DEFAULT_ROUTES.embeddings} only; call /api/ai/<provider>/… for anything else.`);
+        }
+        provider = resolution.provider;
+        path = route.path;
+        fillModel = path === resolution.chat.path ? resolution.model : route.model;
+    }
     const spec = provider ? devAiProvider(provider) : undefined;
     if (!provider || !spec) {
-        throw new ConfigurationError(`Direct local provider fallback only supports ${listOf(Object.keys(DEV_AI_PROVIDERS).map((name) => `${AI_PROXY_PREFIX}${name}`), "and")} paths.`);
+        throw new ConfigurationError(`Direct local provider fallback only supports ${listOf([AI_DEFAULT_PROVIDER, ...Object.keys(DEV_AI_PROVIDERS)].map((name) => `${AI_PROXY_PREFIX}${name}`), "and")} paths.`);
     }
-    const path = match?.[2] || "/";
     if (path.startsWith("//") || path.includes("\\")) {
         throw new ConfigurationError("Invalid provider proxy path.");
     }
-    return { provider, spec, path, search: incoming.search };
+    return { provider, spec, path, search: incoming.search, fillModel };
 }
 /** A provider's settings as a person reads them: `KEY`, or `KEY and SETTING`. */
 function settingsNames(spec, conjunction = "and") {

package/dist/server/index.d.ts

@@ -3,16 +3,20 @@
  *
  * There is intentionally no client-side export.
  */
-export { ConfigurationError, IdentityError, everyApp, getEveryAppUser, hasScope, requireEveryAppUser, type EveryAppOptions, type EveryAppManifestLike, type EveryAppHandler, type EveryAppUser, type IdentityResult, } from "./everyApp.js";
+export { ConfigurationError, IdentityError, everyApp, getEveryAppUser, hasScope, isAdmin, requireCurrentUser, requireEveryAppUser, type EveryAppOptions, type EveryAppManifestLike, type EveryAppHandler, type EveryAppUser, type IdentityResult, type OrgRole, } from "./everyApp.js";
+export { OrganizationMismatchError, RequestContextError, currentUser, withOrganization, } from "./context.js";
 export { AttributionError, type GatewayCallFor } from "./attribution.js";
 export { authorizeUrl, type AuthorizeUrlOptions } from "./authorizeUrl.js";
+export { connectPath, connectUrl, type ConnectUrlOptions, } from "./connectUrl.js";
 export { createGatewayFetch, type CreateGatewayFetchOptions, type GatewayFetchEnv, } from "./gatewayFetch.js";
-export { GatewayRefusalError, gatewayRefusal, integrationFetch, integrationStatus, type EmailIntegrationStatus, type GatewayRefusal, type IntegrationFetchOptions, type IntegrationStatus, type IntegrationStatusOf, type OAuthClientIntegrationStatus, } from "./integrationFetch.js";
+export { ai, AI_DEFAULT_BASE_URL, type AiClient } from "./ai.js";
+export { GatewayRefusalError, gatewayRefusal, devAccessTokenName, integrationFetch, integrationStatus, type EmailIntegrationStatus, type GatewayRefusal, type IntegrationFetchOptions, type IntegrationStatus, type IntegrationStatusOf, type OAuthClientIntegrationStatus, } from "./integrationFetch.js";
 export { nodeServerHandler, type NodeServer, type NodeServerHandlerOptions, } from "./nodeServer.js";
 export { sendEmail, type SendEmailOptions } from "./sendEmail.js";
 export { listMembers, type ListMembersOptions } from "./listMembers.js";
 export { emit, type EmitOptions } from "./emit.js";
-export type { ApiKeyCapabilityId, CapabilityId, OAuthClientCapabilityId, EmailAddressInput, EmailAttachmentInput, SendEmailMessage, SendEmailResult, ListMembersResult, OrganizationMember, OrganizationMemberRole, EmitEventResult, } from "../internal/index.js";
+export type { ApiKeyCapabilityId, CapabilityId, OAuthClientCapabilityId, ConnectionAccount, EmailAddressInput, EmailAttachmentInput, SendEmailMessage, SendEmailResult, ListMembersResult, OrganizationMember, OrganizationMemberRole, EmitEventResult, } from "../internal/index.js";
 export { ToolError, defineTools, toolResult, type DefineToolsOptions, type PlainToolSchema, type StandardSchemaWithJSON, type ToolContext, type ToolDefinition, type ToolResult, type ToolSchema, type ToolSet, } from "./tools.js";
 export type { ToolRisk } from "../internal/index.js";
+export { fromMcpTools, type FromMcpToolsOptions, type McpToolAnnotationsLike, type McpToolLike, type McpToolResultLike, type McpToolSchemaLike, } from "./fromMcpTools.js";
 //# sourceMappingURL=index.d.ts.map