@camelai/camelrun 0.10.1 → 0.11.1

package/README.md

@@ -1,6 +1,6 @@
 # @camelai/camelrun
 
-The Camel Run CLI: deploy and manage agents on the [camelAI agent runtime](https://agents.camelai.dev)
+The camelRun CLI: deploy and manage agents on [camelRun](https://run.camelai.com)
 from a terminal, a script or CI, and give a coding agent the same powers over MCP.
 
 ```sh
@@ -35,7 +35,7 @@ on a person (`camelrun inputs`, `camelrun answer`).
 The hosted MCP server needs nothing installed; sign in when the client asks:
 
 ```sh
-claude mcp add --transport http camelrun https://agents.camelai.dev/mcp
+claude mcp add --transport http camelrun https://run.camelai.com/mcp
 ```
 
 Or run it locally, where its `deploy` also reads your repository's manifests:
@@ -45,4 +45,4 @@ claude mcp add camelrun -- npx -y @camelai/camelrun mcp
 ```
 
 Every command, the manifest's fields and the MCP tools:
-[CLI and MCP server](https://agents.camelai.dev/docs/reference/cli.md).
+[CLI and MCP server](https://run.camelai.com/docs/reference/cli.md).

package/dist/cli.js

@@ -7,7 +7,7 @@ import { DEFAULT_FILES, template } from "./manifest.js";
 import { findManifest, loadManifests } from "./manifest-files.js";
 import * as ops from "./ops.js";
 import { VERSION } from "./version.js";
-const HELP = `camelrun: deploy and manage agents on Camel Run, the camelAI agent runtime
+const HELP = `camelrun: deploy and manage agents on camelRun
 
 Usage: camelrun <command> [options]
 
@@ -47,13 +47,13 @@ Definitions (a definition is its key or its id, def_…)
 
 MCP
   mcp                              Serve these commands as an MCP server over stdio
-                                   (or connect clients to the hosted one: https://agents.camelai.dev/mcp)
+                                   (or connect clients to the hosted one: https://run.camelai.com/mcp)
 
 Options
   --json                           Print JSON (the default when stdout is not a terminal)
   --api-key <key>, --url <url>     Instead of CAMELAI_API_KEY / CAMELAI_URL / the saved login
 
-Docs: https://agents.camelai.dev/llms.txt`;
+Docs: https://run.camelai.com/llms.txt`;
 const OPTIONS = {
     json: { type: "boolean" }, help: { type: "boolean", short: "h" }, version: { type: "boolean", short: "v" },
     "api-key": { type: "string" }, url: { type: "string" },
@@ -197,9 +197,9 @@ async function login(flags, io, print) {
     let apiKey = flags["api-key"] || io.env.CAMELAI_API_KEY;
     if (!apiKey) {
         if (!process.stdin.isTTY)
-            throw new UsageError("Pass --api-key art_… (or set CAMELAI_API_KEY); create one under API tokens at https://agents.camelai.dev/console");
+            throw new UsageError("Pass --api-key art_… (or set CAMELAI_API_KEY); create one under API tokens at https://run.camelai.com/console");
         const prompt = createInterface({ input: process.stdin, output: process.stderr });
-        apiKey = (await prompt.question("API key (from https://agents.camelai.dev/console, API tokens): ")).trim();
+        apiKey = (await prompt.question("API key (from https://run.camelai.com/console, API tokens): ")).trim();
         prompt.close();
     }
     const url = flags.url || io.env.CAMELAI_URL || DEFAULT_URL;

package/dist/config.js

@@ -1,7 +1,7 @@
 import { chmodSync, existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { dirname, join } from "node:path";
-export const DEFAULT_URL = "https://agents.camelai.dev";
+export const DEFAULT_URL = "https://run.camelai.com";
 /** Where `camelrun login` keeps the key: $CAMELRUN_CONFIG, else $XDG_CONFIG_HOME/camelrun, else ~/.config/camelrun. */
 export function configPath(env = process.env) {
     if (env.CAMELRUN_CONFIG)
@@ -37,6 +37,6 @@ export function resolve(flags, env = process.env) {
     const saved = readSaved(env);
     const apiKey = flags.apiKey || env.CAMELAI_API_KEY || saved.apiKey;
     if (!apiKey)
-        throw new Error("No API key: run `camelrun login`, or set CAMELAI_API_KEY (create one under API tokens at https://agents.camelai.dev/console)");
+        throw new Error("No API key: run `camelrun login`, or set CAMELAI_API_KEY (create one under API tokens at https://run.camelai.com/console)");
     return { apiKey, url: flags.url || env.CAMELAI_URL || saved.url || DEFAULT_URL };
 }

package/dist/manifest.js

@@ -83,9 +83,9 @@ export function interpolate(value, env, where) {
     return value;
 }
 export function template(key, model) {
-    return `# An agent on the camelAI agent runtime. Deploy it with \`camelrun deploy\`; deploying again
+    return `# An agent on camelRun. Deploy it with \`camelrun deploy\`; deploying again
 # updates the definition in place (the same key is the same definition).
-# Fields: https://agents.camelai.dev/docs/guides/definitions.md
+# Fields: https://run.camelai.com/docs/guides/definitions.md
 key: ${key}
 name: ${key}
 ${model ? `model: ${model}` : "# model: anthropic/claude-sonnet-5-5   # camelrun models --available lists yours"}

package/dist/mcp.js

@@ -5,6 +5,9 @@ import { findManifest, loadManifests } from "./manifest-files.js";
 import { errorText, INSTRUCTIONS, resultText, tools } from "./tools.js";
 import { VERSION } from "./version.js";
 import { readFileSync } from "node:fs";
+/** A result's most characters: past it the rest is cut, so one long history or spec cannot fill a model's context. */
+export const MAX_RESULT = 100_000;
+const capped = (text) => text.length <= MAX_RESULT ? text : `${text.slice(0, MAX_RESULT)}\n\n[Cut at ${MAX_RESULT} characters of ${text.length}: ask for less, such as a smaller limit.]`;
 /** Serve the CLI's operations as MCP tools over stdio. Credentials are read on each call, so a login takes effect at once. */
 export async function serve(api, options) {
     const server = createServer(api, options);
@@ -21,16 +24,16 @@ export async function serve(api, options) {
  */
 export function createServer(api, options = {}) {
     const { cwd } = options;
-    const server = new McpServer({ name: "camelrun", title: "Camel Run", version: VERSION }, { instructions: INSTRUCTIONS });
+    const server = new McpServer({ name: "camelrun", title: "camelRun", version: VERSION }, { instructions: INSTRUCTIONS });
     const local = cwd === undefined ? undefined : {
         env: process.env,
         readFile: (path) => readFileSync(resolve(cwd, path), "utf8"),
         load: (file) => loadManifests(file ? (isAbsolute(file) ? file : resolve(cwd, file)) : findManifest(cwd)),
     };
     for (const tool of tools(api, { local })) {
-        server.registerTool(tool.name, { description: tool.description, inputSchema: tool.input, annotations: tool.annotations }, (async (args) => {
+        server.registerTool(tool.name, { title: tool.title, description: tool.description, inputSchema: tool.input, annotations: { title: tool.title, ...tool.annotations } }, (async (args) => {
             try {
-                return { content: [{ type: "text", text: resultText(await tool.run(args)) }] };
+                return { content: [{ type: "text", text: capped(resultText(await tool.run(args))) }] };
             }
             catch (error) {
                 return { isError: true, content: [{ type: "text", text: errorText(error) }] };

package/dist/tools.js

@@ -2,7 +2,7 @@ import { z } from "zod";
 import { enc } from "./api.js";
 import { parseManifests } from "./manifest.js";
 import * as ops from "./ops.js";
-export const INSTRUCTIONS = `Deploy and manage agents on Camel Run, the camelAI agent runtime (https://agents.camelai.dev).
+export const INSTRUCTIONS = `Deploy and manage agents on camelRun (https://run.camelai.com).
 
 - An agent is durable and keyed: the same key is the same agent, with its history, until deleted. Tools take an agent's key or its id (client_…).
 - A definition is a reusable configuration (model, system prompt, built-ins, MCP servers, OpenAPI specs). Keep it in the repository as agent.yaml and deploy it with deploy: the same key is the same definition, and deploying again makes a new revision. apply: true also moves live agents to it between their turns.
@@ -14,23 +14,27 @@ const wait = z.number().min(0).max(300).optional().describe("Seconds to wait for
 /** Every tool, for `api`. */
 export function tools(api, options = {}) {
     const list = [];
-    const tool = (name, description, input, run, annotations = {}) => {
-        list.push({ name, description, input, annotations, run });
+    const tool = (name, title, description, input, run, annotations) => {
+        list.push({ name, title, description, input, annotations, run });
     };
-    const read = { readOnlyHint: true };
-    tool("whoami", "The tenant the API key belongs to, the runtime's URL and the default model.", {}, async () => {
+    const read = { readOnlyHint: true, destructiveHint: false, openWorldHint: false };
+    // Adds to the account and changes nothing already there.
+    const add = { readOnlyHint: false, destructiveHint: false, openWorldHint: false };
+    // Overwrites, deletes or stops something, or cannot be taken back.
+    const destructive = { readOnlyHint: false, destructiveHint: true, openWorldHint: false };
+    tool("whoami", "Show account", "The camelRun account (tenant) these credentials act for, the runtime's URL and the default model. Changes nothing.", {}, async () => {
         const client = api();
         return { ...await client.me(), url: client.url };
     }, read);
-    tool("list_models", "Models agents can use: pass a model's id as `model`.", { available: z.boolean().optional().describe("Only models the account has a key for (default true)") }, async ({ available }) => {
+    tool("list_models", "List models", "The models agents can use, with context window, reasoning support and price: pass a model's id as `model` to create_agent, configure_agent or a manifest. Changes nothing.", { available: z.boolean().optional().describe("Only models the account has a key for (default true)") }, async ({ available }) => {
         const models = await api().get(`/v1/models${available === false ? "" : "?available=true"}`);
         return models.map(({ id, name, contextWindow, reasoning, cost, available }) => ({ id, name, available, contextWindow, reasoning, cost }));
     }, read);
     const local = options.local;
     const hosted = !local;
-    tool("deploy", "Deploy agent manifests: upsert each definition by its key (a new revision only when it changed) and make the keyed agents it lists. " +
+    tool("deploy", "Deploy agent manifest", "Deploy agent manifests: upsert each definition by its key (a new revision only when it changed, replacing the current one) and make or update the keyed agents it lists. Use dryRun first to show what would change. " +
         (hosted
-            ? "Give `manifest`, the YAML itself (as an agent.yaml holds it). This server reads no files and no environment variables: put the system prompt in systemPrompt and any OpenAPI spec in spec."
+            ? "Give `manifest`, the YAML itself (as an agent.yaml holds it). This server reads no files and no environment variables: put the system prompt in systemPrompt and any OpenAPI spec in spec. Never ask a person to paste credentials into the conversation: a manifest whose tool servers need secrets is deployed with the camelrun CLI, which reads them from its environment."
             : "Give `file` (a path to an agent.yaml; default ./agent.yaml) or `manifest` (the YAML itself). `${NAME}` in strings reads this server's environment."), {
         ...(hosted ? {} : { file: z.string().optional().describe("Path to the manifest, relative to the working directory") }),
         manifest: hosted ? z.string().describe("The manifest's YAML") : z.string().optional().describe("The manifest's YAML, instead of a file"),
@@ -47,29 +51,29 @@ export function tools(api, options = {}) {
             : local.load(file);
         const results = await ops.deploy(api(), manifests, { apply, dryRun });
         return dryRun ? results.map((result, index) => ({ ...result, definition: ops.redact(manifests[index].definition) })) : results;
-    });
-    tool("list_definitions", "The account's definitions.", {}, async () => {
+    }, destructive);
+    tool("list_definitions", "List definitions", "The account's definitions (reusable agent configurations): id, key, revision, model and built-in tools. Changes nothing.", {}, async () => {
         const list = await api().get("/v1/definitions");
         return list.map(({ id, name, revision, model, builtins, updatedAt }) => ({ id, name, revision, model, builtins, updatedAt }));
     }, read);
-    tool("get_definition", "A definition in full: model, prompt, built-ins and tool sources (never their credentials).", { definition }, async ({ definition }) => {
+    tool("get_definition", "Get definition", "A definition in full: model, system prompt, built-ins and tool sources (never their credentials). Changes nothing.", { definition }, async ({ definition }) => {
         const client = api();
         return client.get(`/v1/definitions/${await client.definitionId(definition)}`);
     }, read);
-    tool("definition_agents", "The agents made from a definition, and the revision each has.", { definition }, async ({ definition }) => {
+    tool("definition_agents", "List a definition's agents", "The agents made from a definition, and the revision each has. Changes nothing.", { definition }, async ({ definition }) => {
         const client = api();
         return client.get(`/v1/definitions/${await client.definitionId(definition)}/agents`);
     }, read);
-    tool("delete_definition", "Delete a definition. Its agents are left as they are.", { definition }, async ({ definition }) => {
+    tool("delete_definition", "Delete definition", "Delete a definition and its revisions; this cannot be undone, so confirm with the person first. Agents made from it keep running as they are.", { definition }, async ({ definition }) => {
         const client = api();
         return client.call("DELETE", `/v1/definitions/${await client.definitionId(definition)}`);
-    }, { destructiveHint: true });
-    tool("list_agents", "The account's agents: key, id, model, and whether each is running.", {}, () => api().get("/v1/agents"), read);
-    tool("get_agent", "An agent's configuration, the definition revision it has, and every source of its tools with what each offers.", { agent }, async ({ agent }) => {
+    }, destructive);
+    tool("list_agents", "List agents", "The account's agents: key, id, model, and whether each is running. Changes nothing.", {}, () => api().get("/v1/agents"), read);
+    tool("get_agent", "Get agent", "An agent's configuration, the definition revision it has, and every source of its tools with what each offers. Changes nothing.", { agent }, async ({ agent }) => {
         const client = api();
         return client.get(`/v1/agents/${enc(await client.agentId(agent))}`);
     }, read);
-    tool("create_agent", "Make the agent for a key, or find it: from a definition, or with its own model and system prompt. The same key is the same agent; it lives until deleted.", {
+    tool("create_agent", "Create agent", "Make the agent for a key: from a definition, or with its own model and system prompt. The same key is the same agent, so calling it again for a key that exists updates that agent to the configuration given, keeping its history. It lives until deleted.", {
         key: z.string().regex(/^[A-Za-z0-9_-]{1,80}$/).describe("Your name for the agent: 1 to 80 letters, digits, _ and -"),
         definition: definition.optional(),
         model: z.string().optional().describe("A model id from list_models"),
@@ -77,8 +81,8 @@ export function tools(api, options = {}) {
         systemPromptAppend: z.string().optional().describe("Text after the prompt, e.g. this agent's own context"),
         name: z.string().optional(),
         builtins: z.array(z.enum(["web_fetch", "web_search", "schedule", "ask_user"])).optional().describe("Without a definition: tools the runtime answers itself"),
-    }, ({ key, ...config }) => ops.upsertAgent(api(), key, config), { idempotentHint: true });
-    tool("configure_agent", "Change one agent's model, system prompt, prompt addition or thinking level between its runs; its history is kept.", {
+    }, ({ key, ...config }) => ops.upsertAgent(api(), key, config), { ...destructive, idempotentHint: true });
+    tool("configure_agent", "Configure agent", "Change one agent's model, system prompt, prompt addition or thinking level between its runs, replacing the current values; its history is kept.", {
         agent,
         model: z.string().optional(),
         systemPrompt: z.string().optional(),
@@ -89,48 +93,48 @@ export function tools(api, options = {}) {
         if (!Object.keys(given).length)
             throw new Error("Nothing to change");
         return ops.configure(api(), agent, given);
-    });
-    tool("delete_agent", "Delete an agent: it stops at once, and its history and files are purged. Its key makes a fresh agent next time.", { agent }, async ({ agent }) => {
+    }, destructive);
+    tool("delete_agent", "Delete agent", "Delete an agent: it stops at once, and its history and files are purged; this cannot be undone, so confirm with the person first. Its key makes a fresh agent next time.", { agent }, async ({ agent }) => {
         const client = api();
         return client.call("DELETE", `/v1/agents/${enc(await client.agentId(agent))}`);
-    }, { destructiveHint: true });
-    tool("run_agent", "Send an agent a message and wait for its run: the reply, the input it waits on, or why it failed. A run still going after `wait` seconds comes back as running; call get_run.", {
+    }, destructive);
+    tool("run_agent", "Run agent", "Send an agent a message and wait for its run: the reply, the input it waits on, or why it failed. A run still going after `wait` seconds comes back as running; call get_run. The agent acts with the tools it was given (such as web search and its MCP servers), and the run uses the account's model credit.", {
         agent, message: z.string(), wait,
         from: z.string().optional().describe("Who is sending, as a user id in the application"),
         steer: z.boolean().optional().describe("If a run is going, have it read this after its current step instead of queuing it"),
         allowDisconnected: z.boolean().optional().describe("Run even though the application serving its attached tools is not connected; those calls then fail"),
         requestId: z.string().optional().describe("Retrying with the same id is the same run"),
-    }, ({ agent, message, wait, ...options }) => ops.run(api(), agent, message, { ...options, wait: wait ?? 50 }));
-    tool("get_run", "A run's status and result, waiting up to `wait` seconds for it to end.", { agent, requestId: z.string(), wait }, async ({ agent, requestId, wait }) => {
+    }, ({ agent, message, wait, ...options }) => ops.run(api(), agent, message, { ...options, wait: wait ?? 50 }), { ...add, openWorldHint: true });
+    tool("get_run", "Get run", "A run's status and result, waiting up to `wait` seconds for it to end. Changes nothing.", { agent, requestId: z.string(), wait }, async ({ agent, requestId, wait }) => {
         const client = api();
         return ops.waitFor(client, await client.agentId(agent), requestId, wait ?? 50);
     }, read);
-    tool("agent_history", "An agent's latest messages, in whole turns: text, tool calls and tool results.", { agent, limit: z.number().int().min(1).max(500).optional().describe("Default 20") }, ({ agent, limit }) => ops.history(api(), agent, limit), read);
-    tool("abort_agent", "Stop an agent's running turn.", { agent }, async ({ agent }) => {
+    tool("agent_history", "Read agent history", "An agent's latest messages, in whole turns: text, tool calls and tool results. Changes nothing.", { agent, limit: z.number().int().min(1).max(500).optional().describe("Default 20") }, ({ agent, limit }) => ops.history(api(), agent, limit), read);
+    tool("abort_agent", "Stop agent's turn", "Stop an agent's running turn; the turn's unfinished work is cancelled. The agent and its history stay.", { agent }, async ({ agent }) => {
         const client = api();
         return client.call("POST", `/v1/agents/${enc(await client.agentId(agent))}/abort`, {});
-    });
-    tool("list_inputs", "Questions, approvals and forms waiting on a person: one agent's, or every agent's.", { agent: agent.optional() }, async ({ agent }) => {
+    }, destructive);
+    tool("list_inputs", "List pending inputs", "Questions, approvals and forms waiting on a person: one agent's, or every agent's. Changes nothing.", { agent: agent.optional() }, async ({ agent }) => {
         const client = api();
         return agent ? client.get(`/v1/agents/${enc(await client.agentId(agent))}/inputs?state=pending`) : client.get("/v1/inputs?state=pending");
     }, read);
-    tool("answer_input", "Answer an input and wait for the run it resumes. An approval takes true or false; a question the chosen label or your own words (several questions: {\"<question>\": \"<answer>\"}); a form its fields; \"decline\" declines. Only answer with what the person decided.", { agent, inputId: z.string(), value: z.union([z.boolean(), z.string(), z.array(z.string()), z.record(z.string(), z.unknown())]), from: z.string().optional().describe("Who is answering, as a user id in the application"), wait }, ({ agent, inputId, value, from, wait }) => ops.answer(api(), agent, inputId, value, { from, wait: wait ?? 50 }));
-    tool("list_schedules", "An agent's scheduled wake-ups.", { agent }, async ({ agent }) => {
+    tool("answer_input", "Answer input", "Answer an input and wait for the run it resumes. An approval takes true or false; a question the chosen label or your own words (several questions: {\"<question>\": \"<answer>\"}); a form its fields; \"decline\" declines. Only answer with what the person decided: an answer cannot be taken back, and an approval lets the agent go ahead with what it asked to do.", { agent, inputId: z.string(), value: z.union([z.boolean(), z.string(), z.array(z.string()), z.record(z.string(), z.unknown())]), from: z.string().optional().describe("Who is answering, as a user id in the application"), wait }, ({ agent, inputId, value, from, wait }) => ops.answer(api(), agent, inputId, value, { from, wait: wait ?? 50 }), { ...destructive, openWorldHint: true });
+    tool("list_schedules", "List schedules", "An agent's scheduled wake-ups. Changes nothing.", { agent }, async ({ agent }) => {
         const client = api();
         return client.get(`/v1/agents/${enc(await client.agentId(agent))}/schedules`);
     }, read);
-    tool("add_schedule", "Wake an agent later with a message: once (inSeconds or at), or repeatedly (everySeconds, at least 60).", {
+    tool("add_schedule", "Add schedule", "Wake an agent later with a message: once (inSeconds or at), or repeatedly (everySeconds, at least 60). Each wake-up is a run that uses the account's model credit.", {
         agent, text: z.string(),
         inSeconds: z.number().optional(), at: z.string().optional().describe("ISO time"), everySeconds: z.number().int().min(60).optional(),
     }, async ({ agent, ...schedule }) => {
         const client = api();
         return client.call("POST", `/v1/agents/${enc(await client.agentId(agent))}/schedules`, schedule);
-    });
-    tool("delete_schedule", "Cancel a scheduled wake-up.", { agent, scheduleId: z.string() }, async ({ agent, scheduleId }) => {
+    }, add);
+    tool("delete_schedule", "Delete schedule", "Cancel a scheduled wake-up; this cannot be undone.", { agent, scheduleId: z.string() }, async ({ agent, scheduleId }) => {
         const client = api();
         return client.call("DELETE", `/v1/agents/${enc(await client.agentId(agent))}/schedules/${enc(scheduleId)}`);
-    }, { destructiveHint: true });
-    tool("read_docs", "The runtime's documentation as Markdown: with no path, the index (llms.txt); else a page such as guides/definitions.md, guides/tools.md or reference/cli.md.", {
+    }, destructive);
+    tool("read_docs", "Read camelRun docs", "camelRun's own documentation as Markdown: with no path, the index (llms.txt); else a page such as guides/definitions.md, guides/tools.md or reference/cli.md. Changes nothing.", {
         path: z.string().regex(/^(?!.*\.\.)[A-Za-z0-9/_.-]*$/).optional(),
     }, ({ path }) => api().text(path ? `/docs/${path.replace(/^\/?(docs\/)?/, "")}` : "/llms.txt"), read);
     return list;

package/package.json

@@ -1,15 +1,15 @@
 {
   "name": "@camelai/camelrun",
-  "version": "0.10.1",
-  "description": "Camel Run CLI: deploy and manage agents on the camelAI agent runtime from a terminal, or from a coding agent over MCP (camelrun mcp).",
+  "version": "0.11.1",
+  "description": "camelRun CLI: deploy and manage agents on camelRun from a terminal, or from a coding agent over MCP (camelrun mcp).",
   "type": "module",
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/qaml-ai/agent-runtime.git",
+    "url": "git+https://github.com/qaml-ai/run.git",
     "directory": "packages/cli"
   },
-  "homepage": "https://agents.camelai.dev",
+  "homepage": "https://run.camelai.com",
   "publishConfig": {
     "registry": "https://registry.npmjs.org",
     "access": "public"