managed-deepagents 0.5.0-dev.90 → 0.5.0-dev.97

package/dist/memory/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/memory/types.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG"}

package/dist/namespaces.d.ts

@@ -6,9 +6,9 @@
  * and providers can be added without growing the barrel:
  *
  * ```ts
- * channels.slack({ on: ["app_mention"] });
+ * channels.slack();
  * connectors.slack({ includeTools: ["slack_list_channels"] });
- * sandboxes.langsmith({ defaultTimeout: 600 });
+ * defineSandbox({ defaultTimeout: 600 });
  * auth.supabase({ projectRef: "abc" });
  * credentials.github({ read: ["user"] });
  * connect.github();
@@ -21,7 +21,6 @@
  * These are the only primitives the managed runtime will mount. A project
  * cannot contribute its own — `defineExtension` stays internal.
  */
-import { LangSmithSandbox } from "deepagents";
 import { type MarketplaceConnectors } from "./connectors/marketplace/index.js";
 import { mcpConnector } from "./connectors/mcp/index.js";
 import { slackChannel } from "./channels/slack/index.js";
@@ -35,12 +34,7 @@ import { connect as linkedinConnect } from "./identity/linkedin/connect-http.js"
 import { connect as microsoftConnect } from "./identity/microsoft/connect-http.js";
 import { connect as slackConnect } from "./identity/slack/connect-http.js";
 import { connect as xConnect } from "./identity/x/connect-http.js";
-import { type LangSmithSandboxOptions, type SandboxDefinition } from "./sandbox.js";
 export { auth } from "./identity/index.js";
-/** Execution environments the agent's shell runs in. Exported from `sandbox/`. */
-export declare const sandboxes: {
-    langsmith(options?: LangSmithSandboxOptions): SandboxDefinition<typeof LangSmithSandbox>;
-};
 /**
  * Integrations: tools, HTTP routes, sandbox provisioning, inbound events, and
  * named messaging. Exported from `connectors/*`.
@@ -115,7 +109,7 @@ export interface Channels {
      *
      * @example
      * ```ts
-     * export const channel = channels.slack({ on: ["app_mention"] });
+     * export const channel = channels.slack();
      * ```
      *
      * @see {@link slackChannel}

package/dist/namespaces.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"namespaces.d.ts","sourceRoot":"","sources":["../src/namespaces.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH,OAAO,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAE9C,OAAO,EAEL,KAAK,qBAAqB,EAC3B,MAAM,mCAAmC,CAAC;AAC3C,OAAO,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AACzD,OAAO,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AACzD,OAAO,EAAE,cAAc,EAAE,MAAM,6BAA6B,CAAC;AAC7D,OAAO,EAEL,KAAK,oBAAoB,EAC1B,MAAM,kCAAkC,CAAC;AAE1C,OAAO,EAAE,OAAO,IAAI,aAAa,EAAE,MAAM,mCAAmC,CAAC;AAC7E,OAAO,EAAE,WAAW,IAAI,iBAAiB,EAAE,MAAM,kCAAkC,CAAC;AACpF,OAAO,EAAE,OAAO,IAAI,aAAa,EAAE,MAAM,mCAAmC,CAAC;AAC7E,OAAO,EAEL,KAAK,kBAAkB,EACxB,MAAM,iCAAiC,CAAC;AACzC,OAAO,EAAE,OAAO,IAAI,eAAe,EAAE,MAAM,qCAAqC,CAAC;AACjF,OAAO,EAAE,OAAO,IAAI,gBAAgB,EAAE,MAAM,sCAAsC,CAAC;AACnF,OAAO,EAAE,OAAO,IAAI,YAAY,EAAE,MAAM,kCAAkC,CAAC;AAC3E,OAAO,EAAE,OAAO,IAAI,QAAQ,EAAE,MAAM,8BAA8B,CAAC;AACnE,OAAO,EACL,KAAK,uBAAuB,EAC5B,KAAK,iBAAiB,EACvB,MAAM,cAAc,CAAC;AAEtB,OAAO,EAAE,IAAI,EAAE,MAAM,qBAAqB,CAAC;AAW3C,kFAAkF;AAClF,eAAO,MAAM,SAAS;IACpB,SAAS,WACG,uBAAuB,GAChC,iBAAiB,CAAC,OAAO,gBAAgB,CAAC;CAG9C,CAAC;AAEF;;;;;;;;;;;;;;;GAeG;AACH,MAAM,WAAW,UACf,SAAQ,oBAAoB,EAAE,qBAAqB;IACnD;;;;;;;;;;;;;;OAcG;IACH,GAAG,EAAE,OAAO,YAAY,CAAC;IAEzB;;;;;;;;;;;;;;OAcG;IACH,KAAK,EAAE,OAAO,cAAc,CAAC;CAC9B;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,UAAU,EAAE,UAKxB,CAAC;AAEF;;;;;GAKG;AACH,MAAM,WAAW,QAAQ;IACvB;;;;;;;;;;;;OAYG;IACH,KAAK,EAAE,OAAO,YAAY,CAAC;CAC5B;AAED;;;GAGG;AACH,eAAO,MAAM,QAAQ,EAAE,QAEtB,CAAC;AAEF,oFAAoF;AACpF,eAAO,MAAM,WAAW;IACtB,MAAM;CACP,CAAC;AAEF;;;;GAIG;AACH,MAAM,WAAW,OAAQ,SAAQ,kBAAkB;IACjD;;;;;;;;;;;;;;;;;OAiBG;IACH,MAAM,EAAE,OAAO,aAAa,CAAC;IAE7B;;;;;;;;;;;;;;OAcG;IACH,MAAM,EAAE,OAAO,aAAa,CAAC;IAE7B;;;;;;;;;;;;;OAaG;IACH,SAAS,EAAE,OAAO,gBAAgB,CAAC;IAEnC;;;;;;;;;;;;;OAaG;IACH,QAAQ,EAAE,OAAO,eAAe,CAAC;IAEjC;;;;;;;;;;;;;OAaG;IACH,CAAC,EAAE,OAAO,QAAQ,CAAC;IAEnB;;;;;;;;;;;;;;;OAeG;IACH,KAAK,EAAE,OAAO,YAAY,CAAC;CAC5B;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,eAAO,MAAM,OAAO,EAAE,OAQrB,CAAC"}
+{"version":3,"file":"namespaces.d.ts","sourceRoot":"","sources":["../src/namespaces.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH,OAAO,EAEL,KAAK,qBAAqB,EAC3B,MAAM,mCAAmC,CAAC;AAC3C,OAAO,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AACzD,OAAO,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AACzD,OAAO,EAAE,cAAc,EAAE,MAAM,6BAA6B,CAAC;AAC7D,OAAO,EAEL,KAAK,oBAAoB,EAC1B,MAAM,kCAAkC,CAAC;AAC1C,OAAO,EAAE,OAAO,IAAI,aAAa,EAAE,MAAM,mCAAmC,CAAC;AAC7E,OAAO,EAAE,WAAW,IAAI,iBAAiB,EAAE,MAAM,kCAAkC,CAAC;AACpF,OAAO,EAAE,OAAO,IAAI,aAAa,EAAE,MAAM,mCAAmC,CAAC;AAC7E,OAAO,EAEL,KAAK,kBAAkB,EACxB,MAAM,iCAAiC,CAAC;AACzC,OAAO,EAAE,OAAO,IAAI,eAAe,EAAE,MAAM,qCAAqC,CAAC;AACjF,OAAO,EAAE,OAAO,IAAI,gBAAgB,EAAE,MAAM,sCAAsC,CAAC;AACnF,OAAO,EAAE,OAAO,IAAI,YAAY,EAAE,MAAM,kCAAkC,CAAC;AAC3E,OAAO,EAAE,OAAO,IAAI,QAAQ,EAAE,MAAM,8BAA8B,CAAC;AAEnE,OAAO,EAAE,IAAI,EAAE,MAAM,qBAAqB,CAAC;AAE3C;;;;;;;;;;;;;;;GAeG;AACH,MAAM,WAAW,UACf,SAAQ,oBAAoB,EAAE,qBAAqB;IACnD;;;;;;;;;;;;;;OAcG;IACH,GAAG,EAAE,OAAO,YAAY,CAAC;IAEzB;;;;;;;;;;;;;;OAcG;IACH,KAAK,EAAE,OAAO,cAAc,CAAC;CAC9B;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,UAAU,EAAE,UAKxB,CAAC;AAEF;;;;;GAKG;AACH,MAAM,WAAW,QAAQ;IACvB;;;;;;;;;;;;OAYG;IACH,KAAK,EAAE,OAAO,YAAY,CAAC;CAC5B;AAED;;;GAGG;AACH,eAAO,MAAM,QAAQ,EAAE,QAEtB,CAAC;AAEF,oFAAoF;AACpF,eAAO,MAAM,WAAW;IACtB,MAAM;CACP,CAAC;AAEF;;;;GAIG;AACH,MAAM,WAAW,OAAQ,SAAQ,kBAAkB;IACjD;;;;;;;;;;;;;;;;;OAiBG;IACH,MAAM,EAAE,OAAO,aAAa,CAAC;IAE7B;;;;;;;;;;;;;;OAcG;IACH,MAAM,EAAE,OAAO,aAAa,CAAC;IAE7B;;;;;;;;;;;;;OAaG;IACH,SAAS,EAAE,OAAO,gBAAgB,CAAC;IAEnC;;;;;;;;;;;;;OAaG;IACH,QAAQ,EAAE,OAAO,eAAe,CAAC;IAEjC;;;;;;;;;;;;;OAaG;IACH,CAAC,EAAE,OAAO,QAAQ,CAAC;IAEnB;;;;;;;;;;;;;;;OAeG;IACH,KAAK,EAAE,OAAO,YAAY,CAAC;CAC5B;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,eAAO,MAAM,OAAO,EAAE,OAQrB,CAAC"}

package/dist/namespaces.js

@@ -6,9 +6,9 @@
  * and providers can be added without growing the barrel:
  *
  * ```ts
- * channels.slack({ on: ["app_mention"] });
+ * channels.slack();
  * connectors.slack({ includeTools: ["slack_list_channels"] });
- * sandboxes.langsmith({ defaultTimeout: 600 });
+ * defineSandbox({ defaultTimeout: 600 });
  * auth.supabase({ projectRef: "abc" });
  * credentials.github({ read: ["user"] });
  * connect.github();
@@ -21,13 +21,11 @@
  * These are the only primitives the managed runtime will mount. A project
  * cannot contribute its own — `defineExtension` stays internal.
  */
-import { LangSmithSandbox } from "deepagents";
 import { marketplaceConnectors, } from "./connectors/marketplace/index.js";
 import { mcpConnector } from "./connectors/mcp/index.js";
 import { slackChannel } from "./channels/slack/index.js";
 import { slackConnector } from "./connectors/slack/index.js";
 import { toolServerConnectors, } from "./connectors/toolserver/index.js";
-import { defineExtension } from "./extension.js";
 import { connect as githubConnect } from "./identity/github/connect-http.js";
 import { credentials as githubCredentials } from "./identity/github/credentials.js";
 import { connect as googleConnect } from "./identity/google/connect-http.js";
@@ -36,22 +34,7 @@ import { connect as linkedinConnect } from "./identity/linkedin/connect-http.js"
 import { connect as microsoftConnect } from "./identity/microsoft/connect-http.js";
 import { connect as slackConnect } from "./identity/slack/connect-http.js";
 import { connect as xConnect } from "./identity/x/connect-http.js";
-import {} from "./sandbox.js";
 export { auth } from "./identity/index.js";
-const langsmithSandbox = defineExtension("sandbox", {
-    label: "sandboxes.langsmith",
-    provider: LangSmithSandbox,
-    // Not a schema: a sandbox's options are inferred from the provider class's
-    // own `create(...)` types, so a hand-written one would restate deepagents'
-    // surface and drift from it.
-    args: (options) => options ?? {},
-});
-/** Execution environments the agent's shell runs in. Exported from `sandbox/`. */
-export const sandboxes = {
-    langsmith(options) {
-        return langsmithSandbox(options);
-    },
-};
 /**
  * Integrations: tools, HTTP routes, sandbox provisioning, inbound events, and
  * named messaging. Exported from `connectors/*`.

package/dist/namespaces.js.map

@@ -1 +1 @@
-{"version":3,"file":"namespaces.js","sourceRoot":"","sources":["../src/namespaces.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH,OAAO,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAE9C,OAAO,EACL,qBAAqB,GAEtB,MAAM,mCAAmC,CAAC;AAC3C,OAAO,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AACzD,OAAO,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AACzD,OAAO,EAAE,cAAc,EAAE,MAAM,6BAA6B,CAAC;AAC7D,OAAO,EACL,oBAAoB,GAErB,MAAM,kCAAkC,CAAC;AAC1C,OAAO,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AACjD,OAAO,EAAE,OAAO,IAAI,aAAa,EAAE,MAAM,mCAAmC,CAAC;AAC7E,OAAO,EAAE,WAAW,IAAI,iBAAiB,EAAE,MAAM,kCAAkC,CAAC;AACpF,OAAO,EAAE,OAAO,IAAI,aAAa,EAAE,MAAM,mCAAmC,CAAC;AAC7E,OAAO,EACL,kBAAkB,GAEnB,MAAM,iCAAiC,CAAC;AACzC,OAAO,EAAE,OAAO,IAAI,eAAe,EAAE,MAAM,qCAAqC,CAAC;AACjF,OAAO,EAAE,OAAO,IAAI,gBAAgB,EAAE,MAAM,sCAAsC,CAAC;AACnF,OAAO,EAAE,OAAO,IAAI,YAAY,EAAE,MAAM,kCAAkC,CAAC;AAC3E,OAAO,EAAE,OAAO,IAAI,QAAQ,EAAE,MAAM,8BAA8B,CAAC;AACnE,OAAO,EAGN,MAAM,cAAc,CAAC;AAEtB,OAAO,EAAE,IAAI,EAAE,MAAM,qBAAqB,CAAC;AAE3C,MAAM,gBAAgB,GAAG,eAAe,CAAC,SAAS,EAAE;IAClD,KAAK,EAAE,qBAAqB;IAC5B,QAAQ,EAAE,gBAAgB;IAC1B,2EAA2E;IAC3E,2EAA2E;IAC3E,6BAA6B;IAC7B,IAAI,EAAE,CAAC,OAAiC,EAAE,EAAE,CAAC,OAAO,IAAI,EAAE;CAC3D,CAAC,CAAC;AAEH,kFAAkF;AAClF,MAAM,CAAC,MAAM,SAAS,GAAG;IACvB,SAAS,CACP,OAAiC;QAEjC,OAAO,gBAAgB,CAAC,OAAO,CAAC,CAAC;IACnC,CAAC;CACF,CAAC;AAuDF;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,UAAU,GAAe;IACpC,GAAG,oBAAoB;IACvB,GAAG,qBAAqB;IACxB,GAAG,EAAE,YAAY;IACjB,KAAK,EAAE,cAAc;CACtB,CAAC;AAyBF;;;GAGG;AACH,MAAM,CAAC,MAAM,QAAQ,GAAa;IAChC,KAAK,EAAE,YAAY;CACpB,CAAC;AAEF,oFAAoF;AACpF,MAAM,CAAC,MAAM,WAAW,GAAG;IACzB,MAAM,EAAE,iBAAiB;CAC1B,CAAC;AAgHF;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,MAAM,CAAC,MAAM,OAAO,GAAY;IAC9B,GAAG,kBAAkB;IACrB,MAAM,EAAE,aAAa;IACrB,MAAM,EAAE,aAAa;IACrB,SAAS,EAAE,gBAAgB;IAC3B,QAAQ,EAAE,eAAe;IACzB,CAAC,EAAE,QAAQ;IACX,KAAK,EAAE,YAAY;CACpB,CAAC"}
+{"version":3,"file":"namespaces.js","sourceRoot":"","sources":["../src/namespaces.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH,OAAO,EACL,qBAAqB,GAEtB,MAAM,mCAAmC,CAAC;AAC3C,OAAO,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AACzD,OAAO,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AACzD,OAAO,EAAE,cAAc,EAAE,MAAM,6BAA6B,CAAC;AAC7D,OAAO,EACL,oBAAoB,GAErB,MAAM,kCAAkC,CAAC;AAC1C,OAAO,EAAE,OAAO,IAAI,aAAa,EAAE,MAAM,mCAAmC,CAAC;AAC7E,OAAO,EAAE,WAAW,IAAI,iBAAiB,EAAE,MAAM,kCAAkC,CAAC;AACpF,OAAO,EAAE,OAAO,IAAI,aAAa,EAAE,MAAM,mCAAmC,CAAC;AAC7E,OAAO,EACL,kBAAkB,GAEnB,MAAM,iCAAiC,CAAC;AACzC,OAAO,EAAE,OAAO,IAAI,eAAe,EAAE,MAAM,qCAAqC,CAAC;AACjF,OAAO,EAAE,OAAO,IAAI,gBAAgB,EAAE,MAAM,sCAAsC,CAAC;AACnF,OAAO,EAAE,OAAO,IAAI,YAAY,EAAE,MAAM,kCAAkC,CAAC;AAC3E,OAAO,EAAE,OAAO,IAAI,QAAQ,EAAE,MAAM,8BAA8B,CAAC;AAEnE,OAAO,EAAE,IAAI,EAAE,MAAM,qBAAqB,CAAC;AAuD3C;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,UAAU,GAAe;IACpC,GAAG,oBAAoB;IACvB,GAAG,qBAAqB;IACxB,GAAG,EAAE,YAAY;IACjB,KAAK,EAAE,cAAc;CACtB,CAAC;AAyBF;;;GAGG;AACH,MAAM,CAAC,MAAM,QAAQ,GAAa;IAChC,KAAK,EAAE,YAAY;CACpB,CAAC;AAEF,oFAAoF;AACpF,MAAM,CAAC,MAAM,WAAW,GAAG;IACzB,MAAM,EAAE,iBAAiB;CAC1B,CAAC;AAgHF;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,MAAM,CAAC,MAAM,OAAO,GAAY;IAC9B,GAAG,kBAAkB;IACrB,MAAM,EAAE,aAAa;IACrB,MAAM,EAAE,aAAa;IACrB,SAAS,EAAE,gBAAgB;IAC3B,QAAQ,EAAE,eAAe;IACzB,CAAC,EAAE,QAAQ;IACX,KAAK,EAAE,YAAY;CACpB,CAAC"}

package/dist/runtime/auth.d.ts

@@ -8,18 +8,24 @@ import { type IdentityConfig, type IdentityDefinition, type RuntimeIdentity } fr
  */
 /** Trusted-backend / channel-loopback identity headers (single source of truth). */
 export declare const USER_HEADER = "x-mda-user-id";
-/** Comma- or space-delimited group memberships. */
-export declare const GROUPS_HEADER = "x-mda-groups";
 export declare const INGRESS_SECRET_HEADER = "x-mda-ingress-secret";
 /**
- * Internal channel handoff headers. Accepted only after the ingress secret
- * validates — never part of the public HTTP identity surface, and deliberately
- * not allowlisted into `config.configurable`.
+ * Internal channel handoff headers. Accepted only after a server API key or
+ * legacy ingress secret validates — never part of the public HTTP identity
+ * surface, and deliberately not allowlisted into `config.configurable`.
  */
 export declare const SOURCE_PROVIDER_HEADER = "x-mda-source-provider";
 export declare const SOURCE_THREAD_HEADER = "x-mda-source-thread-id";
 /** Deployment env var carrying the shared secret the trusted backend presents. */
 export declare const INGRESS_SECRET_ENV = "MDA_INGRESS_SECRET";
+/** Deploy/dev-owned credential used only for internal identity handoffs. */
+export declare const HANDOFF_SECRET_ENV = "MDA_HANDOFF_SECRET";
+export declare const HANDOFF_SECRET_HEADER = "x-mda-handoff-secret";
+/** Platform-owned LangSmith auth configuration. */
+export declare const LANGSMITH_AUTH_ENDPOINT_ENV = "LANGSMITH_AUTH_ENDPOINT";
+export declare const LANGSMITH_TENANT_ID_ENV = "LANGSMITH_TENANT_ID";
+export declare const LANGSMITH_API_KEY_HEADER = "x-api-key";
+export declare const LANGSMITH_API_KEY_ENV = "LANGSMITH_API_KEY";
 /**
  * The user object `@auth.authenticate` returns. `identity`/`permissions` satisfy
  * the LangGraph base shape; the `mda_*` fields carry the identity envelope into
@@ -30,7 +36,7 @@ export interface ManagedUser {
     permissions: string[];
     mda_user_id: string;
     mda_user_email?: string;
-    /** Group memberships the ingress asserted; read-only, never an isolation key. */
+    /** Resolved group memberships; read-only, never an isolation key. */
     mda_groups?: string[];
     mda_claims?: Record<string, unknown>;
     /** Trusted source provider stamped by managed ingress (never client-supplied). */
@@ -42,10 +48,8 @@ export interface ManagedUser {
 /**
  * Build the managed LangGraph custom-auth handler from a declared identity.
  *
- * Handles both ingress modes: `trusted_backend` (reserved headers behind a
- * shared ingress secret) and `validated_token` (browser-direct IdP tokens
- * verified via JWKS / introspection / MDA-signed guest). Also registers thread
- * and store scoping with a studio bypass.
+ * Handles trusted-backend, LangSmith API-key, and validated-token ingress.
+ * Also registers thread and store scoping with a studio bypass.
  */
 export declare function buildManagedAuth(identity: IdentityDefinition): Auth;
 /**
@@ -72,11 +76,19 @@ export declare const GITHUB_CREDENTIALS_STORE_PREFIX = "mda_github_credentials";
  */
 export declare const IDENTITY_LINKS_SERVICE_USER = "mda:identity-links";
 /**
- * Fail-closed (403) unless the store `namespace` contains the caller id as a
- * contiguous ordered prefix (typically after the deployment id). No user slice
- * → no per-identity restriction.
+ * Fail-closed (403) on the managed reserved namespaces.
+ *
+ * `mda_identity_links` and `mda_github_credentials` are deployment-wide managed
+ * tables — account links and OAuth tokens for every caller — so only the trusted
+ * identity-links service principal may touch them. This check deliberately does
+ * not consult memory: it used to sit behind a per-caller memory check, which left
+ * the tables open to any authenticated caller on deployments without a user
+ * slice.
+ *
+ * There is no per-caller store partition to enforce beyond that, because no
+ * declaration mounts per-caller state in this release.
  */
-export declare function assertStoreAccess(cfg: IdentityConfig, user: ManagedUser, value: unknown): void;
+export declare function assertStoreAccess(user: ManagedUser, value: unknown): void;
 /** True when `required` appears as a contiguous ordered subsequence of `namespace`. */
 export declare function namespaceHasOrderedSegments(namespace: string[], required: string[]): boolean;
 /**
@@ -93,6 +105,8 @@ export declare function namespaceHasOrderedSegments(namespace: string[], require
  * loopback handoff — ordinary clients without the secret cannot stamp them.
  */
 export declare function resolveTrustedBackendUser(cfg: IdentityConfig, request: Request): ManagedUser;
+/** Verify a LangSmith API key without replacing MDA's authorization hooks. */
+export declare function resolveLangSmithApiKeyUser(request: Request): Promise<ManagedUser>;
 /**
  * Under `mda dev`, synthetic local/Companion service principals are unscoped
  * for thread search + store so authors can see Studio-created Local threads.
@@ -108,14 +122,12 @@ export declare function isLocalDevUnscopedUser(user: unknown): boolean;
 export declare function tryLocalDevTrustedUser(_cfg: IdentityConfig, request: Request): ManagedUser | null;
 /** Derive the owner value `@auth.on.threads` filters on (the caller user id). */
 export declare function threadOwnerKey(user: ManagedUser): string;
-/** True when this deployment exposes guest issuance and the request targets it. */
-export declare function isGuestIssuanceRequest(request: Request, cfg: IdentityConfig): boolean;
 /** True when the request targets a public channel/connector Events ingress route. */
 export declare function isChannelEventsRequest(request: Request): boolean;
 /** True when the request is a public identity-provider OAuth/OIDC callback. */
 export declare function isIdentityProviderCallbackRequest(request: Request): boolean;
-/** Placeholder identity so LangGraph auth middleware allows tokenless issuance. */
-export declare function guestIssuanceBypassUser(): ManagedUser;
+/** Placeholder identity so LangGraph auth middleware allows public routes. */
+export declare function publicRouteBypassUser(): ManagedUser;
 /** Placeholder identity so middleware allows provider-signed channel Events. */
 export declare function channelEventsBypassUser(): ManagedUser;
 //# sourceMappingURL=auth.d.ts.map

package/dist/runtime/auth.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"auth.d.ts","sourceRoot":"","sources":["../../src/runtime/auth.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,IAAI,EAGL,MAAM,+BAA+B,CAAC;AAIvC,OAAO,EAGL,KAAK,cAAc,EACnB,KAAK,kBAAkB,EACvB,KAAK,eAAe,EACrB,MAAM,sBAAsB,CAAC;AAO9B;;;;;GAKG;AACH,oFAAoF;AACpF,eAAO,MAAM,WAAW,kBAAkB,CAAC;AAC3C,mDAAmD;AACnD,eAAO,MAAM,aAAa,iBAAiB,CAAC;AAC5C,eAAO,MAAM,qBAAqB,yBAAyB,CAAC;AAC5D;;;;GAIG;AACH,eAAO,MAAM,sBAAsB,0BAA0B,CAAC;AAC9D,eAAO,MAAM,oBAAoB,2BAA2B,CAAC;AAE7D,kFAAkF;AAClF,eAAO,MAAM,kBAAkB,uBAAuB,CAAC;AAkDvD;;;;GAIG;AACH,MAAM,WAAW,WAAW;IAC1B,QAAQ,EAAE,MAAM,CAAC;IACjB,WAAW,EAAE,MAAM,EAAE,CAAC;IACtB,WAAW,EAAE,MAAM,CAAC;IACpB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,iFAAiF;IACjF,UAAU,CAAC,EAAE,MAAM,EAAE,CAAC;IACtB,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACrC,kFAAkF;IAClF,mBAAmB,CAAC,EAAE,MAAM,CAAC;IAC7B,oEAAoE;IACpE,oBAAoB,CAAC,EAAE,MAAM,CAAC;IAC9B,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CACxB;AAED;;;;;;;GAOG;AACH,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,kBAAkB,GAAG,IAAI,CAmDnE;AAED;;;;;;;;GAQG;AACH,wBAAsB,sBAAsB,CAC1C,GAAG,EAAE,cAAc,EACnB,OAAO,EAAE,OAAO,GACf,OAAO,CAAC,eAAe,CAAC,CAoB1B;AAED,uEAAuE;AACvE,eAAO,MAAM,2BAA2B,uBAAuB,CAAC;AAEhE;;;;GAIG;AACH,eAAO,MAAM,+BAA+B,2BAA2B,CAAC;AAExE;;;GAGG;AACH,eAAO,MAAM,2BAA2B,uBAAuB,CAAC;AAEhE;;;;GAIG;AACH,wBAAgB,iBAAiB,CAC/B,GAAG,EAAE,cAAc,EACnB,IAAI,EAAE,WAAW,EACjB,KAAK,EAAE,OAAO,GACb,IAAI,CAkCN;AAED,uFAAuF;AACvF,wBAAgB,2BAA2B,CACzC,SAAS,EAAE,MAAM,EAAE,EACnB,QAAQ,EAAE,MAAM,EAAE,GACjB,OAAO,CAeT;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,yBAAyB,CACvC,GAAG,EAAE,cAAc,EACnB,OAAO,EAAE,OAAO,GACf,WAAW,CAoDb;AAOD;;;;GAIG;AACH,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,OAAO,GAAG,OAAO,CAgB7D;AAED;;;;;GAKG;AACH,wBAAgB,sBAAsB,CACpC,IAAI,EAAE,cAAc,EACpB,OAAO,EAAE,OAAO,GACf,WAAW,GAAG,IAAI,CAgBpB;AAED,iFAAiF;AACjF,wBAAgB,cAAc,CAAC,IAAI,EAAE,WAAW,GAAG,MAAM,CAExD;AAkBD,mFAAmF;AACnF,wBAAgB,sBAAsB,CACpC,OAAO,EAAE,OAAO,EAChB,GAAG,EAAE,cAAc,GAClB,OAAO,CAaT;AAED,qFAAqF;AACrF,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAQhE;AAED,+EAA+E;AAC/E,wBAAgB,iCAAiC,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAM3E;AAED,mFAAmF;AACnF,wBAAgB,uBAAuB,IAAI,WAAW,CAMrD;AAED,gFAAgF;AAChF,wBAAgB,uBAAuB,IAAI,WAAW,CAMrD"}
+{"version":3,"file":"auth.d.ts","sourceRoot":"","sources":["../../src/runtime/auth.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,IAAI,EAGL,MAAM,+BAA+B,CAAC;AAIvC,OAAO,EACL,KAAK,cAAc,EACnB,KAAK,kBAAkB,EAEvB,KAAK,eAAe,EACrB,MAAM,sBAAsB,CAAC;AAI9B;;;;;GAKG;AACH,oFAAoF;AACpF,eAAO,MAAM,WAAW,kBAAkB,CAAC;AAC3C,eAAO,MAAM,qBAAqB,yBAAyB,CAAC;AAC5D;;;;GAIG;AACH,eAAO,MAAM,sBAAsB,0BAA0B,CAAC;AAC9D,eAAO,MAAM,oBAAoB,2BAA2B,CAAC;AAE7D,kFAAkF;AAClF,eAAO,MAAM,kBAAkB,uBAAuB,CAAC;AACvD,4EAA4E;AAC5E,eAAO,MAAM,kBAAkB,uBAAuB,CAAC;AACvD,eAAO,MAAM,qBAAqB,yBAAyB,CAAC;AAE5D,mDAAmD;AACnD,eAAO,MAAM,2BAA2B,4BAA4B,CAAC;AACrE,eAAO,MAAM,uBAAuB,wBAAwB,CAAC;AAC7D,eAAO,MAAM,wBAAwB,cAAc,CAAC;AACpD,eAAO,MAAM,qBAAqB,sBAAsB,CAAC;AA+CzD;;;;GAIG;AACH,MAAM,WAAW,WAAW;IAC1B,QAAQ,EAAE,MAAM,CAAC;IACjB,WAAW,EAAE,MAAM,EAAE,CAAC;IACtB,WAAW,EAAE,MAAM,CAAC;IACpB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,qEAAqE;IACrE,UAAU,CAAC,EAAE,MAAM,EAAE,CAAC;IACtB,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACrC,kFAAkF;IAClF,mBAAmB,CAAC,EAAE,MAAM,CAAC;IAC7B,oEAAoE;IACpE,oBAAoB,CAAC,EAAE,MAAM,CAAC;IAC9B,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CACxB;AAED;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,kBAAkB,GAAG,IAAI,CAuDnE;AAED;;;;;;;;GAQG;AACH,wBAAsB,sBAAsB,CAC1C,GAAG,EAAE,cAAc,EACnB,OAAO,EAAE,OAAO,GACf,OAAO,CAAC,eAAe,CAAC,CA4B1B;AAED,uEAAuE;AACvE,eAAO,MAAM,2BAA2B,uBAAuB,CAAC;AAEhE;;;;GAIG;AACH,eAAO,MAAM,+BAA+B,2BAA2B,CAAC;AAExE;;;GAGG;AACH,eAAO,MAAM,2BAA2B,uBAAuB,CAAC;AAEhE;;;;;;;;;;;;GAYG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,WAAW,EAAE,KAAK,EAAE,OAAO,GAAG,IAAI,CAqBzE;AAED,uFAAuF;AACvF,wBAAgB,2BAA2B,CACzC,SAAS,EAAE,MAAM,EAAE,EACnB,QAAQ,EAAE,MAAM,EAAE,GACjB,OAAO,CAeT;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,yBAAyB,CACvC,GAAG,EAAE,cAAc,EACnB,OAAO,EAAE,OAAO,GACf,WAAW,CASb;AA4FD,8EAA8E;AAC9E,wBAAsB,0BAA0B,CAC9C,OAAO,EAAE,OAAO,GACf,OAAO,CAAC,WAAW,CAAC,CA+EtB;AAiBD;;;;GAIG;AACH,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,OAAO,GAAG,OAAO,CAgB7D;AAED;;;;;GAKG;AACH,wBAAgB,sBAAsB,CACpC,IAAI,EAAE,cAAc,EACpB,OAAO,EAAE,OAAO,GACf,WAAW,GAAG,IAAI,CASpB;AAYD,iFAAiF;AACjF,wBAAgB,cAAc,CAAC,IAAI,EAAE,WAAW,GAAG,MAAM,CAExD;AAkBD,qFAAqF;AACrF,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAQhE;AAED,+EAA+E;AAC/E,wBAAgB,iCAAiC,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAM3E;AAED,8EAA8E;AAC9E,wBAAgB,qBAAqB,IAAI,WAAW,CAMnD;AAED,gFAAgF;AAChF,wBAAgB,uBAAuB,IAAI,WAAW,CAMrD"}

package/dist/runtime/auth.js

@@ -1,8 +1,8 @@
 import { Auth, HTTPException, isStudioUser, } from "@langchain/langgraph-sdk/auth";
 import { trustedMessagingProviders } from "../channels/messaging-registry.js";
 import { trustedChannelSourceProviders } from "../channels/registry-store.js";
-import { normalizeGroups, hasUserMemorySlice, } from "../identity/index.js";
-import { buildRuntimeIdentity, memoryIdentitySegments, } from "./identity-runtime.js";
+import {} from "../identity/index.js";
+import { buildRuntimeIdentity } from "./identity-runtime.js";
 import { resolveValidatedTokenUser } from "./validated-token.js";
 /**
  * Reserved transport for the trusted-backend ingress mode. User identity
@@ -12,18 +12,24 @@ import { resolveValidatedTokenUser } from "./validated-token.js";
  */
 /** Trusted-backend / channel-loopback identity headers (single source of truth). */
 export const USER_HEADER = "x-mda-user-id";
-/** Comma- or space-delimited group memberships. */
-export const GROUPS_HEADER = "x-mda-groups";
 export const INGRESS_SECRET_HEADER = "x-mda-ingress-secret";
 /**
- * Internal channel handoff headers. Accepted only after the ingress secret
- * validates — never part of the public HTTP identity surface, and deliberately
- * not allowlisted into `config.configurable`.
+ * Internal channel handoff headers. Accepted only after a server API key or
+ * legacy ingress secret validates — never part of the public HTTP identity
+ * surface, and deliberately not allowlisted into `config.configurable`.
  */
 export const SOURCE_PROVIDER_HEADER = "x-mda-source-provider";
 export const SOURCE_THREAD_HEADER = "x-mda-source-thread-id";
 /** Deployment env var carrying the shared secret the trusted backend presents. */
 export const INGRESS_SECRET_ENV = "MDA_INGRESS_SECRET";
+/** Deploy/dev-owned credential used only for internal identity handoffs. */
+export const HANDOFF_SECRET_ENV = "MDA_HANDOFF_SECRET";
+export const HANDOFF_SECRET_HEADER = "x-mda-handoff-secret";
+/** Platform-owned LangSmith auth configuration. */
+export const LANGSMITH_AUTH_ENDPOINT_ENV = "LANGSMITH_AUTH_ENDPOINT";
+export const LANGSMITH_TENANT_ID_ENV = "LANGSMITH_TENANT_ID";
+export const LANGSMITH_API_KEY_HEADER = "x-api-key";
+export const LANGSMITH_API_KEY_ENV = "LANGSMITH_API_KEY";
 /**
  * Set to `"1"` by `mda dev` so local Studio / API clients can exercise
  * `trusted_backend` identity without injecting ingress headers. Never set in
@@ -32,8 +38,6 @@ export const INGRESS_SECRET_ENV = "MDA_INGRESS_SECRET";
 const LOCAL_DEV_ENV = "MDA_LOCAL_DEV";
 /** Synthetic user for local `mda dev` when ingress headers are absent. */
 const LOCAL_DEV_USER = "mda:local-dev";
-/** Path MDA exposes for anonymous guest token issuance (must stay public). */
-const GUEST_ISSUANCE_PATH = "/identity/guest";
 /**
  * Provider OAuth/OIDC callbacks must stay public (IdP redirects the browser
  * here). Path shape: `/identity/{provider}/callback`.
@@ -56,17 +60,15 @@ function isTrustedSourceProvider(provider) {
         trustedMessagingProviders().has(provider) ||
         trustedChannelSourceProviders().has(provider));
 }
-/** Synthetic user used only to satisfy auth middleware on the issuance route. */
-const GUEST_ISSUER_USER = "mda:guest-issuer";
+/** Synthetic user used only to satisfy auth middleware on public routes. */
+const PUBLIC_ROUTE_USER = "mda:public-route";
 /** Synthetic user so middleware_first allows unsigned Slack Events ingress. */
 const CHANNEL_EVENTS_USER = "mda:channel-events";
 /**
  * Build the managed LangGraph custom-auth handler from a declared identity.
  *
- * Handles both ingress modes: `trusted_backend` (reserved headers behind a
- * shared ingress secret) and `validated_token` (browser-direct IdP tokens
- * verified via JWKS / introspection / MDA-signed guest). Also registers thread
- * and store scoping with a studio bypass.
+ * Handles trusted-backend, LangSmith API-key, and validated-token ingress.
+ * Also registers thread and store scoping with a studio bypass.
  */
 export function buildManagedAuth(identity) {
     const cfg = identity.config;
@@ -78,18 +80,24 @@ export function buildManagedAuth(identity) {
         if (isChannelEventsRequest(request)) {
             return channelEventsBypassUser();
         }
-        // Guest issuance and provider callback requests bypass auth.
-        // Channel loopback (and other trusted handoffs) stamp the ingress secret
-        // even when public HTTP ingress is validated_token (e.g. Supabase web).
-        if (isIdentityProviderCallbackRequest(request) ||
-            isGuestIssuanceRequest(request, cfg)) {
-            return guestIssuanceBypassUser();
+        // Provider OAuth/OIDC callback requests bypass auth (the IdP redirects the
+        // browser here with no MDA token to present).
+        if (isIdentityProviderCallbackRequest(request)) {
+            return publicRouteBypassUser();
+        }
+        // Deploy/dev inject a private handoff credential. A local server API key
+        // remains compatible, as does the legacy trusted-backend ingress secret.
+        const managedHandoff = resolveManagedHandoffUser(request);
+        if (managedHandoff) {
+            return managedHandoff;
         }
-        // Channel loopback (and other trusted handoffs) stamp the ingress secret
-        // even when public HTTP ingress is validated_token (e.g. Supabase web).
         if (http === "backend" || hasValidIngressSecret(request)) {
             return resolveTrustedBackendUser(cfg, request);
         }
+        rejectUntrustedHandoffHeaders(request);
+        if (isLangSmithApiKeyAuth(http)) {
+            return resolveLangSmithApiKeyUser(request);
+        }
         return resolveValidatedTokenUser(cfg, http, request);
     });
     auth.on("threads", ({ user, value }) => {
@@ -109,7 +117,7 @@ export function buildManagedAuth(identity) {
         if (isStudioUser(user) || isLocalDevUnscopedUser(user)) {
             return true;
         }
-        assertStoreAccess(cfg, user, value);
+        assertStoreAccess(user, value);
         return true;
     });
     return auth;
@@ -125,12 +133,20 @@ export function buildManagedAuth(identity) {
  */
 export async function resolveRequestIdentity(cfg, request) {
     const http = cfg.ingress.http;
-    const user = http === "backend" || hasValidIngressSecret(request)
-        ? resolveTrustedBackendUser(cfg, request)
-        : await resolveValidatedTokenUser(cfg, http, request);
+    const managedHandoff = resolveManagedHandoffUser(request);
+    const trustedHandoff = managedHandoff !== null || hasValidIngressSecret(request);
+    if (!managedHandoff && http !== "backend" && !trustedHandoff) {
+        rejectUntrustedHandoffHeaders(request);
+    }
+    const user = managedHandoff
+        ? managedHandoff
+        : http === "backend" || trustedHandoff
+            ? resolveTrustedBackendUser(cfg, request)
+            : isLangSmithApiKeyAuth(http)
+                ? await resolveLangSmithApiKeyUser(request)
+                : await resolveValidatedTokenUser(cfg, http, request);
     // Preserve trusted channel source stamps; default public HTTP to "http".
-    const sourceProvider = user.mda_source_provider ??
-        (hasValidIngressSecret(request) ? undefined : "http");
+    const sourceProvider = user.mda_source_provider ?? (trustedHandoff ? undefined : "http");
     const identity = buildRuntimeIdentity({
         langgraph_auth_user: {
             ...user,
@@ -156,17 +172,19 @@ export const GITHUB_CREDENTIALS_STORE_PREFIX = "mda_github_credentials";
  */
 export const IDENTITY_LINKS_SERVICE_USER = "mda:identity-links";
 /**
- * Fail-closed (403) unless the store `namespace` contains the caller id as a
- * contiguous ordered prefix (typically after the deployment id). No user slice
- * → no per-identity restriction.
+ * Fail-closed (403) on the managed reserved namespaces.
+ *
+ * `mda_identity_links` and `mda_github_credentials` are deployment-wide managed
+ * tables — account links and OAuth tokens for every caller — so only the trusted
+ * identity-links service principal may touch them. This check deliberately does
+ * not consult memory: it used to sit behind a per-caller memory check, which left
+ * the tables open to any authenticated caller on deployments without a user
+ * slice.
+ *
+ * There is no per-caller store partition to enforce beyond that, because no
+ * declaration mounts per-caller state in this release.
  */
-export function assertStoreAccess(cfg, user, value) {
-    const required = hasUserMemorySlice(cfg.scope.memory)
-        ? memoryIdentitySegments(user.mda_user_id ? String(user.mda_user_id) : undefined)
-        : [];
-    if (required.length === 0) {
-        return;
-    }
+export function assertStoreAccess(user, value) {
     const namespace = value &&
         typeof value === "object" &&
         Array.isArray(value.namespace)
@@ -184,11 +202,6 @@ export function assertStoreAccess(cfg, user, value) {
             message: "store namespace is outside the caller's identity boundary",
         });
     }
-    if (!namespaceHasOrderedSegments(namespace, required)) {
-        throw new HTTPException(403, {
-            message: "store namespace is outside the caller's identity boundary",
-        });
-    }
 }
 /** True when `required` appears as a contiguous ordered subsequence of `namespace`. */
 export function namespaceHasOrderedSegments(namespace, required) {
@@ -224,11 +237,14 @@ export function resolveTrustedBackendUser(cfg, request) {
         return local;
     }
     requireIngressSecret(request);
+    return trustedHeadersUser(request);
+}
+/** Resolve headers only after the caller has established a trusted credential. */
+function trustedHeadersUser(request) {
     const userId = trustedUserId(request);
     if (!userId) {
         throw new HTTPException(401, { message: `missing ${USER_HEADER}` });
     }
-    const groups = normalizeGroups(request.headers.get(GROUPS_HEADER));
     const sourceProvider = request.headers.get(SOURCE_PROVIDER_HEADER) ?? undefined;
     const sourceThread = request.headers.get(SOURCE_THREAD_HEADER) ?? undefined;
     if (sourceProvider !== undefined) {
@@ -257,7 +273,6 @@ export function resolveTrustedBackendUser(cfg, request) {
         permissions: [],
         mda_user_id: userId,
         ...(isService ? { mda_user_kind: "service" } : {}),
-        ...(groups.length > 0 ? { mda_groups: groups } : {}),
         ...(sourceProvider
             ? {
                 mda_source_provider: sourceProvider,
@@ -266,6 +281,117 @@ export function resolveTrustedBackendUser(cfg, request) {
             : {}),
     };
 }
+/** Resolve reserved identity headers authenticated by an internal credential. */
+function resolveManagedHandoffUser(request) {
+    if (!hasHandoffHeaders(request) ||
+        (!hasValidHandoffSecret(request) && !hasServerApiKey(request))) {
+        return null;
+    }
+    return trustedHeadersUser(request);
+}
+function hasValidHandoffSecret(request) {
+    const expected = process.env[HANDOFF_SECRET_ENV]?.trim();
+    const provided = request.headers.get(HANDOFF_SECRET_HEADER)?.trim();
+    return Boolean(expected && provided && constantTimeEquals(expected, provided));
+}
+function hasHandoffHeaders(request) {
+    return (request.headers.has(USER_HEADER) ||
+        request.headers.has(SOURCE_PROVIDER_HEADER) ||
+        request.headers.has(SOURCE_THREAD_HEADER));
+}
+function rejectUntrustedHandoffHeaders(request) {
+    if (hasHandoffHeaders(request)) {
+        throw new HTTPException(401, {
+            message: "reserved MDA identity headers require a trusted server credential",
+        });
+    }
+}
+function hasServerApiKey(request) {
+    const expected = process.env[LANGSMITH_API_KEY_ENV]?.trim();
+    const provided = request.headers.get(LANGSMITH_API_KEY_HEADER)?.trim();
+    return Boolean(expected && provided && constantTimeEquals(expected, provided));
+}
+/** Verify a LangSmith API key without replacing MDA's authorization hooks. */
+export async function resolveLangSmithApiKeyUser(request) {
+    const apiKey = request.headers.get(LANGSMITH_API_KEY_HEADER)?.trim();
+    const endpoint = process.env[LANGSMITH_AUTH_ENDPOINT_ENV]?.trim();
+    const expectedTenant = process.env[LANGSMITH_TENANT_ID_ENV]?.trim();
+    if (process.env[LOCAL_DEV_ENV] === "1" && (!endpoint || !expectedTenant)) {
+        return localDevServiceUser(request);
+    }
+    if (!apiKey) {
+        throw new HTTPException(401, { message: "missing x-api-key" });
+    }
+    if (!endpoint || !expectedTenant) {
+        throw new HTTPException(500, {
+            message: "LangSmith API-key authentication is not configured",
+        });
+    }
+    const headers = new Headers({ "x-api-key": apiKey });
+    const tenantHeader = request.headers.get("x-tenant-id");
+    if (tenantHeader) {
+        headers.set("x-tenant-id", tenantHeader);
+    }
+    let response;
+    try {
+        response = await fetch(new URL("/auth/public", endpoint), {
+            headers,
+            signal: AbortSignal.timeout(2_000),
+        });
+    }
+    catch {
+        throw new HTTPException(503, {
+            message: "LangSmith API-key verification unavailable",
+        });
+    }
+    if (response.status === 401) {
+        throw new HTTPException(401, { message: "invalid API key" });
+    }
+    if (response.status === 403) {
+        throw new HTTPException(403, { message: "API key is forbidden" });
+    }
+    if (!response.ok) {
+        throw new HTTPException(503, {
+            message: "LangSmith API-key verification unavailable",
+        });
+    }
+    let verified;
+    try {
+        verified = await response.json();
+    }
+    catch {
+        throw new HTTPException(503, {
+            message: "LangSmith API-key verification returned an invalid response",
+        });
+    }
+    if (!isJsonObject(verified)) {
+        throw new HTTPException(503, {
+            message: "LangSmith API-key verification returned an invalid response",
+        });
+    }
+    if (typeof verified.tenant_id !== "string" ||
+        verified.tenant_id !== expectedTenant) {
+        throw new HTTPException(403, { message: "API key tenant mismatch" });
+    }
+    const userId = typeof verified.user_id === "string" && verified.user_id.trim()
+        ? `langsmith:user:${verified.user_id.trim()}`
+        : `langsmith:tenant:${verified.tenant_id}`;
+    return {
+        identity: userId,
+        permissions: [],
+        mda_user_id: userId,
+        mda_user_kind: "service",
+        ...(typeof verified.user_email === "string" && verified.user_email.trim()
+            ? { mda_user_email: verified.user_email.trim() }
+            : {}),
+    };
+}
+function isJsonObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isLangSmithApiKeyAuth(http) {
+    return typeof http === "object" && http.mode === "langsmith_api_key";
+}
 /** Caller id from the trusted headers. */
 function trustedUserId(request) {
     return request.headers.get(USER_HEADER) ?? undefined;
@@ -303,6 +429,9 @@ export function tryLocalDevTrustedUser(_cfg, request) {
     if (hasValidIngressSecret(request)) {
         return null;
     }
+    return localDevServiceUser(request);
+}
+function localDevServiceUser(request) {
     const userId = trustedUserId(request) ?? LOCAL_DEV_USER;
     return {
         identity: userId,
@@ -327,21 +456,6 @@ function hasValidIngressSecret(request) {
     const provided = request.headers.get(INGRESS_SECRET_HEADER);
     return Boolean(expected && provided && constantTimeEquals(expected, provided));
 }
-/** True when this deployment exposes guest issuance and the request targets it. */
-export function isGuestIssuanceRequest(request, cfg) {
-    if (request.method !== "POST") {
-        return false;
-    }
-    const { pathname } = new URL(request.url);
-    if (pathname !== GUEST_ISSUANCE_PATH) {
-        return false;
-    }
-    const http = cfg.ingress.http;
-    if (http === "backend") {
-        return false;
-    }
-    return http.providers.some((provider) => provider.guest?.issue);
-}
 /** True when the request targets a public channel/connector Events ingress route. */
 export function isChannelEventsRequest(request) {
     if (request.method !== "POST") {
@@ -358,12 +472,12 @@ export function isIdentityProviderCallbackRequest(request) {
     const { pathname } = new URL(request.url);
     return IDENTITY_PROVIDER_CALLBACK_PATH.test(pathname);
 }
-/** Placeholder identity so LangGraph auth middleware allows tokenless issuance. */
-export function guestIssuanceBypassUser() {
+/** Placeholder identity so LangGraph auth middleware allows public routes. */
+export function publicRouteBypassUser() {
     return {
-        identity: GUEST_ISSUER_USER,
+        identity: PUBLIC_ROUTE_USER,
         permissions: [],
-        mda_user_id: GUEST_ISSUER_USER,
+        mda_user_id: PUBLIC_ROUTE_USER,
     };
 }
 /** Placeholder identity so middleware allows provider-signed channel Events. */