@superblocksteam/vite-plugin-file-sync 2.0.115-next.0 → 2.0.115-next.2

package/dist/ai-service/agent/tools/integrations/execute-request.js

@@ -1,6 +1,6 @@
 import z from "zod";
 import { AiEntityType, AiPermissionType, } from "@superblocksteam/library-shared/types";
-import { ActionResponseType, CosmosDbPlugin, DatabricksPlugin, DynamoDBPlugin, EditorLanguage, ExtendedIntegrationPluginId, GCSPlugin, GraphQLIntegrationPluginMergedFieldNames, HttpMethod, MongoDBPlugin, RestApiFields, S3ActionType, S3Plugin, SalesforcePlugin, } from "@superblocksteam/shared";
+import { ActionResponseType, CosmosDbPlugin, DatabricksPlugin, DynamoDBPlugin, EditorLanguage, ExtendedIntegrationPluginId, GCSPlugin, GraphQLIntegrationPluginMergedFieldNames, MongoDBPlugin, RestApiBodyDataType, RestApiFields, S3ActionType, S3Plugin, SalesforcePlugin, } from "@superblocksteam/shared";
 import { getLogger } from "../../../../util/logger.js";
 import { createToolFactory, ToolCategory, PermissionLevel, ToolExecutionError, } from "../../tools2/types.js";
 import { codeBlock } from "../../tools2/utils.js";
@@ -42,6 +42,219 @@ Focus on the domain names, the specific number of records if limited, and the ta
 CRITICAL: Always specify which integration is being used with the format @IntegrationName[id=INTEGRATION_ID] where INTEGRATION_ID is the integrationId parameter and IntegrationName is the tagName of the integration.
 DO NOT explain why or include context.
 `;
+// Hoisted out of the factory so `classifyPermissionType` and tests can derive
+// their argument types directly from the schema via `z.infer`, instead of
+// manually duplicating the discriminated union (which would silently drift
+// when plugin types or fields are added).
+const inputSchema = z.object({
+    integrationId: z.string().min(1).describe("The ID of the integration"),
+    operation: z
+        .enum(["read", "write"])
+        .describe("Declare whether this request only reads data (read) or creates/updates/deletes data (write). " +
+        "This is only consulted for ambiguous cases — REST POST requests and 'other' plugin types — " +
+        "where intent cannot be determined structurally. For SQL/Salesforce/GraphQL/S3/DynamoDB/GCS/" +
+        "CosmosDB/MongoDB, intent is derived from the query or schema and this field is effectively ignored. " +
+        "For REST PUT/PATCH/DELETE, it is always treated as a write regardless of this field. " +
+        "Still set it accurately: choose 'read' for queries, searches, lists, and fetches; 'write' for " +
+        "anything that modifies server state. Write operations require user approval."),
+    description: z.object({
+        request: z.string().min(1).describe(`
+      ${DESCRIPTION_BASE_PROMPT}
+      Phrased as a request for permission.
+      Examples: "Ok if I read 20 orders from @DemoOrders[id=abc123]?", "Ok if I read 5 rows from the users table of @Postgres[id=xyz789]?", "Ok if I read 10 issues from @Linear[id=def456]?".
+    `),
+        present: z.string().min(1).describe(`
+      ${DESCRIPTION_BASE_PROMPT}.
+      Phrased as a present tense statement.
+      Examples: "Reading 20 orders from @DemoOrders[id=abc123]", "Reading 5 rows from the users table of @Postgres[id=xyz789]", "Reading 10 issues from @Linear[id=def456]".
+    `),
+        past: z.string().min(1).describe(`
+      ${DESCRIPTION_BASE_PROMPT}.
+      Phrased as a past tense statement.
+      Examples: "Read 20 orders from @DemoOrders[id=abc123]", "Read 5 rows from the users table of @Postgres[id=xyz789]", "Read 10 issues from @Linear[id=def456]".
+    `),
+    }),
+    params: z.discriminatedUnion("type", [
+        z.object({
+            type: z.literal("sql"),
+            query: z.string().min(1).describe("The SQL query string to execute"),
+        }),
+        z.object({
+            type: z.literal("graphql"),
+            graphQLQuery: z.object({
+                query: z
+                    .string()
+                    .min(1)
+                    .describe("The GraphQL query string to execute"),
+                variables: z
+                    .record(z.unknown())
+                    .optional()
+                    .describe("Optional variables for the GraphQL query"),
+                headers: z
+                    .record(z.string())
+                    .optional()
+                    .describe("Optional HTTP headers to include in the request"),
+            }),
+        }),
+        z.object({
+            type: z.literal("rest"),
+            httpRequest: z.object({
+                httpMethod: z
+                    .enum(["GET", "POST", "PUT", "PATCH", "DELETE"])
+                    .describe("The HTTP method for the request"),
+                path: z
+                    .string()
+                    .min(1)
+                    .describe("The URL path to the API endpoint, beginning with a '/'"),
+                headers: z
+                    .record(z.string())
+                    .optional()
+                    .describe("Optional HTTP headers to include in the request"),
+                queryParams: z
+                    .record(z.string())
+                    .optional()
+                    .describe("Optional query parameters to include in the request"),
+                body: z
+                    .string()
+                    .optional()
+                    .refine((val) => {
+                    if (val === undefined)
+                        return true;
+                    try {
+                        JSON.parse(val);
+                        return true;
+                    }
+                    catch {
+                        return false;
+                    }
+                }, { message: "body must be a JSON-encoded string" })
+                    .describe("Optional JSON-encoded request body (for POST, PUT, PATCH methods). " +
+                    "Must be a string containing valid JSON — e.g. '{\"foo\": 1}'. " +
+                    "Sent with Content-Type: application/json."),
+            }),
+        }),
+        z.object({
+            type: z.literal("s3"),
+            action: z.enum(S3_READ_ACTIONS).describe("The S3 action to perform"),
+            resource: z
+                .string()
+                .optional()
+                .describe("The S3 bucket name (required for all actions except LIST_BUCKETS)"),
+            path: z
+                .string()
+                .optional()
+                .describe("The object key/path (required for GET_OBJECT and GENERATE_PRESIGNED_URL)"),
+            listFilesConfig: z
+                .object({
+                prefix: z
+                    .string()
+                    .optional()
+                    .describe("Prefix filter for listing objects"),
+                delimiter: z
+                    .string()
+                    .optional()
+                    .describe("Delimiter for hierarchical listing (e.g. '/' for folder-like grouping)"),
+            })
+                .optional()
+                .describe("Configuration for LIST_BUCKET_OBJECTS action"),
+        }),
+        z.object({
+            type: z.literal("cosmosdb"),
+            actionCategory: z
+                .enum(COSMOSDB_READ_CATEGORY_CASES)
+                .describe("The CosmosDB action category: 'sql' for SQL queries, 'pointOperation' for single object actions"),
+            actionCase: z
+                .enum(COSMOSDB_READ_ACTION_CASES)
+                .describe("The specific action: 'singleton' for SQL queries, 'read' for point reads"),
+            containerId: z.string().optional().describe("The CosmosDB container ID"),
+            query: z
+                .string()
+                .optional()
+                .describe("The SQL query string (required for sql/singleton action)"),
+            partitionKey: z
+                .string()
+                .optional()
+                .describe("The partition key for point operations"),
+            id: z
+                .string()
+                .optional()
+                .describe("The item ID (required for pointOperation/read action)"),
+        }),
+        z.object({
+            type: z.literal("dynamodb"),
+            action: z
+                .enum(DYNAMODB_READ_ACTIONS)
+                .describe("The DynamoDB action to perform (read-only)"),
+            body: z
+                .string()
+                .optional()
+                .describe("JSON string of DynamoDB request parameters (e.g. TableName, Key, FilterExpression)"),
+        }),
+        z.object({
+            type: z.literal("gcs"),
+            action: z
+                .enum(GCS_READ_ACTIONS)
+                .describe("The GCS action to perform (read-only)"),
+            resource: z
+                .string()
+                .optional()
+                .describe("The GCS bucket name (required for all actions except LIST_BUCKETS)"),
+            path: z
+                .string()
+                .optional()
+                .describe("The object key/path (required for GET_OBJECT and GENERATE_PRESIGNED_URL)"),
+            prefix: z
+                .string()
+                .optional()
+                .describe("Prefix filter for listing objects or buckets"),
+        }),
+        z.object({
+            type: z.literal("mongodb"),
+            action: z
+                .enum(MONGODB_READ_ACTIONS)
+                .describe("The MongoDB operation to perform (read-only)"),
+            collection: z
+                .string()
+                .optional()
+                .describe("The collection name (required for all actions except listCollections)"),
+            query: z
+                .string()
+                .optional()
+                .describe("JSON query filter for count, distinct, find, findOne operations"),
+            pipeline: z
+                .string()
+                .optional()
+                .describe("JSON aggregation pipeline array for aggregate operation"),
+            projection: z
+                .string()
+                .optional()
+                .describe("JSON projection document for find/findOne operations"),
+            sortby: z
+                .string()
+                .optional()
+                .describe("JSON sort specification for find operation"),
+            limit: z
+                .string()
+                .optional()
+                .describe("Maximum number of documents to return for find operation"),
+            field: z
+                .string()
+                .optional()
+                .describe("Field name for distinct operation"),
+        }),
+        z.object({
+            type: z.literal("salesforce"),
+            query: z.string().min(1).describe("The SOQL query string to execute"),
+        }),
+        z.object({
+            type: z.literal("other"),
+            body: z
+                .string()
+                .min(1)
+                .describe("The body of the request to execute against the integration"),
+        }),
+    ]),
+});
 export const executeRequestToIntegrationToolFactory = createToolFactory("executeRequestToIntegration", ({ clark, services, }) => {
     return {
         category: ToolCategory.DATA,
@@ -51,7 +264,7 @@ export const executeRequestToIntegrationToolFactory = createToolFactory("execute
 
       You can use this tool to query data from databases, APIs, or other external services that the user has connected to their application.
 
-      IMPORTANT: Only read-only operations are supported. Do NOT use this tool for any operations that modify data.
+      Both read-only and write operations are supported. Write operations (creating, updating, or deleting data) will require user approval before execution.
 
       IMPORTANT: SQL queries must include a row limit clause with a maximum of ${MAX_QUERY_LIMIT} rows.
       Supported syntax: LIMIT N (MySQL/PostgreSQL), SELECT TOP N (SQL Server), or FETCH NEXT N ROWS ONLY (ANSI SQL).
@@ -64,7 +277,7 @@ export const executeRequestToIntegrationToolFactory = createToolFactory("execute
       Plugin Types:
       - "sql": For SQL database integrations, including Databricks. Provide a SQL query string.
       - "graphql": For GraphQL integrations (${ExtendedIntegrationPluginId.GRAPHQL}). Provide query, variables, and headers.
-      - "rest": For REST API integrations (${ExtendedIntegrationPluginId.REST_API}). HTTP method is fixed to GET. Provide path, headers, and query parameters.
+      - "rest": For REST API integrations (${ExtendedIntegrationPluginId.REST_API}). Provide HTTP method (GET, POST, PUT, PATCH, DELETE), path, headers, query parameters, and optionally a JSON body.
       - "s3": For Amazon S3 integrations (${S3Plugin.id}). Provide a structured action (LIST_BUCKETS, LIST_BUCKET_OBJECTS, GET_OBJECT, GENERATE_PRESIGNED_URL) with optional resource (bucket name), path, and listFilesConfig.
       - "cosmosdb": For Azure Cosmos DB integrations (${CosmosDbPlugin.id}). Provide a structured action with actionCategory (sql or pointOperation) and actionCase (singleton for SQL queries, read for point reads).
       - "dynamodb": For Amazon DynamoDB integrations (${DynamoDBPlugin.id}). Provide a structured action (getItem, query, scan, listTables, describeTable) with JSON params.
@@ -76,197 +289,7 @@ export const executeRequestToIntegrationToolFactory = createToolFactory("execute
       Authentication is handled automatically based on the integration configuration.
       Response data is returned as a JSON object.
 `,
-        inputSchema: z.object({
-            integrationId: z.string().min(1).describe("The ID of the integration"),
-            description: z.object({
-                request: z.string().min(1).describe(`
-            ${DESCRIPTION_BASE_PROMPT}
-            Phrased as a request for permission.
-            Examples: "Ok if I read 20 orders from @DemoOrders[id=abc123]?", "Ok if I read 5 rows from the users table of @Postgres[id=xyz789]?", "Ok if I read 10 issues from @Linear[id=def456]?".
-          `),
-                present: z.string().min(1).describe(`
-            ${DESCRIPTION_BASE_PROMPT}.
-            Phrased as a present tense statement.
-            Examples: "Reading 20 orders from @DemoOrders[id=abc123]", "Reading 5 rows from the users table of @Postgres[id=xyz789]", "Reading 10 issues from @Linear[id=def456]".
-          `),
-                past: z.string().min(1).describe(`
-            ${DESCRIPTION_BASE_PROMPT}.
-            Phrased as a past tense statement.
-            Examples: "Read 20 orders from @DemoOrders[id=abc123]", "Read 5 rows from the users table of @Postgres[id=xyz789]", "Read 10 issues from @Linear[id=def456]".
-          `),
-            }),
-            params: z.discriminatedUnion("type", [
-                z.object({
-                    type: z.literal("sql"),
-                    query: z
-                        .string()
-                        .min(1)
-                        .describe("The SQL query string to execute"),
-                }),
-                z.object({
-                    type: z.literal("graphql"),
-                    graphQLQuery: z.object({
-                        query: z
-                            .string()
-                            .min(1)
-                            .describe("The GraphQL query string to execute"),
-                        variables: z
-                            .record(z.unknown())
-                            .optional()
-                            .describe("Optional variables for the GraphQL query"),
-                        headers: z
-                            .record(z.string())
-                            .optional()
-                            .describe("Optional HTTP headers to include in the request"),
-                    }),
-                }),
-                z.object({
-                    type: z.literal("rest"),
-                    httpRequest: z.object({
-                        path: z
-                            .string()
-                            .min(1)
-                            .describe("The URL path to the API endpoint, beginning with a '/'"),
-                        headers: z
-                            .record(z.string())
-                            .optional()
-                            .describe("Optional HTTP headers to include in the request"),
-                        queryParams: z
-                            .record(z.string())
-                            .optional()
-                            .describe("Optional query parameters to include in the request"),
-                    }),
-                }),
-                z.object({
-                    type: z.literal("s3"),
-                    action: z
-                        .enum(S3_READ_ACTIONS)
-                        .describe("The S3 action to perform"),
-                    resource: z
-                        .string()
-                        .optional()
-                        .describe("The S3 bucket name (required for all actions except LIST_BUCKETS)"),
-                    path: z
-                        .string()
-                        .optional()
-                        .describe("The object key/path (required for GET_OBJECT and GENERATE_PRESIGNED_URL)"),
-                    listFilesConfig: z
-                        .object({
-                        prefix: z
-                            .string()
-                            .optional()
-                            .describe("Prefix filter for listing objects"),
-                        delimiter: z
-                            .string()
-                            .optional()
-                            .describe("Delimiter for hierarchical listing (e.g. '/' for folder-like grouping)"),
-                    })
-                        .optional()
-                        .describe("Configuration for LIST_BUCKET_OBJECTS action"),
-                }),
-                z.object({
-                    type: z.literal("cosmosdb"),
-                    actionCategory: z
-                        .enum(COSMOSDB_READ_CATEGORY_CASES)
-                        .describe("The CosmosDB action category: 'sql' for SQL queries, 'pointOperation' for single object actions"),
-                    actionCase: z
-                        .enum(COSMOSDB_READ_ACTION_CASES)
-                        .describe("The specific action: 'singleton' for SQL queries, 'read' for point reads"),
-                    containerId: z
-                        .string()
-                        .optional()
-                        .describe("The CosmosDB container ID"),
-                    query: z
-                        .string()
-                        .optional()
-                        .describe("The SQL query string (required for sql/singleton action)"),
-                    partitionKey: z
-                        .string()
-                        .optional()
-                        .describe("The partition key for point operations"),
-                    id: z
-                        .string()
-                        .optional()
-                        .describe("The item ID (required for pointOperation/read action)"),
-                }),
-                z.object({
-                    type: z.literal("dynamodb"),
-                    action: z
-                        .enum(DYNAMODB_READ_ACTIONS)
-                        .describe("The DynamoDB action to perform (read-only)"),
-                    body: z
-                        .string()
-                        .optional()
-                        .describe("JSON string of DynamoDB request parameters (e.g. TableName, Key, FilterExpression)"),
-                }),
-                z.object({
-                    type: z.literal("gcs"),
-                    action: z
-                        .enum(GCS_READ_ACTIONS)
-                        .describe("The GCS action to perform (read-only)"),
-                    resource: z
-                        .string()
-                        .optional()
-                        .describe("The GCS bucket name (required for all actions except LIST_BUCKETS)"),
-                    path: z
-                        .string()
-                        .optional()
-                        .describe("The object key/path (required for GET_OBJECT and GENERATE_PRESIGNED_URL)"),
-                    prefix: z
-                        .string()
-                        .optional()
-                        .describe("Prefix filter for listing objects or buckets"),
-                }),
-                z.object({
-                    type: z.literal("mongodb"),
-                    action: z
-                        .enum(MONGODB_READ_ACTIONS)
-                        .describe("The MongoDB operation to perform (read-only)"),
-                    collection: z
-                        .string()
-                        .optional()
-                        .describe("The collection name (required for all actions except listCollections)"),
-                    query: z
-                        .string()
-                        .optional()
-                        .describe("JSON query filter for count, distinct, find, findOne operations"),
-                    pipeline: z
-                        .string()
-                        .optional()
-                        .describe("JSON aggregation pipeline array for aggregate operation"),
-                    projection: z
-                        .string()
-                        .optional()
-                        .describe("JSON projection document for find/findOne operations"),
-                    sortby: z
-                        .string()
-                        .optional()
-                        .describe("JSON sort specification for find operation"),
-                    limit: z
-                        .string()
-                        .optional()
-                        .describe("Maximum number of documents to return for find operation"),
-                    field: z
-                        .string()
-                        .optional()
-                        .describe("Field name for distinct operation"),
-                }),
-                z.object({
-                    type: z.literal("salesforce"),
-                    query: z
-                        .string()
-                        .min(1)
-                        .describe("The SOQL query string to execute"),
-                }),
-                z.object({
-                    type: z.literal("other"),
-                    body: z
-                        .string()
-                        .min(1)
-                        .describe("The body of the request to execute against the integration"),
-                }),
-            ]),
-        }),
+        inputSchema,
         toModelOutput: ({ output }) => {
             if (output.isPartial) {
                 return {
@@ -451,19 +474,34 @@ export const executeRequestToIntegrationToolFactory = createToolFactory("execute
             }
         },
         getRequiredPermissions: (args) => {
+            const permissionType = classifyPermissionType(args);
             return [
                 {
                     entityType: AiEntityType.INTEGRATION,
                     entityId: args.integrationId,
-                    permissionType: AiPermissionType.READ,
+                    permissionType,
                 },
             ];
         },
-        getActionName: () => ({
-            future: "Query",
-            present: "Querying",
-            past: "Queried",
-        }),
+        getActionName: (input) => {
+            // When the tool is about to perform a write (POST/PUT/PATCH/DELETE,
+            // GraphQL mutation, or an "other"/"write"-declared op), use an
+            // operation-neutral verb in the approval dialog so users aren't
+            // told they're "Querying" an integration right before an update
+            // or delete is executed.
+            if (input && classifyPermissionType(input) === AiPermissionType.WRITE) {
+                return {
+                    future: "Execute",
+                    present: "Executing",
+                    past: "Executed",
+                };
+            }
+            return {
+                future: "Query",
+                present: "Querying",
+                past: "Queried",
+            };
+        },
         formatInput: (args) => {
             const { params, integrationId, description } = args;
             const integration = services.integrationStore.getEntityTag(integrationId) ??
@@ -489,15 +527,16 @@ export const executeRequestToIntegrationToolFactory = createToolFactory("execute
                     };
                 }
                 case "rest": {
-                    const { path, queryParams } = params.httpRequest;
+                    const { httpMethod, path, queryParams, body } = params.httpRequest;
                     const queryString = queryParams
                         ? `?${Object.entries(queryParams)
-                            .map((key, val) => [key, val].join("="))
+                            .map(([key, val]) => `${key}=${val}`)
                             .join("&")}`
                         : "";
+                    const bodySnippet = body ? `\n${body}` : "";
                     return {
                         targets: [integration],
-                        details: codeBlock(`GET ${path}${queryString}`),
+                        details: codeBlock(`${httpMethod} ${path}${queryString}${bodySnippet}`),
                         summary: cleanDescription,
                     };
                 }
@@ -704,7 +743,7 @@ function buildS3Request(params) {
 }
 function buildRestApiRequest(httpRequest) {
     const request = {
-        [RestApiFields.HTTP_METHOD]: HttpMethod.GET,
+        [RestApiFields.HTTP_METHOD]: httpRequest.httpMethod,
         [RestApiFields.URL_PATH]: httpRequest.path,
         [RestApiFields.RESPONSE_TYPE]: ActionResponseType.JSON,
     };
@@ -714,6 +753,10 @@ function buildRestApiRequest(httpRequest) {
     if (httpRequest.queryParams) {
         request[RestApiFields.PARAMS] = recordToProto(httpRequest.queryParams);
     }
+    if (httpRequest.body) {
+        request[RestApiFields.BODY] = httpRequest.body;
+        request[RestApiFields.BODY_TYPE] = RestApiBodyDataType.JSON;
+    }
     return request;
 }
 function buildDynamoDBRequest(params) {
@@ -793,4 +836,87 @@ function buildMongoDBRequest(params) {
     }
     return request;
 }
+/**
+ * Strips GraphQL comments and string literals from a query so that
+ * keyword matching only operates on structural tokens.
+ */
+function stripGraphQLNonCode(query) {
+    return query
+        .replace(/"""[\s\S]*?"""/g, "") // strip block strings
+        .replace(/"(?:[^"\\]|\\.)*"/g, "") // strip double-quoted strings
+        .replace(/#.*$/gm, ""); // strip # comments (after strings so # inside strings is safe)
+}
+/**
+ * Classifies a GraphQL query as READ or WRITE by regex-matching the top-level
+ * operation type keyword on a stripped copy of the document (comments and
+ * string literals removed). This is a structural check, not full AST parsing.
+ *
+ * Handles documents with fragments before operations and multiple operations.
+ * Falls back to WRITE on any error (fail-closed).
+ */
+function classifyGraphQLOperation(query) {
+    try {
+        const stripped = stripGraphQLNonCode(query);
+        // In valid GraphQL, the `mutation` keyword appears as an operation type at
+        // the top level — either at the start of the document or after a closing
+        // brace `}` (e.g. after a fragment definition).
+        if (/(?:^|})[\s]*mutation\b/i.test(stripped)) {
+            return AiPermissionType.WRITE;
+        }
+        return AiPermissionType.READ;
+    }
+    catch (err) {
+        // Fail-closed: treat as WRITE on error. Log so future regressions in the
+        // regex/stripping logic are debuggable instead of silently over-prompting.
+        getLogger().warn("classifyGraphQLOperation failed; falling back to WRITE", err);
+        return AiPermissionType.WRITE;
+    }
+}
+/**
+ * Classifies permission type using a hybrid approach:
+ * 1. Deterministic floor (free): GET→READ, DELETE/PUT/PATCH→WRITE,
+ *    SQL/Salesforce→READ, GraphQL structural check,
+ *    S3/DynamoDB/GCS/CosmosDB/MongoDB→READ.
+ * 2. Clark's declared `operation` for the remaining ambiguous cases:
+ *    REST POST, and the "other" plugin type.
+ *
+ * Note on SQL/Salesforce: classification relies on the DML keyword check in
+ * `execute()` (search for `dmlKeywords`) to actually block writes. If that
+ * enforcement is ever relaxed to allow SQL writes, this function must be
+ * updated in lockstep — otherwise writes will silently bypass user approval.
+ */
+function classifyPermissionType(args) {
+    const { params, operation } = args;
+    // Deterministic floor: SQL/Salesforce always READ (DML keyword check in
+    // execute() — see comment above — blocks writes at request time).
+    if (params.type === "sql" || params.type === "salesforce") {
+        return AiPermissionType.READ;
+    }
+    if (params.type === "graphql") {
+        return classifyGraphQLOperation(params.graphQLQuery.query);
+    }
+    // Deterministic floor for REST: GET is always READ; DELETE/PUT/PATCH are
+    // semantically mutating and always WRITE. Only POST is truly ambiguous
+    // (e.g. search APIs, RPC-style reads) and falls through to Clark's
+    // declared operation below.
+    if (params.type === "rest") {
+        const method = params.httpRequest.httpMethod;
+        if (method === "GET") {
+            return AiPermissionType.READ;
+        }
+        if (method === "DELETE" || method === "PUT" || method === "PATCH") {
+            return AiPermissionType.WRITE;
+        }
+    }
+    // Schema-constrained read-only types (enum limits to read actions)
+    if (params.type === "s3" ||
+        params.type === "dynamodb" ||
+        params.type === "gcs" ||
+        params.type === "cosmosdb" ||
+        params.type === "mongodb") {
+        return AiPermissionType.READ;
+    }
+    // For everything else (REST POST, "other"): trust Clark's declaration.
+    return operation === "write" ? AiPermissionType.WRITE : AiPermissionType.READ;
+}
 //# sourceMappingURL=execute-request.js.map