@orchagent/cli 0.3.54 → 0.3.56

package/dist/commands/index.js

@@ -29,6 +29,8 @@ const security_1 = require("./security");
 const billing_1 = require("./billing");
 const agent_keys_1 = require("./agent-keys");
 const schedule_1 = require("./schedule");
+const service_1 = require("./service");
+const transfer_1 = require("./transfer");
 function registerCommands(program) {
     (0, login_1.registerLoginCommand)(program);
     (0, whoami_1.registerWhoamiCommand)(program);
@@ -58,4 +60,6 @@ function registerCommands(program) {
     (0, billing_1.registerBillingCommand)(program);
     (0, agent_keys_1.registerAgentKeysCommand)(program);
     (0, schedule_1.registerScheduleCommand)(program);
+    (0, service_1.registerServiceCommand)(program);
+    (0, transfer_1.registerTransferCommand)(program);
 }

package/dist/commands/init.js

@@ -10,7 +10,8 @@ const errors_1 = require("../lib/errors");
 const MANIFEST_TEMPLATE = `{
   "name": "my-agent",
   "description": "A simple AI agent",
-  "type": "prompt",
+  "type": "agent",
+  "run_mode": "on_demand",
   "tags": []
 }
 `;
@@ -81,13 +82,15 @@ def main():
 if __name__ == "__main__":
     main()
 `;
-function readmeTemplate(agentName, type) {
-    const cloudExample = type === 'tool'
-        ? `orchagent run ${agentName} input-file.txt`
-        : `orchagent run ${agentName} --data '{"${type === 'agent' ? 'task' : 'input'}": "Hello world"}'`;
-    const localExample = type === 'tool'
-        ? `orchagent run ${agentName} --local --data '{"file_path": "src/app.py"}'`
-        : `orchagent run ${agentName} --local --data '{"${type === 'agent' ? 'task' : 'input'}": "Hello world"}'`;
+function readmeTemplate(agentName, flavor) {
+    const inputField = flavor === 'managed_loop' ? 'task' : 'input';
+    const inputDescription = flavor === 'managed_loop' ? 'The task to perform' : 'The input to process';
+    const cloudExample = flavor === 'code_runtime'
+        ? `orchagent run ${agentName} --data '{"input": "Hello world"}'`
+        : `orchagent run ${agentName} --data '{"${inputField}": "Hello world"}'`;
+    const localExample = flavor === 'code_runtime'
+        ? `orchagent run ${agentName} --local --data '{"input": "Hello world"}'`
+        : `orchagent run ${agentName} --local --data '{"${inputField}": "Hello world"}'`;
     return `# ${agentName}
 
 A brief description of what this agent does.
@@ -110,7 +113,7 @@ ${localExample}
 
 | Field | Type | Description |
 |-------|------|-------------|
-| \`${type === 'agent' ? 'task' : 'input'}\` | string | ${type === 'agent' ? 'The task to perform' : 'The input to process'} |
+| \`${inputField}\` | string | ${inputDescription} |
 
 ## Output
 
@@ -119,14 +122,6 @@ ${localExample}
 | \`result\` | string | The agent's response |
 `;
 }
-const AGENT_MANIFEST_TEMPLATE = `{
-  "name": "my-agent",
-  "description": "An AI agent with tool use",
-  "type": "agent",
-  "supported_providers": ["anthropic"],
-  "max_turns": 25
-}
-`;
 const AGENT_PROMPT_TEMPLATE = `You are a helpful AI agent.
 
 Given the input, complete the task step by step.
@@ -169,14 +164,39 @@ license: MIT
 
 Instructions and guidance for AI agents...
 `;
+function resolveInitFlavor(typeOption) {
+    const normalized = (typeOption || 'agent').trim().toLowerCase();
+    if (normalized === 'skill') {
+        return { type: 'skill' };
+    }
+    if (normalized === 'agent') {
+        return { type: 'agent', flavor: 'direct_llm' };
+    }
+    if (normalized === 'prompt') {
+        return { type: 'agent', flavor: 'direct_llm' };
+    }
+    if (normalized === 'agentic') {
+        return { type: 'agent', flavor: 'managed_loop' };
+    }
+    if (normalized === 'tool' || normalized === 'code') {
+        return { type: 'agent', flavor: 'code_runtime' };
+    }
+    throw new errors_1.CliError(`Unknown --type '${typeOption}'. Use 'agent' or 'skill' (legacy: prompt, tool, agentic, code).`);
+}
 function registerInitCommand(program) {
     program
         .command('init')
         .description('Initialize a new agent project')
         .argument('[name]', 'Agent name (default: current directory name)')
-        .option('--type <type>', 'Type: prompt, tool, agent, or skill (default: prompt)', 'prompt')
+        .option('--type <type>', 'Type: agent or skill (legacy: prompt, tool, agentic, code)', 'agent')
+        .option('--run-mode <mode>', 'Run mode for agents: on_demand or always_on', 'on_demand')
         .action(async (name, options) => {
         const cwd = process.cwd();
+        const runMode = (options.runMode || 'on_demand').trim().toLowerCase();
+        if (!['on_demand', 'always_on'].includes(runMode)) {
+            throw new errors_1.CliError("Invalid --run-mode. Use 'on_demand' or 'always_on'.");
+        }
+        const initMode = resolveInitFlavor(options.type);
         // When a name is provided, create a subdirectory for the project
         const targetDir = name ? path_1.default.join(cwd, name) : cwd;
         const agentName = name || path_1.default.basename(cwd);
@@ -185,7 +205,7 @@ function registerInitCommand(program) {
             await promises_1.default.mkdir(targetDir, { recursive: true });
         }
         // Handle skill type separately
-        if (options.type === 'skill') {
+        if (initMode.type === 'skill') {
             const skillPath = path_1.default.join(targetDir, 'SKILL.md');
             // Check if already initialized
             try {
@@ -227,38 +247,45 @@ function registerInitCommand(program) {
                 throw err;
             }
         }
+        if (initMode.flavor === 'direct_llm' && runMode === 'always_on') {
+            throw new errors_1.CliError("run_mode=always_on requires a non-direct runtime. Use legacy '--type tool' or add runtime.command in orchagent.json.");
+        }
         // Create manifest and type-specific files
-        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');
+        const manifest = JSON.parse(MANIFEST_TEMPLATE);
+        manifest.name = agentName;
+        manifest.type = 'agent';
+        manifest.run_mode = runMode;
+        if (initMode.flavor === 'managed_loop') {
+            manifest.description = 'An AI agent with tool use';
+            manifest.supported_providers = ['anthropic'];
+            manifest.loop = { max_turns: 25 };
+        }
+        else if (initMode.flavor === 'code_runtime') {
+            manifest.description = 'A code-runtime agent';
+            manifest.runtime = { command: 'python main.py' };
+        }
+        await promises_1.default.writeFile(manifestPath, JSON.stringify(manifest, null, 2) + '\n');
+        if (initMode.flavor === 'code_runtime') {
+            const entrypointPath = path_1.default.join(targetDir, 'main.py');
+            await promises_1.default.writeFile(entrypointPath, CODE_TEMPLATE_PY);
+            await promises_1.default.writeFile(schemaPath, SCHEMA_TEMPLATE);
+        }
+        else if (initMode.flavor === 'managed_loop') {
             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 = ['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 tool agents)
-            if (options.type === 'tool') {
-                const entrypointPath = path_1.default.join(targetDir, 'main.py');
-                await promises_1.default.writeFile(entrypointPath, CODE_TEMPLATE_PY);
-            }
-            else {
-                await promises_1.default.writeFile(promptPath, PROMPT_TEMPLATE);
-            }
-            // Create schema template
+            await promises_1.default.writeFile(promptPath, PROMPT_TEMPLATE);
             await promises_1.default.writeFile(schemaPath, SCHEMA_TEMPLATE);
         }
         // Create README
         const readmePath = path_1.default.join(targetDir, 'README.md');
-        await promises_1.default.writeFile(readmePath, readmeTemplate(agentName, options.type));
+        await promises_1.default.writeFile(readmePath, readmeTemplate(agentName, initMode.flavor || 'direct_llm'));
         process.stdout.write(`Initialized agent "${agentName}" in ${targetDir}\n`);
         process.stdout.write(`\nFiles created:\n`);
         const prefix = name ? name + '/' : '';
         process.stdout.write(`  ${prefix}orchagent.json - Agent configuration\n`);
-        if (options.type === 'tool') {
+        if (initMode.flavor === 'code_runtime') {
             process.stdout.write(`  ${prefix}main.py        - Agent entrypoint (stdin/stdout JSON)\n`);
         }
         else {
@@ -266,32 +293,26 @@ 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(`  Run mode: ${runMode}\n`);
+        process.stdout.write(`  Execution: ${initMode.flavor}\n`);
         process.stdout.write(`\nNext steps:\n`);
-        if (options.type === 'agent') {
-            const stepNum = name ? 2 : 1;
-            if (name) {
-                process.stdout.write(`  1. cd ${name}\n`);
-            }
-            process.stdout.write(`  ${stepNum}. Edit prompt.md with your agent instructions\n`);
-            process.stdout.write(`  ${stepNum + 1}. Edit schema.json with your input/output schemas\n`);
-            process.stdout.write(`  ${stepNum + 2}. Run: orchagent publish\n`);
-        }
-        else if (options.type !== 'tool') {
+        if (initMode.flavor === 'code_runtime') {
             const stepNum = name ? 2 : 1;
             if (name) {
                 process.stdout.write(`  1. cd ${name}\n`);
             }
-            process.stdout.write(`  ${stepNum}. Edit prompt.md with your prompt template\n`);
+            process.stdout.write(`  ${stepNum}. Edit main.py with your agent logic\n`);
             process.stdout.write(`  ${stepNum + 1}. Edit schema.json with your input/output schemas\n`);
-            process.stdout.write(`  ${stepNum + 2}. Run: orchagent publish\n`);
+            process.stdout.write(`  ${stepNum + 2}. Test: echo '{"input": "test"}' | python main.py\n`);
+            process.stdout.write(`  ${stepNum + 3}. Run: orchagent publish\n`);
         }
         else {
             const stepNum = name ? 2 : 1;
             if (name) {
                 process.stdout.write(`  1. cd ${name}\n`);
             }
-            process.stdout.write(`  ${stepNum}. Edit main.py with your agent logic\n`);
-            process.stdout.write(`  ${stepNum + 1}. Test: echo '{"input": "test"}' | python main.py\n`);
+            process.stdout.write(`  ${stepNum}. Edit prompt.md with your agent instructions\n`);
+            process.stdout.write(`  ${stepNum + 1}. Edit schema.json with your input/output schemas\n`);
             process.stdout.write(`  ${stepNum + 2}. Run: orchagent publish\n`);
         }
     });

package/dist/commands/publish.js

@@ -161,6 +161,48 @@ async function collectSkillFiles(skillDir, maxFiles = 20, maxTotalSize = 500_000
     await walkDir(skillDir);
     return files;
 }
+function canonicalizeManifestType(typeValue) {
+    const rawType = (typeValue || 'agent').trim().toLowerCase();
+    if (rawType === 'skill') {
+        return { canonicalType: 'skill', rawType };
+    }
+    if (['agent', 'prompt', 'tool', 'agentic', 'code'].includes(rawType)) {
+        return { canonicalType: 'agent', rawType };
+    }
+    throw new errors_1.CliError(`Invalid type '${typeValue}'. Use 'agent' or 'skill' (legacy values accepted: prompt, tool, agentic, code).`);
+}
+function normalizeRunMode(runMode) {
+    const normalized = (runMode || 'on_demand').trim().toLowerCase();
+    if (normalized === 'on_demand' || normalized === 'always_on') {
+        return normalized;
+    }
+    throw new errors_1.CliError("run_mode must be 'on_demand' or 'always_on'");
+}
+function inferExecutionEngineFromManifest(manifest, rawType) {
+    const runtimeCommand = manifest.runtime?.command?.trim();
+    const hasLoop = Boolean(manifest.loop && Object.keys(manifest.loop).length > 0);
+    if (runtimeCommand && hasLoop) {
+        throw new errors_1.CliError('runtime.command and loop cannot both be set');
+    }
+    if (runtimeCommand)
+        return 'code_runtime';
+    if (hasLoop)
+        return 'managed_loop';
+    if (rawType === 'tool' || rawType === 'code')
+        return 'code_runtime';
+    if (rawType === 'agentic')
+        return 'managed_loop';
+    if (rawType === 'agent' && (manifest.custom_tools?.length || manifest.max_turns)) {
+        return 'managed_loop';
+    }
+    return 'direct_llm';
+}
+function commandForEntrypoint(entrypoint) {
+    if (entrypoint.endsWith('.js') || entrypoint.endsWith('.mjs') || entrypoint.endsWith('.cjs') || entrypoint.endsWith('.ts')) {
+        return `node ${entrypoint}`;
+    }
+    return `python ${entrypoint}`;
+}
 function registerPublishCommand(program) {
     program
         .command('publish')
@@ -269,6 +311,16 @@ function registerPublishCommand(program) {
         if (!manifest.name) {
             throw new errors_1.CliError('orchagent.json must have name');
         }
+        const { canonicalType, rawType } = canonicalizeManifestType(manifest.type);
+        const runMode = normalizeRunMode(manifest.run_mode);
+        const executionEngine = inferExecutionEngineFromManifest(manifest, rawType);
+        const callable = Boolean(manifest.callable);
+        if (canonicalType === 'skill') {
+            throw new errors_1.CliError("Use SKILL.md for publishing skills. Remove orchagent.json and run 'orchagent publish' from a skill directory.");
+        }
+        if (runMode === 'always_on' && executionEngine === 'direct_llm') {
+            throw new errors_1.CliError('run_mode=always_on requires runtime.command or loop configuration');
+        }
         // Warn about deprecated prompt field
         if (manifest.prompt) {
             process.stderr.write(chalk_1.default.yellow('Warning: "prompt" field in orchagent.json is ignored. Use prompt.md file instead.\n'));
@@ -310,7 +362,7 @@ function registerPublishCommand(program) {
                 `These must be nested under a "manifest" key. Example:\n\n` +
                 `  {\n` +
                 `    "name": "${manifest.name}",\n` +
-                `    "type": "${manifest.type || 'tool'}",\n` +
+                `    "type": "${manifest.type || 'agent'}",\n` +
                 `    "manifest": {\n` +
                 `      "manifest_version": 1,\n` +
                 `      "dependencies": [...],\n` +
@@ -321,26 +373,25 @@ function registerPublishCommand(program) {
                 `  }\n\n` +
                 `See docs/manifest.md for details.`);
         }
-        // Read prompt (for prompt-based, agent, and skill agents)
+        // Read prompt for LLM-driven engines (direct_llm + managed_loop).
         let prompt;
-        if (manifest.type === 'prompt' || manifest.type === 'skill' || manifest.type === 'agent') {
+        if (executionEngine === 'direct_llm' || executionEngine === 'managed_loop') {
             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 === 'agent' ? 'agent' : 'prompt-based agent';
-                    throw new errors_1.CliError(`No prompt.md found for ${agentTypeName}.\n\n` +
+                    throw new errors_1.CliError('No prompt.md found for this agent.\n\n' +
                         'Create a prompt.md file in the current directory with your prompt template.\n' +
                         'See: https://orchagent.io/docs/publishing');
                 }
                 throw err;
             }
         }
-        // For agent type, validate custom_tools and build manifest
-        if (manifest.type === 'agent') {
-            // Validate custom_tools format
+        // Validate managed-loop specific fields + normalize loop payload
+        let loopConfig;
+        if (executionEngine === 'managed_loop') {
             if (manifest.custom_tools) {
                 const reservedNames = new Set(['bash', 'read_file', 'write_file', 'list_files', 'submit_result']);
                 const seenNames = new Set();
@@ -359,24 +410,24 @@ function registerPublishCommand(program) {
                     seenNames.add(tool.name);
                 }
             }
-            // Validate max_turns
             if (manifest.max_turns !== undefined) {
                 if (typeof manifest.max_turns !== 'number' || manifest.max_turns < 1 || manifest.max_turns > 50) {
                     throw new errors_1.CliError('max_turns must be a number between 1 and 50');
                 }
             }
-            // Store agent config in manifest field
-            const agentManifest = {
-                ...(manifest.manifest || {}),
-            };
-            if (manifest.custom_tools) {
-                agentManifest.custom_tools = manifest.custom_tools;
+            const providedLoop = manifest.loop && typeof manifest.loop === 'object'
+                ? { ...manifest.loop }
+                : {};
+            if (!('max_turns' in providedLoop) && manifest.max_turns !== undefined) {
+                providedLoop.max_turns = manifest.max_turns;
+            }
+            if (!('custom_tools' in providedLoop) && manifest.custom_tools?.length) {
+                providedLoop.custom_tools = manifest.custom_tools;
             }
-            if (manifest.max_turns) {
-                agentManifest.max_turns = manifest.max_turns;
+            if (Object.keys(providedLoop).length === 0) {
+                providedLoop.max_turns = 25;
             }
-            manifest.manifest = agentManifest;
-            // Agent type defaults to anthropic provider
+            loopConfig = providedLoop;
             if (!manifest.supported_providers) {
                 manifest.supported_providers = ['anthropic'];
             }
@@ -398,9 +449,8 @@ function registerPublishCommand(program) {
                 throw new errors_1.CliError(`Failed to read schema.json: ${err}`);
             }
         }
-        // For prompt/skill agents, derive input schema from template variables if needed
-        // (Agent type uses schema.json directly — no template variable derivation)
-        if (prompt && (manifest.type === 'prompt' || manifest.type === 'skill')) {
+        // For direct LLM and managed loop agents, derive input schema from template variables if needed.
+        if (prompt && (executionEngine === 'direct_llm' || executionEngine === 'managed_loop')) {
             const templateVars = extractTemplateVariables(prompt);
             if (templateVars.length > 0) {
                 if (!schemaFromFile) {
@@ -426,47 +476,44 @@ function registerPublishCommand(program) {
                 }
             }
         }
-        // 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 === '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');
-                try {
-                    await promises_1.default.access(dockerfilePath);
-                    shouldUploadBundle = true;
-                    process.stdout.write(`Including Dockerfile for custom environment\n`);
+        let runtimeConfig;
+        let bundleEntrypoint = manifest.entrypoint;
+        if (executionEngine === 'code_runtime') {
+            if (!bundleEntrypoint) {
+                bundleEntrypoint = await (0, bundle_1.detectEntrypoint)(cwd) || undefined;
+            }
+            if (!options.url) {
+                if (!bundleEntrypoint) {
+                    throw new errors_1.CliError('Tool requires either --url <url> or an entry point file (main.py, app.py, index.js, etc.)');
                 }
-                catch {
-                    throw new errors_1.CliError('--docker flag specified but no Dockerfile found in project directory');
-                }
-            }
-        }
-        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 tool - we'll bundle and upload
                 shouldUploadBundle = true;
-                // Set a placeholder URL that tells the gateway to use sandbox execution
                 agentUrl = 'https://tool.internal';
-                process.stdout.write(`Detected tool project with entrypoint: ${entrypoint}\n`);
+                process.stdout.write(`Detected code runtime entrypoint: ${bundleEntrypoint}\n`);
             }
-            else {
-                throw new errors_1.CliError('Tool requires either --url <url> or an entry point file (main.py, app.py, index.js, etc.)');
+            let runtimeCommand = manifest.runtime?.command?.trim() || '';
+            if (!runtimeCommand && manifest.run_command?.trim()) {
+                runtimeCommand = manifest.run_command.trim();
+            }
+            if (!runtimeCommand) {
+                runtimeCommand = commandForEntrypoint(bundleEntrypoint || 'main.py');
             }
+            runtimeConfig = { ...(manifest.runtime || {}), command: runtimeCommand };
+        }
+        else {
+            agentUrl = agentUrl || 'https://prompt-agent.internal';
+        }
+        if (options.docker && executionEngine !== 'code_runtime') {
+            throw new errors_1.CliError('--docker is only supported for code runtime agents');
         }
         // 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 tool agents
+        // Detect SDK compatibility for code runtime agents
         let sdkCompatible = false;
-        if (manifest.type === 'tool') {
+        if (executionEngine === 'code_runtime') {
             sdkCompatible = await detectSdkCompatible(cwd);
             if (sdkCompatible && !options.dryRun) {
                 process.stdout.write(`SDK detected - agent will be marked as Local Ready\n`);
@@ -481,8 +528,7 @@ function registerPublishCommand(program) {
             process.stderr.write('\nDRY RUN - No changes will be made\n\n');
             process.stderr.write('Validating...\n');
             process.stderr.write(`  ✓ orchagent.json found and valid\n`);
-            if (manifest.type === 'prompt') {
-                // Prompt agent validations
+            if (executionEngine === 'direct_llm') {
                 const promptBytes = prompt ? Buffer.byteLength(prompt, 'utf-8') : 0;
                 process.stderr.write(`  ✓ prompt.md found (${promptBytes.toLocaleString()} bytes)\n`);
                 if (schemaFromFile) {
@@ -494,31 +540,29 @@ function registerPublishCommand(program) {
                     process.stderr.write(`  ✓ Input schema derived from template variables: ${vars.join(', ')}\n`);
                 }
             }
-            else if (manifest.type === 'agent') {
-                // Agent type validations
+            else if (executionEngine === 'managed_loop') {
                 const promptBytes = prompt ? Buffer.byteLength(prompt, 'utf-8') : 0;
                 process.stderr.write(`  ✓ prompt.md found (${promptBytes.toLocaleString()} bytes)\n`);
                 if (schemaFromFile) {
                     const schemaTypes = [inputSchema ? 'input' : null, outputSchema ? 'output' : null].filter(Boolean).join(' + ');
                     process.stderr.write(`  ✓ schema.json found (${schemaTypes} schemas)\n`);
                 }
-                const customToolCount = manifest.custom_tools?.length || 0;
+                const customToolCount = manifest.custom_tools?.length || Number(Array.isArray(loopConfig?.custom_tools) ? loopConfig.custom_tools.length : 0);
                 process.stderr.write(`  ✓ Custom tools: ${customToolCount}\n`);
-                process.stderr.write(`  ✓ Max turns: ${manifest.max_turns || 25}\n`);
+                process.stderr.write(`  ✓ Max turns: ${loopConfig?.max_turns || manifest.max_turns || 25}\n`);
             }
-            else if (manifest.type === 'tool') {
-                // Tool agent validations
-                const entrypoint = manifest.entrypoint || await (0, bundle_1.detectEntrypoint)(cwd);
-                process.stderr.write(`  ✓ Entrypoint: ${entrypoint}\n`);
+            else if (executionEngine === 'code_runtime') {
+                process.stderr.write(`  ✓ runtime.command: ${String(runtimeConfig?.command || '')}\n`);
+                process.stderr.write(`  ✓ Entrypoint: ${bundleEntrypoint || '(remote url only)'}\n`);
                 if (sdkCompatible) {
                     process.stderr.write(`  ✓ SDK detected (orchagent-sdk in requirements.txt)\n`);
                 }
             }
             process.stderr.write(`  ✓ Authentication valid (org: ${org.slug})\n`);
-            // For tools with bundles, show bundle preview
+            // For hosted code-runtime agents, show bundle preview
             if (shouldUploadBundle) {
                 const bundlePreview = await (0, bundle_1.previewBundle)(cwd, {
-                    entrypoint: manifest.entrypoint,
+                    entrypoint: bundleEntrypoint,
                     exclude: manifest.bundle?.exclude,
                     include: manifest.bundle?.include,
                 });
@@ -529,7 +573,10 @@ function registerPublishCommand(program) {
             }
             process.stderr.write('\nAgent Preview:\n');
             process.stderr.write(`  Name:        ${manifest.name}\n`);
-            process.stderr.write(`  Type:        ${manifest.type}${shouldUploadBundle ? ' (hosted)' : ''}\n`);
+            process.stderr.write(`  Type:        ${canonicalType}\n`);
+            process.stderr.write(`  Run mode:    ${runMode}\n`);
+            process.stderr.write(`  Engine:      ${executionEngine}${shouldUploadBundle ? ' (hosted)' : ''}\n`);
+            process.stderr.write(`  Callable:    ${callable ? 'enabled' : 'disabled'}\n`);
             process.stderr.write(`  Version:     ${versionInfo}\n`);
             process.stderr.write(`  Visibility:  private\n`);
             process.stderr.write(`  Providers:   ${supportedProviders.join(', ')}\n`);
@@ -544,7 +591,7 @@ function registerPublishCommand(program) {
             process.stderr.write(`\nWould publish: ${preview.org_slug}/${manifest.name}@${preview.next_version}\n`);
             if (shouldUploadBundle) {
                 const bundlePreview = await (0, bundle_1.previewBundle)(cwd, {
-                    entrypoint: manifest.entrypoint,
+                    entrypoint: bundleEntrypoint,
                     exclude: manifest.bundle?.exclude,
                     include: manifest.bundle?.include,
                 });
@@ -559,7 +606,11 @@ function registerPublishCommand(program) {
         try {
             result = await (0, api_1.createAgent)(config, {
                 name: manifest.name,
-                type: manifest.type,
+                type: canonicalType,
+                run_mode: runMode,
+                runtime: runtimeConfig,
+                loop: loopConfig,
+                callable,
                 description: manifest.description,
                 prompt,
                 url: agentUrl,
@@ -569,7 +620,7 @@ function registerPublishCommand(program) {
                 is_public: false,
                 supported_providers: supportedProviders,
                 default_models: manifest.default_models,
-                // Local run fields for tool agents
+                // Local run fields for code runtime agents
                 source_url: manifest.source_url,
                 pip_package: manifest.pip_package,
                 run_command: manifest.run_command,
@@ -615,7 +666,7 @@ function registerPublishCommand(program) {
         }
         const assignedVersion = result.agent?.version || 'v1';
         const agentId = result.agent?.id;
-        // Upload code bundle if this is a hosted tool agent or agent type with --docker
+        // Upload code bundle for hosted code runtime agents
         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-'));
@@ -634,8 +685,7 @@ function registerPublishCommand(program) {
                         throw new errors_1.CliError('--docker flag specified but no Dockerfile found in project directory');
                     }
                 }
-                // For agent type, also include requirements.txt if present
-                if (manifest.type === 'agent') {
+                if (executionEngine === 'code_runtime') {
                     const reqPath = path_1.default.join(cwd, 'requirements.txt');
                     try {
                         await promises_1.default.access(reqPath);
@@ -647,10 +697,10 @@ function registerPublishCommand(program) {
                     }
                 }
                 const bundleResult = await (0, bundle_1.createCodeBundle)(cwd, bundlePath, {
-                    entrypoint: manifest.type === 'agent' ? undefined : manifest.entrypoint,
+                    entrypoint: bundleEntrypoint,
                     exclude: manifest.bundle?.exclude,
                     include: includePatterns.length > 0 ? includePatterns : undefined,
-                    skipEntrypointCheck: manifest.type === 'agent',
+                    skipEntrypointCheck: false,
                 });
                 process.stdout.write(`  Created bundle: ${bundleResult.fileCount} files, ${(bundleResult.sizeBytes / 1024).toFixed(1)}KB\n`);
                 // Validate bundle size
@@ -660,7 +710,7 @@ function registerPublishCommand(program) {
                 }
                 // Upload the bundle with entrypoint
                 process.stdout.write(`  Uploading bundle...\n`);
-                const uploadResult = await (0, api_1.uploadCodeBundle)(config, agentId, bundlePath, manifest.entrypoint);
+                const uploadResult = await (0, api_1.uploadCodeBundle)(config, agentId, bundlePath, bundleEntrypoint);
                 process.stdout.write(`  Uploaded: ${uploadResult.code_hash.substring(0, 12)}...\n`);
                 // Show environment info if applicable
                 if (uploadResult.environment_id) {
@@ -682,9 +732,18 @@ function registerPublishCommand(program) {
                 await promises_1.default.rm(tempDir, { recursive: true, force: true });
             }
         }
-        await (0, analytics_1.track)('cli_publish', { agent_type: manifest.type, hosted: shouldUploadBundle });
+        await (0, analytics_1.track)('cli_publish', {
+            agent_type: canonicalType,
+            execution_engine: executionEngine,
+            run_mode: runMode,
+            callable,
+            hosted: shouldUploadBundle,
+        });
         process.stdout.write(`\nPublished agent: ${org.slug}/${manifest.name}@${assignedVersion}\n`);
-        process.stdout.write(`Type: ${manifest.type}${shouldUploadBundle ? ' (hosted)' : ''}\n`);
+        process.stdout.write(`Type: ${canonicalType}\n`);
+        process.stdout.write(`Run mode: ${runMode}\n`);
+        process.stdout.write(`Execution engine: ${executionEngine}${shouldUploadBundle ? ' (hosted)' : ''}\n`);
+        process.stdout.write(`Callable: ${callable ? 'enabled' : 'disabled'}\n`);
         process.stdout.write(`Providers: ${supportedProviders.join(', ')}\n`);
         process.stdout.write(`Visibility: private\n`);
         // Show security review result if available