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

package/dist/server/authorizeUrl.js

@@ -0,0 +1,110 @@
+import { CAPABILITIES, ConfigurationError, } from "../internal/index.js";
+/**
+ * Parameters the helper owns: the status decides the scopes, the caller's
+ * other arguments decide the rest (PKCE from `codeChallenge`, always as
+ * S256), each provider's own are fixed (Google's `access_type=offline` is
+ * what gets a refresh token, Microsoft's `response_mode=query` is what
+ * the callback reads), and Google's `include_granted_scopes` would widen
+ * the token to every scope the person ever granted this client, which the
+ * gateway refuses (`integration_scope_exceeded`).
+ */
+const RESERVED_PARAMS = [
+    "scope",
+    "user_scope",
+    "client_id",
+    "redirect_uri",
+    "state",
+    "response_type",
+    "code_challenge",
+    "code_challenge_method",
+    "access_type",
+    "response_mode",
+    "include_granted_scopes",
+];
+/** The OAuth clients with scope sets: the ones this helper builds for. */
+function scopedClientIds() {
+    return Object.entries(CAPABILITIES)
+        .filter(([, found]) => found.mode === "oauth_client" && found.scopePolicy)
+        .map(([id]) => id);
+}
+/**
+ * The provider's authorize URL to send a person to, for a client with
+ * scope sets (`google-workspace`, `microsoft-365`, `slack`), built from the
+ * capability's status: the registry's authorize endpoint (or the instance
+ * the status names), `client_id`, `response_type=code`, `redirect_uri`,
+ * `state`, and the scopes the status allows this app, which are exactly
+ * what the gateway will let the token carry. Each provider's own needs
+ * are added: Google's `access_type=offline` (a refresh token), Microsoft's
+ * `response_mode=query`, Slack's comma-joined `scope` and its `user_scope`
+ * (the status's `userScopes`, when the app's sets include a user set). With
+ * `codeChallenge`, PKCE as S256. The app keeps its `state` and verifier
+ * for the callback.
+ *
+ * A client without scope sets (LinkedIn, Mastodon, ...) is refused: the
+ * registry's checklist for one isn't what the gateway holds a token to,
+ * so an app builds that URL itself from the status's `clientId`.
+ *
+ * Throws a `TypeError` naming the fix when the client has no scope sets,
+ * when the status isn't ready or has no `clientId`, when the status lacks
+ * `scopes`, or when `params` names a parameter the helper sets.
+ */
+export function authorizeUrl({ provider, status, redirectUri, state, codeChallenge, params, }) {
+    const capability = oauthClientCapability(provider);
+    if (!capability.scopePolicy) {
+        throw new TypeError(`authorizeUrl() builds URLs for clients with scope sets (${scopedClientIds().join(", ")}); build ${capability.label}'s authorize URL yourself from the status's clientId.`);
+    }
+    if (!status.ready || !status.clientId) {
+        throw new TypeError(`authorizeUrl(${JSON.stringify(provider)}) needs a ready status with a clientId, and integrationStatus() answered ready: ${String(status.ready)}. Show ${capability.label} as not available instead: its operator sets the client up on the gateway, and an app lists the scope sets it uses in everyapp.config.ts.`);
+    }
+    if (!status.scopes) {
+        throw new TypeError(`authorizeUrl(${JSON.stringify(provider)}) takes ${capability.label}'s scopes from integrationStatus().scopes, which this status lacks: pass the status as the gateway (or everyapp dev) answered it.`);
+    }
+    for (const name of Object.keys(params ?? {})) {
+        if (!RESERVED_PARAMS.includes(name))
+            continue;
+        throw new TypeError(name === "include_granted_scopes"
+            ? `authorizeUrl(${JSON.stringify(provider)}): include_granted_scopes would widen the token to every scope the person granted this client, which the gateway refuses (integration_scope_exceeded); leave it out of params.`
+            : `authorizeUrl(${JSON.stringify(provider)}) sets ${name} itself; leave it out of params.`);
+    }
+    const base = status.origin ?? capability.defaultOrigin;
+    if (!/^https:/.test(capability.authorize.url) && !base) {
+        throw new TypeError(`authorizeUrl(${JSON.stringify(provider)}) needs the instance ${capability.label} is on: the status carries it as origin once ${capability.hostSetting} is set.`);
+    }
+    const url = new URL(capability.authorize.url, base);
+    // The status speaks for the gateway: its scopes are the token's ceiling.
+    const scopes = status.scopes;
+    const slack = url.host === "slack.com";
+    url.searchParams.set("client_id", status.clientId);
+    url.searchParams.set("response_type", "code");
+    url.searchParams.set("redirect_uri", redirectUri);
+    url.searchParams.set("state", state);
+    url.searchParams.set("scope", scopes.join(slack ? "," : " "));
+    if (status.userScopes && status.userScopes.length > 0) {
+        url.searchParams.set("user_scope", status.userScopes.join(","));
+    }
+    if (codeChallenge) {
+        url.searchParams.set("code_challenge", codeChallenge);
+        url.searchParams.set("code_challenge_method", "S256");
+    }
+    if (url.host === "accounts.google.com") {
+        // Without it Google issues no refresh token.
+        url.searchParams.set("access_type", "offline");
+    }
+    else if (url.host === "login.microsoftonline.com") {
+        url.searchParams.set("response_mode", "query");
+    }
+    for (const [name, value] of Object.entries(params ?? {})) {
+        url.searchParams.set(name, value);
+    }
+    return url;
+}
+/** The OAuth client `provider` names, from plain JavaScript or a stale type too. */
+function oauthClientCapability(provider) {
+    const found = Object.hasOwn(CAPABILITIES, provider)
+        ? CAPABILITIES[provider]
+        : undefined;
+    if (found?.mode !== "oauth_client") {
+        throw new ConfigurationError(`${JSON.stringify(String(provider))} isn't an OAuth client the gateway holds.`);
+    }
+    return found;
+}

package/dist/server/emit.d.ts

@@ -0,0 +1,63 @@
+/**
+ * `emit()`: an app's own event onto the gateway's event bus
+ * (docs/design/2026-10-events-out.md, section 7). It is shaped like
+ * `sendEmail()` on purpose: the same `{ env, for }` attribution, the same
+ * route over the EVERY_APP_GATEWAY binding, the same refusals thrown as
+ * `GatewayRefusalError`, and the same local-dev twin that checks what the
+ * gateway would check and prints instead of sending. The name and data
+ * rules live in `internal/events.ts`, which the gateway reads too, so the
+ * two can't drift.
+ */
+import { type EmitEventResult } from "../internal/index.js";
+import { type GatewayCallFor } from "./attribution.js";
+export interface EmitOptions {
+    /** The Worker env: the EVERY_APP_GATEWAY binding when deployed; EVERYAPP_DEV in local dev. */
+    env: object;
+    /**
+     * Whom the event is about: the inbound request (its user becomes the
+     * event's actor), or `{ background: true, organizationId }` for work no
+     * person started (a cron, a queue, a provider's webhook). An
+     * organization's own app may omit it for background work; a shared app's
+     * Worker must pass one or the other ({@link AttributionError}).
+     */
+    for?: GatewayCallFor;
+    /**
+     * The app's own name for what happened: lowercase letters, digits and
+     * underscores in dotted segments (`invoice.paid`, `todo.completed`), at
+     * most 64 characters. The gateway delivers it as `app.<app id>.<event>`.
+     */
+    event: string;
+    /**
+     * What a subscriber needs to act on it: a JSON object, at most 8 KiB
+     * serialized, nested at most 8 levels. Ids, names, amounts and states;
+     * never a credential. A key named like one at any depth (`token`,
+     * `secret`, `password`, `apiKey`, `session`, `cookie`, ...) is refused.
+     */
+    data: Record<string, unknown>;
+}
+/**
+ * Put an event on the gateway's event bus, for the organization's webhook
+ * and email subscribers. The gateway names it `app.<app id>.<event>`, so an
+ * app can never emit one of the gateway's own types (`member.joined`);
+ * owners and admins choose `app.<app id>.*` (or one name) in Manage
+ * workspace, Events, or with `everyapp events add`. Nothing is declared in
+ * the manifest. Delivery happens after the call returns: a subscriber that
+ * is down doesn't slow or fail the app.
+ *
+ * `data` goes, as written, to every URL a subscriber chose (Slack, Zapier,
+ * an agent): put in it what a person or a workflow reads, never a
+ * credential, a session or a person's private content they didn't expect
+ * to leave the app. The gateway refuses a key named like a credential.
+ *
+ * Throws {@link GatewayRefusalError} when the gateway won't take it
+ * (`event_name_invalid`, `event_data_invalid`, `event_data_refused`,
+ * `event_data_too_large`, `event_rate_limited` past 600 an hour, ...), with
+ * the code and a message to show. An emit that must never fail the work
+ * around it goes under `ctx.waitUntil()` or a `.catch()`.
+ *
+ * In local dev (`everyapp dev`, no binding) the event is checked the way
+ * the gateway checks it, printed, and answered `{ id: "dev-…", type }`;
+ * nothing is delivered.
+ */
+export declare function emit({ env, for: target, event, data, }: EmitOptions): Promise<EmitEventResult>;
+//# sourceMappingURL=emit.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"emit.d.ts","sourceRoot":"","sources":["../../src/server/emit.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,OAAO,EASL,KAAK,eAAe,EACrB,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EAGL,KAAK,cAAc,EACpB,MAAM,kBAAkB,CAAC;AAI1B,MAAM,WAAW,WAAW;IAC1B,8FAA8F;IAC9F,GAAG,EAAE,MAAM,CAAC;IACZ;;;;;;OAMG;IACH,GAAG,CAAC,EAAE,cAAc,CAAC;IACrB;;;;OAIG;IACH,KAAK,EAAE,MAAM,CAAC;IACd;;;;;OAKG;IACH,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAC/B;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAsB,IAAI,CAAC,EACzB,GAAG,EACH,GAAG,EAAE,MAAM,EACX,KAAK,EACL,IAAI,GACL,EAAE,WAAW,GAAG,OAAO,CAAC,eAAe,CAAC,CAoBxC"}

package/dist/server/emit.js

@@ -0,0 +1,101 @@
+/**
+ * `emit()`: an app's own event onto the gateway's event bus
+ * (docs/design/2026-10-events-out.md, section 7). It is shaped like
+ * `sendEmail()` on purpose: the same `{ env, for }` attribution, the same
+ * route over the EVERY_APP_GATEWAY binding, the same refusals thrown as
+ * `GatewayRefusalError`, and the same local-dev twin that checks what the
+ * gateway would check and prints instead of sending. The name and data
+ * rules live in `internal/events.ts`, which the gateway reads too, so the
+ * two can't drift.
+ */
+import { APP_EVENT_DATA_MAX_BYTES, APP_ID_ENV, ConfigurationError, EVENTS_EMIT_PATH, appEventNameProblem, appEventType, checkEventData, } from "../internal/index.js";
+import { applyAttribution, checkAttribution, } from "./attribution.js";
+import { BINDING_ORIGIN } from "./gatewayFetch.js";
+import { GatewayRefusalError, gatewayRefusal } from "./integrationFetch.js";
+/**
+ * Put an event on the gateway's event bus, for the organization's webhook
+ * and email subscribers. The gateway names it `app.<app id>.<event>`, so an
+ * app can never emit one of the gateway's own types (`member.joined`);
+ * owners and admins choose `app.<app id>.*` (or one name) in Manage
+ * workspace, Events, or with `everyapp events add`. Nothing is declared in
+ * the manifest. Delivery happens after the call returns: a subscriber that
+ * is down doesn't slow or fail the app.
+ *
+ * `data` goes, as written, to every URL a subscriber chose (Slack, Zapier,
+ * an agent): put in it what a person or a workflow reads, never a
+ * credential, a session or a person's private content they didn't expect
+ * to leave the app. The gateway refuses a key named like a credential.
+ *
+ * Throws {@link GatewayRefusalError} when the gateway won't take it
+ * (`event_name_invalid`, `event_data_invalid`, `event_data_refused`,
+ * `event_data_too_large`, `event_rate_limited` past 600 an hour, ...), with
+ * the code and a message to show. An emit that must never fail the work
+ * around it goes under `ctx.waitUntil()` or a `.catch()`.
+ *
+ * In local dev (`everyapp dev`, no binding) the event is checked the way
+ * the gateway checks it, printed, and answered `{ id: "dev-…", type }`;
+ * nothing is delivered.
+ */
+export async function emit({ env, for: target, event, data, }) {
+    checkAttribution(env, target, "emit");
+    const values = env;
+    const binding = values["EVERY_APP_GATEWAY"];
+    if (binding) {
+        if (typeof binding.fetch !== "function") {
+            throw new ConfigurationError("EVERY_APP_GATEWAY is configured but is not a valid service binding.");
+        }
+        return emitThroughGateway(binding, target, { event, data });
+    }
+    if (!values["EVERYAPP_DEV"]) {
+        throw new ConfigurationError("Events are unavailable: deploy with the EVERY_APP_GATEWAY binding (everyapp deploy), or run under everyapp dev.");
+    }
+    return emitInDev(values, { event, data });
+}
+async function emitThroughGateway(binding, target, body) {
+    const headers = new Headers({ "content-type": "application/json" });
+    applyAttribution(headers, target);
+    const response = await binding.fetch(new Request(`${BINDING_ORIGIN}${EVENTS_EMIT_PATH}`, {
+        method: "POST",
+        headers,
+        body: JSON.stringify(body),
+    }));
+    const refusal = await gatewayRefusal(response);
+    if (refusal)
+        throw new GatewayRefusalError(refusal);
+    if (!response.ok) {
+        throw new GatewayRefusalError({
+            status: response.status,
+            code: "event_emit_failed",
+            message: `The Every App gateway answered ${response.status} to the event.`,
+        });
+    }
+    return (await response.json());
+}
+/**
+ * What the gateway would do, with no gateway: the same name and data
+ * rules, then one line on the console. The data isn't printed: it may hold
+ * a person's content, and the line is for "it fired", not for its payload.
+ */
+function emitInDev(values, { event, data }) {
+    const nameProblem = appEventNameProblem(event);
+    if (nameProblem) {
+        throw new GatewayRefusalError({
+            status: 400,
+            code: "event_name_invalid",
+            message: nameProblem,
+        });
+    }
+    const checked = checkEventData(data, APP_EVENT_DATA_MAX_BYTES);
+    if (!checked.ok) {
+        throw new GatewayRefusalError({
+            status: checked.code === "event_data_too_large" ? 413 : 400,
+            code: checked.code,
+            message: checked.message,
+        });
+    }
+    const appId = values[APP_ID_ENV];
+    // The gateway prefixes the manifest id; a dev env without it still shows the shape.
+    const type = appEventType(typeof appId === "string" && appId.trim() ? appId.trim() : "app", event);
+    console.info(`[everyapp dev] event ${type} (not delivered: no Gateway)`);
+    return { id: `dev-${crypto.randomUUID()}`, type };
+}

package/dist/server/everyApp.d.ts

@@ -1,20 +1,31 @@
 /**
  * `everyApp()` — the app-side identity boundary.
  *
- *   import manifest from "../everyapp.config.js";
- *   export default everyApp(handler, manifest);
+ *   export default everyApp(handler, { tools });
  *
  * The wrapper verifies the gateway-injected identity before app code runs,
  * stores the result on the original Request, and then delegates to the
- * worker-style handler.
+ * worker-style handler. The expected audience is the Worker's own name in
+ * `env.EVERYAPP_AUDIENCE`, which `everyAppWorker()` sets at deploy (the
+ * gateway stamps every token it mints for the app with it); only in
+ * development, where `everyapp dev` mints for the app id, does the app id in
+ * `env.EVERYAPP_APP_ID` stand in. The Worker never imports
+ * `everyapp.config.ts` (the Cloudflare Vite plugin hides every file
+ * `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.
  */
 import { ConfigurationError, IdentityError, type EveryAppUser, type IdentityResult } from "../internal/index.js";
+import type { ToolSet } from "./tools.js";
 export { ConfigurationError, IdentityError };
 export type { EveryAppUser, IdentityResult };
-export interface ExecutionContextLike {
-    waitUntil(promise: Promise<unknown>): void;
-    passThroughOnException?(): void;
-}
+/**
+ * The runtime's `ExecutionContext`, which `everyApp()` passes to the handler
+ * as the Worker received it, so it goes on to Hono's `app.fetch(request,
+ * env, ctx)` or React Router's request handler as is. Tests that call
+ * `fetch` themselves pass a stub cast to it.
+ */
+export type ExecutionContextLike = ExecutionContext;
 export interface EveryAppManifestLike {
     id: string;
     [key: string]: unknown;
@@ -31,13 +42,21 @@ export interface EveryAppOptions {
      * Never enable this in production.
      */
     allowDevIdentities?: boolean;
+    /**
+     * Agent tools from `defineTools()`. The gateway snapshots them at deploy
+     * and serves them to MCP clients; see `defineTools`.
+     */
+    tools?: ToolSet;
     /** Override for tests. */
     now?: number;
 }
-/** The handler accepted by everyApp, with the verified user as a 4th argument. */
-export type EveryAppHandler<TEnv = Record<string, unknown>> = (request: Request, env: TEnv, ctx: ExecutionContextLike, user: EveryAppUser | null) => Response | Promise<Response>;
-interface EveryAppExport<TEnv> {
-    fetch(request: Request, env: TEnv, ctx: ExecutionContextLike): Promise<Response>;
+/**
+ * The handler accepted by everyApp, with the verified user as a 4th argument.
+ * `TCtx` narrows the context, e.g. to `ExecutionContext<Props>`.
+ */
+export type EveryAppHandler<TEnv = Record<string, unknown>, TCtx extends ExecutionContextLike = ExecutionContext> = (request: Request, env: TEnv, ctx: TCtx, user: EveryAppUser | null) => Response | Promise<Response>;
+interface EveryAppExport<TEnv, TCtx extends ExecutionContextLike> {
+    fetch(request: Request, env: TEnv, ctx: TCtx): Promise<Response>;
 }
 /**
  * Return the verified Every App user for this request, or null for a declared
@@ -51,5 +70,12 @@ export declare function getEveryAppUser(request: Request, env: object): Promise<
  */
 export declare function requireEveryAppUser(request: Request, env: object): Promise<EveryAppUser>;
 export declare function hasScope(user: EveryAppUser, scope: string): boolean;
-export declare function everyApp<TEnv = Record<string, unknown>>(handler: EveryAppHandler<TEnv>, manifest: EveryAppManifestLike, options?: EveryAppOptions): EveryAppExport<TEnv>;
+/** Wrap a Worker fetch handler with Every App identity verification. */
+export declare function everyApp<TEnv = Record<string, unknown>, TCtx extends ExecutionContextLike = ExecutionContext>(handler: EveryAppHandler<TEnv, TCtx>, options?: EveryAppOptions): EveryAppExport<TEnv, TCtx>;
+/**
+ * @deprecated Drop the manifest: the app id now comes from
+ *   `env.EVERYAPP_APP_ID` and the audience from `env.EVERYAPP_AUDIENCE`.
+ *   When passed, it must match the app id.
+ */
+export declare function everyApp<TEnv = Record<string, unknown>, TCtx extends ExecutionContextLike = ExecutionContext>(handler: EveryAppHandler<TEnv, TCtx>, manifest: EveryAppManifestLike | undefined, options?: EveryAppOptions): EveryAppExport<TEnv, TCtx>;
 //# sourceMappingURL=everyApp.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"everyApp.d.ts","sourceRoot":"","sources":["../../src/server/everyApp.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,OAAO,EAEL,kBAAkB,EAElB,aAAa,EAIb,KAAK,YAAY,EACjB,KAAK,cAAc,EACpB,MAAM,sBAAsB,CAAC;AAE9B,OAAO,EAAE,kBAAkB,EAAE,aAAa,EAAE,CAAC;AAC7C,YAAY,EAAE,YAAY,EAAE,cAAc,EAAE,CAAC;AAE7C,MAAM,WAAW,oBAAoB;IACnC,SAAS,CAAC,OAAO,EAAE,OAAO,CAAC,OAAO,CAAC,GAAG,IAAI,CAAC;IAC3C,sBAAsB,CAAC,IAAI,IAAI,CAAC;CACjC;AAED,MAAM,WAAW,oBAAoB;IACnC,EAAE,EAAE,MAAM,CAAC;IACX,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CACxB;AAED,MAAM,WAAW,eAAe;IAC9B,iGAAiG;IACjG,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,qFAAqF;IACrF,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,6DAA6D;IAC7D,UAAU,CAAC,EAAE,MAAM,EAAE,CAAC;IACtB;;;OAGG;IACH,kBAAkB,CAAC,EAAE,OAAO,CAAC;IAC7B,0BAA0B;IAC1B,GAAG,CAAC,EAAE,MAAM,CAAC;CACd;AAED,kFAAkF;AAClF,MAAM,MAAM,eAAe,CAAC,IAAI,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,IAAI,CAC5D,OAAO,EAAE,OAAO,EAChB,GAAG,EAAE,IAAI,EACT,GAAG,EAAE,oBAAoB,EACzB,IAAI,EAAE,YAAY,GAAG,IAAI,KACtB,QAAQ,GAAG,OAAO,CAAC,QAAQ,CAAC,CAAC;AAElC,UAAU,cAAc,CAAC,IAAI;IAC3B,KAAK,CACH,OAAO,EAAE,OAAO,EAChB,GAAG,EAAE,IAAI,EACT,GAAG,EAAE,oBAAoB,GACxB,OAAO,CAAC,QAAQ,CAAC,CAAC;CACtB;AAiFD;;;;GAIG;AACH,wBAAsB,eAAe,CACnC,OAAO,EAAE,OAAO,EAChB,GAAG,EAAE,MAAM,GACV,OAAO,CAAC,YAAY,GAAG,IAAI,CAAC,CAW9B;AAED;;;GAGG;AACH,wBAAsB,mBAAmB,CACvC,OAAO,EAAE,OAAO,EAChB,GAAG,EAAE,MAAM,GACV,OAAO,CAAC,YAAY,CAAC,CAevB;AAED,wBAAgB,QAAQ,CAAC,IAAI,EAAE,YAAY,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAEnE;AAED,wBAAgB,QAAQ,CAAC,IAAI,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACrD,OAAO,EAAE,eAAe,CAAC,IAAI,CAAC,EAC9B,QAAQ,EAAE,oBAAoB,EAC9B,OAAO,GAAE,eAAoB,GAC5B,cAAc,CAAC,IAAI,CAAC,CAqBtB"}
+{"version":3,"file":"everyApp.d.ts","sourceRoot":"","sources":["../../src/server/everyApp.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AACH,OAAO,EAGL,kBAAkB,EAElB,aAAa,EAIb,KAAK,YAAY,EACjB,KAAK,cAAc,EAEpB,MAAM,sBAAsB,CAAC;AAC9B,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC;AAG1C,OAAO,EAAE,kBAAkB,EAAE,aAAa,EAAE,CAAC;AAC7C,YAAY,EAAE,YAAY,EAAE,cAAc,EAAE,CAAC;AAE7C;;;;;GAKG;AACH,MAAM,MAAM,oBAAoB,GAAG,gBAAgB,CAAC;AAEpD,MAAM,WAAW,oBAAoB;IACnC,EAAE,EAAE,MAAM,CAAC;IACX,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CACxB;AAED,MAAM,WAAW,eAAe;IAC9B,iGAAiG;IACjG,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,qFAAqF;IACrF,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,6DAA6D;IAC7D,UAAU,CAAC,EAAE,MAAM,EAAE,CAAC;IACtB;;;OAGG;IACH,kBAAkB,CAAC,EAAE,OAAO,CAAC;IAC7B;;;OAGG;IACH,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,0BAA0B;IAC1B,GAAG,CAAC,EAAE,MAAM,CAAC;CACd;AAED;;;GAGG;AACH,MAAM,MAAM,eAAe,CACzB,IAAI,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC9B,IAAI,SAAS,oBAAoB,GAAG,gBAAgB,IAClD,CACF,OAAO,EAAE,OAAO,EAChB,GAAG,EAAE,IAAI,EACT,GAAG,EAAE,IAAI,EACT,IAAI,EAAE,YAAY,GAAG,IAAI,KACtB,QAAQ,GAAG,OAAO,CAAC,QAAQ,CAAC,CAAC;AAElC,UAAU,cAAc,CAAC,IAAI,EAAE,IAAI,SAAS,oBAAoB;IAC9D,KAAK,CAAC,OAAO,EAAE,OAAO,EAAE,GAAG,EAAE,IAAI,EAAE,GAAG,EAAE,IAAI,GAAG,OAAO,CAAC,QAAQ,CAAC,CAAC;CAClE;AAoHD;;;;GAIG;AACH,wBAAsB,eAAe,CACnC,OAAO,EAAE,OAAO,EAChB,GAAG,EAAE,MAAM,GACV,OAAO,CAAC,YAAY,GAAG,IAAI,CAAC,CAS9B;AAED;;;GAGG;AACH,wBAAsB,mBAAmB,CACvC,OAAO,EAAE,OAAO,EAChB,GAAG,EAAE,MAAM,GACV,OAAO,CAAC,YAAY,CAAC,CAevB;AAED,wBAAgB,QAAQ,CAAC,IAAI,EAAE,YAAY,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAEnE;AAUD,wEAAwE;AACxE,wBAAgB,QAAQ,CACtB,IAAI,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC9B,IAAI,SAAS,oBAAoB,GAAG,gBAAgB,EAEpD,OAAO,EAAE,eAAe,CAAC,IAAI,EAAE,IAAI,CAAC,EACpC,OAAO,CAAC,EAAE,eAAe,GACxB,cAAc,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC;AAC9B;;;;GAIG;AACH,wBAAgB,QAAQ,CACtB,IAAI,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC9B,IAAI,SAAS,oBAAoB,GAAG,gBAAgB,EAEpD,OAAO,EAAE,eAAe,CAAC,IAAI,EAAE,IAAI,CAAC,EACpC,QAAQ,EAAE,oBAAoB,GAAG,SAAS,EAC1C,OAAO,CAAC,EAAE,eAAe,GACxB,cAAc,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC"}

package/dist/server/everyApp.js

@@ -1,14 +1,22 @@
 /**
  * `everyApp()` — the app-side identity boundary.
  *
- *   import manifest from "../everyapp.config.js";
- *   export default everyApp(handler, manifest);
+ *   export default everyApp(handler, { tools });
  *
  * The wrapper verifies the gateway-injected identity before app code runs,
  * stores the result on the original Request, and then delegates to the
- * worker-style handler.
+ * worker-style handler. The expected audience is the Worker's own name in
+ * `env.EVERYAPP_AUDIENCE`, which `everyAppWorker()` sets at deploy (the
+ * gateway stamps every token it mints for the app with it); only in
+ * development, where `everyapp dev` mints for the app id, does the app id in
+ * `env.EVERYAPP_APP_ID` stand in. The Worker never imports
+ * `everyapp.config.ts` (the Cloudflare Vite plugin hides every file
+ * `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.
  */
-import { APP_ID_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, ISSUER_ENV, PUBLIC_KEYS_ENV, getIdentityFromRequest, } from "../internal/index.js";
+import { handleToolsRequest } from "./toolsEndpoint.js";
 export { ConfigurationError, IdentityError };
 const requestIdentities = new WeakMap();
 function envValue(env, key) {
@@ -19,7 +27,7 @@ function envValue(env, key) {
 }
 function configFrom(manifest, options = {}) {
     return {
-        audience: manifest.id,
+        manifestAppId: manifest?.id,
         issuer: options.issuer,
         keysEnvVar: options.keysEnvVar ?? PUBLIC_KEYS_ENV,
         publicKeys: options.publicKeys,
@@ -27,41 +35,62 @@ function configFrom(manifest, options = {}) {
         now: options.now,
     };
 }
+/**
+ * The app id: EVERYAPP_APP_ID, or a manifest passed to everyApp() for
+ * Workers without it; the two must agree when both are present.
+ */
+function appIdFor(env, config) {
+    const fromEnv = envValue(env, APP_ID_ENV);
+    if (fromEnv && config.manifestAppId && fromEnv !== config.manifestAppId) {
+        throw new ConfigurationError(`${APP_ID_ENV} ("${fromEnv}") does not match the manifest id ("${config.manifestAppId}").`);
+    }
+    return fromEnv ?? config.manifestAppId;
+}
+function devIdentitiesAllowed(env, config) {
+    const devEnv = envValue(env, DEV_ENV);
+    return (config.allowDevIdentities ??
+        (devEnv !== undefined &&
+            (devEnv === "1" || devEnv.toLowerCase() === "true")));
+}
+/**
+ * The audience identity tokens must carry: this Worker's name, from
+ * EVERYAPP_AUDIENCE. The gateway mints for the Worker, not the app id, so a
+ * token for one organization's copy of an app never opens another's. Only
+ * under the dev opt-in, where `everyapp dev` mints for the app id, does the
+ * app id stand in when EVERYAPP_AUDIENCE is unset.
+ */
+function audienceFor(env, config) {
+    const appId = appIdFor(env, config);
+    const audience = envValue(env, AUDIENCE_ENV);
+    if (audience)
+        return audience;
+    if (appId && devIdentitiesAllowed(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).`);
+}
 function unauthorized(message) {
     return Response.json({ error: "unauthenticated", message }, { status: 401 });
 }
 function misconfigured(message) {
     return Response.json({ error: "misconfigured", message }, { status: 500 });
 }
-async function resolveIdentity(request, env, config) {
-    const devEnv = env && typeof env === "object"
-        ? env[DEV_ENV]
-        : undefined;
-    return getIdentityFromRequest(request, {
-        audience: config.audience,
+function identityOptions(env, config, audience) {
+    return {
+        audience,
         issuer: config.issuer ?? envValue(env, ISSUER_ENV),
         publicKeys: config.publicKeys,
         env: env,
         keysEnvVar: config.keysEnvVar,
-        allowDevIdentities: config.allowDevIdentities ??
-            (typeof devEnv === "string" &&
-                (devEnv === "1" || devEnv.toLowerCase() === "true")),
+        allowDevIdentities: devIdentitiesAllowed(env, config),
         now: config.now,
-    });
+    };
+}
+async function resolveIdentity(request, env, config) {
+    return getIdentityFromRequest(request, identityOptions(env, config, audienceFor(env, config)));
 }
 function rememberIdentity(request, identity) {
     requestIdentities.set(request, identity);
 }
-function helperConfigFromEnv(env) {
-    const audience = envValue(env, APP_ID_ENV);
-    if (!audience) {
-        throw new ConfigurationError(`${APP_ID_ENV} is not set — the CLI must inject the app id for identity verification.`);
-    }
-    return {
-        audience,
-        keysEnvVar: PUBLIC_KEYS_ENV,
-    };
-}
 /**
  * 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
@@ -71,7 +100,9 @@ export async function getEveryAppUser(request, env) {
     const cached = requestIdentities.get(request);
     if (cached)
         return cached.user;
-    const identity = await resolveIdentity(request, env, helperConfigFromEnv(env));
+    const identity = await resolveIdentity(request, env, {
+        keysEnvVar: PUBLIC_KEYS_ENV,
+    });
     rememberIdentity(request, identity);
     return identity.user;
 }
@@ -97,13 +128,46 @@ export async function requireEveryAppUser(request, env) {
 export function hasScope(user, scope) {
     return user.scopes.includes("*") || user.scopes.includes(scope);
 }
-export function everyApp(handler, manifest, options = {}) {
+function isManifest(value) {
+    return (typeof value === "object" &&
+        value !== null &&
+        typeof value.id === "string");
+}
+export function everyApp(handler, manifestOrOptions, legacyOptions = {}) {
+    const manifest = isManifest(manifestOrOptions)
+        ? manifestOrOptions
+        : undefined;
+    const options = manifest || manifestOrOptions === undefined
+        ? legacyOptions
+        : manifestOrOptions;
     const config = configFrom(manifest, options);
     return {
         async fetch(request, env, ctx) {
+            let audience;
+            let appId;
+            try {
+                audience = audienceFor(env, config);
+                appId = appIdFor(env, config) ?? audience;
+            }
+            catch (err) {
+                if (err instanceof ConfigurationError) {
+                    console.error(err);
+                    return misconfigured(err.message);
+                }
+                throw err;
+            }
+            // The reserved tools contract carries its own gateway-minted tokens and
+            // never reaches the app's handler.
+            const toolsResponse = await handleToolsRequest(request, env, ctx, {
+                toolSet: options.tools,
+                appId,
+                identity: identityOptions(env, config, audience),
+            });
+            if (toolsResponse)
+                return toolsResponse;
             let identity;
             try {
-                identity = await resolveIdentity(request, env, config);
+                identity = await getIdentityFromRequest(request, identityOptions(env, config, audience));
                 rememberIdentity(request, identity);
             }
             catch (err) {

package/dist/server/gatewayFetch.d.ts

@@ -1,21 +1,37 @@
-interface GatewayServiceBinding {
+import { type GatewayCallFor } from "./attribution.js";
+export declare const BINDING_ORIGIN = "http://every-app-gateway.internal";
+export interface GatewayServiceBinding {
     fetch(input: RequestInfo | URL, init?: RequestInit): Promise<Response>;
 }
 export interface GatewayFetchEnv {
     EVERY_APP_GATEWAY?: GatewayServiceBinding;
     EVERYAPP_DEV?: string | boolean;
+    /** `1` on a shared app's Workers (`everyAppWorker()` sets it). */
+    EVERYAPP_SHARED?: string;
     OPENAI_API_KEY?: string;
+    OPENROUTER_API_KEY?: string;
+    /** Workers AI: an API token (Workers AI Read and Edit) and the account it bills. */
+    WORKERS_AI_API_TOKEN?: string;
+    CLOUDFLARE_ACCOUNT_ID?: string;
 }
 export interface CreateGatewayFetchOptions {
     env: GatewayFetchEnv;
-    /** The inbound app request whose verified identity may be forwarded. */
-    request: Request;
+    /**
+     * 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}).
+     */
+    for?: GatewayCallFor;
 }
 /**
- * Create an OpenAI-compatible fetch function backed by the private gateway
- * service binding. In local dev only, the developer's own OPENAI_API_KEY is a
- * direct-provider fallback when no binding exists.
+ * Create a fetch for the gateway's AI providers (`/api/ai/<provider>/…`),
+ * backed by the private gateway service binding. In local dev only, the
+ * developer's own provider key from `.dev.vars` is a direct-provider
+ * fallback when no binding exists.
  */
-export declare function createGatewayFetch({ env, request: inboundRequest, }: CreateGatewayFetchOptions): typeof fetch;
-export {};
+export declare function createGatewayFetch({ env, for: target, }: 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":"AAMA,UAAU,qBAAqB;IAC7B,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,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB;AAED,MAAM,WAAW,yBAAyB;IACxC,GAAG,EAAE,eAAe,CAAC;IACrB,wEAAwE;IACxE,OAAO,EAAE,OAAO,CAAC;CAClB;AAED;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,EACjC,GAAG,EACH,OAAO,EAAE,cAAc,GACxB,EAAE,yBAAyB,GAAG,OAAO,KAAK,CAyC1C"}
+{"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"}