@visulima/storage 1.0.0-alpha.9 → 1.0.1

package/dist/adapter/nuxt/module.d.ts

@@ -1,39 +1,46 @@
-import type { UploadOptions } from "../../handler/types.d.ts";
-import type { BaseStorage } from "../../storage/storage.d.ts";
-import type { UploadFile } from "../../storage/utils/index.d.ts";
+import { U as UploadOptions } from "../../packem_shared/types.d-CggTCgXr.js";
+import { U as UploadFile, B as BaseStorage } from "../../packem_shared/storage.d-CEM1upWM.js";
+import 'node:stream';
+import 'node:events';
+import 'node:http';
+import '@visulima/pagination';
+import "../../packem_shared/media-transformer.d-Quf4ai47.js";
+import "../../packem_shared/types.d-CrUWY4On.js";
+import 'node:crypto';
+import 'lru-cache';
 /**
- * CORS configuration for upload endpoints
- */
-export interface CorsOptions {
-    /** Allowed CORS headers */
-    headers?: string[];
-    /** Allowed HTTP methods */
-    methods?: string[];
-    /** Allowed origins (use "*" for all origins) */
-    origin?: string | string[];
+* CORS configuration for upload endpoints
+*/
+interface CorsOptions {
+  /** Allowed CORS headers */
+  headers?: string[];
+  /** Allowed HTTP methods */
+  methods?: string[];
+  /** Allowed origins (use "*" for all origins) */
+  origin?: string | string[];
 }
 /**
- * Configuration options for the Nuxt storage module
- */
-export interface ModuleOptions {
-    /** Base path for upload routes (default: '/api/upload') */
-    basePath?: string;
-    /** CORS configuration */
-    cors?: CorsOptions;
-    /** Enable multipart upload endpoint (default: true) */
-    multipart?: boolean;
-    /** Additional options for multipart handler */
-    multipartOptions?: Omit<UploadOptions<UploadFile>, "storage">;
-    /** Enable REST API endpoint for direct binary uploads (default: true) */
-    rest?: boolean;
-    /** Additional options for REST handler */
-    restOptions?: Omit<UploadOptions<UploadFile>, "storage">;
-    /** Storage instance to use for file uploads */
-    storage: BaseStorage;
-    /** Enable TUS resumable upload endpoint (default: true) */
-    tus?: boolean;
-    /** Additional options for TUS handler */
-    tusOptions?: Omit<UploadOptions<UploadFile>, "storage">;
+* Configuration options for the Nuxt storage module
+*/
+interface ModuleOptions {
+  /** Base path for upload routes (default: '/api/upload') */
+  basePath?: string;
+  /** CORS configuration */
+  cors?: CorsOptions;
+  /** Enable multipart upload endpoint (default: true) */
+  multipart?: boolean;
+  /** Additional options for multipart handler */
+  multipartOptions?: Omit<UploadOptions<UploadFile>, "storage">;
+  /** Enable REST API endpoint for direct binary uploads (default: true) */
+  rest?: boolean;
+  /** Additional options for REST handler */
+  restOptions?: Omit<UploadOptions<UploadFile>, "storage">;
+  /** Storage instance to use for file uploads */
+  storage: BaseStorage;
+  /** Enable TUS resumable upload endpoint (default: true) */
+  tus?: boolean;
+  /** Additional options for TUS handler */
+  tusOptions?: Omit<UploadOptions<UploadFile>, "storage">;
 }
 declare const nuxtModule: any;
-export default nuxtModule;
+export { CorsOptions, ModuleOptions, nuxtModule as default };

package/dist/adapter/nuxt/module.js

@@ -1,93 +1 @@
-import { defineNuxtModule } from '@nuxt/kit';
-
-const handlerStorage = /* @__PURE__ */ new Map();
-const nuxtModule = defineNuxtModule({
-  defaults: {
-    basePath: "/api/upload",
-    cors: {
-      headers: ["Content-Type", "Upload-Offset", "Upload-Length", "Tus-Resumable"],
-      methods: ["GET", "POST", "PATCH", "PUT", "HEAD", "DELETE", "OPTIONS"],
-      origin: "*"
-    },
-    multipart: true,
-    rest: true,
-    tus: true
-  },
-  meta: {
-    compatibility: {
-      nuxt: ">=4.0.0"
-    },
-    configKey: "storage",
-    name: "@visulima/storage"
-  },
-  async setup(options, nuxt) {
-    const {
-      basePath = "/api/upload",
-      cors = {
-        headers: ["Content-Type", "Upload-Offset", "Upload-Length", "Tus-Resumable"],
-        methods: ["GET", "POST", "PATCH", "PUT", "HEAD", "DELETE", "OPTIONS"],
-        origin: "*"
-      },
-      multipart = true,
-      multipartOptions = {},
-      rest = true,
-      restOptions = {},
-      storage,
-      tus = true,
-      tusOptions = {}
-    } = options;
-    if (!storage) {
-      throw new Error("[@visulima/storage/nuxt] Storage instance is required");
-    }
-    const { Multipart, Rest, Tus } = await import('../../handler/http/node/index.js');
-    const multipartHandler = multipart ? new Multipart({ storage, ...multipartOptions }) : void 0;
-    const restHandler = rest ? new Rest({ storage, ...restOptions }) : void 0;
-    const tusHandler = tus ? new Tus({ storage, ...tusOptions }) : void 0;
-    const setCorsHeaders = (event) => {
-      const origin = Array.isArray(cors.origin) ? cors.origin.join(", ") : cors.origin || "*";
-      event.node.res.setHeader("Access-Control-Allow-Origin", origin);
-      if (cors.methods) {
-        event.node.res.setHeader("Access-Control-Allow-Methods", cors.methods.join(", "));
-      }
-      if (cors.headers) {
-        event.node.res.setHeader("Access-Control-Allow-Headers", cors.headers.join(", "));
-      }
-    };
-    if (multipartHandler) {
-      handlerStorage.set(`${basePath}/multipart`, { handler: multipartHandler, setCorsHeaders });
-    }
-    if (restHandler) {
-      handlerStorage.set(`${basePath}/rest`, { handler: restHandler, setCorsHeaders });
-    }
-    if (tusHandler) {
-      handlerStorage.set(`${basePath}/tus`, { handler: tusHandler, setCorsHeaders });
-    }
-    nuxt.hook("nitro:config", (nitroConfig) => {
-      const routeRules = nitroConfig.routeRules || {};
-      if (multipartHandler) {
-        routeRules[`${basePath}/multipart/**`] = { cors: true };
-      }
-      if (restHandler) {
-        routeRules[`${basePath}/rest/**`] = { cors: true };
-      }
-      if (tusHandler) {
-        routeRules[`${basePath}/tus/**`] = { cors: true };
-      }
-      nitroConfig.routeRules = routeRules;
-    });
-    nuxt.hook("nitro:init", (nitro) => {
-      nitro.hooks.hook("request", async (event) => {
-        const url = event.node.req.url || "";
-        for (const [route, { handler, setCorsHeaders: setHeaders }] of handlerStorage.entries()) {
-          if (url.startsWith(route)) {
-            setHeaders(event);
-            await handler.handle(event.node.req, event.node.res);
-            return;
-          }
-        }
-      });
-    });
-  }
-});
-
-export { nuxtModule as default };
+import{defineNuxtModule as y}from"@nuxt/kit";const a=new Map,$=y({defaults:{basePath:"/api/upload",cors:{headers:["Content-Type","Upload-Offset","Upload-Length","Tus-Resumable"],methods:["GET","POST","PATCH","PUT","HEAD","DELETE","OPTIONS"],origin:"*"},multipart:!0,rest:!0,tus:!0},meta:{compatibility:{nuxt:">=4.0.0"},configKey:"storage",name:"@visulima/storage"},async setup(c,l){const{basePath:r="/api/upload",cors:s={headers:["Content-Type","Upload-Offset","Upload-Length","Tus-Resumable"],methods:["GET","POST","PATCH","PUT","HEAD","DELETE","OPTIONS"],origin:"*"},multipart:h=!0,multipartOptions:p={},rest:m=!0,restOptions:g={},storage:o,tus:T=!0,tusOptions:f={}}=c;if(!o)throw new Error("[@visulima/storage/nuxt] Storage instance is required");const{Multipart:A,Rest:H,Tus:O}=await import("../../handler/http/node/index.js"),n=h?new A({storage:o,...p}):void 0,i=m?new H({storage:o,...g}):void 0,u=T?new O({storage:o,...f}):void 0,d=t=>{const e=Array.isArray(s.origin)?s.origin.join(", "):s.origin||"*";t.node.res.setHeader("Access-Control-Allow-Origin",e),s.methods&&t.node.res.setHeader("Access-Control-Allow-Methods",s.methods.join(", ")),s.headers&&t.node.res.setHeader("Access-Control-Allow-Headers",s.headers.join(", "))};n&&a.set(`${r}/multipart`,{handler:n,setCorsHeaders:d}),i&&a.set(`${r}/rest`,{handler:i,setCorsHeaders:d}),u&&a.set(`${r}/tus`,{handler:u,setCorsHeaders:d}),l.hook("nitro:config",t=>{const e=t.routeRules||{};n&&(e[`${r}/multipart/**`]={cors:!0}),i&&(e[`${r}/rest/**`]={cors:!0}),u&&(e[`${r}/tus/**`]={cors:!0}),t.routeRules=e}),l.hook("nitro:init",t=>{t.hooks.hook("request",async e=>{const w=e.node.req.url||"";for(const[E,{handler:C,setCorsHeaders:P}]of a.entries())if(w.startsWith(E)){P(e),await C.handle(e.node.req,e.node.res);return}})})}});export{$ as default};

package/dist/adapter/nuxt/package.json

@@ -2,12 +2,6 @@
     "name": "@visulima/storage-nuxt",
     "version": "0.0.0",
     "type": "module",
-    "exports": {
-        ".": {
-            "types": "./module.d.ts",
-            "import": "./module.js"
-        }
-    },
     "main": "./module.js",
     "types": "./module.d.ts",
     "files": [

package/dist/ai/ai-sdk/index.d.ts

@@ -0,0 +1,113 @@
+import { F as Files } from "../../packem_shared/files.d-CH0iLBNC.js";
+import 'node:stream';
+import 'node:crypto';
+import 'node:http';
+import 'lru-cache';
+import { C as CopyFileInput, D as DeleteFileInput, a as DownloadFileInput, G as GetFileMetadataInput, b as GetFileUrlInput, L as ListFilesInput, S as SignUploadUrlInput, U as UploadFileInput, F as FileToolName, A as ApprovalConfig, c as FileReadToolName } from "../../packem_shared/approval.d-CMAYH9GF.js";
+export type { d as FileWriteToolName } from "../../packem_shared/approval.d-CMAYH9GF.js";
+import { Tool } from 'ai';
+import { e as executors } from "../../packem_shared/executors.d-BZP2rWo3.js";
+import "../../packem_shared/storage.d-CEM1upWM.js";
+import 'zod';
+/**
+* Common options accepted by every write-tool factory.
+*/
+interface ToolOptions {
+  needsApproval?: boolean;
+}
+/**
+* Per-tool overrides for customizing AI SDK `tool()` properties without
+* changing the underlying implementation. Core properties (`execute`,
+* `inputSchema`, `outputSchema`) are intentionally excluded — those drive
+* the tool's behavior and contract and shouldn't be patched at this layer.
+*/
+type ToolOverrides = Partial<Pick<Tool, "description" | "needsApproval" | "onInputAvailable" | "onInputDelta" | "onInputStart" | "providerOptions" | "toModelOutput">>;
+type ListFilesOutput = Awaited<ReturnType<typeof executors.listFiles>>;
+type GetFileMetadataOutput = Awaited<ReturnType<typeof executors.getFileMetadata>>;
+type DownloadFileOutput = Awaited<ReturnType<typeof executors.downloadFile>>;
+type GetFileUrlOutput = Awaited<ReturnType<typeof executors.getFileUrl>>;
+type UploadFileOutput = Awaited<ReturnType<typeof executors.uploadFile>>;
+type DeleteFileOutput = Awaited<ReturnType<typeof executors.deleteFile>>;
+type CopyFileOutput = Awaited<ReturnType<typeof executors.copyFile>>;
+type SignUploadUrlOutput = Awaited<ReturnType<typeof executors.signUploadUrl>>;
+declare const listFiles: (files: Files) => Tool<ListFilesInput, ListFilesOutput>;
+declare const getFileMetadata: (files: Files) => Tool<GetFileMetadataInput, GetFileMetadataOutput>;
+declare const downloadFile: (files: Files) => Tool<DownloadFileInput, DownloadFileOutput>;
+declare const getFileUrl: (files: Files) => Tool<GetFileUrlInput, GetFileUrlOutput>;
+declare const uploadFile: (files: Files, {
+  needsApproval
+}?: ToolOptions) => Tool<UploadFileInput, UploadFileOutput>;
+declare const deleteFile: (files: Files, {
+  needsApproval
+}?: ToolOptions) => Tool<DeleteFileInput, DeleteFileOutput>;
+declare const copyFile: (files: Files, {
+  needsApproval
+}?: ToolOptions) => Tool<CopyFileInput, CopyFileOutput>;
+declare const signUploadUrl: (files: Files, {
+  needsApproval
+}?: ToolOptions) => Tool<SignUploadUrlInput, SignUploadUrlOutput>;
+interface FileToolsOptions {
+  /**
+  * The configured `Files` instance the tools will operate against.
+  * Each tool delegates to the methods on this instance.
+  */
+  files: Files;
+  /**
+  * Per-tool overrides for customizing tool behavior (description, title,
+  * needsApproval, etc.) without changing the underlying implementation.
+  * `execute` and `inputSchema` cannot be overridden.
+  */
+  overrides?: Partial<Record<FileToolName, ToolOverrides>>;
+  /**
+  * When `true`, write tools (`uploadFile`, `deleteFile`, `copyFile`,
+  * `signUploadUrl`) are omitted entirely. The model cannot mutate the
+  * bucket regardless of approval configuration.
+  */
+  readOnly?: boolean;
+  /**
+  * Approval gating for write tools. Defaults to `true` (all writes
+  * require approval). See {@link ApprovalConfig}.
+  */
+  requireApproval?: ApprovalConfig;
+}
+interface FileTools {
+  copyFile: ReturnType<typeof copyFile>;
+  deleteFile: ReturnType<typeof deleteFile>;
+  downloadFile: ReturnType<typeof downloadFile>;
+  getFileMetadata: ReturnType<typeof getFileMetadata>;
+  getFileUrl: ReturnType<typeof getFileUrl>;
+  listFiles: ReturnType<typeof listFiles>;
+  signUploadUrl: ReturnType<typeof signUploadUrl>;
+  uploadFile: ReturnType<typeof uploadFile>;
+}
+type ReadOnlyFileTools = Pick<FileTools, FileReadToolName>;
+/**
+* Create a set of visulima/storage tools for the Vercel AI SDK.
+*
+* Write operations require user approval by default. Control globally or
+* per-tool via `requireApproval`, or strip writes entirely with
+* `readOnly: true`.
+* @example
+* ```ts
+* import { Files } from "@visulima/storage";
+* import { S3Storage } from "@visulima/storage/provider/aws";
+* import { createFileTools } from "@visulima/storage/ai/sdk";
+* import { generateText } from "ai";
+*
+* const files = new Files({ adapter: new S3Storage({ bucket: "uploads" }) });
+*
+* const result = await generateText({
+*   model,
+*   tools: createFileTools({ files }),
+*   prompt: "Find every CSV under reports/ and summarize the latest one.",
+* });
+* ```
+*/
+declare function createFileTools(options: FileToolsOptions & {
+  readOnly: true;
+}): ReadOnlyFileTools;
+declare function createFileTools(options: FileToolsOptions & {
+  readOnly?: false | undefined;
+}): FileTools;
+declare function createFileTools(options: FileToolsOptions): FileTools | ReadOnlyFileTools;
+export { type ApprovalConfig, type FileReadToolName, type FileToolName, FileTools, FileToolsOptions, ReadOnlyFileTools, type ToolOptions, type ToolOverrides, copyFile, createFileTools, deleteFile, downloadFile, getFileMetadata, getFileUrl, listFiles, signUploadUrl, uploadFile };

package/dist/ai/ai-sdk/index.js

@@ -0,0 +1 @@
+import{r as d}from"../../packem_shared/approval-fVHwBp7u.js";import{W as n}from"../../packem_shared/executors-BDzMjc4y.js";import{uploadFile as F,signUploadUrl as c,listFiles as f,getFileUrl as g,getFileMetadata as U,downloadFile as m,deleteFile as u,copyFile as O}from"../../packem_shared/copyFile-49FtxXcm.js";function y({files:e,overrides:r,readOnly:s=!1,requireApproval:p=!0}){const o=l=>({needsApproval:d(l,p)}),i={copyFile:O(e,o("copyFile")),deleteFile:u(e,o("deleteFile")),downloadFile:m(e),getFileMetadata:U(e),getFileUrl:g(e),listFiles:f(e),signUploadUrl:c(e,o("signUploadUrl")),uploadFile:F(e,o("uploadFile"))};if(r){for(const[l,t]of Object.entries(r))if(l in i&&t){const a=l;Object.assign(i,{[a]:{...i[a],...t}})}}return s?Object.fromEntries(Object.entries(i).filter(([l])=>!n.has(l))):i}export{O as copyFile,y as createFileTools,u as deleteFile,m as downloadFile,U as getFileMetadata,g as getFileUrl,f as listFiles,c as signUploadUrl,F as uploadFile};

package/dist/ai/claude/index.d.ts

@@ -0,0 +1,177 @@
+import { SdkMcpToolDefinition, CanUseTool, McpSdkServerConfigWithInstance } from '@anthropic-ai/claude-agent-sdk';
+import { F as Files } from "../../packem_shared/files.d-CH0iLBNC.js";
+import 'node:stream';
+import 'node:crypto';
+import 'node:http';
+import 'lru-cache';
+import { T as TOOL_SCHEMAS, F as FileToolName, A as ApprovalConfig } from "../../packem_shared/approval.d-CMAYH9GF.js";
+export type { c as FileReadToolName, d as FileWriteToolName } from "../../packem_shared/approval.d-CMAYH9GF.js";
+import "../../packem_shared/storage.d-CEM1upWM.js";
+import 'zod';
+/**
+* MCP tool annotations as accepted by `tool()` and exposed on
+* `SdkMcpToolDefinition`. Re-derived from the SDK rather than imported from
+* `@modelcontextprotocol/sdk` directly to avoid taking on a second peer
+* dependency.
+*/
+type ToolAnnotations = NonNullable<SdkMcpToolDefinition["annotations"]>;
+/**
+* Per-tool overrides for `createClaudeFileTools`. `name`, `inputSchema`, and
+* `handler` are intentionally not overridable — the contract that drives tool
+* behavior should not be patched at this layer.
+*/
+interface ClaudeToolOverrides {
+  annotations?: ToolAnnotations;
+  description?: string;
+}
+interface ClaudeWriteToolOptions {
+  annotations?: ToolAnnotations;
+}
+type ListFilesShape = (typeof TOOL_SCHEMAS.listFiles.input)["shape"];
+type GetFileMetadataShape = (typeof TOOL_SCHEMAS.getFileMetadata.input)["shape"];
+type DownloadFileShape = (typeof TOOL_SCHEMAS.downloadFile.input)["shape"];
+type GetFileUrlShape = (typeof TOOL_SCHEMAS.getFileUrl.input)["shape"];
+type UploadFileShape = (typeof TOOL_SCHEMAS.uploadFile.input)["shape"];
+type DeleteFileShape = (typeof TOOL_SCHEMAS.deleteFile.input)["shape"];
+type CopyFileShape = (typeof TOOL_SCHEMAS.copyFile.input)["shape"];
+type SignUploadUrlShape = (typeof TOOL_SCHEMAS.signUploadUrl.input)["shape"];
+declare const claudeListFiles: (files: Files) => SdkMcpToolDefinition<ListFilesShape>;
+declare const claudeGetFileMetadata: (files: Files) => SdkMcpToolDefinition<GetFileMetadataShape>;
+declare const claudeDownloadFile: (files: Files) => SdkMcpToolDefinition<DownloadFileShape>;
+declare const claudeGetFileUrl: (files: Files) => SdkMcpToolDefinition<GetFileUrlShape>;
+declare const claudeUploadFile: (files: Files, {
+  annotations
+}?: ClaudeWriteToolOptions) => SdkMcpToolDefinition<UploadFileShape>;
+declare const claudeDeleteFile: (files: Files, {
+  annotations
+}?: ClaudeWriteToolOptions) => SdkMcpToolDefinition<DeleteFileShape>;
+declare const claudeCopyFile: (files: Files, {
+  annotations
+}?: ClaudeWriteToolOptions) => SdkMcpToolDefinition<CopyFileShape>;
+declare const claudeSignUploadUrl: (files: Files, {
+  annotations
+}?: ClaudeWriteToolOptions) => SdkMcpToolDefinition<SignUploadUrlShape>;
+interface ClaudeFileToolsOptions {
+  /**
+  * The configured `Files` instance the tools will operate against.
+  */
+  files: Files;
+  /**
+  * Per-tool overrides for `description` / `annotations` without touching
+  * the underlying handler or input schema.
+  */
+  overrides?: Partial<Record<FileToolName, ClaudeToolOverrides>>;
+  /**
+  * When `true`, write tools (`uploadFile`, `deleteFile`, `copyFile`,
+  * `signUploadUrl`) are omitted from the MCP server. The model cannot
+  * mutate the bucket regardless of approval configuration.
+  */
+  readOnly?: boolean;
+  /**
+  * Approval gating reflected by {@link ClaudeFileTools.needsApproval} and
+  * the bundled {@link ClaudeFileTools.canUseTool}. Defaults to `true`
+  * (every write requires approval). Pass `false` to disable, or an object
+  * keyed by write-tool name for fine-grained control.
+  */
+  requireApproval?: ApprovalConfig;
+  /**
+  * Name of the in-process MCP server that wraps these tools. Affects the
+  * `mcp__&lt;server-name>__&lt;tool-name>` strings the agent uses to address
+  * each tool. Defaults to `"files"`.
+  */
+  serverName?: string;
+  /**
+  * MCP server `version` metadata. Defaults to `"1.0.0"`.
+  */
+  serverVersion?: string;
+}
+interface ClaudeFileTools {
+  /**
+  * Pass into `query({ options: { allowedTools: tools.allowedTools } })`.
+  * Each entry is of the form `mcp__&lt;serverName>__&lt;toolName>`.
+  */
+  allowedTools: string[];
+  /**
+  * Ready-made `canUseTool` callback. Allows reads unconditionally, allows
+  * writes whose `needsApproval` resolves to `false`, denies the rest with
+  * a `"requires approval"` message. Pass directly into `query()`, or
+  * compose your own using {@link ClaudeFileTools.needsApproval}.
+  */
+  canUseTool: CanUseTool;
+  /**
+  * Pass into `query({ options: { mcpServers: tools.mcpServers } })`.
+  */
+  mcpServers: Record<string, McpSdkServerConfigWithInstance>;
+  /**
+  * Whether the named tool is approval-gated under the configured
+  * `requireApproval`. Accepts both bare names (`"uploadFile"`) and the
+  * MCP-prefixed form (`"mcp__files__uploadFile"`). Read tools and unknown
+  * names return `false`.
+  */
+  needsApproval: (toolName: string) => boolean;
+  /**
+  * The raw SDK MCP server instance — same value as
+  * `mcpServers[serverName]`. Exposed for callers that want to compose it
+  * into a larger `mcpServers` map.
+  */
+  server: McpSdkServerConfigWithInstance;
+  /**
+  * The MCP server name used in the `mcp__&lt;server>__*` prefix.
+  */
+  serverName: string;
+}
+/**
+* Create storage tools shaped for the Claude Agent SDK
+* (`@anthropic-ai/claude-agent-sdk`).
+*
+* The Claude Agent SDK consumes tools by way of an in-process MCP server +
+* an `allowedTools` allow-list + a `canUseTool` approval callback. The
+* returned bundle gives you all three, plus the raw server instance and a
+* `needsApproval()` helper if you want to wire your own `canUseTool`.
+* @example
+* ```ts
+* import { query } from "@anthropic-ai/claude-agent-sdk";
+* import { Files } from "@visulima/storage";
+* import { S3Storage } from "@visulima/storage/provider/aws";
+* import { createClaudeFileTools } from "@visulima/storage/ai/claude";
+*
+* const files = new Files({ adapter: new S3Storage({ bucket: "uploads" }) });
+* const tools = createClaudeFileTools({ files });
+*
+* for await (const message of query({
+*   prompt: "List my files.",
+*   options: {
+*     mcpServers: tools.mcpServers,
+*     allowedTools: tools.allowedTools,
+*     canUseTool: tools.canUseTool,
+*   },
+* })) {
+*   // handle messages
+* }
+* ```
+* @example Read-only agent
+* ```ts
+* createClaudeFileTools({ files, readOnly: true })
+* ```
+* @example Granular approval
+* ```ts
+* createClaudeFileTools({
+*   files,
+*   requireApproval: {
+*     copyFile: false,
+*     deleteFile: true,
+*     signUploadUrl: true,
+*     uploadFile: false,
+*   },
+* })
+* ```
+*/
+declare const createClaudeFileTools: ({
+  files,
+  overrides,
+  readOnly,
+  requireApproval,
+  serverName,
+  serverVersion
+}: ClaudeFileToolsOptions) => ClaudeFileTools;
+export { type ApprovalConfig, ClaudeFileTools, ClaudeFileToolsOptions, type ClaudeToolOverrides, type ClaudeWriteToolOptions, type FileToolName, type ToolAnnotations, claudeCopyFile, claudeDeleteFile, claudeDownloadFile, claudeGetFileMetadata, claudeGetFileUrl, claudeListFiles, claudeSignUploadUrl, claudeUploadFile, createClaudeFileTools };

package/dist/ai/claude/index.js

@@ -0,0 +1 @@
+import{createSdkMcpServer as g}from"@anthropic-ai/claude-agent-sdk";import{r as T}from"../../packem_shared/approval-fVHwBp7u.js";import{W as _}from"../../packem_shared/executors-BDzMjc4y.js";import{claudeUploadFile as h,claudeSignUploadUrl as w,claudeListFiles as S,claudeGetFileUrl as O,claudeGetFileMetadata as b,claudeDownloadFile as y,claudeDeleteFile as A,claudeCopyFile as M}from"../../packem_shared/claudeCopyFile-BX9O4ORk.js";const $="files",E="1.0.0",n=l=>_.has(l),x=({files:l,overrides:i,readOnly:m=!1,requireApproval:u=!0,serverName:a=$,serverVersion:v=E})=>{const o={copyFile:M(l),deleteFile:A(l),downloadFile:y(l),getFileMetadata:b(l),getFileUrl:O(l),listFiles:S(l),signUploadUrl:w(l),uploadFile:h(l)};if(i){for(const[e,r]of Object.entries(i))if(e in o&&r){const c=e;o[c]={...o[c],...r}}}const s=Object.entries(o).filter(([e])=>!(m&&n(e))),t=`mcp__${a}__`,F=e=>e.startsWith(t)?e.slice(t.length):e,f=new Set(s.map(([e])=>e)),d=e=>{const r=F(e);return!f.has(r)||!n(r)?!1:T(r,u)},U=(e,r)=>Promise.resolve(d(e)?{behavior:"deny",message:`Tool "${e}" requires approval.`}:{behavior:"allow",updatedInput:r}),p=g({name:a,tools:s.map(([,e])=>e),version:v});return{allowedTools:s.map(([e])=>`${t}${e}`),canUseTool:U,mcpServers:{[a]:p},needsApproval:d,server:p,serverName:a}};export{M as claudeCopyFile,A as claudeDeleteFile,y as claudeDownloadFile,b as claudeGetFileMetadata,O as claudeGetFileUrl,S as claudeListFiles,w as claudeSignUploadUrl,h as claudeUploadFile,x as createClaudeFileTools};