@orchagent/cli 0.3.41 → 0.3.43

package/dist/adapters/agents-md.js

@@ -17,8 +17,8 @@ exports.agentsMdAdapter = {
     canConvert(agent) {
         const warnings = [];
         const errors = [];
-        if (agent.type === 'code') {
-            errors.push('Code agents cannot be converted to AGENTS.md');
+        if (agent.type === 'tool') {
+            errors.push('Tool agents cannot be converted to AGENTS.md');
             return { canConvert: false, warnings, errors };
         }
         if (!agent.prompt) {

package/dist/adapters/claude-code.js

@@ -27,9 +27,9 @@ exports.claudeCodeAdapter = {
     canConvert(agent) {
         const warnings = [];
         const errors = [];
-        // Code agents cannot be converted
-        if (agent.type === 'code') {
-            errors.push('Code agents cannot be converted to Claude Code sub-agents (they require execution)');
+        // Tool agents cannot be converted
+        if (agent.type === 'tool') {
+            errors.push('Tool agents cannot be converted to Claude Code sub-agents (they require execution)');
             return { canConvert: false, warnings, errors };
         }
         // Check for prompt

package/dist/adapters/cursor.js

@@ -18,8 +18,8 @@ exports.cursorAdapter = {
     canConvert(agent) {
         const warnings = [];
         const errors = [];
-        if (agent.type === 'code') {
-            errors.push('Code agents cannot be converted to Cursor rules');
+        if (agent.type === 'tool') {
+            errors.push('Tool agents cannot be converted to Cursor rules');
             return { canConvert: false, warnings, errors };
         }
         if (!agent.prompt) {

package/dist/commands/agents.js

@@ -80,7 +80,7 @@ function registerAgentsCommand(program) {
         filteredAgents.forEach((agent) => {
             const name = agent.name;
             const version = agent.version;
-            const type = agent.type || 'code';
+            const type = agent.type || 'tool';
             const stars = agent.stars_count ?? 0;
             const price = (0, pricing_1.formatPrice)(agent);
             const coloredPrice = (0, pricing_1.isPaidAgent)(agent) ? chalk_1.default.yellow(price) : chalk_1.default.green(price);

package/dist/commands/call.js

@@ -194,7 +194,7 @@ Note: Use 'call' for server-side execution (requires login), 'run' for local exe
 File handling:
   For prompt agents, file content is read and sent as JSON mapped to the agent's
   input schema. Use --file-field to specify the field name (auto-detected by default).
-  For code agents, files are uploaded as multipart form data.
+  For tools, files are uploaded as multipart form data.
 
 Important: Remote agents cannot access your local filesystem. If your --data payload
 contains keys like 'path', 'directory', 'file', etc., those values will be interpreted
@@ -438,7 +438,7 @@ Paid Agents:
             headers['Content-Type'] = 'application/json';
         }
         else if (filePaths.length > 0 || options.metadata) {
-            // Code agent: handle multipart file uploads
+            // Tool: handle multipart file uploads
             // Inject llm_credentials into metadata if available
             let metadata = options.metadata;
             if (llmCredentials) {

package/dist/commands/env.js

@@ -201,7 +201,7 @@ async function clearDefault(config, options) {
 function registerEnvCommand(program) {
     const env = program
         .command('env')
-        .description('Manage custom Docker environments for code agents');
+        .description('Manage custom Docker environments for tools');
     env
         .command('list')
         .description('List environments in workspace')

package/dist/commands/info.js

@@ -176,7 +176,7 @@ function registerInfoCommand(program) {
             process.stdout.write(chalk_1.default.gray('Note: Paid agents run on server only (use orch call)\n'));
             process.stdout.write(chalk_1.default.gray('      Owners can still download for development/testing\n'));
         }
-        if (agentData.type === 'code') {
+        if (agentData.type === 'tool') {
             // Don't show internal routing URLs - they confuse users
             if (agentData.url && !agentData.url.includes('.internal')) {
                 process.stdout.write(`Server: ${agentData.url}\n`);

package/dist/commands/init.js

@@ -46,10 +46,10 @@ const SCHEMA_TEMPLATE = `{
 }
 `;
 const CODE_TEMPLATE_PY = `"""
-orchagent code agent entrypoint.
+orchagent tool entrypoint.
 
 Reads JSON input from stdin, processes it, and writes JSON output to stdout.
-This is the standard orchagent code agent protocol.
+This is the standard orchagent tool protocol.
 
 Usage:
   echo '{"input": "hello"}' | python main.py
@@ -82,12 +82,12 @@ if __name__ == "__main__":
     main()
 `;
 function readmeTemplate(agentName, type) {
-    const callExample = type === 'code'
+    const callExample = type === 'tool'
         ? `orchagent call ${agentName} input-file.txt`
-        : `orchagent call ${agentName} --data '{"${type === 'agentic' ? 'task' : 'input'}": "Hello world"}'`;
-    const runExample = type === 'code'
+        : `orchagent call ${agentName} --data '{"${type === 'agent' ? 'task' : 'input'}": "Hello world"}'`;
+    const runExample = type === 'tool'
         ? `orchagent run ${agentName} --input '{"file_path": "src/app.py"}'`
-        : `orchagent run ${agentName} --input '{"${type === 'agentic' ? 'task' : 'input'}": "Hello world"}'`;
+        : `orchagent run ${agentName} --input '{"${type === 'agent' ? 'task' : 'input'}": "Hello world"}'`;
     return `# ${agentName}
 
 A brief description of what this agent does.
@@ -110,7 +110,7 @@ ${runExample}
 
 | Field | Type | Description |
 |-------|------|-------------|
-| \`input\` | string | The input to process |
+| \`${type === 'agent' ? 'task' : 'input'}\` | string | ${type === 'agent' ? 'The task to perform' : 'The input to process'} |
 
 ## Output
 
@@ -119,13 +119,12 @@ ${runExample}
 | \`result\` | string | The agent's response |
 `;
 }
-const AGENTIC_MANIFEST_TEMPLATE = `{
+const AGENT_MANIFEST_TEMPLATE = `{
   "name": "my-agent",
-  "description": "An agentic AI agent with tool use",
-  "type": "agentic",
+  "description": "An AI agent with tool use",
+  "type": "agent",
   "supported_providers": ["anthropic"],
   "max_turns": 25,
-  "timeout_seconds": 300,
   "custom_tools": [
     {
       "name": "run_tests",
@@ -135,7 +134,7 @@ const AGENTIC_MANIFEST_TEMPLATE = `{
   ]
 }
 `;
-const AGENTIC_PROMPT_TEMPLATE = `You are a helpful AI agent with access to a sandboxed environment.
+const AGENT_PROMPT_TEMPLATE = `You are a helpful AI agent with access to a sandboxed environment.
 
 Given the input, complete the task using the available tools:
 - Use bash to run commands
@@ -147,7 +146,7 @@ Input: The caller's input will be provided as JSON.
 
 Work step by step, verify your results, and submit the final output.
 `;
-const AGENTIC_SCHEMA_TEMPLATE = `{
+const AGENT_SCHEMA_TEMPLATE = `{
   "input": {
     "type": "object",
     "properties": {
@@ -189,7 +188,7 @@ function registerInitCommand(program) {
         .command('init')
         .description('Initialize a new agent project')
         .argument('[name]', 'Agent name (default: current directory name)')
-        .option('--type <type>', 'Type: prompt, code, agentic, or skill (default: prompt)', 'prompt')
+        .option('--type <type>', 'Type: prompt, tool, agent, or skill (default: prompt)', 'prompt')
         .action(async (name, options) => {
         const cwd = process.cwd();
         // When a name is provided, create a subdirectory for the project
@@ -243,20 +242,20 @@ function registerInitCommand(program) {
             }
         }
         // Create manifest and type-specific files
-        if (options.type === 'agentic') {
-            const manifest = JSON.parse(AGENTIC_MANIFEST_TEMPLATE);
+        if (options.type === 'agent') {
+            const manifest = JSON.parse(AGENT_MANIFEST_TEMPLATE);
             manifest.name = agentName;
             await promises_1.default.writeFile(manifestPath, JSON.stringify(manifest, null, 2) + '\n');
-            await promises_1.default.writeFile(promptPath, AGENTIC_PROMPT_TEMPLATE);
-            await promises_1.default.writeFile(schemaPath, AGENTIC_SCHEMA_TEMPLATE);
+            await promises_1.default.writeFile(promptPath, AGENT_PROMPT_TEMPLATE);
+            await promises_1.default.writeFile(schemaPath, AGENT_SCHEMA_TEMPLATE);
         }
         else {
             const manifest = JSON.parse(MANIFEST_TEMPLATE);
             manifest.name = agentName;
-            manifest.type = ['code', 'skill'].includes(options.type) ? options.type : 'prompt';
+            manifest.type = ['tool', 'skill'].includes(options.type) ? options.type : 'prompt';
             await promises_1.default.writeFile(manifestPath, JSON.stringify(manifest, null, 2) + '\n');
-            // Create prompt template (for prompt-based agents) or entrypoint (for code agents)
-            if (options.type === 'code') {
+            // Create prompt template (for prompt-based agents) or entrypoint (for tool agents)
+            if (options.type === 'tool') {
                 const entrypointPath = path_1.default.join(targetDir, 'main.py');
                 await promises_1.default.writeFile(entrypointPath, CODE_TEMPLATE_PY);
             }
@@ -273,7 +272,7 @@ function registerInitCommand(program) {
         process.stdout.write(`\nFiles created:\n`);
         const prefix = name ? name + '/' : '';
         process.stdout.write(`  ${prefix}orchagent.json - Agent configuration\n`);
-        if (options.type === 'code') {
+        if (options.type === 'tool') {
             process.stdout.write(`  ${prefix}main.py        - Agent entrypoint (stdin/stdout JSON)\n`);
         }
         else {
@@ -282,7 +281,7 @@ function registerInitCommand(program) {
         process.stdout.write(`  ${prefix}schema.json    - Input/output schemas\n`);
         process.stdout.write(`  ${prefix}README.md      - Agent documentation\n`);
         process.stdout.write(`\nNext steps:\n`);
-        if (options.type === 'agentic') {
+        if (options.type === 'agent') {
             const stepNum = name ? 2 : 1;
             if (name) {
                 process.stdout.write(`  1. cd ${name}\n`);
@@ -292,7 +291,7 @@ function registerInitCommand(program) {
             process.stdout.write(`  ${stepNum + 2}. Edit schema.json with your input/output schemas\n`);
             process.stdout.write(`  ${stepNum + 3}. Run: orchagent publish\n`);
         }
-        else if (options.type !== 'code') {
+        else if (options.type !== 'tool') {
             const stepNum = name ? 2 : 1;
             if (name) {
                 process.stdout.write(`  1. cd ${name}\n`);

package/dist/commands/publish.js

@@ -317,7 +317,7 @@ function registerPublishCommand(program) {
                 `These must be nested under a "manifest" key. Example:\n\n` +
                 `  {\n` +
                 `    "name": "${manifest.name}",\n` +
-                `    "type": "${manifest.type || 'code'}",\n` +
+                `    "type": "${manifest.type || 'tool'}",\n` +
                 `    "manifest": {\n` +
                 `      "manifest_version": 1,\n` +
                 `      "dependencies": [...],\n` +
@@ -328,16 +328,16 @@ function registerPublishCommand(program) {
                 `  }\n\n` +
                 `See docs/manifest.md for details.`);
         }
-        // Read prompt (for prompt-based, agentic, and skill agents)
+        // Read prompt (for prompt-based, agent, and skill agents)
         let prompt;
-        if (manifest.type === 'prompt' || manifest.type === 'skill' || manifest.type === 'agentic') {
+        if (manifest.type === 'prompt' || manifest.type === 'skill' || manifest.type === 'agent') {
             const promptPath = path_1.default.join(cwd, 'prompt.md');
             try {
                 prompt = await promises_1.default.readFile(promptPath, 'utf-8');
             }
             catch (err) {
                 if (err.code === 'ENOENT') {
-                    const agentTypeName = manifest.type === 'skill' ? 'skill' : manifest.type === 'agentic' ? 'agentic agent' : 'prompt-based agent';
+                    const agentTypeName = manifest.type === 'skill' ? 'skill' : manifest.type === 'agent' ? 'agent' : 'prompt-based agent';
                     throw new errors_1.CliError(`No prompt.md found for ${agentTypeName}.\n\n` +
                         'Create a prompt.md file in the current directory with your prompt template.\n' +
                         'See: https://orchagent.io/docs/publishing');
@@ -345,15 +345,25 @@ function registerPublishCommand(program) {
                 throw err;
             }
         }
-        // For agentic agents, validate custom_tools and build manifest
-        if (manifest.type === 'agentic') {
+        // For agent type, validate custom_tools and build manifest
+        if (manifest.type === 'agent') {
             // Validate custom_tools format
             if (manifest.custom_tools) {
+                const reservedNames = new Set(['bash', 'read_file', 'write_file', 'list_files', 'submit_result']);
+                const seenNames = new Set();
                 for (const tool of manifest.custom_tools) {
                     if (!tool.name || !tool.command) {
                         throw new errors_1.CliError(`Invalid custom_tool: each tool must have 'name' and 'command' fields.\n` +
                             `Found: ${JSON.stringify(tool)}`);
                     }
+                    if (reservedNames.has(tool.name)) {
+                        throw new errors_1.CliError(`Custom tool '${tool.name}' conflicts with a built-in tool name.\n` +
+                            `Reserved names: ${[...reservedNames].join(', ')}`);
+                    }
+                    if (seenNames.has(tool.name)) {
+                        throw new errors_1.CliError(`Duplicate custom tool name: '${tool.name}'`);
+                    }
+                    seenNames.add(tool.name);
                 }
             }
             // Validate max_turns
@@ -362,18 +372,18 @@ function registerPublishCommand(program) {
                     throw new errors_1.CliError('max_turns must be a number between 1 and 50');
                 }
             }
-            // Store agentic config in manifest field
-            const agenticManifest = {
+            // Store agent config in manifest field
+            const agentManifest = {
                 ...(manifest.manifest || {}),
             };
             if (manifest.custom_tools) {
-                agenticManifest.custom_tools = manifest.custom_tools;
+                agentManifest.custom_tools = manifest.custom_tools;
             }
             if (manifest.max_turns) {
-                agenticManifest.max_turns = manifest.max_turns;
+                agentManifest.max_turns = manifest.max_turns;
             }
-            manifest.manifest = agenticManifest;
-            // Agentic agents default to anthropic provider
+            manifest.manifest = agentManifest;
+            // Agent type defaults to anthropic provider
             if (!manifest.supported_providers) {
                 manifest.supported_providers = ['anthropic'];
             }
@@ -397,7 +407,7 @@ function registerPublishCommand(program) {
             }
         }
         // For prompt/skill agents, derive input schema from template variables if needed
-        // (Agentic agents use schema.json directly — no template variable derivation)
+        // (Agent type uses schema.json directly — no template variable derivation)
         if (prompt && (manifest.type === 'prompt' || manifest.type === 'skill')) {
             const templateVars = extractTemplateVariables(prompt);
             if (templateVars.length > 0) {
@@ -424,13 +434,13 @@ function registerPublishCommand(program) {
                 }
             }
         }
-        // For code-based agents, either --url is required OR we bundle the code
-        // For agentic agents, use internal placeholder (no user code, platform handles execution)
+        // For tool-based agents, either --url is required OR we bundle the code
+        // For agent type, use internal placeholder (no user code, platform handles execution)
         let agentUrl = options.url;
         let shouldUploadBundle = false;
-        if (manifest.type === 'agentic') {
-            // Agentic agents don't need a URL or code bundle
-            agentUrl = agentUrl || 'https://agentic-agent.internal';
+        if (manifest.type === 'agent') {
+            // Agent type doesn't need a URL or code bundle
+            agentUrl = agentUrl || 'https://agent.internal';
             // But they can include a Dockerfile for custom environments
             if (options.docker) {
                 const dockerfilePath = path_1.default.join(cwd, 'Dockerfile');
@@ -444,27 +454,27 @@ function registerPublishCommand(program) {
                 }
             }
         }
-        else if (manifest.type === 'code' && !options.url) {
+        else if (manifest.type === 'tool' && !options.url) {
             // Check if this looks like a Python or JS project that can be bundled
             const entrypoint = manifest.entrypoint || await (0, bundle_1.detectEntrypoint)(cwd);
             if (entrypoint) {
-                // This is a hosted code agent - we'll bundle and upload
+                // This is a hosted tool - we'll bundle and upload
                 shouldUploadBundle = true;
                 // Set a placeholder URL that tells the gateway to use sandbox execution
-                agentUrl = 'https://code-agent.internal';
-                process.stdout.write(`Detected code project with entrypoint: ${entrypoint}\n`);
+                agentUrl = 'https://tool.internal';
+                process.stdout.write(`Detected tool project with entrypoint: ${entrypoint}\n`);
             }
             else {
-                throw new errors_1.CliError('Code agent requires either --url <url> or an entry point file (main.py, app.py, index.js, etc.)');
+                throw new errors_1.CliError('Tool requires either --url <url> or an entry point file (main.py, app.py, index.js, etc.)');
             }
         }
         // Get org info
         const org = await (0, api_1.getOrg)(config);
         // Default to 'any' provider if not specified
         const supportedProviders = manifest.supported_providers || ['any'];
-        // Detect SDK compatibility for code agents
+        // Detect SDK compatibility for tool agents
         let sdkCompatible = false;
-        if (manifest.type === 'code') {
+        if (manifest.type === 'tool') {
             sdkCompatible = await detectSdkCompatible(cwd);
             if (sdkCompatible && !options.dryRun) {
                 process.stdout.write(`SDK detected - agent will be marked as Local Ready\n`);
@@ -492,8 +502,8 @@ function registerPublishCommand(program) {
                     process.stderr.write(`  ✓ Input schema derived from template variables: ${vars.join(', ')}\n`);
                 }
             }
-            else if (manifest.type === 'agentic') {
-                // Agentic agent validations
+            else if (manifest.type === 'agent') {
+                // Agent type validations
                 const promptBytes = prompt ? Buffer.byteLength(prompt, 'utf-8') : 0;
                 process.stderr.write(`  ✓ prompt.md found (${promptBytes.toLocaleString()} bytes)\n`);
                 if (schemaFromFile) {
@@ -504,8 +514,8 @@ function registerPublishCommand(program) {
                 process.stderr.write(`  ✓ Custom tools: ${customToolCount}\n`);
                 process.stderr.write(`  ✓ Max turns: ${manifest.max_turns || 25}\n`);
             }
-            else if (manifest.type === 'code') {
-                // Code agent validations
+            else if (manifest.type === 'tool') {
+                // Tool agent validations
                 const entrypoint = manifest.entrypoint || await (0, bundle_1.detectEntrypoint)(cwd);
                 process.stderr.write(`  ✓ Entrypoint: ${entrypoint}\n`);
                 if (sdkCompatible) {
@@ -513,7 +523,7 @@ function registerPublishCommand(program) {
                 }
             }
             process.stderr.write(`  ✓ Authentication valid (org: ${org.slug})\n`);
-            // For code agents with bundles, show bundle preview
+            // For tools with bundles, show bundle preview
             if (shouldUploadBundle) {
                 const bundlePreview = await (0, bundle_1.previewBundle)(cwd, {
                     entrypoint: manifest.entrypoint,
@@ -567,7 +577,7 @@ function registerPublishCommand(program) {
                 is_public: options.public ? true : false,
                 supported_providers: supportedProviders,
                 default_models: manifest.default_models,
-                // Local run fields for code agents
+                // Local run fields for tool agents
                 source_url: manifest.source_url,
                 pip_package: manifest.pip_package,
                 run_command: manifest.run_command,
@@ -585,7 +595,7 @@ function registerPublishCommand(program) {
         }
         const assignedVersion = result.agent?.version || 'v1';
         const agentId = result.agent?.id;
-        // Upload code bundle if this is a hosted code agent or agentic agent with --docker
+        // Upload code bundle if this is a hosted tool agent or agent type with --docker
         if (shouldUploadBundle && agentId) {
             process.stdout.write(`\nBundling code...\n`);
             const tempDir = await promises_1.default.mkdtemp(path_1.default.join(os_1.default.tmpdir(), 'orchagent-bundle-'));
@@ -604,8 +614,8 @@ function registerPublishCommand(program) {
                         throw new errors_1.CliError('--docker flag specified but no Dockerfile found in project directory');
                     }
                 }
-                // For agentic agents, also include requirements.txt if present
-                if (manifest.type === 'agentic') {
+                // For agent type, also include requirements.txt if present
+                if (manifest.type === 'agent') {
                     const reqPath = path_1.default.join(cwd, 'requirements.txt');
                     try {
                         await promises_1.default.access(reqPath);
@@ -617,9 +627,10 @@ function registerPublishCommand(program) {
                     }
                 }
                 const bundleResult = await (0, bundle_1.createCodeBundle)(cwd, bundlePath, {
-                    entrypoint: manifest.type === 'agentic' ? undefined : manifest.entrypoint,
+                    entrypoint: manifest.type === 'agent' ? undefined : manifest.entrypoint,
                     exclude: manifest.bundle?.exclude,
                     include: includePatterns.length > 0 ? includePatterns : undefined,
+                    skipEntrypointCheck: manifest.type === 'agent',
                 });
                 process.stdout.write(`  Created bundle: ${bundleResult.fileCount} files, ${(bundleResult.sizeBytes / 1024).toFixed(1)}KB\n`);
                 // Validate bundle size

package/dist/commands/run.js

@@ -269,9 +269,9 @@ async function downloadDependenciesRecursively(config, depStatuses, visited = ne
             if (status.agentData.has_bundle) {
                 await saveBundleLocally(config, org, agent, status.dep.version, status.agentData.id);
             }
-            // Install if it's a pip/source code agent
-            if (status.agentData.type === 'code' && (status.agentData.source_url || status.agentData.pip_package)) {
-                await installCodeAgent(status.agentData);
+            // Install if it's a pip/source tool agent
+            if (status.agentData.type === 'tool' && (status.agentData.source_url || status.agentData.pip_package)) {
+                await installTool(status.agentData);
             }
         }, { successText: `Downloaded ${depRef}` });
         // Download default skills
@@ -476,10 +476,10 @@ async function checkPackageInstalled(packageName) {
         return false;
     }
 }
-async function installCodeAgent(agentData) {
+async function installTool(agentData) {
     const installSource = agentData.pip_package || agentData.source_url;
     if (!installSource) {
-        throw new errors_1.CliError('This code agent does not support local execution.\n' +
+        throw new errors_1.CliError('This tool does not support local execution.\n' +
             'Use `orch call` to run it on the server instead.');
     }
     // Check if already installed (for pip packages)
@@ -503,13 +503,13 @@ async function installCodeAgent(agentData) {
         }
     }, { successText: 'Installation complete' });
 }
-async function executeCodeAgent(agentData, args) {
+async function executeTool(agentData, args) {
     if (!agentData.run_command) {
-        throw new errors_1.CliError('This code agent does not have a run command defined.\n' +
+        throw new errors_1.CliError('This tool does not have a run command defined.\n' +
             'Use `orch call` to run it on the server instead.');
     }
     // Install the agent if needed
-    await installCodeAgent(agentData);
+    await installTool(agentData);
     // Parse the run command and append user args
     const [cmd, ...cmdArgs] = agentData.run_command.split(' ');
     const fullArgs = [...cmdArgs, ...args];
@@ -760,7 +760,7 @@ async function saveAgentLocally(org, agent, agentData) {
     if (agentData.type === 'prompt' && agentData.prompt) {
         await promises_1.default.writeFile(path_1.default.join(agentDir, 'prompt.md'), agentData.prompt);
     }
-    // For code agents, save files if provided
+    // For tools, save files if provided
     if (agentData.files) {
         for (const file of agentData.files) {
             const filePath = path_1.default.join(agentDir, file.path);
@@ -887,7 +887,7 @@ Paid Agents:
                 // Fall back to getting public agent info if download endpoint not available
                 const agentMeta = await (0, api_1.getPublicAgent)(resolved, org, parsed.agent, parsed.version);
                 return {
-                    type: agentMeta.type || 'code',
+                    type: agentMeta.type || 'tool',
                     name: agentMeta.name,
                     version: agentMeta.version,
                     description: agentMeta.description || undefined,
@@ -903,6 +903,13 @@ Paid Agents:
                 `  Install for AI tools:  orchagent skill install ${org}/${parsed.agent}\n` +
                 `  Use with an agent:     orchagent run <agent> --skills ${org}/${parsed.agent}`);
         }
+        // Agent type requires a sandbox with tool use — cannot run locally
+        if (agentData.type === 'agent') {
+            throw new errors_1.CliError('Agent type cannot be run locally.\n\n' +
+                'Agent type requires a sandbox environment with tool use capabilities.\n\n' +
+                'Use server execution instead:\n' +
+                `  orchagent call ${org}/${parsed.agent}@${parsed.version} --data '{"task": "..."}'`);
+        }
         // Check for dependencies (orchestrator agents)
         if (agentData.dependencies && agentData.dependencies.length > 0) {
             const depStatuses = await (0, spinner_1.withSpinner)('Checking dependencies...', async () => checkDependencies(resolved, agentData.dependencies), { successText: `Found ${agentData.dependencies.length} dependencies` });
@@ -946,31 +953,31 @@ Paid Agents:
         // Save locally
         const agentDir = await saveAgentLocally(org, parsed.agent, agentData);
         process.stderr.write(`\nAgent saved to: ${agentDir}\n`);
-        if (agentData.type === 'code') {
+        if (agentData.type === 'tool') {
             // Check if this agent has a bundle available for local execution
             if (agentData.has_bundle) {
                 if (options.downloadOnly) {
-                    process.stdout.write(`\nCode agent has bundle available for local execution.\n`);
+                    process.stdout.write(`\nTool has bundle available for local execution.\n`);
                     process.stdout.write(`Run with: orch run ${org}/${parsed.agent} [args...]\n`);
                     return;
                 }
-                // Execute the bundle-based code agent locally
+                // Execute the bundle-based tool locally
                 await executeBundleAgent(resolved, org, parsed.agent, parsed.version, agentData, args, options.input);
                 return;
             }
             // Check for pip/source-based local execution (legacy)
             if (agentData.run_command && (agentData.source_url || agentData.pip_package)) {
                 if (options.downloadOnly) {
-                    process.stdout.write(`\nCode agent ready for local execution.\n`);
+                    process.stdout.write(`\nTool ready for local execution.\n`);
                     process.stdout.write(`Run with: orch run ${org}/${parsed.agent} [args...]\n`);
                     return;
                 }
-                // Execute the code agent locally
-                await executeCodeAgent(agentData, args);
+                // Execute the tool locally
+                await executeTool(agentData, args);
                 return;
             }
             // Fallback: agent doesn't support local execution
-            process.stdout.write(`\nThis is a code-based agent that runs on the server.\n`);
+            process.stdout.write(`\nThis is a tool-based agent that runs on the server.\n`);
             process.stdout.write(`\nUse: orch call ${org}/${parsed.agent}@${parsed.version} --input '{...}'\n`);
             return;
         }

package/dist/commands/test.js

@@ -138,7 +138,7 @@ async function detectAgentType(agentDir) {
                 return 'prompt';
             if (manifest.type === 'skill')
                 return 'skill';
-            if (manifest.type === 'code') {
+            if (manifest.type === 'tool') {
                 // Detect language
                 if (await fileExists(path_1.default.join(agentDir, 'requirements.txt')))
                     return 'code-python';
@@ -146,7 +146,7 @@ async function detectAgentType(agentDir) {
                     return 'code-python';
                 if (await fileExists(path_1.default.join(agentDir, 'package.json')))
                     return 'code-js';
-                // Default to Python for code agents
+                // Default to Python for tool agents
                 return 'code-python';
             }
         }

package/dist/lib/api.js

@@ -299,12 +299,12 @@ async function searchMyAgents(config, query, options) {
     if (options?.type) {
         const typeFilter = options.type;
         if (typeFilter === 'agents') {
-            agents = agents.filter(a => a.type === 'prompt' || a.type === 'code');
+            agents = agents.filter(a => a.type === 'prompt' || a.type === 'tool');
         }
         else if (typeFilter === 'skills' || typeFilter === 'skill') {
             agents = agents.filter(a => a.type === 'skill');
         }
-        else if (typeFilter === 'code' || typeFilter === 'prompt') {
+        else if (typeFilter === 'tool' || typeFilter === 'prompt') {
             agents = agents.filter(a => a.type === typeFilter);
         }
     }
@@ -342,7 +342,7 @@ async function fetchLlmKeys(config) {
     return result.keys;
 }
 /**
- * Download a code bundle for local execution.
+ * Download a tool bundle for local execution.
  */
 async function downloadCodeBundle(config, org, agent, version) {
     const response = await safeFetch(`${config.apiUrl.replace(/\/$/, '')}/public/agents/${org}/${agent}/${version}/bundle`);
@@ -353,7 +353,7 @@ async function downloadCodeBundle(config, org, agent, version) {
     return Buffer.from(arrayBuffer);
 }
 /**
- * Upload a code bundle for a hosted code agent.
+ * Upload a code bundle for a hosted tool agent.
  */
 async function uploadCodeBundle(config, agentId, bundlePath, entrypoint) {
     if (!config.apiKey) {
@@ -421,7 +421,7 @@ async function getAgentWithFallback(config, org, agentName, version) {
     return myAgent;
 }
 /**
- * Download a code bundle for a private agent using authenticated endpoint.
+ * Download a tool bundle for a private agent using authenticated endpoint.
  */
 async function downloadCodeBundleAuthenticated(config, agentId) {
     if (!config.apiKey) {

package/dist/lib/bundle.js

@@ -1,6 +1,6 @@
 "use strict";
 /**
- * Code bundling utilities for hosted code agents.
+ * Code bundling utilities for hosted tools.
  *
  * Creates zip bundles from project directories for upload to orchagent.
  */
@@ -119,14 +119,16 @@ async function createCodeBundle(sourceDir, outputPath, options = {}) {
     if (!stat.isDirectory()) {
         throw new Error(`Source path is not a directory: ${sourceDir}`);
     }
-    // Verify entrypoint exists if specified
-    const entrypoint = options.entrypoint || 'main.py';
-    const entrypointPath = path_1.default.join(sourceDir, entrypoint);
-    try {
-        await promises_1.default.access(entrypointPath);
-    }
-    catch {
-        throw new Error(`Entrypoint file not found: ${entrypoint}`);
+    // Verify entrypoint exists if specified (skip for agent type that has no code)
+    if (!options.skipEntrypointCheck) {
+        const entrypoint = options.entrypoint || 'main.py';
+        const entrypointPath = path_1.default.join(sourceDir, entrypoint);
+        try {
+            await promises_1.default.access(entrypointPath);
+        }
+        catch {
+            throw new Error(`Entrypoint file not found: ${entrypoint}`);
+        }
     }
     // Create output directory if needed
     const outputDir = path_1.default.dirname(outputPath);

package/dist/lib/output.js

@@ -24,7 +24,7 @@ function printAgentsTable(agents, options) {
     const table = new cli_table3_1.default({ head });
     agents.forEach((agent) => {
         const fullName = `${agent.org_slug}/${agent.name}`;
-        const type = agent.type || 'code';
+        const type = agent.type || 'tool';
         const providers = formatProviders(agent.supported_providers);
         const stars = agent.stars_count ?? 0;
         const price = (0, pricing_1.formatPrice)(agent);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@orchagent/cli",
-  "version": "0.3.41",
+  "version": "0.3.43",
   "description": "Command-line interface for the orchagent AI agent marketplace",
   "license": "MIT",
   "author": "orchagent <hello@orchagent.io>",