@agent-native/core 0.201.0 → 0.201.1

package/dist/a2a/server.js

@@ -12,6 +12,7 @@ import { generateAgentCard } from "./agent-card.js";
 import { canonicalA2AAudience } from "./audience.js";
 import { hasConfiguredA2ASecret, isA2AProductionRuntime, } from "./auth-policy.js";
 import { handleJsonRpcH3, processA2ATaskFromQueue } from "./handlers.js";
+import { verifyA2AOrganizationIdentity } from "./organization-identity.js";
 import { claimA2AApproval, getA2AApprovalForOwner, settleA2AApproval, } from "./task-store.js";
 let _warnedUnauthA2A = false;
 function warnA2AUnauthOnce() {
@@ -22,11 +23,48 @@ function warnA2AUnauthOnce() {
     console.warn("[a2a] No A2A_SECRET or apiKeyEnv configured — A2A endpoint runs unauthenticated. " +
         "This is allowed in development but blocked in production. Set A2A_SECRET before deploying.");
 }
-function addSecretCandidate(candidates, secret) {
-    const trimmed = secret?.trim();
-    if (!trimmed || candidates.includes(trimmed))
-        return;
-    candidates.push(trimmed);
+export class A2AIdentityVerificationUnavailableError extends Error {
+    cause;
+    constructor(cause) {
+        super("A2A identity verification is temporarily unavailable");
+        this.name = "A2AIdentityVerificationUnavailableError";
+        this.cause = cause;
+    }
+}
+export function isA2AIdentityVerificationUnavailableError(error) {
+    return (error instanceof A2AIdentityVerificationUnavailableError ||
+        (error instanceof Error &&
+            error.name === "A2AIdentityVerificationUnavailableError"));
+}
+function identityPayload(payload, audienceOptions, verifiedOrganization) {
+    const claims = verifiedOrganization
+        ? {
+            ...payload,
+            org_id: verifiedOrganization.orgId,
+            ...(verifiedOrganization.orgDomain
+                ? { org_domain: verifiedOrganization.orgDomain }
+                : { org_domain: undefined }),
+        }
+        : payload;
+    return {
+        email: payload.sub ?? null,
+        orgDomain: verifiedOrganization?.orgDomain ?? payload.org_domain ?? null,
+        ...(verifiedOrganization ? { orgId: verifiedOrganization.orgId } : {}),
+        ...(audienceOptions?.includeClaims ? { claims } : {}),
+    };
+}
+async function verifyJwtWithSecret(token, secret, options) {
+    try {
+        const { payload } = await jose.jwtVerify(token, new TextEncoder().encode(secret), options);
+        return isMcpCredential(payload) ? null : payload;
+    }
+    catch {
+        // coercion-ok: invalid signatures, expiry, or audience are rejected tokens; credential lookup failures throw separately.
+        return null;
+    }
+}
+function isMcpCredential(payload) {
+    return (payload.scope === "mcp-connect" || payload.typ === "agent-native-mcp-oauth");
 }
 /**
  * Resolve the audience (`aud`) value to expect in an inbound JWT. We use the
@@ -67,15 +105,6 @@ function audienceForRoute(baseAudience, options) {
         ? [routeAudience, baseAudience]
         : routeAudience;
 }
-/**
- * MCP connect tokens and MCP OAuth access tokens can be signed with the A2A
- * secret, but they are long-lived bearers whose revocation and membership
- * checks live in the MCP endpoint's `verifyAuth`. A2A callers sign a
- * short-lived token per call, so an MCP credential is never an A2A token.
- */
-function isMcpCredential(payload) {
-    return (payload.scope === "mcp-connect" || payload.typ === "agent-native-mcp-oauth");
-}
 function tokenHasAudienceClaim(token) {
     return typeof jose.decodeJwt(token).aud !== "undefined";
 }
@@ -86,12 +115,14 @@ function isDirectReadSkill(skill) {
 /**
  * Verify an inbound A2A bearer token (HS256) exactly as the
  * `/_agent-native/a2a` endpoint does: it peeks at the unverified `org_domain`
- * claim to build an ordered candidate-secret set (`process.env.A2A_SECRET`
- * plus any org-level secret for that domain), then verifies the JWT — checking
+ * claim to locate an org credential after trying the global credential, then
+ * verifies the JWT — checking
  * `aud`/`iss` when the token carries them and `exp` always. Returns the
  * caller's email (`sub`) and org domain on success, or `{ email: null,
- * orgDomain: null }` on any failure (malformed, bad signature, expired, no
- * secret configured, or an MCP credential), never throwing.
+ * orgDomain: null }` for an invalid token or absent credential. If the
+ * organization credential or membership evidence cannot be read, throws
+ * `A2AIdentityVerificationUnavailableError` so callers cannot treat an
+ * unreadable authorization lookup as an unauthenticated fallback.
  *
  * Exported so workspaces can accept A2A callers on the HTTP action route with
  * the same routine — including org-level fallback secrets — instead of
@@ -101,6 +132,9 @@ function isDirectReadSkill(skill) {
  * the same audience the client derived from the advertised URL.
  */
 export async function verifyA2AToken(token, event, audienceOptions) {
+    return (await verifyA2ATokenInternal(token, event, audienceOptions)).payload;
+}
+async function verifyA2ATokenInternal(token, event, audienceOptions) {
     // Step 1: Peek at JWT claims WITHOUT verification to get org_domain.
     // This is safe because we only use org_domain to look up the secret,
     // then verify the full JWT with that secret. If someone forges a JWT
@@ -110,35 +144,24 @@ export async function verifyA2AToken(token, event, audienceOptions) {
     let unverifiedPayload;
     try {
         unverifiedPayload = jose.decodeJwt(token);
-        orgDomainHint = unverifiedPayload.org_domain;
+        const domain = unverifiedPayload.org_domain;
+        if (typeof domain === "string" && domain.trim()) {
+            orgDomainHint = domain.trim();
+        }
     }
     catch {
         // Malformed token — fall through to global secret attempt
     }
-    // Step 2: Build a small, ordered set of candidate secrets. An explicit
-    // verification credential is isolated from the deployment-wide and
-    // org-level credentials so a caller cannot use one app's trust grant as
+    // An explicit verification credential is isolated from the deployment-wide
+    // and org-level credentials so a caller cannot use one app's trust grant as
     // another app's identity.
-    const candidateSecrets = [];
     const hasExplicitVerificationSecret = audienceOptions?.verificationSecret !== undefined;
-    addSecretCandidate(candidateSecrets, hasExplicitVerificationSecret
+    const globalSecret = (hasExplicitVerificationSecret
         ? audienceOptions?.verificationSecret
-        : readDeployCredentialEnv("A2A_SECRET"));
-    if (orgDomainHint &&
-        !audienceOptions?.globalSecretOnly &&
-        !hasExplicitVerificationSecret) {
-        try {
-            const { getA2ASecretByDomain } = await import("../org/context.js");
-            const orgSecret = await getA2ASecretByDomain(orgDomainHint);
-            addSecretCandidate(candidateSecrets, orgSecret ?? undefined);
-        }
-        catch {
-            // DB not ready or column doesn't exist yet — fall through
-        }
-    }
-    if (candidateSecrets.length === 0)
-        return { email: null, orgDomain: null };
-    // Step 3: Verify JWT with the candidate secrets.
+        : readDeployCredentialEnv("A2A_SECRET"))?.trim();
+    // Step 2: Build verification options once, then try the explicit/global
+    // credential first. A token accepted by that credential remains a global
+    // or explicitly delegated caller and does not depend on org-table reads.
     //
     // - `audience`: passed only when the token carries an `aud` claim
     //   (backward-compat: tokens minted by older `signA2AToken` versions
@@ -153,49 +176,93 @@ export async function verifyA2AToken(token, event, audienceOptions) {
     //   it was minted from", which `jose.jwtVerify` validates exactly when
     //   `issuer` is supplied as a string. Backward-compat: when the token
     //   has no `iss`, we skip the check.
-    try {
-        const verifyOptions = {};
-        if (unverifiedPayload && typeof unverifiedPayload.aud !== "undefined") {
-            // Fail closed: the token was minted for a specific audience, but this
-            // receiver can't derive its own expected audience (no APP_URL/URL and no
-            // usable request host). Accepting here would let a correctly-signed token
-            // whose `aud` targets ANOTHER service verify against a shared secret. A
-            // token that self-declares an audience must be checked against ours, so
-            // when we have nothing to check it against we reject rather than skip.
-            const aud = expectedJwtAudience(event, audienceOptions);
-            if (!aud)
-                return { email: null, orgDomain: null };
-            verifyOptions.audience = aud;
-        }
-        if (unverifiedPayload &&
-            typeof unverifiedPayload.iss === "string" &&
-            unverifiedPayload.iss.length > 0) {
-            verifyOptions.issuer = unverifiedPayload.iss;
-        }
-        for (const secret of candidateSecrets) {
+    const verifyOptions = {};
+    if (unverifiedPayload && typeof unverifiedPayload.aud !== "undefined") {
+        // Fail closed: the token was minted for a specific audience, but this
+        // receiver can't derive its own expected audience (no APP_URL/URL and no
+        // usable request host). Accepting here would let a correctly-signed token
+        // whose `aud` targets ANOTHER service verify against a shared secret. A
+        // token that self-declares an audience must be checked against ours, so
+        // when we have nothing to check it against we reject rather than skip.
+        const aud = expectedJwtAudience(event, audienceOptions);
+        if (!aud)
+            return { payload: { email: null, orgDomain: null } };
+        verifyOptions.audience = aud;
+    }
+    if (unverifiedPayload &&
+        typeof unverifiedPayload.iss === "string" &&
+        unverifiedPayload.iss.length > 0) {
+        verifyOptions.issuer = unverifiedPayload.iss;
+    }
+    if (globalSecret) {
+        const payload = await verifyJwtWithSecret(token, globalSecret, verifyOptions);
+        if (payload) {
+            let verifiedOrganization;
             try {
-                const { payload } = await jose.jwtVerify(token, new TextEncoder().encode(secret), verifyOptions);
-                if (isMcpCredential(payload))
-                    return { email: null, orgDomain: null };
-                const orgId = typeof payload.org_id === "string" && payload.org_id.trim()
-                    ? payload.org_id.trim()
-                    : undefined;
-                return {
-                    email: payload.sub ?? null,
-                    orgDomain: payload.org_domain ?? null,
-                    ...(orgId ? { orgId } : {}),
-                    ...(audienceOptions?.includeClaims ? { claims: payload } : {}),
-                };
+                verifiedOrganization = await verifyA2AOrganizationIdentity(payload);
+            }
+            catch (cause) {
+                throw new A2AIdentityVerificationUnavailableError(cause);
             }
-            catch {
-                // Try the next candidate without leaking which secret failed.
+            if (verifiedOrganization === null) {
+                return { payload: { email: null, orgDomain: null } };
             }
+            return {
+                payload: identityPayload(payload, audienceOptions, verifiedOrganization),
+                ...(verifiedOrganization
+                    ? { verifiedOrgId: verifiedOrganization.orgId }
+                    : {}),
+            };
         }
     }
-    catch {
-        // Keep malformed option construction indistinguishable from auth failure.
+    if (!orgDomainHint ||
+        audienceOptions?.globalSecretOnly ||
+        hasExplicitVerificationSecret) {
+        return { payload: { email: null, orgDomain: null } };
+    }
+    let organization;
+    try {
+        const { resolveA2AOrganizationCredentialsByDomain } = await import("../org/context.js");
+        organization =
+            await resolveA2AOrganizationCredentialsByDomain(orgDomainHint);
     }
-    return { email: null, orgDomain: null };
+    catch (cause) {
+        throw new A2AIdentityVerificationUnavailableError(cause);
+    }
+    if (!organization)
+        return { payload: { email: null, orgDomain: null } };
+    const payload = await verifyJwtWithSecret(token, organization.secret, verifyOptions);
+    if (!payload)
+        return { payload: { email: null, orgDomain: null } };
+    const verifiedDomain = typeof payload.org_domain === "string"
+        ? payload.org_domain.trim().toLowerCase()
+        : "";
+    const email = typeof payload.sub === "string" ? payload.sub.trim() : "";
+    const claimedOrgId = payload.org_id;
+    if (verifiedDomain !== organization.orgDomain ||
+        !email ||
+        (typeof claimedOrgId !== "undefined" &&
+            (typeof claimedOrgId !== "string" ||
+                claimedOrgId.trim() !== organization.orgId))) {
+        return { payload: { email: null, orgDomain: null } };
+    }
+    let member;
+    try {
+        const { isOrgMemberForA2A } = await import("../org/membership.js");
+        member = await isOrgMemberForA2A(organization.orgId, email);
+    }
+    catch (cause) {
+        throw new A2AIdentityVerificationUnavailableError(cause);
+    }
+    if (!member)
+        return { payload: { email: null, orgDomain: null } };
+    return {
+        payload: identityPayload(payload, audienceOptions, {
+            orgId: organization.orgId,
+            orgDomain: organization.orgDomain,
+        }),
+        verifiedOrgId: organization.orgId,
+    };
 }
 export function mountA2A(nitroApp, config, routePrefix = "/_agent-native") {
     // Public agent card endpoint (no auth required).
@@ -220,14 +287,25 @@ export function mountA2A(nitroApp, config, routePrefix = "/_agent-native") {
         if (config.authenticatedSkills?.length) {
             const bearer = extractBearerToken(getRequestHeader(event, "authorization"));
             if (bearer) {
-                const payload = await verifyA2AToken(bearer, event, {
-                    routePrefix,
-                    allowBaseAudience: true,
-                });
-                if (payload.email) {
-                    skills = tokenHasAudienceClaim(bearer)
-                        ? config.authenticatedSkills
-                        : config.authenticatedSkills.filter((skill) => !isDirectReadSkill(skill));
+                try {
+                    const { payload } = await verifyA2ATokenInternal(bearer, event, {
+                        routePrefix,
+                        allowBaseAudience: true,
+                    });
+                    if (payload.email) {
+                        skills = tokenHasAudienceClaim(bearer)
+                            ? config.authenticatedSkills
+                            : config.authenticatedSkills.filter((skill) => !isDirectReadSkill(skill));
+                    }
+                }
+                catch (error) {
+                    if (!(error instanceof A2AIdentityVerificationUnavailableError)) {
+                        throw error;
+                    }
+                    setResponseStatus(event, 503);
+                    return {
+                        error: "A2A identity verification is temporarily unavailable",
+                    };
                 }
             }
         }
@@ -383,6 +461,7 @@ export function mountA2A(nitroApp, config, routePrefix = "/_agent-native") {
         const bearerToken = extractBearerToken(authHeader);
         let verifiedCallerEmail = null;
         let verifiedOrgDomain = null;
+        let verifiedOrgId;
         let verifiedAudienceBound = false;
         let legacyApiKeyAuthenticated = false;
         let bearerTokenRejectedByJwt = false;
@@ -394,9 +473,26 @@ export function mountA2A(nitroApp, config, routePrefix = "/_agent-native") {
         const hasA2ASecret = hasConfiguredA2ASecret();
         const hasApiKey = !!(config.apiKeyEnv && process.env[config.apiKeyEnv]);
         if (bearerToken) {
-            const tokenPayload = await verifyA2AToken(bearerToken, event, {
-                routePrefix,
-            });
+            let tokenPayload;
+            try {
+                const verification = await verifyA2ATokenInternal(bearerToken, event, { routePrefix });
+                tokenPayload = verification.payload;
+                verifiedOrgId = verification.verifiedOrgId;
+            }
+            catch (error) {
+                if (!(error instanceof A2AIdentityVerificationUnavailableError)) {
+                    throw error;
+                }
+                setResponseStatus(event, 503);
+                return {
+                    jsonrpc: "2.0",
+                    id: null,
+                    error: {
+                        code: -32003,
+                        message: "A2A identity verification is temporarily unavailable",
+                    },
+                };
+            }
             verifiedCallerEmail = tokenPayload.email;
             verifiedOrgDomain = tokenPayload.orgDomain;
             if (verifiedCallerEmail) {
@@ -477,6 +573,9 @@ export function mountA2A(nitroApp, config, routePrefix = "/_agent-native") {
         if (verifiedOrgDomain) {
             event.context.__a2aOrgDomain = verifiedOrgDomain;
         }
+        if (verifiedOrgId) {
+            event.context.__a2aVerifiedOrgId = verifiedOrgId;
+        }
         const body = await readBody(event);
         return handleJsonRpcH3(body, event, config);
     }));

package/dist/a2a/task-store.d.ts

@@ -1,6 +1,7 @@
 import type { Task, Message, TaskState, Artifact } from "./types.js";
 export declare const MAX_A2A_IDEMPOTENCY_KEY_CHARS = 128;
 export declare const A2A_PERSONAL_OWNER_SCOPE = "__personal__";
+export declare const A2A_ORG_ID_OWNER_SCOPE_PREFIX = "__a2a_org_id__:";
 export interface A2ATaskListCursor {
     createdAt: number;
     id: string;
@@ -42,6 +43,10 @@ export interface A2ATaskOwnership {
     ownerEmail: string | null;
     ownerScope: string | null;
 }
+export interface A2ATaskAccessScope {
+    ownerEmail: string;
+    ownerScope: string | null;
+}
 export declare function getTaskOwner(id: string): Promise<string | null>;
 export declare function getTaskOwnership(id: string): Promise<A2ATaskOwnership>;
 export declare function claimA2ATaskForProcessing(id: string): Promise<Task | null>;
@@ -57,12 +62,12 @@ export declare function touchProcessingA2ATask(id: string): Promise<boolean>;
 export declare function resetStuckA2ATaskForRetry(id: string, processingCutoff: number): Promise<boolean>;
 export declare function failStuckA2ATask(id: string, processingCutoff: number, reason: string, createdAtCutoff?: number): Promise<boolean>;
 export declare function failStuckQueuedA2ATask(id: string, createdAtCutoff: number, reason: string): Promise<boolean>;
-export declare function getTask(id: string): Promise<Task | null>;
+export declare function getTask(id: string, accessScope?: A2ATaskAccessScope): Promise<Task | null>;
 export declare function updateTask(id: string, update: {
     state?: TaskState;
     message?: Message;
     artifacts?: Artifact[];
-}): Promise<Task | null>;
+}, accessScope?: A2ATaskAccessScope): Promise<Task | null>;
 /**
  * Persist the terminal result produced by the async processor, but only while
  * that processor still owns a task in `processing`. A tasks/get request may

package/dist/a2a/task-store.js

@@ -6,6 +6,7 @@ export const MAX_A2A_IDEMPOTENCY_KEY_CHARS = 128;
 const A2A_IDEMPOTENCY_INDEX = "idx_a2a_tasks_owner_scope_idempotency";
 const A2A_RECOVERY_INDEX = "idx_a2a_tasks_recovery_created";
 export const A2A_PERSONAL_OWNER_SCOPE = "__personal__";
+export const A2A_ORG_ID_OWNER_SCOPE_PREFIX = "__a2a_org_id__:";
 const MAX_TASK_LIST_PAGE_SIZE = 100;
 export async function ensureTable() {
     if (!_initPromise) {
@@ -371,6 +372,14 @@ export async function createOrReuseTask(message, contextId, metadata, ownerEmail
     }
     throw new Error("A2A terminal task idempotency key could not be released");
 }
+function taskAccessPredicate(scope) {
+    if (!scope)
+        return { sql: "", args: [] };
+    return {
+        sql: " AND LOWER(COALESCE(owner_email, '')) = LOWER(?) AND LOWER(COALESCE(owner_scope, '')) = LOWER(?)",
+        args: [scope.ownerEmail, scope.ownerScope ?? ""],
+    };
+}
 export async function getTaskOwner(id) {
     return (await getTaskOwnership(id)).ownerEmail;
 }
@@ -537,23 +546,25 @@ export async function failStuckQueuedA2ATask(id, createdAtCutoff, reason) {
     const affected = getAffectedRowCount(result);
     return affected !== 0;
 }
-export async function getTask(id) {
+export async function getTask(id, accessScope) {
     await ensureTable();
     const client = getDbExec();
+    const predicate = taskAccessPredicate(accessScope);
     const { rows } = await client.execute({
-        sql: `SELECT * FROM a2a_tasks WHERE id = ?`,
-        args: [id],
+        sql: `SELECT * FROM a2a_tasks WHERE id = ?${predicate.sql}`,
+        args: [id, ...predicate.args],
     });
     if (rows.length === 0)
         return null;
     return taskFromRow(rows[0]);
 }
-export async function updateTask(id, update) {
+export async function updateTask(id, update, accessScope) {
     await ensureTable();
     const client = getDbExec();
+    const predicate = taskAccessPredicate(accessScope);
     const { rows } = await client.execute({
-        sql: `SELECT * FROM a2a_tasks WHERE id = ?`,
-        args: [id],
+        sql: `SELECT * FROM a2a_tasks WHERE id = ?${predicate.sql}`,
+        args: [id, ...predicate.args],
     });
     if (rows.length === 0)
         return null;
@@ -572,8 +583,8 @@ export async function updateTask(id, update) {
     if (update.artifacts) {
         task.artifacts = [...(task.artifacts ?? []), ...update.artifacts];
     }
-    await client.execute({
-        sql: `UPDATE a2a_tasks SET status_state = ?, status_message = ?, status_timestamp = ?, history = ?, artifacts = ?, updated_at = ? WHERE id = ?`,
+    const result = await client.execute({
+        sql: `UPDATE a2a_tasks SET status_state = ?, status_message = ?, status_timestamp = ?, history = ?, artifacts = ?, updated_at = ? WHERE id = ?${predicate.sql}`,
         args: [
             task.status.state,
             task.status.message ? JSON.stringify(task.status.message) : null,
@@ -582,8 +593,12 @@ export async function updateTask(id, update) {
             JSON.stringify(task.artifacts),
             now,
             id,
+            ...predicate.args,
         ],
     });
+    if (accessScope && getAffectedRowCount(result) !== 1) {
+        return null;
+    }
     return task;
 }
 /**

package/dist/a2a-claims.js

@@ -13,14 +13,24 @@ export async function verifyA2ATokenWithClaims(token, event) {
                 : [];
         if (audiences.length === 0 || audiences.some((value) => !value.trim()))
             return null;
-        const orgId = typeof raw.org_id === "string" ? raw.org_id.trim() : "";
+        const claimedOrgId = typeof raw.org_id === "string" ? raw.org_id.trim() : "";
+        // Global-secret verification can resolve an ID-only claim locally; require
+        // the signed domain too so the ID alone cannot choose the authorization scope.
+        const claimedOrgDomain = typeof raw.org_domain === "string"
+            ? raw.org_domain.trim().toLowerCase()
+            : "";
+        const orgId = identity.orgId?.trim() ?? "";
         const jti = typeof raw.jti === "string" ? raw.jti.trim() : "";
         const scopes = typeof raw.scope === "string"
             ? raw.scope.split(/\s+/).filter(Boolean)
             : [];
         const issuer = typeof raw.iss === "string" ? raw.iss.trim() : "";
         const orgDomain = identity.orgDomain?.trim().toLowerCase() ?? "";
-        return orgId && orgDomain && jti
+        return claimedOrgId &&
+            claimedOrgId === orgId &&
+            claimedOrgDomain &&
+            claimedOrgDomain === orgDomain &&
+            jti
             ? {
                 email: identity.email,
                 orgId,

package/dist/app-config/mcp.d.ts

@@ -0,0 +1,4 @@
+import { z } from "zod";
+export declare const mcpConfig: z.ZodObject<{
+    allowDevOpen: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>;

package/dist/app-config/mcp.js

@@ -0,0 +1,7 @@
+import { z } from "zod";
+export const mcpConfig = z.object({
+    allowDevOpen: z.boolean().default(false).meta({
+        env: "AGENT_NATIVE_MCP_DEV_OPEN",
+        doc: "Allow unauthenticated MCP requests from loopback during local development.",
+    }),
+});

package/dist/app-config/schema.d.ts

@@ -79,6 +79,9 @@ export declare const appConfigSchema: z.ZodObject<{
     launchDarkly: z.ZodPrefault<z.ZodObject<{
         sdkKey: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>>;
+    mcp: z.ZodPrefault<z.ZodObject<{
+        allowDevOpen: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strip>>;
     migration: z.ZodPrefault<z.ZodObject<{
         releaseMigrations: z.ZodDefault<z.ZodBoolean>;
         deployContext: z.ZodOptional<z.ZodString>;

package/dist/app-config/schema.js

@@ -8,6 +8,7 @@ import { authConfig } from "./auth.js";
 import { dispatchConfig } from "./dispatch.js";
 import { integrationsConfig } from "./integrations.js";
 import { launchDarklyConfig } from "./launchdarkly.js";
+import { mcpConfig } from "./mcp.js";
 import { migrationConfig } from "./migration.js";
 import { observabilityConfig } from "./observability.js";
 import { onboardingConfig } from "./onboarding.js";
@@ -27,6 +28,7 @@ export const appConfigSchema = z.object({
     dispatch: dispatchConfig.prefault({}),
     integrations: integrationsConfig.prefault({}),
     launchDarkly: launchDarklyConfig.prefault({}),
+    mcp: mcpConfig.prefault({}),
     migration: migrationConfig.prefault({}),
     observability: observabilityConfig.prefault({}),
     onboarding: onboardingConfig.prefault({}),

package/dist/automation/index.d.ts

@@ -139,8 +139,8 @@ export declare function createAutomationCallbackHandler(runtime: AutomationRunti
     duplicate?: undefined;
     eventId?: undefined;
 } | {
-    error?: undefined;
     accepted: boolean;
     duplicate: boolean;
     eventId: string;
+    error?: undefined;
 }>;