dexto 1.5.8 → 1.6.1

package/dist/cli/utils/template-engine.js

@@ -2,135 +2,86 @@
  * Template Engine for Dexto Project Scaffolding
  *
  * Provides code generation functions for various project types.
- * Uses the image/harness terminology strategy:
- * - "Image" for distributable artifacts, packages, composition
- * - "Harness" for runtime behavior, what it provides
+ *
+ * Note: create-app/init-app scaffolds are programmatic (no YAML/images).
+ * Image scaffolds are generated via `dexto create-image`.
  */
 /**
- * Generates src/index.ts for an app using an image
+ * Generates src/index.ts for an app using programmatic configuration.
  */
-export function generateIndexForImage(context) {
-    return `// Load image environment (Pattern 1: Static Import)
-// This auto-registers providers as a side-effect
-import '${context.imageName}';
-
-// Import from core packages
-import { DextoAgent } from '@dexto/core';
-import { loadAgentConfig } from '@dexto/agent-management';
-
-async function main() {
-    console.log('🚀 Starting ${context.projectName}\\n');
-
-    // Load agent configuration
-    const config = await loadAgentConfig('./agents/default.yml');
-
-    // Create agent - providers already registered by image environment
-    const agent = new DextoAgent(config, './agents/default.yml');
-
-    await agent.start();
-    console.log('✅ Agent started\\n');
-
-    // Create a session
-    const session = await agent.createSession();
-
-    // Example interaction
-    const response = await agent.run(
-        'Hello! What can you help me with?',
-        undefined, // imageDataInput
-        undefined, // fileDataInput
-        session.id // sessionId
-    );
-
-    console.log('Agent response:', response);
-
-    // Cleanup
-    await agent.stop();
-}
+export function generateIndexForCodeFirstDI(context) {
+    const defaultProvider = context.llmProvider ?? 'openai';
+    const defaultModel = context.llmModel ?? 'gpt-4o';
+    return `// Standalone Dexto app (programmatic)
+import 'dotenv/config';
+
+import { DextoAgent, createLogger } from '@dexto/core';
+import { MemoryBlobStore, MemoryCacheStore, MemoryDatabaseStore } from '@dexto/storage';
+
+const agentId = '${context.projectName}';
+const logger = createLogger({
+    agentId,
+    config: { level: 'info', transports: [{ type: 'console', colorize: true }] },
+});
 
-main().catch((error) => {
-    console.error('Error:', error);
-    process.exit(1);
+const agent = new DextoAgent({
+    agentId,
+    llm: { provider: '${defaultProvider}', model: '${defaultModel}' },
+    systemPrompt: 'You are a helpful AI assistant.',
+    logger,
+    storage: {
+        cache: new MemoryCacheStore(),
+        database: new MemoryDatabaseStore(),
+        blob: new MemoryBlobStore({}, logger),
+    },
 });
+
+await agent.start();
+const session = await agent.createSession();
+console.log((await agent.generate('Hello! What can you do?', session.id)).content);
+await agent.stop();
 `;
 }
 /**
- * Generates src/index.ts for a web server application using an image
+ * Generates src/index.ts for a web server application using programmatic configuration.
  */
-export function generateWebServerIndex(context) {
-    return `// Load image environment (Pattern 1: Static Import)
-// This auto-registers providers as a side-effect
-import '${context.imageName}';
-
-// Import from core packages
-import { DextoAgent } from '@dexto/core';
-import { loadAgentConfig } from '@dexto/agent-management';
+export function generateWebServerIndexForCodeFirstDI(context) {
+    const defaultProvider = context.llmProvider ?? 'openai';
+    const defaultModel = context.llmModel ?? 'gpt-4o';
+    return `// Dexto Web Server (programmatic)
+import 'dotenv/config';
+
+import { DextoAgent, createLogger } from '@dexto/core';
+import { MemoryBlobStore, MemoryCacheStore, MemoryDatabaseStore } from '@dexto/storage';
 import { startDextoServer } from '@dexto/server';
 import { resolve } from 'node:path';
-import { existsSync } from 'node:fs';
 
-async function main() {
-    console.log('🚀 Starting ${context.projectName}\\n');
-
-    // Load agent configuration
-    console.log('📝 Loading configuration...');
-    const config = await loadAgentConfig('./agents/default.yml');
-    console.log('✅ Config loaded\\n');
-
-    // Create agent
-    console.log('🤖 Creating agent...');
-    const agent = new DextoAgent(config, './agents/default.yml');
-    console.log('✅ Agent created\\n');
-
-    // Start the server
-    console.log('🌐 Starting Dexto server...');
-
-    const webRoot = resolve(process.cwd(), 'app');
-
-    if (!existsSync(webRoot)) {
-        console.error(\`❌ Error: Web root not found at \${webRoot}\`);
-        console.error('   Make sure the app/ directory exists');
-        process.exit(1);
-    }
-
-    console.log(\`📁 Serving static files from: \${webRoot}\`);
+const agentId = '${context.projectName}';
+const logger = createLogger({
+    agentId,
+    config: { level: 'info', transports: [{ type: 'console', colorize: true }] },
+});
 
-    const { stop } = await startDextoServer(agent, {
-        port: 3000,
-        webRoot,
-        agentCard: {
-            name: '${context.projectName}',
-            description: '${context.description}',
-        },
-    });
-
-    console.log('\\n✅ Server is running!\\n');
-    console.log('🌐 Open your browser:');
-    console.log('  http://localhost:3000\\n');
-    console.log('📚 Available endpoints:');
-    console.log('  • Web UI:        http://localhost:3000');
-    console.log('  • REST API:      http://localhost:3000/api/*');
-    console.log('  • Health Check:  http://localhost:3000/health');
-    console.log('  • OpenAPI Spec:  http://localhost:3000/openapi.json');
-    console.log('  • Agent Card:    http://localhost:3000/.well-known/agent-card.json\\n');
-
-    console.log('Press Ctrl+C to stop the server...\\n');
-
-    // Handle graceful shutdown
-    const shutdown = async () => {
-        console.log('\\n🛑 Shutting down...');
-        await stop();
-        console.log('✅ Server stopped\\n');
-        process.exit(0);
-    };
-
-    process.on('SIGINT', shutdown);
-    process.on('SIGTERM', shutdown);
-}
+const agent = new DextoAgent({
+    agentId,
+    llm: { provider: '${defaultProvider}', model: '${defaultModel}' },
+    systemPrompt: 'You are a helpful AI assistant.',
+    logger,
+    storage: {
+        cache: new MemoryCacheStore(),
+        database: new MemoryDatabaseStore(),
+        blob: new MemoryBlobStore({}, logger),
+    },
+});
 
-main().catch((error) => {
-    console.error('Error:', error);
-    process.exit(1);
+const { stop } = await startDextoServer(agent, {
+    port: 3000,
+    webRoot: resolve(process.cwd(), 'app'),
+    agentCard: { name: '${context.projectName}', description: '${context.description}' },
 });
+
+process.on('SIGINT', () => void stop());
+process.on('SIGTERM', () => void stop());
 `;
 }
 /**
@@ -569,44 +520,8 @@ header h1 {
  */
 export function generateDextoImageFile(context) {
     const extendsField = context.baseImage ? `    extends: '${context.baseImage}',\n` : '';
-    return `import { defineImage } from '@dexto/core';
-
-export default defineImage({
-    name: '${context.imageName || context.projectName}',
-    version: '1.0.0',
-    description: '${context.description}',
-    target: '${context.target || 'local-development'}',
-${extendsField}
-    // Providers are AUTO-DISCOVERED from convention-based folders:
-    //   tools/         - Custom tool providers
-    //   blob-store/    - Blob storage providers
-    //   compression/   - Compression strategy providers
-    //   plugins/       - Plugin providers
-    //
-    // Each provider must export from an index.ts file in its folder.
-    // The bundler will automatically register them when the image is imported.
-
-    providers: {
-        // Manual registration for built-in core providers
-        // (These come from core, not from our providers/ folder)
-        // TODO: This is a hack to get the local blob store provider to work. Should be auto-registered or dealt with in a better way.
-        blobStore: {
-            register: async () => {
-                const { localBlobStoreProvider, inMemoryBlobStoreProvider } = await import(
-                    '@dexto/core'
-                );
-                const { blobStoreRegistry } = await import('@dexto/core');
-
-                blobStoreRegistry.register(localBlobStoreProvider);
-                blobStoreRegistry.register(inMemoryBlobStoreProvider);
-
-                console.log('✓ Registered core blob storage providers: local, in-memory');
-            },
-        },
-    },
-
-    defaults: {
-        storage: {
+    const storageDefaults = context.baseImage
+        ? `        storage: {
             blob: {
                 type: 'local',
                 storePath: './data/blobs',
@@ -618,83 +533,48 @@ ${extendsField}
             cache: {
                 type: 'in-memory',
             },
-        },
-        logging: {
-            level: 'info',
-            fileLogging: true,
-        },
-    },
-
-    constraints: ['filesystem-required', 'offline-capable'],
-});
-`;
-}
-/**
- * Generates dexto.config.ts file for manual registration projects
- */
-export function generateDextoConfigFile(context) {
-    return `/**
- * ${context.projectName} - Provider Registration
- *
- * This file registers all custom providers before agent initialization.
- * This is the manual registration approach - for most use cases, consider
- * using Dexto images instead (see: dexto create-image).
- */
-
-import {
-    blobStoreRegistry,
-    customToolRegistry,
-    compactionRegistry,
-    pluginRegistry,
-} from '@dexto/core';
+        },`
+        : `        storage: {
+            blob: {
+                type: 'example-blob',
+            },
+            database: {
+                type: 'example-database',
+            },
+            cache: {
+                type: 'example-cache',
+            },
+        },`;
+    return `import type { ImageDefinition } from '@dexto/image-bundler';
 
-/**
- * Project metadata
- */
-export const projectConfig = {
-    name: '${context.projectName}',
+const image = {
+    name: '${context.imageName || context.projectName}',
     version: '1.0.0',
     description: '${context.description}',
-};
-
-/**
- * Register all custom providers
- *
- * This function is called at application startup before loading agent configs.
- * Register your providers here by importing them and calling the appropriate
- * registry.register() method.
- */
-export function registerProviders() {
-    // Example: Register blob storage provider
-    // import { myBlobProvider } from './storage/my-blob.js';
-    // blobStoreRegistry.register(myBlobProvider);
-
-    // Example: Register custom tool
-    // import { myToolProvider } from './tools/my-tool.js';
-    // customToolRegistry.register(myToolProvider);
-
-    // Example: Register plugin
-    // import { myPluginProvider } from './plugins/my-plugin.js';
-    // pluginRegistry.register(myPluginProvider);
+    target: '${context.target || 'local-development'}',
+${extendsField}
+    // Factories are AUTO-DISCOVERED from convention-based folders:
+    //   tools/<type>/index.ts
+    //   storage/blob/<type>/index.ts
+    //   storage/database/<type>/index.ts
+    //   storage/cache/<type>/index.ts
+    //   hooks/<type>/index.ts
+    //   compaction/<type>/index.ts
+    //
+    // Each factory module must export a factory constant (export const factory = ...).
 
-    console.log(\`✓ Registered providers for \${projectConfig.name}\`);
-}
+    defaults: {
+${storageDefaults}
+        logger: {
+            level: 'info',
+            transports: [{ type: 'console', colorize: true }],
+        },
+    },
 
-/**
- * Optional: Project-wide initialization logic
- * Use this for setting up monitoring, analytics, error tracking, etc.
- */
-export async function initialize() {
-    console.log(\`✓ Initialized \${projectConfig.name} v\${projectConfig.version}\`);
-}
+    constraints: ['filesystem-required', 'offline-capable'],
+} satisfies ImageDefinition;
 
-/**
- * Optional: Cleanup logic
- * Called when the application shuts down
- */
-export async function cleanup() {
-    console.log(\`✓ Cleaned up \${projectConfig.name}\`);
-}
+export default image;
 `;
 }
 /**
@@ -703,7 +583,7 @@ export async function cleanup() {
 export function generateImageReadme(context) {
     const imageName = context.imageName || context.projectName;
     const extendsNote = context.baseImage
-        ? `\n\nThis image extends \`${context.baseImage}\`, inheriting its providers and adding custom ones.\n`
+        ? `\n\nThis image extends \`${context.baseImage}\`, inheriting its factories and adding custom ones.\n`
         : '';
     return `# ${imageName}
 
@@ -711,16 +591,14 @@ ${context.description}${extendsNote}
 
 ## What is this?
 
-A **Dexto image** - a pre-configured agent harness packaged as an npm module.
-Install it, import it, and you have a complete runtime harness ready to use.
+A **Dexto image** is a distributable npm module that exports a typed \`DextoImage\` (a plain object)
+describing tool/storage/hook/compaction factories + optional default config.
 
 ## What's Included
 
-The harness provides:
-- ✅ Pre-registered providers (auto-discovered from convention-based folders)
-- ✅ Runtime orchestration
-- ✅ Context management
-- ✅ Default configurations
+This package contains:
+- ✅ Factories (auto-discovered from convention-based folders)
+- ✅ Optional defaults (\`image.defaults\`) that merge into agent config (config wins)
 
 ## Quick Start
 
@@ -728,40 +606,33 @@ The harness provides:
 # Build the image
 pnpm run build
 
-# Use in your app
-pnpm add ${imageName}
+# Install into the Dexto CLI (local)
+npm pack
+dexto image install ./<generated-file>.tgz
 \`\`\`
 
 ## Usage
 
-\`\`\`typescript
-import { createAgent } from '${imageName}';
-import { loadAgentConfig } from '@dexto/agent-management';
-
-const config = await loadAgentConfig('./agents/default.yml');
-
-// Import creates the harness (providers auto-registered)
-const agent = createAgent(config);
-
-// The harness handles everything
-await agent.start();
-\`\`\`
+Set \`image: '${imageName}'\` in your agent config (or pass \`--image\` in the CLI), then run Dexto.
 
-## Adding Providers
+## Adding Factories
 
-Add your custom providers to convention-based folders:
-- \`tools/\` - Custom tool providers
-- \`blob-store/\` - Blob storage providers
-- \`compression/\` - Compression strategies
-- \`plugins/\` - Plugin providers
+Add your custom factories to convention-based folders:
+- \`tools/<type>/\` - Tool factories
+- \`storage/blob/<type>/\` - Blob storage factories
+- \`storage/database/<type>/\` - Database factories
+- \`storage/cache/<type>/\` - Cache factories
+- \`hooks/<type>/\` - Hook factories
+- \`compaction/<type>/\` - Compaction factories
 
-**Convention:** Each provider lives in its own folder with an \`index.ts\` file.
+**Convention:** Each factory lives in its own folder with an \`index.ts\` file.
+Each \`index.ts\` must export a \`factory\` constant (e.g. \`export const factory = myToolFactory;\`).
 
 Example:
 \`\`\`
 tools/
   my-tool/
-    index.ts       # Provider implementation (auto-discovered)
+    index.ts       # Factory implementation (auto-discovered)
     helpers.ts     # Optional helper functions
     types.ts       # Optional type definitions
 \`\`\`
@@ -772,20 +643,10 @@ tools/
 pnpm run build
 \`\`\`
 
-This runs \`dexto-bundle build\` which:
-1. Discovers providers from convention-based folders
-2. Generates \`dist/index.js\` with side-effect registration
-3. Exports \`createAgent()\` factory function
-
-## Architecture
-
-When imported, this image:
-1. Auto-registers providers (side effect)
-2. Exposes harness factory (\`createAgent\`)
-3. Re-exports registries for runtime customization
-
-The resulting harness manages your agent's runtime, including provider lifecycle,
-context management, and tool orchestration.
+This runs \`dexto-bundle build\`, which:
+1. Discovers factories from convention-based folders
+2. Compiles factory source files to \`dist/\`
+3. Generates \`dist/index.js\` exporting a \`DextoImage\` (no side effects)
 
 ## Publishing
 
@@ -795,24 +656,19 @@ npm publish
 
 Users can then:
 \`\`\`bash
-pnpm add ${imageName}
+dexto image install ${imageName}
 \`\`\`
-
-## Learn More
-
-- [Dexto Images Guide](https://docs.dexto.ai/docs/guides/images)
-- [Provider Development](https://docs.dexto.ai/docs/guides/providers)
-- [Bundler Documentation](https://docs.dexto.ai/docs/tools/bundler)
 `;
 }
 /**
- * Generates an example custom tool provider
+ * Generates an example custom tool factory
  */
 export function generateExampleTool(toolName = 'example-tool') {
-    // Convert kebab-case to camelCase for provider name
-    const providerName = toolName.replace(/-([a-z])/g, (_, char) => char.toUpperCase());
+    // Convert kebab-case to camelCase for a readable type name base
+    const typeNameBase = toolName.replace(/-([a-z])/g, (_, char) => char.toUpperCase());
     return `import { z } from 'zod';
-import type { CustomToolProvider, InternalTool, ToolCreationContext } from '@dexto/core';
+import type { ToolFactory } from '@dexto/agent-config';
+import type { Tool, ToolExecutionContext } from '@dexto/core';
 
 const ConfigSchema = z
     .object({
@@ -821,32 +677,34 @@ const ConfigSchema = z
     })
     .strict();
 
-type ${providerName.charAt(0).toUpperCase() + providerName.slice(1)}Config = z.output<typeof ConfigSchema>;
+type ${typeNameBase.charAt(0).toUpperCase() + typeNameBase.slice(1)}Config = z.output<typeof ConfigSchema>;
 
 /**
- * Example custom tool provider
+ * Example tool factory
  *
- * This demonstrates how to create a custom tool that can be used by the agent.
- * The tool is auto-discovered by the bundler when placed in the tools/ folder.
+ * This demonstrates how to create a tool factory that can be used by an image.
+ * The bundler auto-discovers this module when placed in tools/<type>/index.ts.
+ *
+ * Contract: export a factory constant with { configSchema, create }.
  */
-export const ${providerName}Provider: CustomToolProvider<'${toolName}', ${providerName.charAt(0).toUpperCase() + providerName.slice(1)}Config> = {
-    type: '${toolName}',
+export const factory: ToolFactory<${typeNameBase.charAt(0).toUpperCase() + typeNameBase.slice(1)}Config> = {
     configSchema: ConfigSchema,
-
-    create: (config: ${providerName.charAt(0).toUpperCase() + providerName.slice(1)}Config, context: ToolCreationContext): InternalTool[] => {
-        // Create and return tools
-        const tool: InternalTool = {
-            id: '${providerName}',
-            description: 'An example custom tool that demonstrates the tool provider pattern',
+    metadata: {
+        displayName: 'Example Tool',
+        description: 'Example tool factory',
+        category: 'utilities',
+    },
+    create: (_config) => {
+        const tool: Tool = {
+            id: '${toolName}',
+            description: 'An example tool that demonstrates the tool factory pattern',
             inputSchema: z.object({
                 input: z.string().describe('Input text to process'),
             }),
-
-            execute: async (input: unknown) => {
+            execute: async (input: unknown, context: ToolExecutionContext) => {
                 const { input: inputText } = input as { input: string };
                 context.logger.info(\`Example tool called with: \${inputText}\`);
 
-                // Your tool logic here
                 return {
                     result: \`Processed: \${inputText}\`,
                 };
@@ -855,33 +713,196 @@ export const ${providerName}Provider: CustomToolProvider<'${toolName}', ${provid
 
         return [tool];
     },
+};
+`;
+}
+/**
+ * Generates an example custom hook factory
+ */
+export function generateExampleHook(hookName) {
+    return `import { z } from 'zod';
+import type { HookFactory } from '@dexto/agent-config';
+import type { Hook } from '@dexto/core';
 
-    metadata: {
-        displayName: 'Example Tool',
-        description: 'Example custom tool provider',
-        category: 'utilities',
+const ConfigSchema = z
+    .object({
+        type: z.literal('${hookName}'),
+    })
+    .strict();
+
+type ExampleHookConfig = z.output<typeof ConfigSchema>;
+
+/**
+ * Example hook factory
+ *
+ * Hooks are resolved from image factories, same as tools.
+ * The bundler auto-discovers this module when placed in hooks/<type>/index.ts.
+ */
+export const factory: HookFactory<ExampleHookConfig> = {
+    configSchema: ConfigSchema,
+    create: (_config) => {
+        const hook: Hook = {
+            beforeLLMRequest: async (payload, context) => {
+                context.logger.info(\`${hookName} saw input: \${payload.text}\`);
+                return { ok: true };
+            },
+        };
+
+        return hook;
     },
 };
 `;
 }
 /**
- * Generates README for an app project
+ * Generates an example custom compaction factory
  */
-export function generateAppReadme(context) {
-    const usingImage = context.imageName;
-    const imageSection = usingImage
-        ? `\n## Image
+export function generateExampleCompaction(compactionType) {
+    return `import { z } from 'zod';
+import type { CompactionFactory } from '@dexto/agent-config';
+import type { CompactionStrategy } from '@dexto/core';
+
+	const ConfigSchema = z
+	    .object({
+	        type: z.literal('${compactionType}'),
+	        enabled: z.boolean().default(true).describe('Enable compaction strategy'),
+	        maxContextTokens: z
+	            .number()
+	            .positive()
+	            .optional()
+	            .describe('Max tokens before compaction'),
+	        thresholdPercent: z
+	            .number()
+	            .min(0.1)
+	            .max(1.0)
+	            .default(0.9)
+	            .describe('Trigger threshold (0–1)'),
+	    })
+	    .strict();
+
+type ExampleCompactionConfig = z.output<typeof ConfigSchema>;
+
+/**
+ * Example compaction factory
+ *
+ * Compaction is a DI surface. Agents select exactly one strategy via \`compaction.type\`.
+ * The bundler auto-discovers this module when placed in compaction/<type>/index.ts.
+ */
+export const factory: CompactionFactory<ExampleCompactionConfig> = {
+    configSchema: ConfigSchema,
+    create: (config) => {
+        const strategy: CompactionStrategy = {
+            name: '${compactionType}',
+            getSettings: () => ({
+                enabled: config.enabled,
+                maxContextTokens: config.maxContextTokens,
+                thresholdPercent: config.thresholdPercent,
+            }),
+            getModelLimits: (modelContextWindow) => ({
+                contextWindow: config.maxContextTokens
+                    ? Math.min(modelContextWindow, config.maxContextTokens)
+                    : modelContextWindow,
+            }),
+            shouldCompact: () => false,
+            compact: async () => [],
+        };
 
-This app uses the \`${context.imageName}\` image, which provides a complete agent harness with:
-- Pre-configured providers
-- Runtime orchestration
-- Context management
+        return strategy;
+    },
+};
+`;
+}
+/**
+ * Generates an example in-memory cache factory
+ */
+export function generateExampleCacheFactory(cacheType) {
+    return `import { z } from 'zod';
+import type { CacheFactory } from '@dexto/agent-config';
+import { MemoryCacheStore } from '@dexto/storage';
 
-The harness is automatically initialized when you import the image.\n`
-        : '';
+const ConfigSchema = z
+    .object({
+        type: z.literal('${cacheType}'),
+    })
+    .strict();
+
+type ExampleCacheConfig = z.output<typeof ConfigSchema>;
+
+/**
+ * Example cache factory
+ *
+ * Storage backends are resolved from image factories.
+ * The bundler auto-discovers this module when placed in storage/cache/<type>/index.ts.
+ */
+export const factory: CacheFactory<ExampleCacheConfig> = {
+    configSchema: ConfigSchema,
+    create: (_config, _logger) => new MemoryCacheStore(),
+};
+`;
+}
+/**
+ * Generates an example in-memory database factory
+ */
+export function generateExampleDatabaseFactory(databaseType) {
+    return `import { z } from 'zod';
+import type { DatabaseFactory } from '@dexto/agent-config';
+import { MemoryDatabaseStore } from '@dexto/storage';
+
+const ConfigSchema = z
+    .object({
+        type: z.literal('${databaseType}'),
+    })
+    .strict();
+
+type ExampleDatabaseConfig = z.output<typeof ConfigSchema>;
+
+/**
+ * Example database factory
+ *
+ * Storage backends are resolved from image factories.
+ * The bundler auto-discovers this module when placed in storage/database/<type>/index.ts.
+ */
+export const factory: DatabaseFactory<ExampleDatabaseConfig> = {
+    configSchema: ConfigSchema,
+    create: (_config, _logger) => new MemoryDatabaseStore(),
+};
+`;
+}
+/**
+ * Generates an example in-memory blob store factory
+ */
+export function generateExampleBlobStoreFactory(blobType) {
+    return `import { z } from 'zod';
+import type { BlobStoreFactory } from '@dexto/agent-config';
+import { InMemoryBlobStoreSchema, MemoryBlobStore } from '@dexto/storage';
+
+const ConfigSchema = InMemoryBlobStoreSchema.extend({
+    type: z.literal('${blobType}'),
+}).strict();
+
+type ExampleBlobStoreConfig = z.output<typeof ConfigSchema>;
+
+/**
+ * Example blob store factory
+ *
+ * Blob stores are resolved from image factories.
+ * The bundler auto-discovers this module when placed in storage/blob/<type>/index.ts.
+ */
+export const factory: BlobStoreFactory<ExampleBlobStoreConfig> = {
+    configSchema: ConfigSchema,
+    create: (config, logger) => {
+        const { type: _type, ...options } = config;
+        return new MemoryBlobStore(options, logger);
+    },
+};
+`;
+}
+/**
+ * Generates README for an app project
+ */
+export function generateAppReadme(context) {
     return `# ${context.projectName}
 
-${context.description}${imageSection}
+${context.description}
 
 ## Quick Start
 
@@ -903,8 +924,6 @@ pnpm start
 ${context.projectName}/
 ├── src/
 │   └── index.ts         # Entry point
-├── agents/
-│   └── default.yml      # Agent configuration
 ├── .env                 # Environment variables (gitignored)
 ├── package.json
 └── tsconfig.json
@@ -912,178 +931,19 @@ ${context.projectName}/
 
 ## Configuration
 
-Edit \`agents/default.yml\` to configure:
-- System prompts
-- LLM provider and model
-- MCP servers
-- Internal tools
-- Custom tools
+Edit \`src/index.ts\` to configure:
+- System prompt
+- LLM provider/model/API keys
+- Storage backends
+- Tools
+- External tools via MCP (\`mcpServers\`)
+
+By default this scaffold uses in-memory storage. To add persistence, swap in a file-backed
+database and blob store (e.g. SQLite + local blobs).
 
 ## Learn More
 
 - [Dexto Documentation](https://docs.dexto.ai)
 - [Agent Configuration Guide](https://docs.dexto.ai/docs/guides/configuration)
-- [Using Images](https://docs.dexto.ai/docs/guides/images)
-`;
-}
-/**
- * Generates auto-discovery script for from-core mode
- */
-export function generateDiscoveryScript() {
-    return `#!/usr/bin/env tsx
-/**
- * Provider Auto-Discovery Script
- *
- * Scans conventional folders (tools/, blob-store/, compression/, plugins/)
- * and generates src/providers.ts with import + registration statements.
- */
-
-import * as fs from 'fs/promises';
-import * as path from 'path';
-import { fileURLToPath } from 'url';
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-const projectRoot = path.resolve(__dirname, '..');
-
-interface ProviderInfo {
-    category: 'customTools' | 'blobStore' | 'compression' | 'plugins';
-    folderName: string;
-    path: string;
-    registryName: string;
-}
-
-const PROVIDER_CATEGORIES = [
-    { folder: 'tools', category: 'customTools' as const, registry: 'customToolRegistry' },
-    { folder: 'blob-store', category: 'blobStore' as const, registry: 'blobStoreRegistry' },
-    { folder: 'compaction', category: 'compaction' as const, registry: 'compactionRegistry' },
-    { folder: 'plugins', category: 'plugins' as const, registry: 'pluginRegistry' },
-];
-
-async function discoverProviders(): Promise<ProviderInfo[]> {
-    const providers: ProviderInfo[] = [];
-
-    for (const { folder, category, registry } of PROVIDER_CATEGORIES) {
-        const folderPath = path.join(projectRoot, folder);
-
-        try {
-            const entries = await fs.readdir(folderPath, { withFileTypes: true });
-
-            for (const entry of entries) {
-                if (!entry.isDirectory()) continue;
-                if (entry.name.startsWith('.')) continue;
-
-                // Check if provider has index.ts
-                const indexPath = path.join(folderPath, entry.name, 'index.ts');
-                try {
-                    await fs.access(indexPath);
-                    providers.push({
-                        category,
-                        folderName: entry.name,
-                        path: \`../\${folder}/\${entry.name}/index.js\`,
-                        registryName: registry,
-                    });
-                } catch {
-                    // No index.ts found, skip
-                }
-            }
-        } catch {
-            // Folder doesn't exist or can't be read, skip
-        }
-    }
-
-    return providers;
-}
-
-function generateProvidersFile(providers: ProviderInfo[]): string {
-    // Helper to convert kebab-case to camelCase for valid JS identifiers
-    const toCamelCase = (str: string): string => {
-        return str.replace(/-([a-z])/g, (_, char) => char.toUpperCase());
-    };
-
-    const imports: string[] = [];
-    const registrations: string[] = [];
-    const registries = new Set<string>();
-
-    providers.forEach((provider, index) => {
-        const varName = \`provider\${index}\`;
-        const providerName = \`\${toCamelCase(provider.folderName)}Provider\`;
-        imports.push(\`import { \${providerName} as \${varName} } from '\${provider.path}';\`);
-        registrations.push(\`    \${provider.registryName}.register(\${varName});\`);
-        registries.add(provider.registryName);
-    });
-
-    const registryImports = Array.from(registries).join(', ');
-
-    return \`// AUTO-GENERATED - DO NOT EDIT
-// This file is generated by scripts/discover-providers.ts
-// Run 'pnpm run discover' to regenerate
-
-import { \${registryImports} } from '@dexto/core';
-\${imports.join('\\n')}
-
-/**
- * Register all discovered providers
- * Called automatically when this module is imported
- */
-export function registerProviders(): void {
-\${registrations.join('\\n')}
-}
-
-// Auto-register on import
-registerProviders();
-
-console.log('✓ Registered \${providers.length} provider(s)');
-\`;
-}
-
-function generateEntryPoint(): string {
-    return \`// AUTO-GENERATED - DO NOT EDIT
-// This file is the build entry point that wires everything together
-// Run 'pnpm run discover' to regenerate
-
-// Register providers first
-import './_providers.js';
-
-// Then run the user's app
-import './index.js';
-\`;
-}
-
-async function main() {
-    console.log('🔍 Discovering providers...\\n');
-
-    const providers = await discoverProviders();
-
-    if (providers.length === 0) {
-        console.log('⚠️  No providers found');
-        console.log('   Add providers to: tools/, blob-store/, compression/, or plugins/\\n');
-    } else {
-        console.log(\`✅ Found \${providers.length} provider(s):\`);
-        providers.forEach(p => {
-            console.log(\`   • \${p.category}/\${p.folderName}\`);
-        });
-        console.log();
-    }
-
-    // Generate provider registrations
-    const providersPath = path.join(projectRoot, 'src', '_providers.ts');
-    const providersContent = generateProvidersFile(providers);
-    await fs.writeFile(providersPath, providersContent, 'utf-8');
-    console.log(\`📝 Generated: src/_providers.ts\`);
-
-    // Generate build entry point
-    const entryPath = path.join(projectRoot, 'src', '_entry.ts');
-    const entryContent = generateEntryPoint();
-    await fs.writeFile(entryPath, entryContent, 'utf-8');
-    console.log(\`📝 Generated: src/_entry.ts\`);
-
-    console.log();
-}
-
-main().catch(error => {
-    console.error('❌ Discovery failed:', error);
-    process.exit(1);
-});
 `;
 }