@bubblelab/bubble-core 0.1.0

package/dist/bubbles/tool-bubble/tool-template.d.ts

@@ -0,0 +1,257 @@
+/**
+ * TOOL BUBBLE TEMPLATE
+ *
+ * This template provides a starting point for creating new tool bubbles in the NodeX system.
+ * Tool bubbles are specialized bubbles that provide utility functions for other bubbles,
+ * particularly useful for AI agents that need to perform specific operations.
+ *
+ * NEW FEATURES (v2):
+ * - Automatic credential injection via base class
+ * - Config parameter support for runtime configuration
+ * - No need to implement toAgentTool() - handled automatically
+ * - IMPORTANT: credentials and config are HIDDEN from AI agents
+ *   - AI agents only see your actual tool parameters (inputData, options, etc.)
+ *   - credentials and config are injected at runtime and available in performAction()
+ *   - This keeps the tool interface clean for AI while providing access to secrets
+ *
+ * To create a new tool bubble:
+ * 1. Copy this template and rename it (e.g., my-custom-tool.ts)
+ * 2. Replace all instances of "MyCustomTool" with your tool name
+ * 3. Update the schema to define your input parameters
+ * 4. Add credentials/config fields if needed (see examples below)
+ * 5. Update the result schema to define your output structure
+ * 6. Implement the performAction method with your tool logic
+ * 7. Update all static metadata (bubbleName, descriptions, etc.)
+ * 8. Register your tool in the BubbleFactory
+ */
+import { z } from 'zod';
+import { ToolBubble } from '../../types/tool-bubble-class.js';
+import type { BubbleContext } from '../../types/bubble.js';
+import { CredentialType } from '@bubblelab/shared-schemas';
+/**
+ * Define the parameters schema using Zod
+ * This schema validates and types the input parameters for your tool
+ *
+ * Common patterns:
+ * - Required string: z.string().min(1, 'Field is required')
+ * - Optional string: z.string().optional()
+ * - Number with range: z.number().min(0).max(100)
+ * - Enum: z.enum(['option1', 'option2'])
+ * - Array: z.array(z.string())
+ * - Object: z.object({ key: z.string() })
+ * - Credentials: z.record(z.nativeEnum(CredentialType), z.string()).optional()
+ */
+declare const MyCustomToolParamsSchema: z.ZodObject<{
+    inputData: z.ZodString;
+    options: z.ZodOptional<z.ZodObject<{
+        includeDetails: z.ZodDefault<z.ZodBoolean>;
+        maxResults: z.ZodDefault<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        maxResults: number;
+        includeDetails: boolean;
+    }, {
+        maxResults?: number | undefined;
+        includeDetails?: boolean | undefined;
+    }>>;
+    credentials: z.ZodOptional<z.ZodRecord<z.ZodNativeEnum<typeof CredentialType>, z.ZodString>>;
+    config: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, "strip", z.ZodTypeAny, {
+    inputData: string;
+    options?: {
+        maxResults: number;
+        includeDetails: boolean;
+    } | undefined;
+    credentials?: Partial<Record<CredentialType, string>> | undefined;
+    config?: Record<string, unknown> | undefined;
+}, {
+    inputData: string;
+    options?: {
+        maxResults?: number | undefined;
+        includeDetails?: boolean | undefined;
+    } | undefined;
+    credentials?: Partial<Record<CredentialType, string>> | undefined;
+    config?: Record<string, unknown> | undefined;
+}>;
+/**
+ * Type definitions derived from schemas
+ * These provide TypeScript types for compile-time type safety
+ */
+type MyCustomToolParamsInput = z.input<typeof MyCustomToolParamsSchema>;
+type MyCustomToolParams = z.output<typeof MyCustomToolParamsSchema>;
+type MyCustomToolResult = z.output<typeof MyCustomToolResultSchema>;
+/**
+ * Define the result schema
+ * This schema defines what your tool returns
+ * Always include success and error fields for consistent error handling
+ */
+declare const MyCustomToolResultSchema: z.ZodObject<{
+    processedData: z.ZodString;
+    metadata: z.ZodObject<{
+        processedAt: z.ZodString;
+        itemsProcessed: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        processedAt: string;
+        itemsProcessed: number;
+    }, {
+        processedAt: string;
+        itemsProcessed: number;
+    }>;
+    success: z.ZodBoolean;
+    error: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    success: boolean;
+    error: string;
+    metadata: {
+        processedAt: string;
+        itemsProcessed: number;
+    };
+    processedData: string;
+}, {
+    success: boolean;
+    error: string;
+    metadata: {
+        processedAt: string;
+        itemsProcessed: number;
+    };
+    processedData: string;
+}>;
+/**
+ * Main tool class implementation
+ * Extends ToolBubble with your parameter and result types
+ */
+export declare class MyCustomTool extends ToolBubble<MyCustomToolParams, MyCustomToolResult> {
+    /**
+     * REQUIRED STATIC METADATA
+     * These fields are used by the BubbleFactory and AI agents
+     */
+    static readonly type: "tool";
+    static readonly bubbleName = "my-custom-tool";
+    static readonly schema: z.ZodObject<{
+        inputData: z.ZodString;
+        options: z.ZodOptional<z.ZodObject<{
+            includeDetails: z.ZodDefault<z.ZodBoolean>;
+            maxResults: z.ZodDefault<z.ZodNumber>;
+        }, "strip", z.ZodTypeAny, {
+            maxResults: number;
+            includeDetails: boolean;
+        }, {
+            maxResults?: number | undefined;
+            includeDetails?: boolean | undefined;
+        }>>;
+        credentials: z.ZodOptional<z.ZodRecord<z.ZodNativeEnum<typeof CredentialType>, z.ZodString>>;
+        config: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, "strip", z.ZodTypeAny, {
+        inputData: string;
+        options?: {
+            maxResults: number;
+            includeDetails: boolean;
+        } | undefined;
+        credentials?: Partial<Record<CredentialType, string>> | undefined;
+        config?: Record<string, unknown> | undefined;
+    }, {
+        inputData: string;
+        options?: {
+            maxResults?: number | undefined;
+            includeDetails?: boolean | undefined;
+        } | undefined;
+        credentials?: Partial<Record<CredentialType, string>> | undefined;
+        config?: Record<string, unknown> | undefined;
+    }>;
+    static readonly resultSchema: z.ZodObject<{
+        processedData: z.ZodString;
+        metadata: z.ZodObject<{
+            processedAt: z.ZodString;
+            itemsProcessed: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            processedAt: string;
+            itemsProcessed: number;
+        }, {
+            processedAt: string;
+            itemsProcessed: number;
+        }>;
+        success: z.ZodBoolean;
+        error: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        success: boolean;
+        error: string;
+        metadata: {
+            processedAt: string;
+            itemsProcessed: number;
+        };
+        processedData: string;
+    }, {
+        success: boolean;
+        error: string;
+        metadata: {
+            processedAt: string;
+            itemsProcessed: number;
+        };
+        processedData: string;
+    }>;
+    static readonly shortDescription = "Brief description of what your tool does";
+    static readonly longDescription = "\n    A comprehensive description of your tool bubble.\n    \n    What it does:\n    - Main functionality point 1\n    - Main functionality point 2\n    \n    How it works:\n    - Implementation detail 1\n    - Implementation detail 2\n    \n    Use cases:\n    - When an AI agent needs to perform X\n    - When processing Y type of data\n    - When integrating with Z system\n  ";
+    static readonly alias = "custom";
+    /**
+     * Constructor
+     * Initialize your tool with parameters and optional context
+     */
+    constructor(params: MyCustomToolParamsInput, context?: BubbleContext);
+    /**
+     * Main action method - this is where your tool logic goes
+     * This method is called when the tool is executed
+     *
+     * @param context - Optional bubble context (contains metadata, credentials, etc.)
+     * @returns Promise with your result object
+     */
+    performAction(context?: BubbleContext): Promise<MyCustomToolResult>;
+    /**
+     * PRIVATE HELPER METHODS
+     * Add your internal logic methods here
+     */
+    private processData;
+}
+export {};
+/**
+ * REGISTRATION AND USAGE
+ *
+ * 1. Register your tool in the BubbleFactory:
+ * ```typescript
+ * import { MyCustomTool } from './bubbles/tool-bubble/my-custom-tool.js';
+ *
+ * // In registerDefaults() method:
+ * this.register('my-custom-tool', MyCustomTool as BubbleClassWithMetadata);
+ * ```
+ *
+ * 2. Direct usage:
+ * ```typescript
+ * const tool = new MyCustomTool({
+ *   inputData: 'some data',
+ *   options: { includeDetails: true },
+ *   credentials: { DATABASE_CRED: 'connection_string' }
+ * });
+ * const result = await tool.action();
+ * ```
+ *
+ * 3. AI Agent usage:
+ * ```typescript
+ * // When AI agent calls your tool, it ONLY sees these parameters:
+ * {
+ *   "inputData": "some data",
+ *   "options": { "includeDetails": true }
+ * }
+ *
+ * // The AI agent configuration provides credentials/config separately:
+ * tools: [{
+ *   name: 'my-custom-tool',
+ *   credentials: { DATABASE_CRED: 'connection_string' },  // Runtime injection
+ *   config: { someOption: true }  // Runtime injection
+ * }]
+ * ```
+ *
+ * IMPORTANT SECURITY FEATURE:
+ * - AI agents NEVER see credentials or config in the tool schema
+ * - The base ToolBubble class automatically strips these from the AI-visible schema
+ * - Runtime injects credentials/config before calling performAction()
+ * - This prevents AI from accidentally exposing or misusing secrets
+ */
+//# sourceMappingURL=tool-template.d.ts.map

package/dist/bubbles/tool-bubble/tool-template.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool-template.d.ts","sourceRoot":"","sources":["../../../src/bubbles/tool-bubble/tool-template.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,UAAU,EAAE,MAAM,kCAAkC,CAAC;AAC9D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AAC3D,OAAO,EAAE,cAAc,EAAE,MAAM,2BAA2B,CAAC;AAI3D;;;;;;;;;;;;GAYG;AACH,QAAA,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA6B5B,CAAC;AAEH;;;GAGG;AACH,KAAK,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC;AACxE,KAAK,kBAAkB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,wBAAwB,CAAC,CAAC;AACpE,KAAK,kBAAkB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAEpE;;;;GAIG;AACH,QAAA,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAW5B,CAAC;AAEH;;;GAGG;AACH,qBAAa,YAAa,SAAQ,UAAU,CAC1C,kBAAkB,EAClB,kBAAkB,CACnB;IACC;;;OAGG;IAGH,MAAM,CAAC,QAAQ,CAAC,IAAI,EAAG,MAAM,CAAU;IAGvC,MAAM,CAAC,QAAQ,CAAC,UAAU,oBAAoB;IAG9C,MAAM,CAAC,QAAQ,CAAC,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAA4B;IAClD,MAAM,CAAC,QAAQ,CAAC,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAA4B;IAGxD,MAAM,CAAC,QAAQ,CAAC,gBAAgB,8CAA8C;IAG9E,MAAM,CAAC,QAAQ,CAAC,eAAe,iYAe7B;IAGF,MAAM,CAAC,QAAQ,CAAC,KAAK,YAAY;IAKjC;;;OAGG;gBACS,MAAM,EAAE,uBAAuB,EAAE,OAAO,CAAC,EAAE,aAAa;IAMpE;;;;;;OAMG;IACG,aAAa,CAAC,OAAO,CAAC,EAAE,aAAa,GAAG,OAAO,CAAC,kBAAkB,CAAC;IAkDzE;;;OAGG;YAEW,WAAW;CAkB1B;;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG"}

package/dist/bubbles/tool-bubble/tool-template.js

@@ -0,0 +1,238 @@
+/**
+ * TOOL BUBBLE TEMPLATE
+ *
+ * This template provides a starting point for creating new tool bubbles in the NodeX system.
+ * Tool bubbles are specialized bubbles that provide utility functions for other bubbles,
+ * particularly useful for AI agents that need to perform specific operations.
+ *
+ * NEW FEATURES (v2):
+ * - Automatic credential injection via base class
+ * - Config parameter support for runtime configuration
+ * - No need to implement toAgentTool() - handled automatically
+ * - IMPORTANT: credentials and config are HIDDEN from AI agents
+ *   - AI agents only see your actual tool parameters (inputData, options, etc.)
+ *   - credentials and config are injected at runtime and available in performAction()
+ *   - This keeps the tool interface clean for AI while providing access to secrets
+ *
+ * To create a new tool bubble:
+ * 1. Copy this template and rename it (e.g., my-custom-tool.ts)
+ * 2. Replace all instances of "MyCustomTool" with your tool name
+ * 3. Update the schema to define your input parameters
+ * 4. Add credentials/config fields if needed (see examples below)
+ * 5. Update the result schema to define your output structure
+ * 6. Implement the performAction method with your tool logic
+ * 7. Update all static metadata (bubbleName, descriptions, etc.)
+ * 8. Register your tool in the BubbleFactory
+ */
+import { z } from 'zod';
+import { ToolBubble } from '../../types/tool-bubble-class.js';
+import { CredentialType } from '@bubblelab/shared-schemas';
+// Import BubbleFactory if you need to access other bubbles
+// import { BubbleFactory } from '../../bubble-factory.js';
+/**
+ * Define the parameters schema using Zod
+ * This schema validates and types the input parameters for your tool
+ *
+ * Common patterns:
+ * - Required string: z.string().min(1, 'Field is required')
+ * - Optional string: z.string().optional()
+ * - Number with range: z.number().min(0).max(100)
+ * - Enum: z.enum(['option1', 'option2'])
+ * - Array: z.array(z.string())
+ * - Object: z.object({ key: z.string() })
+ * - Credentials: z.record(z.nativeEnum(CredentialType), z.string()).optional()
+ */
+const MyCustomToolParamsSchema = z.object({
+    // Example required parameter
+    inputData: z.string().min(1, 'Input data is required'),
+    // Example optional parameter with description
+    options: z
+        .object({
+        includeDetails: z.boolean().default(false),
+        maxResults: z.number().min(1).max(100).default(10),
+    })
+        .optional()
+        .describe('Configuration options for the tool'),
+    // IMPORTANT: These fields are AUTOMATICALLY REMOVED from AI agent schema
+    // AI agents will NOT see these parameters - they're injected at runtime
+    // Credentials (if your tool needs API keys or other secrets)
+    credentials: z
+        .record(z.nativeEnum(CredentialType), z.string())
+        .optional()
+        .describe('Database credentials (HIDDEN from AI - injected at runtime)'),
+    // Optional configuration passed from the agent system
+    config: z
+        .record(z.string(), z.unknown())
+        .optional()
+        .describe('Configuration for the tool bubble (HIDDEN from AI - injected at runtime)'),
+});
+/**
+ * Define the result schema
+ * This schema defines what your tool returns
+ * Always include success and error fields for consistent error handling
+ */
+const MyCustomToolResultSchema = z.object({
+    // Your custom result fields
+    processedData: z.string(),
+    metadata: z.object({
+        processedAt: z.string(),
+        itemsProcessed: z.number(),
+    }),
+    // Standard result fields (always include these)
+    success: z.boolean(),
+    error: z.string(),
+});
+/**
+ * Main tool class implementation
+ * Extends ToolBubble with your parameter and result types
+ */
+export class MyCustomTool extends ToolBubble {
+    /**
+     * REQUIRED STATIC METADATA
+     * These fields are used by the BubbleFactory and AI agents
+     */
+    // Bubble type - always 'tool' for tool bubbles
+    static type = 'tool';
+    // Unique identifier for your tool (use kebab-case)
+    static bubbleName = 'my-custom-tool';
+    // Schemas for validation
+    static schema = MyCustomToolParamsSchema;
+    static resultSchema = MyCustomToolResultSchema;
+    // Short description (one line, used in lists and summaries)
+    static shortDescription = 'Brief description of what your tool does';
+    // Long description with detailed information
+    static longDescription = `
+    A comprehensive description of your tool bubble.
+    
+    What it does:
+    - Main functionality point 1
+    - Main functionality point 2
+    
+    How it works:
+    - Implementation detail 1
+    - Implementation detail 2
+    
+    Use cases:
+    - When an AI agent needs to perform X
+    - When processing Y type of data
+    - When integrating with Z system
+  `;
+    // Optional: Short alias for the tool (e.g., 'custom' instead of 'my-custom-tool')
+    static alias = 'custom';
+    // Optional: Define which credentials this tool can use
+    // static readonly credentialOptions = [CredentialType.OPENAI_CRED];
+    /**
+     * Constructor
+     * Initialize your tool with parameters and optional context
+     */
+    constructor(params, context) {
+        super(params, context);
+        // Initialize any instance variables here
+        // Example: this.factory = new BubbleFactory();
+    }
+    /**
+     * Main action method - this is where your tool logic goes
+     * This method is called when the tool is executed
+     *
+     * @param context - Optional bubble context (contains metadata, credentials, etc.)
+     * @returns Promise with your result object
+     */
+    async performAction(context) {
+        // Context is available but often not used in tools
+        void context;
+        try {
+            // Extract parameters
+            // NOTE: credentials and config are automatically injected by the base class
+            // AI agents only provided inputData and options - never see credentials/config
+            const { inputData, options } = this.params;
+            // Access credentials if needed (injected by runtime, not provided by AI)
+            // const dbConnection = credentials?.DATABASE_CRED;
+            // const apiKey = credentials?.OPENAI_CRED;
+            // Access config if needed (injected by runtime, not provided by AI)
+            // const customSetting = config?.customSetting;
+            // Implement your tool logic here
+            // Example: Process the input data
+            const processedData = await this.processData(inputData, options);
+            // Return successful result
+            return {
+                processedData,
+                metadata: {
+                    processedAt: new Date().toISOString(),
+                    itemsProcessed: 1,
+                },
+                success: true,
+                error: '',
+            };
+        }
+        catch (error) {
+            // Handle errors gracefully
+            return {
+                processedData: '',
+                metadata: {
+                    processedAt: new Date().toISOString(),
+                    itemsProcessed: 0,
+                },
+                success: false,
+                error: error instanceof Error ? error.message : 'Unknown error occurred',
+            };
+        }
+    }
+    // Note: The toAgentTool() static method is now implemented in the base ToolBubble class
+    // It automatically handles credential and config injection
+    // You don't need to implement it unless you need custom behavior
+    /**
+     * PRIVATE HELPER METHODS
+     * Add your internal logic methods here
+     */
+    async processData(data, options) {
+        // Example processing logic
+        const includeDetails = options?.includeDetails ?? false;
+        const maxResults = options?.maxResults ?? 10;
+        // Your actual processing logic here
+        return `Processed: ${data} (details: ${includeDetails}, max: ${maxResults})`;
+    }
+}
+/**
+ * REGISTRATION AND USAGE
+ *
+ * 1. Register your tool in the BubbleFactory:
+ * ```typescript
+ * import { MyCustomTool } from './bubbles/tool-bubble/my-custom-tool.js';
+ *
+ * // In registerDefaults() method:
+ * this.register('my-custom-tool', MyCustomTool as BubbleClassWithMetadata);
+ * ```
+ *
+ * 2. Direct usage:
+ * ```typescript
+ * const tool = new MyCustomTool({
+ *   inputData: 'some data',
+ *   options: { includeDetails: true },
+ *   credentials: { DATABASE_CRED: 'connection_string' }
+ * });
+ * const result = await tool.action();
+ * ```
+ *
+ * 3. AI Agent usage:
+ * ```typescript
+ * // When AI agent calls your tool, it ONLY sees these parameters:
+ * {
+ *   "inputData": "some data",
+ *   "options": { "includeDetails": true }
+ * }
+ *
+ * // The AI agent configuration provides credentials/config separately:
+ * tools: [{
+ *   name: 'my-custom-tool',
+ *   credentials: { DATABASE_CRED: 'connection_string' },  // Runtime injection
+ *   config: { someOption: true }  // Runtime injection
+ * }]
+ * ```
+ *
+ * IMPORTANT SECURITY FEATURE:
+ * - AI agents NEVER see credentials or config in the tool schema
+ * - The base ToolBubble class automatically strips these from the AI-visible schema
+ * - Runtime injects credentials/config before calling performAction()
+ * - This prevents AI from accidentally exposing or misusing secrets
+ */
+//# sourceMappingURL=tool-template.js.map

package/dist/bubbles/tool-bubble/tool-template.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool-template.js","sourceRoot":"","sources":["../../../src/bubbles/tool-bubble/tool-template.ts"],"names":[],"mappings":"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"}

package/dist/bubbles/tool-bubble/virtual-file-editor-example.d.ts

@@ -0,0 +1,8 @@
+/**
+ * EXAMPLE: Virtual File Editor Tool with Hidden Parameters
+ *
+ * This example demonstrates how the VirtualFileEditorTool now works with
+ * codeLines hidden from AI agents and stored in the config field.
+ */
+export {};
+//# sourceMappingURL=virtual-file-editor-example.d.ts.map

package/dist/bubbles/tool-bubble/virtual-file-editor-example.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"virtual-file-editor-example.d.ts","sourceRoot":"","sources":["../../../src/bubbles/tool-bubble/virtual-file-editor-example.ts"],"names":[],"mappings":"AAAA;;;;;GAKG"}

package/dist/bubbles/tool-bubble/virtual-file-editor-example.js

@@ -0,0 +1,65 @@
+/**
+ * EXAMPLE: Virtual File Editor Tool with Hidden Parameters
+ *
+ * This example demonstrates how the VirtualFileEditorTool now works with
+ * codeLines hidden from AI agents and stored in the config field.
+ */
+import { VirtualFileEditorTool } from './virtual-file-editor.tool.js';
+// Example 1: AI Agent sees clean interface
+console.log('=== AI Agent Interface ===');
+console.log('AI agents only see these parameters:');
+console.log('- edits: Array of edit operations');
+console.log('- (credentials and config are hidden)');
+// Example 2: How the tool is used internally
+console.log('\n=== Internal Usage ===');
+// First call - initialize with empty file
+const tool1 = new VirtualFileEditorTool({
+    edits: [
+        {
+            op: 'insert',
+            startLine: 1,
+            text: 'function hello() {\n  console.log("Hello World");\n}',
+        },
+    ],
+    config: {
+        codeLines: [], // Hidden from AI - starts with empty file
+    },
+});
+const result1 = await tool1.performAction();
+console.log('First call result:');
+console.log('Code lines:', result1.codeLines);
+console.log('Success:', result1.success);
+// Second call - AI agent only provides edits, codeLines maintained in config
+const tool2 = new VirtualFileEditorTool({
+    edits: [
+        {
+            op: 'insert',
+            startLine: 2,
+            text: '  // Added comment',
+        },
+    ],
+    config: {
+        codeLines: result1.codeLines, // Previous state maintained
+    },
+});
+const result2 = await tool2.performAction();
+console.log('\nSecond call result:');
+console.log('Code lines:', result2.codeLines);
+console.log('Success:', result2.success);
+// Example 3: How AI agents would use this tool
+console.log('\n=== AI Agent Usage ===');
+console.log('AI agents would call the tool like this:');
+console.log(`
+{
+  "edits": [
+    {
+      "op": "insert",
+      "startLine": 1,
+      "text": "// New comment"
+    }
+  ]
+}
+`);
+console.log('The codeLines parameter is completely hidden from AI agents!');
+console.log('The tool maintains state through the config field internally.');
+//# sourceMappingURL=virtual-file-editor-example.js.map

package/dist/bubbles/tool-bubble/virtual-file-editor-example.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"virtual-file-editor-example.js","sourceRoot":"","sources":["../../../src/bubbles/tool-bubble/virtual-file-editor-example.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,qBAAqB,EAAE,MAAM,+BAA+B,CAAC;AAEtE,2CAA2C;AAC3C,OAAO,CAAC,GAAG,CAAC,4BAA4B,CAAC,CAAC;AAC1C,OAAO,CAAC,GAAG,CAAC,sCAAsC,CAAC,CAAC;AACpD,OAAO,CAAC,GAAG,CAAC,mCAAmC,CAAC,CAAC;AACjD,OAAO,CAAC,GAAG,CAAC,uCAAuC,CAAC,CAAC;AAErD,6CAA6C;AAC7C,OAAO,CAAC,GAAG,CAAC,0BAA0B,CAAC,CAAC;AAExC,0CAA0C;AAC1C,MAAM,KAAK,GAAG,IAAI,qBAAqB,CAAC;IACtC,KAAK,EAAE;QACL;YACE,EAAE,EAAE,QAAQ;YACZ,SAAS,EAAE,CAAC;YACZ,IAAI,EAAE,sDAAsD;SAC7D;KACF;IACD,MAAM,EAAE;QACN,SAAS,EAAE,EAAE,EAAE,0CAA0C;KAC1D;CACF,CAAC,CAAC;AAEH,MAAM,OAAO,GAAG,MAAM,KAAK,CAAC,aAAa,EAAE,CAAC;AAC5C,OAAO,CAAC,GAAG,CAAC,oBAAoB,CAAC,CAAC;AAClC,OAAO,CAAC,GAAG,CAAC,aAAa,EAAE,OAAO,CAAC,SAAS,CAAC,CAAC;AAC9C,OAAO,CAAC,GAAG,CAAC,UAAU,EAAE,OAAO,CAAC,OAAO,CAAC,CAAC;AAEzC,6EAA6E;AAC7E,MAAM,KAAK,GAAG,IAAI,qBAAqB,CAAC;IACtC,KAAK,EAAE;QACL;YACE,EAAE,EAAE,QAAQ;YACZ,SAAS,EAAE,CAAC;YACZ,IAAI,EAAE,oBAAoB;SAC3B;KACF;IACD,MAAM,EAAE;QACN,SAAS,EAAE,OAAO,CAAC,SAAS,EAAE,4BAA4B;KAC3D;CACF,CAAC,CAAC;AAEH,MAAM,OAAO,GAAG,MAAM,KAAK,CAAC,aAAa,EAAE,CAAC;AAC5C,OAAO,CAAC,GAAG,CAAC,uBAAuB,CAAC,CAAC;AACrC,OAAO,CAAC,GAAG,CAAC,aAAa,EAAE,OAAO,CAAC,SAAS,CAAC,CAAC;AAC9C,OAAO,CAAC,GAAG,CAAC,UAAU,EAAE,OAAO,CAAC,OAAO,CAAC,CAAC;AAEzC,+CAA+C;AAC/C,OAAO,CAAC,GAAG,CAAC,0BAA0B,CAAC,CAAC;AACxC,OAAO,CAAC,GAAG,CAAC,0CAA0C,CAAC,CAAC;AACxD,OAAO,CAAC,GAAG,CAAC;;;;;;;;;;CAUX,CAAC,CAAC;AAEH,OAAO,CAAC,GAAG,CAAC,8DAA8D,CAAC,CAAC;AAC5E,OAAO,CAAC,GAAG,CAAC,+DAA+D,CAAC,CAAC"}