@agent-native/core 0.210.2 → 0.211.0

package/dist/mcp/actions/revoke-org-service-token.js

@@ -10,11 +10,15 @@ import { defineAction } from "../../action.js";
 import { revokeOrgServiceToken } from "../connect-store.js";
 import { requireServiceTokenCaller } from "./service-token-access.js";
 export default defineAction({
-    description: "Revoke one of your organization's service tokens by id (get ids from list-org-service-tokens). The token stops working immediately. Org owner/admin only. Idempotent.",
+    description: "Revoke one of your organization's service tokens by id (get ids from list-org-service-tokens). The token stops working immediately. Every call needs the user's approval. Org owner/admin only. Idempotent.",
     schema: z.object({
         id: z.string().min(1).describe("Service token id to revoke"),
     }),
     toolCallable: false,
+    // It creates, changes, or revokes a credential or who may use one: every
+    // call needs the user's approval, and "always allow" is not offered.
+    needsApproval: true,
+    allowPersistentApproval: false,
     run: async (args, ctx) => {
         const caller = await requireServiceTokenCaller({
             userEmail: ctx?.userEmail,

package/dist/mcp/build-server.js

@@ -2094,10 +2094,23 @@ export async function createMCPServerForRequest(config, identity, requestMeta) {
             }
             : {}),
     });
-    async function withCallerContext(fn, mcpRequestId) {
+    // A verified user's MCP token names them by email. Browser sessions also
+    // carry the Better Auth user id, and per-user gates such as Clips' hosted
+    // storage key on it, so a tool call resolves it the same way.
+    let callerAuthUserId;
+    function resolveCallerAuthUserId() {
+        if (!hasVerifiedMcpUserIdentity(effectiveIdentity)) {
+            return Promise.resolve(undefined);
+        }
+        const email = effectiveIdentity.userEmail;
+        callerAuthUserId ??= import("../server/better-auth-instance.js").then(({ findBetterAuthUserIdForEmail }) => findBetterAuthUserIdForEmail(email));
+        return callerAuthUserId;
+    }
+    async function withCallerContext(fn, mcpRequestId, authUserId) {
         const orgId = await orgIdPromise;
         return runWithRequestContext({
             userEmail: effectiveIdentity?.userEmail,
+            ...(authUserId ? { authUserId } : {}),
             orgId,
             ...(verifiedServiceIdentity ? { verifiedServiceIdentity } : {}),
             ...(effectiveIdentity?.orgId === null
@@ -2108,6 +2121,9 @@ export async function createMCPServerForRequest(config, identity, requestMeta) {
             mcpCredentialIssuedAtMs: effectiveIdentity?.mcpCredentialIssuedAtMs ?? null,
         }, fn);
     }
+    async function withToolCallContext(fn, mcpRequestId) {
+        return withCallerContext(fn, mcpRequestId, await resolveCallerAuthUserId());
+    }
     const actionCallContext = {
         appId: config.appId,
         identity: effectiveIdentity,
@@ -2350,7 +2366,7 @@ export async function createMCPServerForRequest(config, identity, requestMeta) {
                 : requestMeta?.mcpRetryToken
                     ? `stateless:${requestMeta.mcpRetryToken}`
                     : undefined;
-        const result = await withCallerContext(async () => {
+        const result = await withToolCallContext(async () => {
             const { name, arguments: args } = request.params;
             try {
                 const { allowedActions } = await resolveServiceGrant();

package/dist/mcp/execute-action-call.js

@@ -1,6 +1,6 @@
 import { isMcpReadOnlyTool } from "../action-call-classification.js";
 import { vouchedOutcome } from "../action-frame.js";
-import { actionCallIntent, isActionContractError, recordInvalidActionCall, preparedCallArguments, runPreparedActionCall, } from "../action.js";
+import { actionCallIntent, isActionContractError, recordInvalidActionCall, preparedCallNeedsApproval, runPreparedActionCall, } from "../action.js";
 import { AGENT_IMAGES_FIELD } from "../agent/tool-result-images.js";
 import { MCP_ACTION_RESULT_MARKER, isMcpActionResult, mcpActionResultText, } from "../mcp-client/app-result.js";
 import { assertServicePrincipalMayCall, assertServicePrincipalMayRun, recordServicePrincipalDenial, ServicePrincipalRefusedError, } from "../org/service-principal-guard.js";
@@ -564,22 +564,13 @@ async function authorizeApproval(context, call, entry, args, prepared) {
     if (entry.needsApproval === undefined) {
         return { status: "authorized", clientAccepted: false };
     }
-    let mustApprove = false;
-    try {
-        mustApprove =
-            typeof entry.needsApproval === "function"
-                ? Boolean(await entry.needsApproval(preparedCallArguments(prepared), {
-                    userEmail: getRequestUserEmail(),
-                    orgId: getRequestOrgId() ?? null,
-                    appId: context.appId,
-                    caller: "mcp",
-                    actionName: name,
-                }))
-                : entry.needsApproval === true;
-    }
-    catch {
-        mustApprove = true;
-    }
+    const mustApprove = await preparedCallNeedsApproval(entry, prepared, {
+        userEmail: getRequestUserEmail(),
+        orgId: getRequestOrgId() ?? null,
+        appId: context.appId,
+        caller: "mcp",
+        actionName: name,
+    });
     if (!mustApprove)
         return { status: "authorized", clientAccepted: false };
     if (!hasVerifiedUserIdentity) {

package/dist/notifications/routes.d.ts

@@ -16,6 +16,6 @@ export declare function createNotificationsHandler(): import("h3").EventHandlerW
 } | {
     count?: undefined;
     updated?: undefined;
-    ok: boolean;
     error?: undefined;
+    ok: boolean;
 }>>;

package/dist/observability/routes.d.ts

@@ -33,26 +33,26 @@ export declare function createObservabilityHandler(): import("h3").EventHandlerW
     spans?: undefined;
     ok?: undefined;
 } | {
-    error?: undefined;
     message?: undefined;
     summary: import("./types.js").TraceSummary;
     spans: import("./types.js").TraceSpan[];
+    error?: undefined;
     ok?: undefined;
 } | {
-    error?: undefined;
     message?: undefined;
     summary?: undefined;
     spans?: undefined;
     traceMissing: true;
     id: string;
+    error?: undefined;
     ok?: undefined;
 } | {
-    error?: undefined;
     message?: undefined;
     summary?: undefined;
     spans?: undefined;
     traceMissing?: undefined;
     id: string;
+    error?: undefined;
     ok?: undefined;
 } | {
     message?: undefined;
@@ -61,9 +61,9 @@ export declare function createObservabilityHandler(): import("h3").EventHandlerW
     error: any;
     ok?: undefined;
 } | {
-    error?: undefined;
     message?: undefined;
     summary?: undefined;
     spans?: undefined;
     ok: boolean;
+    error?: undefined;
 }>>;

package/dist/org/actions/set-app-member-roles.js

@@ -19,6 +19,10 @@ export default defineAction({
             return `Updated ${args.appId} roles for ${args.email}: [${(change.previousRoles ?? []).join(", ")}] -> [${(change.roles ?? []).join(", ")}]`;
         },
     }),
+    // It changes who may use an app or what they may do in it: every call
+    // needs the user's approval, and "always allow" is not offered.
+    needsApproval: true,
+    allowPersistentApproval: false,
     run: async ({ appId, email, roles }, ctx) => {
         const caller = await requireOrgMember(ctx, true);
         const descriptor = getRegisteredAppRoles(appId);

package/dist/org/actions/set-app-permission-roles.js

@@ -19,6 +19,10 @@ export default defineAction({
             return `${args.reset ? "Reset" : "Updated"} ${args.appId} permission ${args.permission}: [${(change.previousRoles ?? []).join(", ")}] -> [${(change.roles ?? []).join(", ")}]`;
         },
     }),
+    // It changes who may use an app or what they may do in it: every call
+    // needs the user's approval, and "always allow" is not offered.
+    needsApproval: true,
+    allowPersistentApproval: false,
     run: async ({ appId, permission, roles, reset }, ctx) => {
         const caller = await requireOrgMember(ctx, true);
         const descriptor = getRegisteredAppRoles(appId);

package/dist/org/actions/set-workspace-app-access.js

@@ -16,6 +16,10 @@ export default defineAction({
         targetId: (args) => args.appId,
         summary: (args) => `Set ${args.appId} workspace access to ${args.mode}`,
     }),
+    // It changes who may use an app or what they may do in it: every call
+    // needs the user's approval, and "always allow" is not offered.
+    needsApproval: true,
+    allowPersistentApproval: false,
     run: async ({ appId, mode }, ctx) => {
         const caller = await requireOrgMember(ctx, true);
         const db = getDbExec();

package/dist/org/handlers.d.ts

@@ -73,9 +73,9 @@ export declare const setWorkspaceAppDefaultVisibilityHandler: import("h3").Event
 }>>;
 export declare const createOrgHandler: import("h3").EventHandlerWithFetch<import("h3").EventHandlerRequest, Promise<{
     success: boolean;
-    id?: undefined;
     name?: undefined;
     role?: undefined;
+    id?: undefined;
 } | {
     success?: undefined;
     id: string;

package/dist/org/index.d.ts

@@ -162,8 +162,8 @@ export declare const getMyOrgHandler: import("h3").EventHandlerWithFetch<import(
     soloDeploymentAdmin: boolean;
 }>>;
 export declare const createOrgHandler: import("h3").EventHandlerWithFetch<import("h3").EventHandlerRequest, Promise<{
-    name?: undefined;
     success: boolean;
+    name?: undefined;
     role?: undefined;
     id?: undefined;
 } | {

package/dist/progress/routes.d.ts

@@ -2,6 +2,6 @@ export declare function createProgressHandler(): import("h3").EventHandlerWithFe
     error: string;
     ok?: undefined;
 } | {
-    error?: undefined;
     ok: boolean;
+    error?: undefined;
 }>>;

package/dist/provider-api/actions/custom-provider-registration.d.ts

@@ -75,10 +75,8 @@ export declare function createCustomProviderRegistrationAction<TSchema extends Z
         user: "user";
     }>>;
 }, z.core.$strip>>, {
-    provider?: undefined;
+    message?: undefined;
     id?: undefined;
-    deleted?: undefined;
-    found?: undefined;
     providers: {
         id: string;
         label: string;
@@ -89,45 +87,47 @@ export declare function createCustomProviderRegistrationAction<TSchema extends Z
         updatedAt: number;
     }[];
     count: number;
+    provider?: undefined;
+    found?: undefined;
+    deleted?: undefined;
     registered?: undefined;
     label?: undefined;
-    message?: undefined;
 } | {
+    message?: undefined;
     id?: undefined;
-    count?: undefined;
-    deleted?: undefined;
     providers?: undefined;
+    count?: undefined;
     found: boolean;
     provider: import("../custom-registry.js").CustomProviderConfig;
+    deleted?: undefined;
     registered?: undefined;
     label?: undefined;
-    message?: undefined;
 } | {
-    provider?: undefined;
-    count?: undefined;
-    deleted?: undefined;
+    message?: undefined;
     providers?: undefined;
+    count?: undefined;
+    provider?: undefined;
     found: boolean;
     id: string;
+    deleted?: undefined;
     registered?: undefined;
     label?: undefined;
-    message?: undefined;
 } | {
-    provider?: undefined;
+    message?: undefined;
+    providers?: undefined;
     count?: undefined;
+    provider?: undefined;
     found?: undefined;
-    providers?: undefined;
     deleted: boolean;
     id: string;
     registered?: undefined;
     label?: undefined;
-    message?: undefined;
 } | {
-    provider?: undefined;
+    providers?: undefined;
     count?: undefined;
-    deleted?: undefined;
+    provider?: undefined;
     found?: undefined;
-    providers?: undefined;
+    deleted?: undefined;
     registered: boolean;
     id: string;
     label: string;

package/dist/provider-api/actions/provider-api.d.ts

@@ -316,11 +316,9 @@ export declare function createProviderApiActions(runtime: Pick<ProviderApiRuntim
         notes?: string | undefined;
         scope?: "org" | "user" | undefined;
     }, {
-        id?: undefined;
         provider?: undefined;
-        message?: undefined;
+        id?: undefined;
         deleted?: undefined;
-        found?: undefined;
         providers: {
             id: string;
             label: string;
@@ -331,44 +329,46 @@ export declare function createProviderApiActions(runtime: Pick<ProviderApiRuntim
             updatedAt: number;
         }[];
         count: number;
+        found?: undefined;
         registered?: undefined;
         label?: undefined;
+        message?: undefined;
     } | {
         id?: undefined;
-        count?: undefined;
-        message?: undefined;
         deleted?: undefined;
         providers?: undefined;
+        count?: undefined;
         found: boolean;
         provider: import("../custom-registry.js").CustomProviderConfig;
         registered?: undefined;
         label?: undefined;
+        message?: undefined;
     } | {
         provider?: undefined;
-        count?: undefined;
-        message?: undefined;
         deleted?: undefined;
         providers?: undefined;
+        count?: undefined;
         found: boolean;
         id: string;
         registered?: undefined;
         label?: undefined;
+        message?: undefined;
     } | {
         provider?: undefined;
+        providers?: undefined;
         count?: undefined;
-        message?: undefined;
         found?: undefined;
-        providers?: undefined;
         deleted: boolean;
         id: string;
         registered?: undefined;
         label?: undefined;
+        message?: undefined;
     } | {
         provider?: undefined;
-        count?: undefined;
         deleted?: undefined;
-        found?: undefined;
         providers?: undefined;
+        count?: undefined;
+        found?: undefined;
         registered: boolean;
         id: string;
         label: string;

package/dist/review/suggestions/actions.d.ts

@@ -83,6 +83,7 @@ export declare const createResourceSuggestionProposal: import("../../action.js")
         }[];
         metadata?: Record<string, unknown>;
     }[];
+    supersedes?: string[];
 }, {
     proposal: import("./types.js").ResourceSuggestionProposal;
     suggestions: ResourceSuggestion[];

package/dist/review/suggestions/actions.js

@@ -58,6 +58,50 @@ function assertCreationReplay(receipt, requestHash, authorEmail, actorKind) {
     }
     return receipt.suggestion;
 }
+// One revised proposal can replace every edit of the one before it.
+const MAX_SUPERSEDED = 100;
+async function supersedeSuggestions(tx, args, authorEmail, replacementId) {
+    for (const supersededId of new Set(args.supersedes ?? [])) {
+        const prior = await getSuggestion(supersededId, tx);
+        if (!prior ||
+            prior.resourceType !== args.resourceType ||
+            prior.resourceId !== args.resourceId) {
+            fail("A superseded suggestion was not found on this resource", {
+                statusCode: 404,
+                errorCode: "not_found",
+            });
+        }
+        if (!authorEmail || prior.authorEmail !== authorEmail) {
+            fail("Only the author can supersede this suggestion", {
+                statusCode: 403,
+                errorCode: "forbidden",
+            });
+        }
+        if (prior.status !== "pending")
+            continue;
+        const claimed = await updateSuggestionStatus(tx, prior.id, "superseded", prior.revision);
+        if (!claimed) {
+            const latest = await getSuggestion(prior.id, tx);
+            // A reviewer decided it first; only pending proposals are replaced.
+            if (latest && latest.status !== "pending")
+                continue;
+            fail("The superseded suggestion changed; refresh and try again", {
+                statusCode: 409,
+                errorCode: "suggestion_conflict",
+            });
+        }
+        await recordDecision(tx, {
+            suggestionId: prior.id,
+            idempotencyKey: `${args.idempotencyKey}:supersedes:${prior.id}`,
+            reviewer: authorEmail,
+            decision: "superseded",
+            observedBase: prior.baseRevision,
+            outcome: "superseded",
+            detail: replacementId,
+        });
+        await resolveReviewThreadWithClient(tx, prior.threadId, authorEmail, { resourceType: prior.resourceType, resourceId: prior.resourceId }, "superseded");
+    }
+}
 export const createResourceSuggestion = defineAction({
     description: "Create a typed pending suggestion without changing the canonical resource. Pass supersedes to replace your own earlier pending suggestions on the same resource in the same step.",
     schema: z.object({
@@ -70,7 +114,7 @@ export const createResourceSuggestion = defineAction({
         metadata: z.record(z.string(), z.unknown()).optional(),
         supersedes: z
             .array(z.string().min(1))
-            .max(20)
+            .max(MAX_SUPERSEDED)
             .optional()
             .describe("IDs of your own earlier suggestions on this resource that this one replaces. Pending ones become superseded atomically with this creation; already decided ones are left as they are."),
     }),
@@ -133,46 +177,7 @@ export const createResourceSuggestion = defineAction({
                     threadComment: null,
                 };
             }
-            for (const supersededId of new Set(args.supersedes ?? [])) {
-                const prior = await getSuggestion(supersededId, tx);
-                if (!prior ||
-                    prior.resourceType !== args.resourceType ||
-                    prior.resourceId !== args.resourceId) {
-                    fail("A superseded suggestion was not found on this resource", {
-                        statusCode: 404,
-                        errorCode: "not_found",
-                    });
-                }
-                if (!authorEmail || prior.authorEmail !== authorEmail) {
-                    fail("Only the author can supersede this suggestion", {
-                        statusCode: 403,
-                        errorCode: "forbidden",
-                    });
-                }
-                if (prior.status !== "pending")
-                    continue;
-                const claimed = await updateSuggestionStatus(tx, prior.id, "superseded", prior.revision);
-                if (!claimed) {
-                    const latest = await getSuggestion(prior.id, tx);
-                    // A reviewer decided it first; only pending proposals are replaced.
-                    if (latest && latest.status !== "pending")
-                        continue;
-                    fail("The superseded suggestion changed; refresh and try again", {
-                        statusCode: 409,
-                        errorCode: "suggestion_conflict",
-                    });
-                }
-                await recordDecision(tx, {
-                    suggestionId: prior.id,
-                    idempotencyKey: `${args.idempotencyKey}:supersedes:${prior.id}`,
-                    reviewer: authorEmail,
-                    decision: "superseded",
-                    observedBase: prior.baseRevision,
-                    outcome: "superseded",
-                    detail: created.id,
-                });
-                await resolveReviewThreadWithClient(tx, prior.threadId, authorEmail, { resourceType: prior.resourceType, resourceId: prior.resourceId }, "superseded");
-            }
+            await supersedeSuggestions(tx, args, authorEmail, created.id);
             const threadComment = await insertReviewCommentWithClient({
                 resourceType: created.resourceType,
                 resourceId: created.resourceId,
@@ -533,6 +538,11 @@ const proposalCreationSchema = z.object({
         metadata: z.record(z.string(), z.unknown()).optional(),
     }))
         .min(1),
+    supersedes: z
+        .array(z.string().min(1))
+        .max(MAX_SUPERSEDED)
+        .optional()
+        .describe("IDs of your own earlier suggestions on this resource that this proposal replaces. Pending ones become superseded atomically with this creation; already decided ones are left as they are."),
 });
 export const getResourceSuggestionProposalByCreationKey = defineAction({
     description: "Find an earlier proposal creation by its idempotency key before recomputing an edit.",
@@ -565,7 +575,7 @@ export const getResourceSuggestionProposalByCreationKey = defineAction({
     },
 });
 export const createResourceSuggestionProposal = defineAction({
-    description: "Create or append independently reviewable suggestions under one durable proposal.",
+    description: "Create or append independently reviewable suggestions under one durable proposal. Pass supersedes to replace your own earlier pending suggestions on the same resource in the same step.",
     schema: proposalCreationSchema,
     run: async (args, ctx) => {
         await assertReviewableResourceAccess(args.resourceType, args.resourceId, ctx, "commenter");
@@ -582,6 +592,7 @@ export const createResourceSuggestionProposal = defineAction({
             summary: args.summary,
             operations: args.suggestions,
             metadata: { proposalId: args.proposalId ?? null },
+            supersedes: args.supersedes,
         });
         const db = getDbExec();
         await ensureSuggestionTables();
@@ -701,6 +712,7 @@ export const createResourceSuggestionProposal = defineAction({
             const recorded = await recordProposalCreation(tx, args.idempotencyKey, proposal.id, authorEmail, actorKind, requestHash, suggestions.map((suggestion) => suggestion.id));
             if (!recorded)
                 throw concurrentCreation;
+            await supersedeSuggestions(tx, args, authorEmail, suggestions[0].id);
             return { proposal, suggestions, comments };
         })
             .catch(async (error) => {

package/dist/secrets/actions/delete-api-key.js

@@ -29,6 +29,10 @@ export default defineAction({
             ? `Deleted organization key ${args.name}`
             : `Deleted personal key ${args.name}`,
     },
+    // It creates, changes, or revokes a credential or who may use one: every
+    // call needs the user's approval, and "always allow" is not offered.
+    needsApproval: true,
+    allowPersistentApproval: false,
     run: async (args, ctx) => {
         const email = ctx?.userEmail?.trim().toLowerCase();
         if (!email)

package/dist/secrets/routes.d.ts

@@ -65,31 +65,31 @@ export declare function createWriteSecretHandler(): import("h3").EventHandlerWit
     status?: undefined;
     ok?: undefined;
 } | {
-    error?: undefined;
     errorCode?: undefined;
     ok: boolean;
     status: string;
+    error?: undefined;
 } | {
     error: string;
     removed?: undefined;
     ok?: undefined;
 } | {
-    error?: undefined;
     ok: boolean;
     removed: boolean;
+    error?: undefined;
 }>>;
 export declare function createTestSecretHandler(): import("h3").EventHandlerWithFetch<import("h3").EventHandlerRequest, Promise<{
     error: string;
     note?: undefined;
     ok?: undefined;
 } | {
-    error?: undefined;
     ok: boolean;
     note?: undefined;
-} | {
     error?: undefined;
+} | {
     ok: boolean;
     note: string;
+    error?: undefined;
 } | {
     note?: undefined;
     ok: boolean;
@@ -117,11 +117,11 @@ export declare function createAdHocSecretHandler(): import("h3").EventHandlerWit
 } | {
     error: string;
 } | {
-    error?: undefined;
     ok: boolean;
     key: string;
-} | {
     error?: undefined;
+} | {
     ok: boolean;
     removed: boolean;
+    error?: undefined;
 }>>;

package/dist/server/action-approval.d.ts

@@ -0,0 +1,15 @@
+import { actionCallIntent, ActionContractError, preparedCallNeedsApproval, type ActionCaller, type ActionRunContext } from "../action.js";
+/**
+ * The refusal for an HTTP call that needs approval. No HTTP caller can grant
+ * approval: it is given in the app's UI, or in an agent chat or MCP flow that
+ * runs the action in-process.
+ */
+export declare function actionApprovalRequiredError(name: string, caller: ActionCaller, serviceIdentity: boolean): ActionContractError;
+/**
+ * For a dispatcher that runs `entry.run` directly instead of a prepared call
+ * (the generated worker entry): the refusal when this call needs approval.
+ * Arguments that fail validation get no refusal here; the run refuses them.
+ */
+export declare function directHttpActionApprovalRefusal(entry: Parameters<typeof actionCallIntent>[0] & Parameters<typeof preparedCallNeedsApproval>[0], params: unknown, ctx: ActionRunContext & {
+    actionName: string;
+}): Promise<ActionContractError | null>;

package/dist/server/action-approval.js

@@ -0,0 +1,39 @@
+import { actionCallIntent, ActionContractError, preparedCallNeedsApproval, } from "../action.js";
+import { UI_CAPABILITY_REQUIRED_ERROR_CODE } from "../shared/action-error-codes.js";
+/**
+ * The refusal for an HTTP call that needs approval. No HTTP caller can grant
+ * approval: it is given in the app's UI, or in an agent chat or MCP flow that
+ * runs the action in-process.
+ */
+export function actionApprovalRequiredError(name, caller, serviceIdentity) {
+    // The browser client answers this code by minting its UI capability and
+    // retrying once, so the app's own UI is never refused for lacking proof.
+    if (caller === "frontend") {
+        return new ActionContractError(`"${name}" requires approval for these arguments, which only the signed-in app can give.`, { errorCode: UI_CAPABILITY_REQUIRED_ERROR_CODE, statusCode: 403 });
+    }
+    const message = serviceIdentity
+        ? `"${name}" requires human approval for these arguments, and a service identity can never give it. Ask a person to run this action from the app.`
+        : caller === "webmcp"
+            ? `"${name}" requires human approval for these arguments. WebMCP tool calls cannot grant that approval themselves — ask the user to confirm this action in chat, then call it there.`
+            : `"${name}" requires human approval for these arguments, which an HTTP action call cannot grant. Ask the user to approve it in the app's agent chat, or call it as an MCP tool, where the approval flow exists.`;
+    return new ActionContractError(message, {
+        errorCode: "approval_required",
+        statusCode: 409,
+    });
+}
+/**
+ * For a dispatcher that runs `entry.run` directly instead of a prepared call
+ * (the generated worker entry): the refusal when this call needs approval.
+ * Arguments that fail validation get no refusal here; the run refuses them.
+ */
+export async function directHttpActionApprovalRefusal(entry, params, ctx) {
+    if (entry.needsApproval === undefined || entry.needsApproval === false) {
+        return null;
+    }
+    const prepared = await actionCallIntent(entry, params);
+    if (!prepared.valid)
+        return null;
+    return (await preparedCallNeedsApproval(entry, prepared, ctx))
+        ? actionApprovalRequiredError(ctx.actionName, ctx.caller, false)
+        : null;
+}