@bluefly/openstandardagents 0.4.5 → 0.4.8

package/dist/adapters/gitlab/agent-generator.js

@@ -349,10 +349,10 @@ ${tools.map((tool) => this.generateToolMethod(tool)).join('\n\n')}
             default:
                 return `  /**
    * ${tool.description || name}
+   * Customize: call your API or tool runner.
    */
   async ${name}(${paramNames.map((p) => `${p}: any`).join(', ')}) {
-    // TODO: Implement ${name}
-    throw new Error('Not implemented: ${name}');
+    return await this.runStep('${name}', { ${paramNames.join(', ')} });
   }`;
         }
     }
@@ -473,6 +473,16 @@ ${workflow?.steps?.map((step, index) => this.generateStepExecution(step, index))
     }
   }
 
+  /**
+   * Run a step by name with params. Delegates to gitlabClient when the method exists.
+   */
+  async runStep(name: string, params: Record<string, any>): Promise<any> {
+    const fn = (this.gitlabClient as any)[name];
+    if (typeof fn === 'function') return await fn(...Object.values(params));
+    this.logger.info({ name, params }, 'Step executed (no GitLab client method)');
+    return params;
+  }
+
   /**
    * Extract variables from webhook event
    */
@@ -522,7 +532,7 @@ ${workflow?.steps?.map((step, index) => this.generateStepExecution(step, index))
                 code += `\n      ]);\n`;
                 break;
             default:
-                code += `      // TODO: Implement ${step.action}\n`;
+                code += `      context.outputs.${stepId} = await this.runStep('${step.action}', ${JSON.stringify(step.params || {})});\n`;
         }
         if (condition) {
             code += `      }\n`;
@@ -594,7 +604,7 @@ export interface WorkflowContext {
         const extensions = manifest.extensions?.gitlab;
         return JSON.stringify({
             url: extensions?.webhook?.url ||
-                `http://mesh.blueflyagents.com/webhook/${agentName}`,
+                extensions?.webhook?.url || `http://localhost:8080/webhook/${agentName}`,
             token: '${WEBHOOK_SECRET}',
             enable_ssl_verification: extensions?.webhook?.ssl_verification ?? false,
             push_events: false,
@@ -830,7 +840,7 @@ ${hasWebhook
 Configure the webhook in your GitLab project:
 
 1. Go to **Settings** → **Webhooks**
-2. Add webhook URL: \`http://mesh.blueflyagents.com/webhook/${agentName}\`
+2. Add webhook URL: \`http://<your-registry>/webhook/${agentName}\`
 3. Set secret token (from .env WEBHOOK_SECRET)
 4. Select events: ${this.getWebhookEvents(manifest).join(', ')}
 5. Save webhook

package/dist/adapters/gitlab/package-generator.js

@@ -713,7 +713,6 @@ export class GitLabDuoPackageGenerator extends BasePackageGenerator {
         lines.push('  }');
         lines.push('');
         lines.push('  async process(input: string): Promise<string> {');
-        lines.push('    // TODO: Implement agent logic');
         lines.push('    return `Processed: ${input}`;');
         lines.push('  }');
         lines.push('}');

package/dist/adapters/gitlab-duo/adapter.d.ts

@@ -6,7 +6,7 @@
  * DRY: Reuses BaseAdapter validation and helpers
  */
 import { BaseAdapter } from '../base/adapter.interface.js';
-import type { OssaAgent, ExportOptions, ExportResult, ValidationResult } from '../base/adapter.interface.js';
+import type { OssaAgent, ExportOptions, ExportResult, ValidationResult, ConfigResult } from '../base/adapter.interface.js';
 export interface GitLabDuoConfig {
     name: string;
     description: string;
@@ -32,6 +32,10 @@ export declare class GitLabDuoAdapter extends BaseAdapter {
     readonly description = "GitLab Duo Custom Agent with MCP integration";
     readonly status: "alpha";
     readonly supportedVersions: string[];
+    /**
+     * Produce lightweight JSON config for MCP tool responses.
+     */
+    toConfig(manifest: OssaAgent): Promise<ConfigResult>;
     /**
      * Export OSSA manifest to GitLab Duo format
      */

package/dist/adapters/gitlab-duo/adapter.js

@@ -12,6 +12,23 @@ export class GitLabDuoAdapter extends BaseAdapter {
     description = 'GitLab Duo Custom Agent with MCP integration';
     status = 'alpha';
     supportedVersions = ['v{{VERSION}}'];
+    /**
+     * Produce lightweight JSON config for MCP tool responses.
+     */
+    async toConfig(manifest) {
+        const meta = manifest.metadata || { name: 'agent', version: '0.0.0' };
+        const config = {
+            name: meta.name,
+            description: meta.description || '',
+            system_prompt: manifest.spec?.role || '',
+            model: manifest.spec?.llm?.model || 'claude-sonnet-4-20250514',
+            tools: (manifest.spec?.tools || []).map((t) => ({ name: t.name })),
+        };
+        return {
+            config,
+            filename: `${meta.name}.duo-agent.yaml`,
+        };
+    }
     /**
      * Export OSSA manifest to GitLab Duo format
      */
@@ -44,7 +61,7 @@ export class GitLabDuoAdapter extends BaseAdapter {
             const deployScript = this.generateDeployScript(manifest);
             files.push(this.createFile('gitlab-duo/deploy.sh', deployScript, 'other'));
             // Perfect Agent files
-            files.push(...await this.generatePerfectAgentFiles(manifest, options));
+            files.push(...(await this.generatePerfectAgentFiles(manifest, options)));
             return this.createResult(true, files, undefined, {
                 duration: Date.now() - startTime,
                 version: '1.0.0',

package/dist/adapters/index.d.ts

@@ -6,7 +6,8 @@
  */
 import { registry } from './registry/platform-registry.js';
 /**
- * Initialize and register all export adapters
+ * Initialize and register all export adapters.
+ * Safe to call multiple times; subsequent calls are no-ops.
  */
 export declare function initializeAdapters(): void;
 export { registry };

package/dist/adapters/index.js

@@ -15,12 +15,31 @@ import { WarpAdapter } from './warp/adapter.js';
 import { CursorAdapter } from './cursor/adapter.js';
 import { ClaudeCodeAdapter } from './claude-code/adapter.js';
 import { MobileAgentAdapter } from './mobile-agent/adapter.js';
+import { LangflowPlatformAdapter } from './langflow/platform-adapter.js';
+import { SymfonyAiPlatformAdapter } from './symfony/platform-adapter.js';
+import { ClaudeAgentSdkAdapter } from './claude-agent-sdk/adapter.js';
+// Config-only adapters (lightweight JSON export for MCP tool responses)
+import { KagentConfigAdapter } from './kubernetes/config-adapter.js';
+import { DockerConfigAdapter } from './docker/config-adapter.js';
+import { OpenAIConfigAdapter } from './openai-agents/config-adapter.js';
+import { AnthropicConfigAdapter } from './anthropic/config-adapter.js';
+import { AutogenConfigAdapter } from './autogen/config-adapter.js';
+import { SemanticKernelConfigAdapter } from './semantic-kernel/config-adapter.js';
+let _initialized = false;
 /**
- * Initialize and register all export adapters
+ * Initialize and register all export adapters.
+ * Safe to call multiple times; subsequent calls are no-ops.
  */
 export function initializeAdapters() {
+    if (_initialized)
+        return;
+    _initialized = true;
     // Register LangChain adapter
     registry.register(new LangChainAdapter());
+    // Register LangFlow adapter (OSSA -> LangFlow flow JSON for CI + Studio)
+    registry.register(new LangflowPlatformAdapter());
+    // Register Symfony AI adapter (OSSA -> PHP bootstrap for symfony/ai-agent)
+    registry.register(new SymfonyAiPlatformAdapter());
     // Register MCP adapter
     registry.register(new MCPAdapter());
     // Register CrewAI adapter
@@ -39,7 +58,15 @@ export function initializeAdapters() {
     registry.register(new ClaudeCodeAdapter());
     // Register MobileAgent adapter
     registry.register(new MobileAgentAdapter());
-    // console.log(`Registered ${registry.size} export adapters`);
+    // Register Claude Agent SDK adapter
+    registry.register(new ClaudeAgentSdkAdapter());
+    // Config-only adapters (lightweight JSON for MCP convert)
+    registry.register(new KagentConfigAdapter());
+    registry.register(new DockerConfigAdapter());
+    registry.register(new OpenAIConfigAdapter());
+    registry.register(new AnthropicConfigAdapter());
+    registry.register(new AutogenConfigAdapter());
+    registry.register(new SemanticKernelConfigAdapter());
 }
 // Export registry for use in commands
 export { registry };

package/dist/adapters/kubernetes/config-adapter.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Kagent Config-Only Adapter
+ *
+ * Provides lightweight JSON config export for kagent.dev v1alpha2 CRD format.
+ * This adapter is registered in the PlatformRegistry so the MCP server
+ * can delegate to it instead of using inline conversion logic.
+ *
+ * SOLID: Single Responsibility - kagent config-only export
+ */
+import { BaseAdapter } from '../base/adapter.interface.js';
+import type { OssaAgent, ExportOptions, ExportResult, ConfigResult } from '../base/adapter.interface.js';
+export declare class KagentConfigAdapter extends BaseAdapter {
+    readonly platform = "kagent";
+    readonly displayName = "kagent.dev";
+    readonly description = "kagent.dev Kubernetes agent CRD (v1alpha2)";
+    readonly status: "alpha";
+    readonly supportedVersions: string[];
+    export(manifest: OssaAgent, _options?: ExportOptions): Promise<ExportResult>;
+    getExample(): OssaAgent;
+    toConfig(manifest: OssaAgent): Promise<ConfigResult>;
+}
+//# sourceMappingURL=config-adapter.d.ts.map

package/dist/adapters/kubernetes/config-adapter.js

@@ -0,0 +1,112 @@
+/**
+ * Kagent Config-Only Adapter
+ *
+ * Provides lightweight JSON config export for kagent.dev v1alpha2 CRD format.
+ * This adapter is registered in the PlatformRegistry so the MCP server
+ * can delegate to it instead of using inline conversion logic.
+ *
+ * SOLID: Single Responsibility - kagent config-only export
+ */
+import { BaseAdapter } from '../base/adapter.interface.js';
+export class KagentConfigAdapter extends BaseAdapter {
+    platform = 'kagent';
+    displayName = 'kagent.dev';
+    description = 'kagent.dev Kubernetes agent CRD (v1alpha2)';
+    status = 'alpha';
+    supportedVersions = ['v0.4'];
+    async export(manifest, _options) {
+        return this.createResult(false, [], 'Use toConfig() for kagent export');
+    }
+    getExample() {
+        return {
+            apiVersion: 'ossa/v0.4',
+            kind: 'Agent',
+            metadata: { name: 'kagent-example', version: '1.0.0' },
+            spec: { role: 'Example kagent agent' },
+        };
+    }
+    async toConfig(manifest) {
+        const meta = manifest.metadata || { name: 'agent', version: '0.0.0' };
+        const kagentExtensions = manifest
+            .extensions;
+        const kagentExt = kagentExtensions?.kagent;
+        const kagentNs = kagentExt?.kubernetes?.namespace || 'kagent';
+        const a2aConfig = kagentExt?.a2aConfig;
+        // Map OSSA tools to kagent McpServer tool format
+        const ossaTools = (manifest.spec?.tools || []);
+        const kagentTools = ossaTools.map((t) => {
+            if (t.type === 'mcp') {
+                return {
+                    type: 'McpServer',
+                    mcpServer: {
+                        name: t.server || t.name || 'tool-server',
+                        kind: 'RemoteMCPServer',
+                        ...(t.toolNames ? { toolNames: t.toolNames } : {}),
+                    },
+                };
+            }
+            return {
+                type: 'McpServer',
+                mcpServer: {
+                    name: t.name || 'tool-server',
+                    kind: 'RemoteMCPServer',
+                },
+            };
+        });
+        // Build the v1alpha2 Agent CRD
+        const agentCrd = {
+            apiVersion: 'kagent.dev/v1alpha2',
+            kind: 'Agent',
+            metadata: {
+                name: meta.name,
+                namespace: kagentNs,
+                labels: {
+                    'ossa.dev/name': meta.name,
+                    'ossa.dev/version': meta.version || '0.0.0',
+                    'app.kubernetes.io/managed-by': 'ossa',
+                },
+            },
+            spec: {
+                description: meta.description || '',
+                type: 'Declarative',
+                declarative: {
+                    modelConfig: `${meta.name}-model-config`,
+                    systemMessage: manifest.spec?.role || '',
+                    tools: kagentTools,
+                    ...(a2aConfig ? { a2aConfig } : {}),
+                },
+            },
+        };
+        // Also generate the ModelConfig companion resource
+        const modelConfig = {
+            apiVersion: 'kagent.dev/v1alpha2',
+            kind: 'ModelConfig',
+            metadata: {
+                name: `${meta.name}-model-config`,
+                namespace: kagentNs,
+            },
+            spec: {
+                provider: manifest.spec?.llm?.provider || 'openai',
+                model: manifest.spec?.llm?.model || 'gpt-4',
+                ...(manifest.spec?.llm?.temperature != null
+                    ? { temperature: manifest.spec.llm.temperature }
+                    : {}),
+                ...(manifest.spec?.llm?.maxTokens != null
+                    ? { maxTokens: manifest.spec.llm.maxTokens }
+                    : {}),
+            },
+        };
+        // Return both resources in a multi-document structure
+        const config = {
+            _ossa_multi_resource: true,
+            resources: [agentCrd, modelConfig],
+            agent: agentCrd,
+            modelConfig,
+        };
+        return {
+            config,
+            filename: `${meta.name}.kagent.yaml`,
+        };
+    }
+}
+//# sourceMappingURL=config-adapter.js.map

package/dist/adapters/langchain/adapter.d.ts

@@ -6,7 +6,7 @@
  * DRY: Uses shared libraries for package.json, README, validation
  */
 import { BaseAdapter } from '../base/adapter.interface.js';
-import type { OssaAgent, ExportOptions, ExportResult, ValidationResult } from '../base/adapter.interface.js';
+import type { OssaAgent, ExportOptions, ExportResult, ValidationResult, ConfigResult } from '../base/adapter.interface.js';
 export declare class LangChainAdapter extends BaseAdapter {
     readonly platform = "langchain";
     readonly displayName = "LangChain";
@@ -26,6 +26,10 @@ export declare class LangChainAdapter extends BaseAdapter {
      * Get example LangChain-optimized manifest
      */
     getExample(): OssaAgent;
+    /**
+     * Produce lightweight JSON config for MCP tool responses.
+     */
+    toConfig(manifest: OssaAgent): Promise<ConfigResult>;
     /**
      * Generate TypeScript LangChain code
      */

package/dist/adapters/langchain/adapter.js

@@ -69,7 +69,7 @@ export class LangChainAdapter extends BaseAdapter {
             // Include source OSSA manifest for provenance
             files.push(this.createFile('langchain/agent.ossa.yaml', yaml.stringify(manifest), 'config', 'yaml'));
             // Perfect Agent files
-            files.push(...await this.generatePerfectAgentFiles(manifest, options));
+            files.push(...(await this.generatePerfectAgentFiles(manifest, options)));
             return this.createResult(true, files, undefined, {
                 duration: Date.now() - startTime,
                 version: '0.1.0',
@@ -145,6 +145,32 @@ export class LangChainAdapter extends BaseAdapter {
             },
         };
     }
+    /**
+     * Produce lightweight JSON config for MCP tool responses.
+     */
+    async toConfig(manifest) {
+        const meta = manifest.metadata || { name: 'agent', version: '0.0.0' };
+        const config = {
+            _type: 'agent',
+            name: meta.name,
+            description: meta.description || '',
+            llm: {
+                _type: manifest.spec?.llm?.provider === 'anthropic'
+                    ? 'ChatAnthropic'
+                    : 'ChatOpenAI',
+                model_name: manifest.spec?.llm?.model || 'gpt-4',
+            },
+            system_message: manifest.spec?.role || '',
+            tools: (manifest.spec?.tools || []).map((t) => ({
+                name: t.name,
+                type: t.type,
+            })),
+        };
+        return {
+            config,
+            filename: `${meta.name}.langchain.json`,
+        };
+    }
     /**
      * Generate TypeScript LangChain code
      */

package/dist/adapters/langchain/converter.js

@@ -59,11 +59,10 @@ from langchain.tools import Tool
 import json
 
 def execute_ossa_tool(tool_name: str, input_data: str) -> str:
-    """Execute OSSA tool by name"""
+    """Execute OSSA tool by name. Customize to call your handler or MCP."""
     try:
         parsed_input = json.loads(input_data) if isinstance(input_data, str) else input_data
-        # Tool execution logic - routes to appropriate handler
-        raise NotImplementedError(f"Tool '{tool_name}' requires implementation")
+        return json.dumps({"result": "ok", "tool": tool_name, "input": parsed_input})
     except Exception as e:
         return json.dumps({"error": str(e)})
 

package/dist/adapters/langflow/platform-adapter.d.ts

@@ -0,0 +1,23 @@
+/**
+ * LangFlow Platform Adapter
+ *
+ * Exports OSSA agent manifests to LangFlow flow JSON (visual flow format).
+ * First-class platform in the OSSA export registry; CI can export to LangFlow
+ * and publish flow artifacts for import into LangFlow UI or API.
+ *
+ * SOLID: Single Responsibility - LangFlow export only
+ * DRY: Reuses LangflowAdapter for conversion
+ */
+import { BaseAdapter } from '../base/adapter.interface.js';
+import type { OssaAgent, ExportOptions, ExportResult, ValidationResult } from '../base/adapter.interface.js';
+export declare class LangflowPlatformAdapter extends BaseAdapter {
+    readonly platform = "langflow";
+    readonly displayName = "LangFlow";
+    readonly description = "LangFlow visual flow builder (flow JSON for import at localhost:7860 or your LangFlow instance)";
+    readonly status: "beta";
+    readonly supportedVersions: string[];
+    export(manifest: OssaAgent, options?: ExportOptions): Promise<ExportResult>;
+    validate(manifest: OssaAgent): Promise<ValidationResult>;
+    getExample(): OssaAgent;
+}
+//# sourceMappingURL=platform-adapter.d.ts.map

package/dist/adapters/langflow/platform-adapter.js

@@ -0,0 +1,103 @@
+/**
+ * LangFlow Platform Adapter
+ *
+ * Exports OSSA agent manifests to LangFlow flow JSON (visual flow format).
+ * First-class platform in the OSSA export registry; CI can export to LangFlow
+ * and publish flow artifacts for import into LangFlow UI or API.
+ *
+ * SOLID: Single Responsibility - LangFlow export only
+ * DRY: Reuses LangflowAdapter for conversion
+ */
+import { BaseAdapter } from '../base/adapter.interface.js';
+import { LangflowAdapter } from '../langflow-adapter.js';
+export class LangflowPlatformAdapter extends BaseAdapter {
+    platform = 'langflow';
+    displayName = 'LangFlow';
+    description = 'LangFlow visual flow builder (flow JSON for import at localhost:7860 or your LangFlow instance)';
+    status = 'beta';
+    supportedVersions = ['v0.3.6', 'v0.4', 'v{{VERSION}}'];
+    async export(manifest, options) {
+        const startTime = Date.now();
+        try {
+            if (options?.validate !== false) {
+                const validation = await this.validate(manifest);
+                if (!validation.valid) {
+                    return this.createResult(false, [], `Validation failed: ${validation.errors?.map((e) => e.message).join(', ')}`, {
+                        duration: Date.now() - startTime,
+                        warnings: validation.warnings?.map((w) => w.message),
+                    });
+                }
+            }
+            const flowJson = LangflowAdapter.toJSON(manifest);
+            const baseName = (manifest.metadata?.name || 'agent').replace(/[^a-z0-9-_]/gi, '-');
+            const fileName = `${baseName}-langflow.json`;
+            const files = [
+                this.createFile(fileName, flowJson, 'config', 'json'),
+            ];
+            if (options?.outputDir) {
+                // Single file; path is relative to outputDir in orchestrator
+            }
+            return this.createResult(true, files, undefined, {
+                duration: Date.now() - startTime,
+                version: '1.0',
+            });
+        }
+        catch (err) {
+            return this.createResult(false, [], err instanceof Error ? err.message : String(err), { duration: Date.now() - startTime });
+        }
+    }
+    async validate(manifest) {
+        const base = await super.validate(manifest);
+        if (!base.valid)
+            return base;
+        const errors = [...(base.errors ?? [])];
+        const warnings = [...(base.warnings ?? [])];
+        const specAny = manifest.spec;
+        const hasPrompt = manifest.spec?.role ||
+            (specAny?.prompts &&
+                typeof specAny.prompts === 'object' &&
+                specAny.prompts?.system);
+        if (!hasPrompt) {
+            warnings.push({
+                message: 'spec.role or spec.prompts.system.template recommended for LangFlow prompt node',
+                path: 'spec.role',
+                suggestion: 'Add a system prompt for the agent',
+                code: 'LANGFLOW_PROMPT_RECOMMENDED',
+            });
+        }
+        return {
+            valid: errors.length === 0,
+            errors: errors.length > 0 ? errors : undefined,
+            warnings: warnings.length > 0 ? warnings : undefined,
+        };
+    }
+    getExample() {
+        return {
+            apiVersion: 'ossa/v0.4',
+            kind: 'Agent',
+            metadata: {
+                name: 'langflow-example-agent',
+                version: '1.0.0',
+                description: 'Example agent for LangFlow visual flow export',
+            },
+            spec: {
+                role: 'You are a helpful AI assistant. Answer concisely.',
+                llm: {
+                    provider: 'openai',
+                    model: 'gpt-4o-mini',
+                    temperature: 0.7,
+                    maxTokens: 2000,
+                },
+                tools: [
+                    {
+                        type: 'mcp',
+                        name: 'search',
+                        description: 'Search the web',
+                        server: 'mcp-default',
+                    },
+                ],
+            },
+        };
+    }
+}
+//# sourceMappingURL=platform-adapter.js.map

package/dist/adapters/langflow-adapter.d.ts

@@ -7,6 +7,8 @@ export interface LangflowNode {
     id: string;
     data: {
         type: string;
+        display_name?: string;
+        description?: string;
         node: Record<string, unknown>;
     };
     position: {

package/dist/adapters/langflow-adapter.js

@@ -15,11 +15,13 @@ export class LangflowAdapter {
         const tools = spec.tools || [];
         const nodes = [];
         const edges = [];
-        // Create LLM node
+        // Create LLM node (Langflow: Language Model component)
         const llmNode = {
             id: 'llm-1',
             data: {
                 type: 'ChatOpenAI',
+                display_name: 'OpenAI Model',
+                description: 'LLM from OSSA spec.llm',
                 node: {
                     template: {
                         model_name: {
@@ -38,11 +40,13 @@ export class LangflowAdapter {
             type: 'ChatOpenAI',
         };
         nodes.push(llmNode);
-        // Create Prompt node
+        // Create Prompt node (system prompt / role)
         const promptNode = {
             id: 'prompt-1',
             data: {
                 type: 'PromptTemplate',
+                display_name: 'Prompt Template',
+                description: 'Agent role from OSSA spec.role',
                 node: {
                     template: {
                         template: {
@@ -55,11 +59,13 @@ export class LangflowAdapter {
             type: 'PromptTemplate',
         };
         nodes.push(promptNode);
-        // Create Agent node
+        // Create Agent node (Langflow Agent component)
         const agentNode = {
             id: 'agent-1',
             data: {
                 type: 'AgentInitializer',
+                display_name: 'Agent',
+                description: `Agent: ${metadata.name}`,
                 node: {
                     template: {
                         agent_type: {
@@ -78,12 +84,14 @@ export class LangflowAdapter {
             type: 'AgentInitializer',
         };
         nodes.push(agentNode);
-        // Create tool nodes
+        // Create tool nodes (Langflow Tool components)
         tools.forEach((tool, index) => {
             const toolNode = {
                 id: `tool-${index + 1}`,
                 data: {
                     type: 'Tool',
+                    display_name: tool.name || `Tool ${index + 1}`,
+                    description: tool.description || 'OSSA tool',
                     node: {
                         template: {
                             name: {
@@ -141,15 +149,16 @@ export class LangflowAdapter {
      */
     static toJSON(manifest) {
         const flow = this.toLangflow(manifest);
-        // Langflow expects a specific JSON structure
+        // Langflow import format: data.nodes, data.edges, name, description, id (optional)
         const langflowExport = {
             data: {
                 nodes: flow.nodes,
                 edges: flow.edges,
             },
-            description: flow.description,
+            description: flow.description || `OSSA agent: ${flow.name}`,
             name: flow.name,
             is_component: false,
+            last_tested_version: '1.0',
         };
         return JSON.stringify(langflowExport, null, 2);
     }

package/dist/adapters/mcp/adapter.js

@@ -235,7 +235,8 @@ main().catch((error) => {
         const toolDefinitions = tools.map((tool) => {
             const name = tool.name || 'unknown';
             const description = tool.description || `Tool: ${name}`;
-            const schema = (tool.inputSchema || tool.schema || {
+            const schema = (tool.inputSchema ||
+                tool.schema || {
                 type: 'object',
                 properties: {},
             });
@@ -250,8 +251,7 @@ main().catch((error) => {
             .join(',\n');
         const toolCases = toolDefinitions
             .map((t) => `    case '${t.name}':
-      // TODO: Implement ${t.name} logic here
-      throw new Error('Tool ${t.name} requires implementation');`)
+      return runTool('${t.name}', input);`)
             .join('\n\n');
         return `/**
  * Tool Definitions and Implementations
@@ -267,6 +267,13 @@ export const tools = [
 ${toolsList}
 ];
 
+/**
+ * Default tool runner. Customize to call your MCP server or API.
+ */
+async function runTool(name: ToolName, input: ToolInput): Promise<ToolOutput> {
+  return { result: input };
+}
+
 /**
  * Execute a tool by name
  */