@tanstack/ai-code-mode-skills 0.1.0

package/README.md

@@ -0,0 +1,199 @@
+# @tanstack/ai-code-mode-skills
+
+Persistent skill library for TanStack AI Code Mode - LLM-created reusable code snippets.
+
+## Overview
+
+The Skills System extends Code Mode with persistent, LLM-creatable reusable code snippets. Skills are TypeScript functions that the LLM can create, catalog, and invoke across sessions—enabling compounding capability over time.
+
+## Installation
+
+```bash
+pnpm add @tanstack/ai-code-mode-skills
+```
+
+## Usage
+
+```typescript
+import {
+  codeModeWithSkills,
+  createFileSkillStorage,
+  createAlwaysTrustedStrategy,
+} from '@tanstack/ai-code-mode-skills'
+import { createNodeIsolateDriver } from '@tanstack/ai-isolate-node'
+
+// Create skill storage
+const skillStorage = createFileSkillStorage({
+  directory: './.skills',
+  trustStrategy: createAlwaysTrustedStrategy(),
+})
+
+// Create code mode config
+const codeModeConfig = {
+  driver: createNodeIsolateDriver(),
+  tools: allTools, // Your external tools
+  timeout: 60000,
+  memoryLimit: 128,
+}
+
+// Build a dynamic registry and system prompt with skills
+const { registry, systemPrompt, selectedSkills } = await codeModeWithSkills({
+  config: codeModeConfig,
+  adapter: anthropic('claude-3-haiku'), // Cheap model for skill selection
+  skills: {
+    storage: skillStorage,
+    maxSkillsInContext: 5,
+  },
+  messages,
+})
+
+// Use in chat
+const stream = chat({
+  adapter: anthropic('claude-sonnet-4-20250514'), // Main model
+  toolRegistry: registry,
+  messages,
+  systemPrompts: [basePrompt, systemPrompt],
+})
+```
+
+## Testing
+
+This package includes a CLI for testing the skills system. The tests verify the complete skills lifecycle:
+
+1. **First run (Skill Creation)**: LLM uses `execute_typescript` to solve a problem and registers a reusable skill
+2. **Second run (Skill Reuse)**: LLM calls the saved skill directly without needing `execute_typescript`
+
+### Running the Simulated Test
+
+The simulated test uses a mock adapter with predetermined responses for fully deterministic testing. No API key required.
+
+```bash
+# From the package directory
+cd packages/typescript/ai-code-mode-skills
+
+# Run the simulated test
+pnpm test:cli:simulated
+```
+
+### Running the Live Test
+
+The live test uses a real LLM (OpenAI or Anthropic) to verify the skills flow with actual LLM responses.
+
+#### Setup
+
+1. Copy the environment example file:
+
+   ```bash
+   cp test-cli/env.example test-cli/.env.local
+   ```
+
+2. Edit `test-cli/.env.local` and add your API key:
+   ```
+   OPENAI_API_KEY=sk-...
+   # or
+   ANTHROPIC_API_KEY=sk-ant-...
+   ```
+
+#### Run the test
+
+```bash
+# Run with OpenAI (default)
+pnpm test:cli:live
+
+# Run with Anthropic
+pnpm test:cli:live --provider anthropic
+
+# Run with a specific model
+pnpm test:cli:live --model gpt-4o-mini
+
+# Run with verbose output
+pnpm test:cli:live -v
+```
+
+### CLI Commands
+
+```bash
+# Show help
+pnpm test:cli --help
+
+# Run simulated test (deterministic, no API key)
+pnpm test:cli simulated
+
+# Run live test (requires API key)
+pnpm test:cli live [options]
+
+Options:
+  --provider <provider>  LLM provider: openai or anthropic (default: openai)
+  --model <model>        Model to use (default depends on provider)
+  -v, --verbose          Enable verbose output
+```
+
+## API Reference
+
+### `codeModeWithSkills(options)`
+
+Creates Code Mode tools and system prompt with skills integration.
+
+**Options:**
+
+- `config` - Code Mode tool configuration (driver, tools, timeout, memoryLimit)
+- `adapter` - Text adapter for skill selection (should be a cheap/fast model)
+- `skills.storage` - Skill storage implementation
+- `skills.maxSkillsInContext` - Maximum skills to load into context (default: 5)
+- `messages` - Current conversation messages
+- `skillsAsTools` - Whether to include skills as direct tools (default: true)
+
+**Returns:**
+
+- `registry` - Mutable `ToolRegistry` containing `execute_typescript`, skill management tools, and selected skill tools
+- `systemPrompt` - System prompt documenting available skills and external functions
+- `selectedSkills` - Skills that were selected for this request
+
+### Storage
+
+Storage is available from both the root export and the explicit storage subpath:
+
+```typescript
+import { createFileSkillStorage } from '@tanstack/ai-code-mode-skills'
+// or
+import { createFileSkillStorage } from '@tanstack/ai-code-mode-skills/storage'
+```
+
+#### `createFileSkillStorage(options)`
+
+Git-friendly file-based storage:
+
+```
+.skills/
+├── compare_react_state_libraries/
+│   ├── meta.json      # Metadata, schemas, stats
+│   └── code.ts        # TypeScript implementation
+└── fetch_github_stats/
+    ├── meta.json
+    └── code.ts
+```
+
+#### `createMemorySkillStorage(options)`
+
+In-memory storage for testing.
+
+### Trust Strategies
+
+Skills track execution success and promote trust levels over time:
+
+| Trust Level   | Description                       |
+| ------------- | --------------------------------- |
+| `untrusted`   | Newly created, not yet proven     |
+| `provisional` | 10+ executions with ≥90% success  |
+| `trusted`     | 100+ executions with ≥95% success |
+
+Available strategies:
+
+- `createDefaultTrustStrategy()` - Earn trust through successful executions
+- `createAlwaysTrustedStrategy()` - Trust immediately (dev/testing)
+- `createRelaxedTrustStrategy()` - Faster promotion
+- `createCustomTrustStrategy(options)` - Custom thresholds
+
+## License
+
+MIT

package/dist/esm/code-mode-with-skills.d.ts

@@ -0,0 +1,58 @@
+import { CodeModeWithSkillsOptions, CodeModeWithSkillsResult, Skill } from './types.js';
+export type { CodeModeWithSkillsOptions, CodeModeWithSkillsResult };
+/**
+ * Create Code Mode tools and system prompt with skills integration.
+ *
+ * This function:
+ * 1. Loads the skill index from storage
+ * 2. Uses a cheap/fast LLM to select relevant skills based on conversation context
+ * 3. Creates the execute_typescript tool with dynamic skill bindings
+ * 4. Creates skill management tools (search, get, register)
+ * 5. Generates system prompts documenting available skills
+ * 6. Returns a ToolRegistry that allows dynamic skill additions mid-stream
+ *
+ * @example
+ * ```typescript
+ * const { toolsRegistry, systemPrompt, selectedSkills } = await codeModeWithSkills({
+ *   config: {
+ *     driver: createNodeIsolateDriver(),
+ *     tools: allTools,
+ *     timeout: 60000,
+ *   },
+ *   adapter: openaiText('gpt-4o-mini'),  // Cheap model for selection
+ *   skills: {
+ *     storage: createFileSkillStorage('./.skills'),
+ *     maxSkillsInContext: 5,
+ *   },
+ *   messages,
+ * });
+ *
+ * const stream = chat({
+ *   adapter: openaiText('gpt-4o'),  // Main model
+ *   toolRegistry: toolsRegistry,  // Dynamic tool registry
+ *   messages,
+ *   systemPrompts: [BASE_PROMPT, systemPrompt],
+ * });
+ * ```
+ */
+export declare function codeModeWithSkills({ config, adapter, skills, messages, skillsAsTools, }: CodeModeWithSkillsOptions): Promise<CodeModeWithSkillsResult>;
+/**
+ * Create a Code Mode tool configuration extended with skills.
+ * This is an alternative to codeModeWithSkills that returns
+ * a config object instead of directly creating tools.
+ *
+ * Useful when you want more control over the tool creation process.
+ */
+export declare function createCodeModeWithSkillsConfig({ config, selectedSkills, storage, }: {
+    config: CodeModeWithSkillsOptions['config'];
+    selectedSkills: Array<Skill>;
+    storage: CodeModeWithSkillsOptions['skills']['storage'];
+}): {
+    skillTools: import('@tanstack/ai').ServerTool<any, any, any>[];
+    selectedSkills: Skill[];
+    driver: import('@tanstack/ai-code-mode').IsolateDriver;
+    tools: Array<import('@tanstack/ai-code-mode').CodeModeTool>;
+    timeout?: number;
+    memoryLimit?: number;
+    getSkillBindings?: () => Promise<Record<string, import('@tanstack/ai-code-mode').ToolBinding>>;
+};

package/dist/esm/code-mode-with-skills.js

@@ -0,0 +1,124 @@
+import { toolsToBindings, createCodeModeTool, createCodeModeSystemPrompt } from "@tanstack/ai-code-mode";
+import { createToolRegistry } from "@tanstack/ai";
+import { selectRelevantSkills } from "./select-relevant-skills.js";
+import { createSkillManagementTools } from "./create-skill-management-tools.js";
+import { createSkillsSystemPrompt } from "./create-skills-system-prompt.js";
+import { skillsToTools } from "./skills-to-tools.js";
+async function codeModeWithSkills({
+  config,
+  adapter,
+  skills,
+  messages,
+  skillsAsTools = true
+}) {
+  const { storage, maxSkillsInContext = 5 } = skills;
+  const skillIndex = await storage.loadIndex();
+  const selectedSkills = await selectRelevantSkills({
+    adapter,
+    messages,
+    skillIndex,
+    maxSkills: maxSkillsInContext,
+    storage
+  });
+  const baseBindings = toolsToBindings(config.tools, "external_");
+  const codeModeTool = createCodeModeTool({
+    ...config,
+    // Dynamic skill bindings - fetched at execution time
+    getSkillBindings: async () => {
+      const allSkills = await storage.loadAll();
+      const skillBindings = {};
+      for (const skill of allSkills) {
+        skillBindings[`skill_${skill.name}`] = {
+          name: `skill_${skill.name}`,
+          description: skill.description,
+          inputSchema: skill.inputSchema,
+          outputSchema: skill.outputSchema,
+          execute: async (input) => {
+            const wrappedCode = `const input = ${JSON.stringify(input)};
+${skill.code}`;
+            const { stripTypeScript, createEventAwareBindings } = await import("@tanstack/ai-code-mode");
+            const strippedCode = await stripTypeScript(wrappedCode);
+            const context = await config.driver.createContext({
+              bindings: createEventAwareBindings(baseBindings, () => {
+              }),
+              timeout: config.timeout,
+              memoryLimit: config.memoryLimit
+            });
+            try {
+              const result = await context.execute(strippedCode);
+              if (!result.success) {
+                throw new Error(
+                  result.error?.message || "Skill execution failed"
+                );
+              }
+              return result.value;
+            } finally {
+              await context.dispose();
+            }
+          }
+        };
+      }
+      return skillBindings;
+    }
+  });
+  const registry = createToolRegistry();
+  registry.add(codeModeTool);
+  const skillManagementTools = createSkillManagementTools({
+    storage,
+    registry,
+    config,
+    baseBindings
+  });
+  for (const tool of skillManagementTools) {
+    registry.add(tool);
+  }
+  if (skillsAsTools && selectedSkills.length > 0) {
+    const skillToolsList = skillsToTools({
+      skills: selectedSkills,
+      driver: config.driver,
+      tools: config.tools,
+      storage,
+      timeout: config.timeout,
+      memoryLimit: config.memoryLimit
+    });
+    for (const skillTool of skillToolsList) {
+      registry.add(skillTool);
+    }
+  }
+  const basePrompt = createCodeModeSystemPrompt(config);
+  const skillsPrompt = createSkillsSystemPrompt({
+    selectedSkills,
+    totalSkillCount: skillIndex.length,
+    skillsAsTools
+  });
+  const systemPrompt = basePrompt + "\n\n" + skillsPrompt;
+  return {
+    toolsRegistry: registry,
+    systemPrompt,
+    selectedSkills
+  };
+}
+function createCodeModeWithSkillsConfig({
+  config,
+  selectedSkills,
+  storage
+}) {
+  const skillToolsList = skillsToTools({
+    skills: selectedSkills,
+    driver: config.driver,
+    tools: config.tools,
+    storage,
+    timeout: config.timeout,
+    memoryLimit: config.memoryLimit
+  });
+  return {
+    ...config,
+    skillTools: skillToolsList,
+    selectedSkills
+  };
+}
+export {
+  codeModeWithSkills,
+  createCodeModeWithSkillsConfig
+};
+//# sourceMappingURL=code-mode-with-skills.js.map

package/dist/esm/code-mode-with-skills.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"code-mode-with-skills.js","sources":["../../src/code-mode-with-skills.ts"],"sourcesContent":["import {\n  createCodeModeSystemPrompt,\n  createCodeModeTool,\n  toolsToBindings,\n} from '@tanstack/ai-code-mode'\nimport { createToolRegistry } from '@tanstack/ai'\nimport { selectRelevantSkills } from './select-relevant-skills'\nimport { createSkillManagementTools } from './create-skill-management-tools'\nimport { createSkillsSystemPrompt } from './create-skills-system-prompt'\nimport { skillsToTools } from './skills-to-tools'\nimport type {\n  CodeModeWithSkillsOptions,\n  CodeModeWithSkillsResult,\n  Skill,\n} from './types'\n\nexport type { CodeModeWithSkillsOptions, CodeModeWithSkillsResult }\n\n/**\n * Create Code Mode tools and system prompt with skills integration.\n *\n * This function:\n * 1. Loads the skill index from storage\n * 2. Uses a cheap/fast LLM to select relevant skills based on conversation context\n * 3. Creates the execute_typescript tool with dynamic skill bindings\n * 4. Creates skill management tools (search, get, register)\n * 5. Generates system prompts documenting available skills\n * 6. Returns a ToolRegistry that allows dynamic skill additions mid-stream\n *\n * @example\n * ```typescript\n * const { toolsRegistry, systemPrompt, selectedSkills } = await codeModeWithSkills({\n *   config: {\n *     driver: createNodeIsolateDriver(),\n *     tools: allTools,\n *     timeout: 60000,\n *   },\n *   adapter: openaiText('gpt-4o-mini'),  // Cheap model for selection\n *   skills: {\n *     storage: createFileSkillStorage('./.skills'),\n *     maxSkillsInContext: 5,\n *   },\n *   messages,\n * });\n *\n * const stream = chat({\n *   adapter: openaiText('gpt-4o'),  // Main model\n *   toolRegistry: toolsRegistry,  // Dynamic tool registry\n *   messages,\n *   systemPrompts: [BASE_PROMPT, systemPrompt],\n * });\n * ```\n */\nexport async function codeModeWithSkills({\n  config,\n  adapter,\n  skills,\n  messages,\n  skillsAsTools = true,\n}: CodeModeWithSkillsOptions): Promise<CodeModeWithSkillsResult> {\n  const { storage, maxSkillsInContext = 5 } = skills\n\n  // 1. Load the skill index (lightweight metadata only)\n  const skillIndex = await storage.loadIndex()\n\n  // 2. Use adapter to select relevant skills based on transcript\n  const selectedSkills = await selectRelevantSkills({\n    adapter,\n    messages,\n    skillIndex,\n    maxSkills: maxSkillsInContext,\n    storage,\n  })\n\n  // Pre-compute bindings from base tools (shared across skill executions)\n  const baseBindings = toolsToBindings(config.tools, 'external_')\n\n  // 3. Create the execute_typescript tool with dynamic skill bindings\n  const codeModeTool = createCodeModeTool({\n    ...config,\n    // Dynamic skill bindings - fetched at execution time\n    getSkillBindings: async () => {\n      // Get all skills from storage (includes newly registered ones)\n      const allSkills = await storage.loadAll()\n      // Convert to bindings with skill_ prefix\n      const skillBindings: Record<string, any> = {}\n      for (const skill of allSkills) {\n        // Create a simple binding that executes the skill code\n        skillBindings[`skill_${skill.name}`] = {\n          name: `skill_${skill.name}`,\n          description: skill.description,\n          inputSchema: skill.inputSchema,\n          outputSchema: skill.outputSchema,\n          execute: async (input: unknown) => {\n            // This is a simplified execution - the full skillToTool handles events\n            const wrappedCode = `const input = ${JSON.stringify(input)};\\n${skill.code}`\n            const { stripTypeScript, createEventAwareBindings } =\n              await import('@tanstack/ai-code-mode')\n            const strippedCode = await stripTypeScript(wrappedCode)\n            const context = await config.driver.createContext({\n              bindings: createEventAwareBindings(baseBindings, () => {}),\n              timeout: config.timeout,\n              memoryLimit: config.memoryLimit,\n            })\n            try {\n              const result = await context.execute(strippedCode)\n              if (!result.success) {\n                throw new Error(\n                  result.error?.message || 'Skill execution failed',\n                )\n              }\n              return result.value\n            } finally {\n              await context.dispose()\n            }\n          },\n        }\n      }\n      return skillBindings\n    },\n  })\n\n  // 4. Create a mutable tool registry\n  const registry = createToolRegistry()\n\n  // 5. Add the execute_typescript tool to the registry\n  registry.add(codeModeTool)\n\n  // 6. Create skill management tools (they need access to the registry)\n  const skillManagementTools = createSkillManagementTools({\n    storage,\n    registry,\n    config,\n    baseBindings,\n  })\n\n  for (const tool of skillManagementTools) {\n    registry.add(tool)\n  }\n\n  // 7. Convert selected skills to direct tools and add to registry (if enabled)\n  if (skillsAsTools && selectedSkills.length > 0) {\n    const skillToolsList = skillsToTools({\n      skills: selectedSkills,\n      driver: config.driver,\n      tools: config.tools,\n      storage,\n      timeout: config.timeout,\n      memoryLimit: config.memoryLimit,\n    })\n\n    for (const skillTool of skillToolsList) {\n      registry.add(skillTool)\n    }\n  }\n\n  // 8. Generate combined system prompt\n  const basePrompt = createCodeModeSystemPrompt(config)\n  const skillsPrompt = createSkillsSystemPrompt({\n    selectedSkills,\n    totalSkillCount: skillIndex.length,\n    skillsAsTools,\n  })\n  const systemPrompt = basePrompt + '\\n\\n' + skillsPrompt\n\n  return {\n    toolsRegistry: registry,\n    systemPrompt,\n    selectedSkills,\n  }\n}\n\n/**\n * Create a Code Mode tool configuration extended with skills.\n * This is an alternative to codeModeWithSkills that returns\n * a config object instead of directly creating tools.\n *\n * Useful when you want more control over the tool creation process.\n */\nexport function createCodeModeWithSkillsConfig({\n  config,\n  selectedSkills,\n  storage,\n}: {\n  config: CodeModeWithSkillsOptions['config']\n  selectedSkills: Array<Skill>\n  storage: CodeModeWithSkillsOptions['skills']['storage']\n}) {\n  // Create skill tools for direct calling\n  const skillToolsList = skillsToTools({\n    skills: selectedSkills,\n    driver: config.driver,\n    tools: config.tools,\n    storage,\n    timeout: config.timeout,\n    memoryLimit: config.memoryLimit,\n  })\n\n  return {\n    ...config,\n    skillTools: skillToolsList,\n    selectedSkills,\n  }\n}\n"],"names":[],"mappings":"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"}

package/dist/esm/create-skill-management-tools.d.ts

@@ -0,0 +1,40 @@
+import { ServerTool, ToolRegistry } from '@tanstack/ai';
+import { CodeModeToolConfig, ToolBinding } from '@tanstack/ai-code-mode';
+import { SkillStorage } from './types.js';
+import { TrustStrategy } from './trust-strategies.js';
+interface CreateSkillManagementToolsOptions {
+    /**
+     * Storage implementation for skills
+     */
+    storage: SkillStorage;
+    /**
+     * Trust strategy for determining initial trust level.
+     * If not provided, uses the storage's trustStrategy or falls back to default.
+     */
+    trustStrategy?: TrustStrategy;
+    /**
+     * Tool registry for adding newly registered skills immediately.
+     * When provided, register_skill will add the new skill to this registry
+     * so it's available as a direct tool in the current chat session.
+     */
+    registry?: ToolRegistry;
+    /**
+     * Code mode config for creating skill tools.
+     * Required when registry is provided.
+     */
+    config?: CodeModeToolConfig;
+    /**
+     * Pre-computed bindings for external_* functions.
+     * Required when registry is provided.
+     */
+    baseBindings?: Record<string, ToolBinding>;
+}
+/**
+ * Create tools for searching, retrieving, and registering skills.
+ * These tools allow the LLM to interact with the skill library at runtime.
+ *
+ * When registry, config, and baseBindings are provided, newly registered skills
+ * will be immediately added to the registry and available as direct tools.
+ */
+export declare function createSkillManagementTools({ storage, trustStrategy, registry, config, baseBindings, }: CreateSkillManagementToolsOptions): Array<ServerTool<any, any, any>>;
+export {};

package/dist/esm/create-skill-management-tools.js

@@ -0,0 +1,198 @@
+import { toolDefinition } from "@tanstack/ai";
+import { toolsToBindings } from "@tanstack/ai-code-mode";
+import { z } from "zod";
+import { createDefaultTrustStrategy } from "./trust-strategies.js";
+import { skillToTool } from "./skills-to-tools.js";
+function createSkillManagementTools({
+  storage,
+  trustStrategy,
+  registry,
+  config,
+  baseBindings
+}) {
+  const strategy = trustStrategy ?? storage.trustStrategy ?? createDefaultTrustStrategy();
+  const bindings = baseBindings ?? (config ? toolsToBindings(config.tools, "external_") : {});
+  return [
+    // Search for skills
+    toolDefinition({
+      name: "search_skills",
+      description: "Search the skill library for reusable skills. Use this to find skills that can help accomplish a task. Returns matching skills with their descriptions.",
+      inputSchema: z.object({
+        query: z.string().describe("Search query describing what you want to accomplish"),
+        limit: z.number().optional().default(5).describe("Maximum number of results (default: 5)")
+      }),
+      outputSchema: z.array(
+        z.object({
+          name: z.string(),
+          description: z.string(),
+          usageHints: z.array(z.string()),
+          trustLevel: z.enum(["untrusted", "provisional", "trusted"])
+        })
+      )
+    }).server(async ({ query, limit }) => {
+      const results = await storage.search(query, { limit: limit ?? 5 });
+      return results.map((s) => ({
+        name: s.name,
+        description: s.description,
+        usageHints: s.usageHints,
+        trustLevel: s.trustLevel
+      }));
+    }),
+    // Get full skill details
+    toolDefinition({
+      name: "get_skill",
+      description: "Get the full implementation details of a skill, including its code. Use this after search_skills to see how a skill works before using it.",
+      inputSchema: z.object({
+        name: z.string().describe("The skill name (without skill_ prefix)")
+      }),
+      outputSchema: z.object({
+        name: z.string().optional(),
+        description: z.string().optional(),
+        code: z.string().optional(),
+        inputSchema: z.string().optional().describe("JSON Schema as string"),
+        outputSchema: z.string().optional().describe("JSON Schema as string"),
+        usageHints: z.array(z.string()).optional(),
+        dependsOn: z.array(z.string()).optional(),
+        trustLevel: z.enum(["untrusted", "provisional", "trusted"]).optional(),
+        stats: z.object({
+          executions: z.number(),
+          successRate: z.number()
+        }).optional(),
+        error: z.string().optional()
+      })
+    }).server(async ({ name }) => {
+      const skill = await storage.get(name);
+      if (!skill) {
+        return { error: `Skill '${name}' not found` };
+      }
+      return {
+        name: skill.name,
+        description: skill.description,
+        code: skill.code,
+        inputSchema: JSON.stringify(skill.inputSchema),
+        outputSchema: JSON.stringify(skill.outputSchema),
+        usageHints: skill.usageHints,
+        dependsOn: skill.dependsOn,
+        trustLevel: skill.trustLevel,
+        stats: skill.stats
+      };
+    }),
+    // Register a new skill
+    toolDefinition({
+      name: "register_skill",
+      description: "Save working TypeScript code as a reusable skill for future use. Only register code that has been tested and works correctly. The skill becomes available as a callable tool immediately.",
+      inputSchema: z.object({
+        name: z.string().regex(
+          /^[a-z][a-z0-9_]*$/,
+          "Must be snake_case starting with a letter"
+        ).describe(
+          "Unique skill name in snake_case (e.g., fetch_github_stats)"
+        ),
+        description: z.string().describe("Clear description of what the skill does"),
+        code: z.string().describe(
+          "The TypeScript code. Receives `input` variable, can call external_* and skill_* functions, should return a value."
+        ),
+        inputSchema: z.string().describe(
+          'JSON Schema as a JSON string describing the input parameter, e.g. {"type":"object","properties":{"a":{"type":"number"}},"required":["a"]}'
+        ),
+        outputSchema: z.string().describe(
+          'JSON Schema as a JSON string describing the return value, e.g. {"type":"object","properties":{"result":{"type":"number"}}}'
+        ),
+        usageHints: z.array(z.string()).describe(
+          'Hints about when to use this skill, e.g. "Use when user asks about..."'
+        ),
+        dependsOn: z.array(z.string()).optional().default([]).describe("Names of other skills this skill calls")
+      }),
+      outputSchema: z.object({
+        success: z.boolean().optional(),
+        skillId: z.string().optional(),
+        name: z.string().optional(),
+        message: z.string().optional(),
+        error: z.string().optional()
+      })
+    }).server(async (rawSkillDef, context) => {
+      let inputSchema;
+      let outputSchema;
+      try {
+        inputSchema = JSON.parse(rawSkillDef.inputSchema);
+      } catch {
+        return { error: "inputSchema must be a valid JSON string" };
+      }
+      try {
+        outputSchema = JSON.parse(rawSkillDef.outputSchema);
+      } catch {
+        return { error: "outputSchema must be a valid JSON string" };
+      }
+      const skillDef = {
+        ...rawSkillDef,
+        inputSchema,
+        outputSchema
+      };
+      try {
+        if (skillDef.name.startsWith("external_")) {
+          return { error: "Skill names cannot start with 'external_'" };
+        }
+        if (skillDef.name.startsWith("skill_")) {
+          return {
+            error: "Skill names should not include the 'skill_' prefix - it will be added automatically"
+          };
+        }
+        const existing = await storage.get(skillDef.name);
+        if (existing) {
+          return {
+            error: `Skill '${skillDef.name}' already exists. Use a different name or update the existing skill.`
+          };
+        }
+        const id = crypto.randomUUID();
+        const initialTrustLevel = strategy.getInitialTrustLevel();
+        const skill = await storage.save({
+          id,
+          name: skillDef.name,
+          description: skillDef.description,
+          code: skillDef.code,
+          inputSchema: skillDef.inputSchema,
+          outputSchema: skillDef.outputSchema,
+          usageHints: skillDef.usageHints,
+          dependsOn: skillDef.dependsOn ?? [],
+          trustLevel: initialTrustLevel,
+          stats: { executions: 0, successRate: 0 }
+        });
+        if (registry && config) {
+          const skillTool = skillToTool({
+            skill,
+            driver: config.driver,
+            bindings,
+            storage,
+            timeout: config.timeout,
+            memoryLimit: config.memoryLimit
+          });
+          registry.add(skillTool);
+          console.log(
+            `[register_skill] Added skill '${skill.name}' to registry immediately`
+          );
+        }
+        context?.emitCustomEvent("skill:registered", {
+          id: skill.id,
+          name: skill.name,
+          description: skill.description,
+          timestamp: Date.now()
+        });
+        return {
+          success: true,
+          skillId: skill.id,
+          name: skill.name,
+          message: `Skill '${skill.name}' registered successfully and is now available as the '${skill.name}' tool.`
+        };
+      } catch (error) {
+        console.error("[register_skill] Error:", error);
+        return {
+          error: `Failed to register skill: ${error instanceof Error ? error.message : String(error)}`
+        };
+      }
+    })
+  ];
+}
+export {
+  createSkillManagementTools
+};
+//# sourceMappingURL=create-skill-management-tools.js.map

package/dist/esm/create-skill-management-tools.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-skill-management-tools.js","sources":["../../src/create-skill-management-tools.ts"],"sourcesContent":["import { toolDefinition } from '@tanstack/ai'\nimport { toolsToBindings } from '@tanstack/ai-code-mode'\nimport { z } from 'zod'\nimport { createDefaultTrustStrategy } from './trust-strategies'\nimport { skillToTool } from './skills-to-tools'\nimport type { ServerTool, ToolRegistry } from '@tanstack/ai'\nimport type { CodeModeToolConfig, ToolBinding } from '@tanstack/ai-code-mode'\nimport type { SkillStorage } from './types'\nimport type { TrustStrategy } from './trust-strategies'\n\ninterface CreateSkillManagementToolsOptions {\n  /**\n   * Storage implementation for skills\n   */\n  storage: SkillStorage\n\n  /**\n   * Trust strategy for determining initial trust level.\n   * If not provided, uses the storage's trustStrategy or falls back to default.\n   */\n  trustStrategy?: TrustStrategy\n\n  /**\n   * Tool registry for adding newly registered skills immediately.\n   * When provided, register_skill will add the new skill to this registry\n   * so it's available as a direct tool in the current chat session.\n   */\n  registry?: ToolRegistry\n\n  /**\n   * Code mode config for creating skill tools.\n   * Required when registry is provided.\n   */\n  config?: CodeModeToolConfig\n\n  /**\n   * Pre-computed bindings for external_* functions.\n   * Required when registry is provided.\n   */\n  baseBindings?: Record<string, ToolBinding>\n}\n\n/**\n * Create tools for searching, retrieving, and registering skills.\n * These tools allow the LLM to interact with the skill library at runtime.\n *\n * When registry, config, and baseBindings are provided, newly registered skills\n * will be immediately added to the registry and available as direct tools.\n */\nexport function createSkillManagementTools({\n  storage,\n  trustStrategy,\n  registry,\n  config,\n  baseBindings,\n}: CreateSkillManagementToolsOptions): Array<ServerTool<any, any, any>> {\n  // Use provided strategy, or storage's strategy, or default\n  const strategy =\n    trustStrategy ?? storage.trustStrategy ?? createDefaultTrustStrategy()\n\n  // Compute bindings if not provided but config is available\n  const bindings =\n    baseBindings ?? (config ? toolsToBindings(config.tools, 'external_') : {})\n  return [\n    // Search for skills\n    toolDefinition({\n      name: 'search_skills',\n      description:\n        'Search the skill library for reusable skills. Use this to find skills that can help accomplish a task. Returns matching skills with their descriptions.',\n      inputSchema: z.object({\n        query: z\n          .string()\n          .describe('Search query describing what you want to accomplish'),\n        limit: z\n          .number()\n          .optional()\n          .default(5)\n          .describe('Maximum number of results (default: 5)'),\n      }),\n      outputSchema: z.array(\n        z.object({\n          name: z.string(),\n          description: z.string(),\n          usageHints: z.array(z.string()),\n          trustLevel: z.enum(['untrusted', 'provisional', 'trusted']),\n        }),\n      ),\n    }).server(async ({ query, limit }) => {\n      const results = await storage.search(query, { limit: limit ?? 5 })\n      return results.map((s) => ({\n        name: s.name,\n        description: s.description,\n        usageHints: s.usageHints,\n        trustLevel: s.trustLevel,\n      }))\n    }),\n\n    // Get full skill details\n    toolDefinition({\n      name: 'get_skill',\n      description:\n        'Get the full implementation details of a skill, including its code. Use this after search_skills to see how a skill works before using it.',\n      inputSchema: z.object({\n        name: z.string().describe('The skill name (without skill_ prefix)'),\n      }),\n      outputSchema: z.object({\n        name: z.string().optional(),\n        description: z.string().optional(),\n        code: z.string().optional(),\n        inputSchema: z.string().optional().describe('JSON Schema as string'),\n        outputSchema: z.string().optional().describe('JSON Schema as string'),\n        usageHints: z.array(z.string()).optional(),\n        dependsOn: z.array(z.string()).optional(),\n        trustLevel: z.enum(['untrusted', 'provisional', 'trusted']).optional(),\n        stats: z\n          .object({\n            executions: z.number(),\n            successRate: z.number(),\n          })\n          .optional(),\n        error: z.string().optional(),\n      }),\n    }).server(async ({ name }) => {\n      const skill = await storage.get(name)\n      if (!skill) {\n        return { error: `Skill '${name}' not found` }\n      }\n      return {\n        name: skill.name,\n        description: skill.description,\n        code: skill.code,\n        inputSchema: JSON.stringify(skill.inputSchema),\n        outputSchema: JSON.stringify(skill.outputSchema),\n        usageHints: skill.usageHints,\n        dependsOn: skill.dependsOn,\n        trustLevel: skill.trustLevel,\n        stats: skill.stats,\n      }\n    }),\n\n    // Register a new skill\n    toolDefinition({\n      name: 'register_skill',\n      description:\n        'Save working TypeScript code as a reusable skill for future use. Only register code that has been tested and works correctly. The skill becomes available as a callable tool immediately.',\n      inputSchema: z.object({\n        name: z\n          .string()\n          .regex(\n            /^[a-z][a-z0-9_]*$/,\n            'Must be snake_case starting with a letter',\n          )\n          .describe(\n            'Unique skill name in snake_case (e.g., fetch_github_stats)',\n          ),\n        description: z\n          .string()\n          .describe('Clear description of what the skill does'),\n        code: z\n          .string()\n          .describe(\n            'The TypeScript code. Receives `input` variable, can call external_* and skill_* functions, should return a value.',\n          ),\n        inputSchema: z\n          .string()\n          .describe(\n            'JSON Schema as a JSON string describing the input parameter, e.g. {\"type\":\"object\",\"properties\":{\"a\":{\"type\":\"number\"}},\"required\":[\"a\"]}',\n          ),\n        outputSchema: z\n          .string()\n          .describe(\n            'JSON Schema as a JSON string describing the return value, e.g. {\"type\":\"object\",\"properties\":{\"result\":{\"type\":\"number\"}}}',\n          ),\n        usageHints: z\n          .array(z.string())\n          .describe(\n            'Hints about when to use this skill, e.g. \"Use when user asks about...\"',\n          ),\n        dependsOn: z\n          .array(z.string())\n          .optional()\n          .default([])\n          .describe('Names of other skills this skill calls'),\n      }),\n      outputSchema: z.object({\n        success: z.boolean().optional(),\n        skillId: z.string().optional(),\n        name: z.string().optional(),\n        message: z.string().optional(),\n        error: z.string().optional(),\n      }),\n    }).server(async (rawSkillDef, context) => {\n      // Parse the JSON string schemas\n      let inputSchema: Record<string, unknown>\n      let outputSchema: Record<string, unknown>\n      try {\n        inputSchema = JSON.parse(rawSkillDef.inputSchema) as Record<\n          string,\n          unknown\n        >\n      } catch {\n        return { error: 'inputSchema must be a valid JSON string' }\n      }\n      try {\n        outputSchema = JSON.parse(rawSkillDef.outputSchema) as Record<\n          string,\n          unknown\n        >\n      } catch {\n        return { error: 'outputSchema must be a valid JSON string' }\n      }\n\n      const skillDef = {\n        ...rawSkillDef,\n        inputSchema,\n        outputSchema,\n      }\n      try {\n        // Validate the skill name isn't reserved\n        if (skillDef.name.startsWith('external_')) {\n          return { error: \"Skill names cannot start with 'external_'\" }\n        }\n        if (skillDef.name.startsWith('skill_')) {\n          return {\n            error:\n              \"Skill names should not include the 'skill_' prefix - it will be added automatically\",\n          }\n        }\n\n        // Check if skill already exists\n        const existing = await storage.get(skillDef.name)\n        if (existing) {\n          return {\n            error: `Skill '${skillDef.name}' already exists. Use a different name or update the existing skill.`,\n          }\n        }\n\n        // Generate a unique ID\n        const id = crypto.randomUUID()\n\n        // Get initial trust level from strategy\n        const initialTrustLevel = strategy.getInitialTrustLevel()\n\n        // Save the skill\n        const skill = await storage.save({\n          id,\n          name: skillDef.name,\n          description: skillDef.description,\n          code: skillDef.code,\n          inputSchema: skillDef.inputSchema,\n          outputSchema: skillDef.outputSchema,\n          usageHints: skillDef.usageHints,\n          dependsOn: skillDef.dependsOn ?? [],\n          trustLevel: initialTrustLevel,\n          stats: { executions: 0, successRate: 0 },\n        })\n\n        // If registry and config are available, add the skill as a tool immediately\n        if (registry && config) {\n          const skillTool = skillToTool({\n            skill,\n            driver: config.driver,\n            bindings,\n            storage,\n            timeout: config.timeout,\n            memoryLimit: config.memoryLimit,\n          })\n          registry.add(skillTool)\n          console.log(\n            `[register_skill] Added skill '${skill.name}' to registry immediately`,\n          )\n        }\n\n        // Emit event for UI notification\n        context?.emitCustomEvent('skill:registered', {\n          id: skill.id,\n          name: skill.name,\n          description: skill.description,\n          timestamp: Date.now(),\n        })\n\n        return {\n          success: true,\n          skillId: skill.id,\n          name: skill.name,\n          message: `Skill '${skill.name}' registered successfully and is now available as the '${skill.name}' tool.`,\n        }\n      } catch (error) {\n        console.error('[register_skill] Error:', error)\n        return {\n          error: `Failed to register skill: ${error instanceof Error ? error.message : String(error)}`,\n        }\n      }\n    }),\n  ]\n}\n"],"names":[],"mappings":"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"}