recker 1.0.72 → 1.0.75-next.2e5a94f

package/dist/mcp/cli.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import { RekCommand as Command } from '../cli/router.js';
 import { MCPServer } from './server.js';
-import { listCategories, validateCategories, estimateCategoryTokens, } from './profiles.js';
+import { listCategories, DEFAULT_CATEGORY, validateCategories, estimateCategoryTokens, } from './profiles.js';
 import { LEGACY_TOOL_GROUPS } from './legacy-tool-groups.js';
 const program = new Command('recker-mcp');
 program
@@ -13,7 +13,7 @@ program
     .option('--docs-path <path>', 'Path to documentation directory')
     .option('--examples-path <path>', 'Path to examples directory')
     .option('--src-path <path>', 'Path to source directory')
-    .option('-c, --category <categories>', 'Tool categories to enable (comma-separated): minimal, docs, network, dns, seo, security, scrape, video, ai, protocols, parsing, streaming, full')
+    .option('-c, --category <categories>', 'Tool categories to enable (comma-separated): minimal, docs, network, dns, seo, security, scrape, video, ai, protocols, parsing, streaming, template, full')
     .option('--list-categories', 'List available categories and exit')
     .option('--no-docs', 'Disable documentation tools (search, get, examples, schema, suggest)')
     .option('--no-http', 'Disable HTTP request tool')
@@ -50,6 +50,7 @@ program
         console.log('');
         process.exit(0);
     }
+    const useExplicitCategory = Boolean(opts.category);
     if (opts.category) {
         const categoryNames = opts.category.split(',').map((p) => p.trim());
         const validation = validateCategories(categoryNames);
@@ -99,6 +100,7 @@ program
         console.error(`Invalid transport mode: ${transport}. Use: stdio, http, or sse`);
         process.exit(1);
     }
+    const effectiveCategory = useExplicitCategory ? opts.category : (!opts.only && !opts.filter ? DEFAULT_CATEGORY : undefined);
     const server = new MCPServer({
         transport,
         port,
@@ -106,8 +108,8 @@ program
         docsPath: opts.docsPath,
         examplesPath: opts.examplesPath,
         srcPath: opts.srcPath,
-        category: opts.category,
-        toolsFilter: !opts.category && toolsFilter.length > 0 ? toolsFilter : undefined,
+        category: effectiveCategory,
+        toolsFilter: !effectiveCategory && toolsFilter.length > 0 ? toolsFilter : undefined,
     });
     if (transport !== 'stdio') {
         console.log('╔═══════════════════════════════════════════════════════════════════╗');
@@ -117,15 +119,15 @@ program
         console.log(`  Transport: ${transport}`);
         console.log(`  Port:      ${port}`);
         console.log(`  Debug:     ${opts.debug ? 'enabled' : 'disabled'}`);
-        if (opts.category) {
-            const tokens = estimateCategoryTokens(opts.category);
-            console.log(`  Category:  ${opts.category} (~${tokens} tokens)`);
+        if (effectiveCategory) {
+            const tokens = estimateCategoryTokens(effectiveCategory);
+            console.log(`  Category:  ${effectiveCategory} (~${tokens} tokens)`);
         }
         else if (toolsFilter.length > 0) {
             console.log(`  Filters:   ${toolsFilter.join(', ')}`);
         }
         else {
-            console.log(`  Category:  full (all tools enabled)`);
+            console.log(`  Category:  minimal (default)`);
         }
         console.log('');
         console.log('  Available tools:');

package/dist/mcp/profiles.d.ts

@@ -1,4 +1,4 @@
-export type CategoryName = 'minimal' | 'docs' | 'network' | 'dns' | 'seo' | 'security' | 'scrape' | 'video' | 'ai' | 'protocols' | 'parsing' | 'streaming' | 'full';
+export type CategoryName = 'minimal' | 'docs' | 'network' | 'dns' | 'seo' | 'security' | 'scrape' | 'video' | 'ai' | 'protocols' | 'parsing' | 'streaming' | 'template' | 'full';
 export interface Category {
     name: CategoryName;
     description: string;

package/dist/mcp/profiles.js

@@ -118,11 +118,10 @@ export const categories = {
     },
     ai: {
         name: 'ai',
-        description: 'Multi-provider AI chat, embeddings, and comparison',
+        description: 'Multi-provider AI chat and comparison',
         icon: '🤖',
         tools: [
             'rek_ai_chat',
-            'rek_ai_embed',
             'rek_ai_providers',
             'rek_ai_tokens',
             'rek_ai_compare',
@@ -173,14 +172,39 @@ export const categories = {
         ],
         estimatedTokens: 900,
     },
+    template: {
+        name: 'template',
+        description: 'Template rendering, validation, parsing, and helper metadata',
+        icon: '📝',
+        tools: [
+            'rek_template_render',
+            'rek_template_validate',
+            'rek_template_parse',
+            'rek_template_variables',
+            'rek_template_check',
+            'rek_template_helpers',
+        ],
+        estimatedTokens: 1800,
+    },
     full: {
         name: 'full',
         description: 'All available tools (high context cost)',
         icon: '🌟',
         tools: ['*'],
-        estimatedTokens: 18000,
+        estimatedTokens: 0,
     },
 };
+function getAllConcreteProfileTools() {
+    const toolNames = new Set();
+    for (const category of Object.values(categories)) {
+        for (const tool of category.tools) {
+            if (tool !== '*') {
+                toolNames.add(tool);
+            }
+        }
+    }
+    return toolNames;
+}
 export const DEFAULT_CATEGORY = 'minimal';
 export const profiles = categories;
 export const DEFAULT_PROFILE = DEFAULT_CATEGORY;
@@ -226,7 +250,7 @@ export function estimateCategoryTokens(categoryNames) {
         if (!category)
             continue;
         if (category.tools.includes('*')) {
-            return category.estimatedTokens;
+            return getAllConcreteProfileTools().size * 300;
         }
         for (const tool of category.tools) {
             if (!seenTools.has(tool)) {
@@ -239,12 +263,13 @@ export function estimateCategoryTokens(categoryNames) {
 }
 export const estimateProfileTokens = estimateCategoryTokens;
 export function listCategories() {
+    const toolCount = getAllConcreteProfileTools().size;
     return Object.values(categories).map((p) => ({
         name: p.name,
         description: p.description,
         icon: p.icon,
-        toolCount: p.tools.includes('*') ? -1 : p.tools.length,
-        estimatedTokens: p.estimatedTokens,
+        toolCount: p.tools.includes('*') ? toolCount : p.tools.length,
+        estimatedTokens: p.estimatedTokens || (p.tools.includes('*') ? toolCount * 300 : p.tools.length * 300),
     }));
 }
 export const listProfiles = listCategories;

package/dist/mcp/tools/categories.js

@@ -97,7 +97,6 @@ export const toolCategories = {
     rek_dns_toolkit: 'security',
     rek_security_headers: 'security',
     rek_ai_chat: 'ai',
-    rek_ai_embed: 'ai',
     rek_ai_providers: 'ai',
     rek_ai_tokens: 'ai',
     rek_ai_compare: 'ai',

package/dist/mcp/tools/seo.js

@@ -1,6 +1,114 @@
+import { promises as fs } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { createHash } from 'node:crypto';
 import { createClient } from '../../core/client.js';
 import { analyzeSeo } from '../../seo/analyzer.js';
 import { seoSpider } from '../../seo/seo-spider.js';
+const DEFAULT_SEO_CACHE_TTL_SEC = 6 * 60 * 60;
+const SEO_REPORT_DIR = join(tmpdir(), 'recker', 'seo');
+function normalizeStringArray(value) {
+    if (!Array.isArray(value))
+        return undefined;
+    const items = value.map(item => String(item).trim()).filter(Boolean);
+    if (items.length === 0)
+        return undefined;
+    return items;
+}
+function safeHost(url) {
+    try {
+        const parsed = new URL(url);
+        const host = parsed.hostname || parsed.host;
+        return host.replace(/[^a-z0-9.-]/gi, '_') || 'unknown';
+    }
+    catch {
+        return url.replace(/[^a-z0-9.-]/gi, '_').slice(0, 64) || 'unknown';
+    }
+}
+function hashArgs(value) {
+    return createHash('sha1').update(JSON.stringify(value)).digest('hex').slice(0, 12);
+}
+function resolveReportPersistence(args, options) {
+    const output = typeof args.output === 'string' ? args.output : undefined;
+    const outputDir = typeof args.outputDir === 'string' ? args.outputDir : undefined;
+    const persist = args.persist === true;
+    const persistenceEnabled = Boolean(output || outputDir || persist);
+    const cacheEnabled = persistenceEnabled ? (typeof args.cache === 'boolean' ? args.cache : true) : false;
+    const forceRefresh = args.forceRefresh === true;
+    const cacheTtlInput = typeof args.cacheTtlSec === 'number'
+        ? args.cacheTtlSec
+        : Number.isFinite(Number(args.cacheTtlSec))
+            ? Number(args.cacheTtlSec)
+            : undefined;
+    const cacheTtlSec = cacheEnabled
+        ? Math.max(0, cacheTtlInput ?? DEFAULT_SEO_CACHE_TTL_SEC)
+        : 0;
+    if (!persistenceEnabled) {
+        return {
+            enabled: false,
+            reportPath: null,
+            cacheEnabled: false,
+            cacheTtlSec: 0,
+            forceRefresh,
+        };
+    }
+    const host = safeHost(options.url);
+    const hash = hashArgs(options.cacheKey);
+    const fileName = `${options.toolSlug}--${host}--${hash}.json`;
+    const reportPath = output
+        ? output
+        : outputDir
+            ? join(outputDir, fileName)
+            : join(SEO_REPORT_DIR, fileName);
+    return {
+        enabled: true,
+        reportPath,
+        cacheEnabled,
+        cacheTtlSec,
+        forceRefresh,
+    };
+}
+async function readCachedReport(path, ttlSec) {
+    if (!path || ttlSec <= 0)
+        return null;
+    try {
+        const stats = await fs.stat(path);
+        const ageSec = (Date.now() - stats.mtimeMs) / 1000;
+        if (ageSec > ttlSec) {
+            return null;
+        }
+        const text = await fs.readFile(path, 'utf8');
+        const report = JSON.parse(text);
+        if (report && typeof report === 'object') {
+            delete report.reportMeta;
+            delete report.note;
+        }
+        return {
+            report,
+            ageSec,
+            bytes: stats.size,
+            savedAt: new Date(stats.mtimeMs).toISOString(),
+        };
+    }
+    catch {
+        return null;
+    }
+}
+async function writeReport(path, payload) {
+    await fs.mkdir(dirname(path), { recursive: true });
+    await fs.writeFile(path, payload, 'utf8');
+    return { bytes: Buffer.byteLength(payload), savedAt: new Date().toISOString() };
+}
+function buildReportMeta(params) {
+    return {
+        reportPath: params.reportPath ?? null,
+        cacheHit: params.cacheHit ?? false,
+        source: params.source,
+        ...(params.cacheAgeSec !== undefined ? { cacheAgeSec: params.cacheAgeSec } : {}),
+        ...(params.savedAt ? { savedAt: params.savedAt } : {}),
+        ...(params.reportBytes !== undefined ? { reportBytes: params.reportBytes } : {}),
+    };
+}
 function formatCheck(check) {
     const icon = check.status === 'pass' ? '✓' : check.status === 'fail' ? '✗' : '⚠';
     let line = `${icon} [${check.status.toUpperCase()}] ${check.name}: ${check.message}`;
@@ -75,14 +183,46 @@ function generateQuickWins(report) {
 }
 async function seoAnalyze(args) {
     const url = String(args.url || '');
-    const categories = args.categories;
+    const categories = normalizeStringArray(args.categories);
     if (!url) {
         return {
             content: [{ type: 'text', text: 'Error: url is required' }],
             isError: true,
         };
     }
+    const persistence = resolveReportPersistence(args, {
+        toolSlug: 'seo',
+        url,
+        cacheKey: {
+            url,
+            categories: categories ? [...categories].sort() : [],
+        },
+    });
     try {
+        if (persistence.enabled && persistence.cacheEnabled && !persistence.forceRefresh && persistence.reportPath) {
+            const cached = await readCachedReport(persistence.reportPath, persistence.cacheTtlSec);
+            if (cached) {
+                const reportMeta = buildReportMeta({
+                    reportPath: persistence.reportPath,
+                    cacheHit: true,
+                    cacheAgeSec: cached.ageSec,
+                    savedAt: cached.savedAt,
+                    reportBytes: cached.bytes,
+                    source: 'cached',
+                });
+                const output = {
+                    ...cached.report,
+                    reportMeta,
+                    note: `Cache hit: report loaded from ${persistence.reportPath}`,
+                };
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify(output, null, 2),
+                        }],
+                };
+            }
+        }
         const client = createClient({ timeout: 30000 });
         const response = await client.get(url);
         const html = await response.text();
@@ -135,10 +275,56 @@ async function seoAnalyze(args) {
             images: report.images,
             technical: report.technical,
         };
+        const reportPayload = JSON.stringify(output, null, 2);
+        let reportMeta = buildReportMeta({
+            reportPath: persistence.reportPath,
+            cacheHit: false,
+            source: 'fresh',
+        });
+        let note = persistence.enabled
+            ? `Report generated (not yet saved).`
+            : 'Report generated (not persisted). Set persist=true to save and enable caching.';
+        if (persistence.enabled && persistence.reportPath) {
+            try {
+                const saved = await writeReport(persistence.reportPath, reportPayload);
+                reportMeta = buildReportMeta({
+                    reportPath: persistence.reportPath,
+                    cacheHit: false,
+                    savedAt: saved.savedAt,
+                    reportBytes: saved.bytes,
+                    source: 'fresh',
+                });
+                note = `Report saved to ${persistence.reportPath}`;
+            }
+            catch (error) {
+                const message = `Failed to save report to ${persistence.reportPath}: ${error.message}`;
+                const failedOutput = {
+                    ...output,
+                    reportMeta,
+                    note: message,
+                };
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify(failedOutput, null, 2),
+                        }],
+                    isError: true,
+                };
+            }
+        }
+        else {
+            reportMeta = buildReportMeta({
+                reportPath: null,
+                cacheHit: false,
+                reportBytes: Buffer.byteLength(reportPayload),
+                savedAt: new Date().toISOString(),
+                source: 'fresh',
+            });
+        }
         return {
             content: [{
                     type: 'text',
-                    text: JSON.stringify(output, null, 2),
+                    text: JSON.stringify({ ...output, reportMeta, note }, null, 2),
                 }],
         };
     }
@@ -165,6 +351,41 @@ async function seoSpiderCrawl(args) {
         };
     }
     try {
+        const persistence = resolveReportPersistence(args, {
+            toolSlug: 'seo-spider',
+            url,
+            cacheKey: {
+                url,
+                maxPages,
+                maxDepth,
+                concurrency,
+                transport,
+            },
+        });
+        if (persistence.enabled && persistence.cacheEnabled && !persistence.forceRefresh && persistence.reportPath) {
+            const cached = await readCachedReport(persistence.reportPath, persistence.cacheTtlSec);
+            if (cached) {
+                const reportMeta = buildReportMeta({
+                    reportPath: persistence.reportPath,
+                    cacheHit: true,
+                    cacheAgeSec: cached.ageSec,
+                    savedAt: cached.savedAt,
+                    reportBytes: cached.bytes,
+                    source: 'cached',
+                });
+                const output = {
+                    ...cached.report,
+                    reportMeta,
+                    note: `Cache hit: report loaded from ${persistence.reportPath}`,
+                };
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify(output, null, 2),
+                        }],
+                };
+            }
+        }
         const result = await seoSpider(url, {
             seo: true,
             maxPages,
@@ -226,10 +447,56 @@ async function seoSpiderCrawl(args) {
         if (recommendations.length > 0) {
             output.recommendations = recommendations;
         }
+        const reportPayload = JSON.stringify(output, null, 2);
+        let reportMeta = buildReportMeta({
+            reportPath: persistence.reportPath,
+            cacheHit: false,
+            source: 'fresh',
+        });
+        let note = persistence.enabled
+            ? 'Report generated (not yet saved).'
+            : 'Report generated (not persisted). Set persist=true to save and enable caching.';
+        if (persistence.enabled && persistence.reportPath) {
+            try {
+                const saved = await writeReport(persistence.reportPath, reportPayload);
+                reportMeta = buildReportMeta({
+                    reportPath: persistence.reportPath,
+                    cacheHit: false,
+                    savedAt: saved.savedAt,
+                    reportBytes: saved.bytes,
+                    source: 'fresh',
+                });
+                note = `Report saved to ${persistence.reportPath}`;
+            }
+            catch (error) {
+                const message = `Failed to save report to ${persistence.reportPath}: ${error.message}`;
+                const failedOutput = {
+                    ...output,
+                    reportMeta,
+                    note: message,
+                };
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify(failedOutput, null, 2),
+                        }],
+                    isError: true,
+                };
+            }
+        }
+        else {
+            reportMeta = buildReportMeta({
+                reportPath: null,
+                cacheHit: false,
+                reportBytes: Buffer.byteLength(reportPayload),
+                savedAt: new Date().toISOString(),
+                source: 'fresh',
+            });
+        }
         return {
             content: [{
                     type: 'text',
-                    text: JSON.stringify(output, null, 2),
+                    text: JSON.stringify({ ...output, reportMeta, note }, null, 2),
                 }],
         };
     }
@@ -330,6 +597,7 @@ Returns:
 - Warnings and recommendations
 - OpenGraph/social meta analysis
 - Request timing breakdown
+- Optional report persistence and caching for AI agent workflows
 
 Perfect for analyzing your localhost dev server or any public URL. Categories include: meta, content, links, images, technical, security, performance, mobile, accessibility, schema, structural, i18n, PWA, social, e-commerce, local SEO, Core Web Vitals, readability, crawlability, internal linking, and best practices.`,
         inputSchema: {
@@ -344,6 +612,30 @@ Perfect for analyzing your localhost dev server or any public URL. Categories in
                     items: { type: 'string' },
                     description: 'Filter by specific categories (e.g., ["meta", "security", "performance"]). Leave empty for all.',
                 },
+                output: {
+                    type: 'string',
+                    description: 'Save report to explicit file path',
+                },
+                outputDir: {
+                    type: 'string',
+                    description: 'Save report to directory with auto-generated filename',
+                },
+                persist: {
+                    type: 'boolean',
+                    description: 'Save report to default temp path (os.tmpdir()/recker/seo)',
+                },
+                cache: {
+                    type: 'boolean',
+                    description: 'Reuse existing saved report if present and within TTL (default: true when persistence enabled)',
+                },
+                cacheTtlSec: {
+                    type: 'number',
+                    description: `Cache TTL in seconds (default: ${DEFAULT_SEO_CACHE_TTL_SEC})`,
+                },
+                forceRefresh: {
+                    type: 'boolean',
+                    description: 'Bypass cache and recompute even if a saved report exists',
+                },
             },
             required: ['url'],
         },
@@ -357,7 +649,7 @@ Detects site-wide issues:
 - Orphan pages (no internal links pointing to them)
 - Pages with low SEO scores
 
-Returns per-page scores and prioritized recommendations for improving overall site SEO. Great for auditing a full site before launch or finding issues across your dev environment.`,
+Returns per-page scores and prioritized recommendations for improving overall site SEO. Great for auditing a full site before launch or finding issues across your dev environment. Supports optional report persistence and caching for AI agent workflows.`,
         inputSchema: {
             type: 'object',
             properties: {
@@ -386,6 +678,30 @@ Returns per-page scores and prioritized recommendations for improving overall si
                     description: 'HTTP transport: auto (try undici, fallback to curl on WAF block), undici (fast), curl (curl-impersonate for protected sites)',
                     default: 'auto',
                 },
+                output: {
+                    type: 'string',
+                    description: 'Save report to explicit file path',
+                },
+                outputDir: {
+                    type: 'string',
+                    description: 'Save report to directory with auto-generated filename',
+                },
+                persist: {
+                    type: 'boolean',
+                    description: 'Save report to default temp path (os.tmpdir()/recker/seo)',
+                },
+                cache: {
+                    type: 'boolean',
+                    description: 'Reuse existing saved report if present and within TTL (default: true when persistence enabled)',
+                },
+                cacheTtlSec: {
+                    type: 'number',
+                    description: `Cache TTL in seconds (default: ${DEFAULT_SEO_CACHE_TTL_SEC})`,
+                },
+                forceRefresh: {
+                    type: 'boolean',
+                    description: 'Bypass cache and recompute even if a saved report exists',
+                },
             },
             required: ['url'],
         },

package/dist/plugins/auth/aws-sigv4.d.ts

@@ -8,3 +8,4 @@ export interface AWSSignatureV4Options {
 }
 export declare function awsSignatureV4(options: AWSSignatureV4Options): Middleware;
 export declare function awsSignatureV4Plugin(options: AWSSignatureV4Options): Plugin;
+export declare function clearAwsSigV4PluginCache(): void;

package/dist/plugins/auth/aws-sigv4.js

@@ -81,8 +81,25 @@ export function awsSignatureV4(options) {
         return next(newReq);
     };
 }
+const awsSigV4PluginCache = new Map();
 export function awsSignatureV4Plugin(options) {
-    return (client) => {
-        client.use(awsSignatureV4(options));
+    const cacheKey = [
+        options.accessKeyId,
+        options.secretAccessKey,
+        options.region,
+        options.service,
+        options.sessionToken || '',
+    ].join('|');
+    const cached = awsSigV4PluginCache.get(cacheKey);
+    if (cached)
+        return cached;
+    const safeOptions = { ...options };
+    const plugin = (client) => {
+        client.use(awsSignatureV4(safeOptions));
     };
+    awsSigV4PluginCache.set(cacheKey, plugin);
+    return plugin;
+}
+export function clearAwsSigV4PluginCache() {
+    awsSigV4PluginCache.clear();
 }

package/dist/plugins/retry.js

@@ -1,4 +1,5 @@
-import { HttpError, NetworkError, TimeoutError } from '../core/errors.js';
+import { HttpError, NetworkError, TimeoutError, classifyTransportError } from '../core/errors.js';
+import { getRequestContext } from '../core-runtime/request-context.js';
 function calculateDelay(attempt, baseDelay, maxDelay, strategy, useJitter) {
     let calculatedDelay;
     switch (strategy) {
@@ -54,6 +55,13 @@ export function retryPlugin(options = {}) {
         if (error instanceof HttpError) {
             return statusCodes.includes(error.status);
         }
+        const classification = classifyTransportError(error);
+        if (classification && classification.canRetry === false) {
+            return false;
+        }
+        if (classification) {
+            return classification.canRetry;
+        }
         if (error && typeof error === 'object' && 'code' in error) {
             const code = error.code;
             return code === 'ECONNRESET' || code === 'ETIMEDOUT' || code === 'ENOTFOUND';
@@ -62,6 +70,24 @@ export function retryPlugin(options = {}) {
     };
     const shouldRetry = options.shouldRetry || defaultShouldRetry;
     return (client) => {
+        const emitRequestRetry = (error, attempt, delayMs, req) => {
+            const eventBus = client.runtimeEventBus;
+            if (!eventBus?.emit) {
+                return;
+            }
+            const context = getRequestContext(req);
+            if (!context) {
+                return;
+            }
+            const classification = classifyTransportError(error);
+            eventBus.emit('request:retry', {
+                context,
+                req,
+                attempt,
+                delayMs,
+                reason: classification?.reason || error?.message || 'retry requested'
+            });
+        };
         const middleware = async (req, next) => {
             let attempt = 0;
             while (true) {
@@ -80,6 +106,7 @@ export function retryPlugin(options = {}) {
                             delayMs = calculateDelay(attempt, baseDelay, maxDelay, backoffStrategy, useJitter);
                         }
                         const err = new HttpError(res, req);
+                        emitRequestRetry(err, attempt, delayMs, req);
                         if (onRetry) {
                             onRetry(attempt, err, delayMs);
                         }
@@ -96,6 +123,7 @@ export function retryPlugin(options = {}) {
                 catch (error) {
                     if (attempt < maxAttempts && shouldRetry(error)) {
                         const delayMs = calculateDelay(attempt, baseDelay, maxDelay, backoffStrategy, useJitter);
+                        emitRequestRetry(error, attempt, delayMs, req);
                         if (onRetry) {
                             onRetry(attempt, error, delayMs);
                         }

package/dist/presets/aws.d.ts

@@ -10,6 +10,7 @@ export interface AWSPresetOptions {
 export type AWSService = 's3' | 'dynamodb' | 'lambda' | 'sqs' | 'sns' | 'ses' | 'secretsmanager' | 'ssm' | 'sts' | 'iam' | 'ec2' | 'ecs' | 'eks' | 'cloudwatch' | 'logs' | 'events' | 'kinesis' | 'firehose' | 'apigateway' | 'execute-api' | 'cognito-idp' | 'cognito-identity' | 'kms' | 'athena' | 'glue' | 'stepfunctions' | 'states' | 'bedrock' | 'bedrock-runtime';
 export declare function aws(options: AWSPresetOptions): ClientOptions;
 export declare function awsS3(options: Omit<AWSPresetOptions, 'service'>): ClientOptions;
+export declare function s3(options: Omit<AWSPresetOptions, 'service'>): ClientOptions;
 export declare function awsDynamoDB(options: Omit<AWSPresetOptions, 'service'>): ClientOptions;
 export declare function awsLambda(options: Omit<AWSPresetOptions, 'service'>): ClientOptions;
 export declare function awsSQS(options: Omit<AWSPresetOptions, 'service'>): ClientOptions;