@opencomputer/cli 0.4.1 → 0.4.3

package/dist/project.js

@@ -321,7 +321,7 @@ ${template.suggestedPrompts.map((prompt) => `- ${prompt}`).join("\n")}
 `;
 }
 function gmailToolSource() {
-    return `import { tool } from "@opencode-ai/plugin";
+    return `import { tool } from "@opencomputer/agent";
 
 async function gmail(input: {
   path: string;
@@ -365,28 +365,40 @@ async function gmail(input: {
 }
 
 export const search = tool({
+  id: "gmail_search",
   description:
     "Read-only: search Gmail messages using a Gmail search query. Use this before reading individual messages.",
-  args: {
-    query: tool.schema.string(),
-    maxResults: tool.schema.number().min(1).max(25).default(10),
-    connection: tool.schema.string().optional(),
+  input: {
+    type: "object",
+    properties: {
+      query: { type: "string" },
+      maxResults: { type: "integer", minimum: 1, maximum: 25, default: 10 },
+      connection: { type: "string" },
+    },
+    required: ["query"],
+    additionalProperties: false,
   },
   async execute(args) {
     const query = encodeURIComponent(args.query);
     return JSON.stringify(await gmail({
-      path: \`/gmail/v1/users/me/messages?q=\${query}&maxResults=\${args.maxResults}\`,
+      path: \`/gmail/v1/users/me/messages?q=\${query}&maxResults=\${args.maxResults ?? 10}\`,
       connection: args.connection,
     }));
   },
 });
 
 export const read = tool({
+  id: "gmail_read",
   description:
     "Read-only: get a Gmail message's sender, recipients, subject, date, labels, and snippet. Use this for inbox triage after gmail_search.",
-  args: {
-    messageId: tool.schema.string(),
-    connection: tool.schema.string().optional(),
+  input: {
+    type: "object",
+    properties: {
+      messageId: { type: "string" },
+      connection: { type: "string" },
+    },
+    required: ["messageId"],
+    additionalProperties: false,
   },
   async execute(args) {
     return JSON.stringify(await gmail({
@@ -404,11 +416,17 @@ export const read = tool({
 });
 
 export const read_full = tool({
+  id: "gmail_read_full",
   description:
     "Read-only: get the complete Gmail message body. Use only when gmail_read metadata and snippet are insufficient.",
-  args: {
-    messageId: tool.schema.string(),
-    connection: tool.schema.string().optional(),
+  input: {
+    type: "object",
+    properties: {
+      messageId: { type: "string" },
+      connection: { type: "string" },
+    },
+    required: ["messageId"],
+    additionalProperties: false,
   },
   async execute(args) {
     return JSON.stringify(await gmail({
@@ -419,21 +437,27 @@ export const read_full = tool({
 });
 
 export const modify = tool({
+  id: "gmail_modify",
   description:
     "Consequential: add or remove Gmail labels only after the user explicitly confirms the exact change.",
-  args: {
-    messageId: tool.schema.string(),
-    addLabelIds: tool.schema.array(tool.schema.string()).default([]),
-    removeLabelIds: tool.schema.array(tool.schema.string()).default([]),
-    connection: tool.schema.string().optional(),
+  input: {
+    type: "object",
+    properties: {
+      messageId: { type: "string" },
+      addLabelIds: { type: "array", items: { type: "string" }, default: [] },
+      removeLabelIds: { type: "array", items: { type: "string" }, default: [] },
+      connection: { type: "string" },
+    },
+    required: ["messageId"],
+    additionalProperties: false,
   },
   async execute(args) {
     return JSON.stringify(await gmail({
       method: "POST",
       path: \`/gmail/v1/users/me/messages/\${encodeURIComponent(args.messageId)}/modify\`,
       body: {
-        addLabelIds: args.addLabelIds,
-        removeLabelIds: args.removeLabelIds,
+        addLabelIds: args.addLabelIds ?? [],
+        removeLabelIds: args.removeLabelIds ?? [],
       },
       connection: args.connection,
     }));
@@ -441,13 +465,19 @@ export const modify = tool({
 });
 
 export const send = tool({
+  id: "gmail_send",
   description:
     "Consequential: send an email only after the user reviews the full draft and explicitly confirms this exact send.",
-  args: {
-    to: tool.schema.string(),
-    subject: tool.schema.string(),
-    body: tool.schema.string(),
-    connection: tool.schema.string().optional(),
+  input: {
+    type: "object",
+    properties: {
+      to: { type: "string" },
+      subject: { type: "string" },
+      body: { type: "string" },
+      connection: { type: "string" },
+    },
+    required: ["to", "subject", "body"],
+    additionalProperties: false,
   },
   async execute(args) {
     if (/[\\r\\n]/.test(args.to) || /[\\r\\n]/.test(args.subject)) {
@@ -471,7 +501,7 @@ export const send = tool({
 `;
 }
 function calendarToolSource() {
-    return `import { tool } from "@opencode-ai/plugin";
+    return `import { tool } from "@opencomputer/agent";
 
 async function calendar(input: {
   path: string;
@@ -545,10 +575,13 @@ function nextDate(value: string): string {
 }
 
 export const list = tool({
+  id: "calendar_list",
   description:
     "Read-only: list the Google Calendars available through the selected connection.",
-  args: {
-    connection: tool.schema.string().optional(),
+  input: {
+    type: "object",
+    properties: { connection: { type: "string" } },
+    additionalProperties: false,
   },
   async execute(args) {
     return JSON.stringify(await calendar({
@@ -559,14 +592,20 @@ export const list = tool({
 });
 
 export const events = tool({
+  id: "calendar_events",
   description:
     "Read-only: list events in an exact time range before preparing PTO or identifying conflicts.",
-  args: {
-    calendarId: tool.schema.string().default("primary"),
-    timeMin: tool.schema.string().describe("Inclusive RFC3339 start timestamp"),
-    timeMax: tool.schema.string().describe("Exclusive RFC3339 end timestamp"),
-    query: tool.schema.string().optional(),
-    connection: tool.schema.string().optional(),
+  input: {
+    type: "object",
+    properties: {
+      calendarId: { type: "string", default: "primary" },
+      timeMin: { type: "string", description: "Inclusive RFC3339 start timestamp" },
+      timeMax: { type: "string", description: "Exclusive RFC3339 end timestamp" },
+      query: { type: "string" },
+      connection: { type: "string" },
+    },
+    required: ["timeMin", "timeMax"],
+    additionalProperties: false,
   },
   async execute(args) {
     const calendarId = args.calendarId || "primary";
@@ -588,14 +627,25 @@ export const events = tool({
 });
 
 export const freebusy = tool({
+  id: "calendar_freebusy",
   description:
     "Read-only: check busy periods for one or more calendars in an exact RFC3339 time range.",
-  args: {
-    calendarIds: tool.schema.array(tool.schema.string()).min(1).default(["primary"]),
-    timeMin: tool.schema.string(),
-    timeMax: tool.schema.string(),
-    timeZone: tool.schema.string().optional(),
-    connection: tool.schema.string().optional(),
+  input: {
+    type: "object",
+    properties: {
+      calendarIds: {
+        type: "array",
+        items: { type: "string" },
+        minItems: 1,
+        default: ["primary"],
+      },
+      timeMin: { type: "string" },
+      timeMax: { type: "string" },
+      timeZone: { type: "string" },
+      connection: { type: "string" },
+    },
+    required: ["timeMin", "timeMax"],
+    additionalProperties: false,
   },
   async execute(args) {
     const calendarIds = args.calendarIds?.length
@@ -616,16 +666,22 @@ export const freebusy = tool({
 });
 
 export const create_time_off = tool({
+  id: "calendar_create_time_off",
   description:
     "Consequential: create an all-day PTO event only after the user explicitly confirms the exact title, dates, calendar, and availability.",
-  args: {
-    calendarId: tool.schema.string().default("primary"),
-    title: tool.schema.string().default("Out of office"),
-    startDate: tool.schema.string().describe("First PTO day, YYYY-MM-DD"),
-    endDate: tool.schema.string().describe("Last PTO day, inclusive, YYYY-MM-DD"),
-    description: tool.schema.string().optional(),
-    availability: tool.schema.enum(["busy", "free"]).default("busy"),
-    connection: tool.schema.string().optional(),
+  input: {
+    type: "object",
+    properties: {
+      calendarId: { type: "string", default: "primary" },
+      title: { type: "string", default: "Out of office" },
+      startDate: { type: "string", description: "First PTO day, YYYY-MM-DD" },
+      endDate: { type: "string", description: "Last PTO day, inclusive, YYYY-MM-DD" },
+      description: { type: "string" },
+      availability: { type: "string", enum: ["busy", "free"], default: "busy" },
+      connection: { type: "string" },
+    },
+    required: ["startDate", "endDate"],
+    additionalProperties: false,
   },
   async execute(args) {
     const calendarId = args.calendarId || "primary";
@@ -638,7 +694,7 @@ export const create_time_off = tool({
       method: "POST",
       path: \`/calendars/\${encodeURIComponent(calendarId)}/events\`,
       body: {
-        summary: args.title,
+        summary: args.title || "Out of office",
         description: args.description,
         start: { date: startDate },
         end: { date: nextDate(endDate) },
@@ -653,7 +709,7 @@ export const create_time_off = tool({
 function githubReviewToolSource() {
     return `import { mkdir, writeFile } from "node:fs/promises";
 import { resolve, sep } from "node:path";
-import { tool } from "@opencode-ai/plugin";
+import { tool } from "@opencomputer/agent";
 
 const MAX_PAGES = 10;
 const MAX_CHECKOUT_FILES = 100;
@@ -744,10 +800,14 @@ async function githubPages(path: string): Promise<{
 }
 
 export const pr_context = tool({
+  id: "github_pr_context",
   description:
     "Read-only: fetch an accessible GitHub PR, all available issue comments, reviews, inline review comments, changed files, and the full available diff through the connection broker.",
-  args: {
-    pullRequestUrl: tool.schema.string(),
+  input: {
+    type: "object",
+    properties: { pullRequestUrl: { type: "string", format: "uri" } },
+    required: ["pullRequestUrl"],
+    additionalProperties: false,
   },
   async execute(args) {
     const { repository, number } = parsePullRequestUrl(args.pullRequestUrl);
@@ -813,12 +873,16 @@ export const pr_context = tool({
 });
 
 export const checkout = tool({
+  id: "github_checkout",
   description:
     "Read-only: materialize changed files plus relevant repository instructions and manifests from the exact PR head into a bounded session-workspace directory, without downloading the whole repository or creating a Git remote. Use the destination returned by this tool for subsequent file reads.",
-  args: {
-    pullRequestUrl: tool.schema.string(),
+  input: {
+    type: "object",
+    properties: { pullRequestUrl: { type: "string", format: "uri" } },
+    required: ["pullRequestUrl"],
+    additionalProperties: false,
   },
-  async execute(args, context) {
+  async execute(args) {
     const { repository, number } = parsePullRequestUrl(args.pullRequestUrl);
     const pull = await githubJson(
       "/repos/" + repository + "/pulls/" + String(number),
@@ -830,7 +894,7 @@ export const checkout = tool({
     if (typeof head.sha !== "string" || !/^[a-f0-9]{40}$/i.test(head.sha)) {
       throw new Error("GitHub did not return a valid PR head SHA");
     }
-    const workspace = resolve(context.directory);
+    const workspace = resolve(process.cwd());
     const destinationName =
       "github-pr-" + number + "-" + head.sha.slice(0, 12).toLowerCase();
     const destination = resolve(workspace, destinationName);
@@ -936,7 +1000,7 @@ export const checkout = tool({
 `;
 }
 function connectionControlToolSource() {
-    return `import { tool } from "@opencode-ai/plugin";
+    return `import { tool } from "@opencomputer/agent";
 
 async function connectionControl(
   method: "GET" | "POST",
@@ -996,21 +1060,35 @@ async function connectionControl(
 }
 
 export const list = tool({
+  id: "opencomputer_connections_list",
   description:
     "List the connected accounts available to the current session identity. Use this to discover connection providers and aliases without exposing credentials.",
-  args: {},
+  input: {
+    type: "object",
+    properties: {},
+    additionalProperties: false,
+  },
   async execute() {
     return JSON.stringify(await connectionControl("GET"));
   },
 });
 
 export const request = tool({
+  id: "opencomputer_connections_request",
   description:
     "Ask the current user to connect an account. Use gmail for an email account. Set newAccount=true when the user asks for another account of the same service. In a messaging channel OpenComputer privately sends the authorization link to that user; otherwise the result includes the link.",
-  args: {
-    service: tool.schema.enum(["gmail", "calendar", "drive", "sheets", "github"]),
-    label: tool.schema.string().optional(),
-    newAccount: tool.schema.boolean().optional(),
+  input: {
+    type: "object",
+    properties: {
+      service: {
+        type: "string",
+        enum: ["gmail", "calendar", "drive", "sheets", "github"],
+      },
+      label: { type: "string" },
+      newAccount: { type: "boolean" },
+    },
+    required: ["service"],
+    additionalProperties: false,
   },
   async execute(args) {
     return JSON.stringify(await connectionControl("POST", args));
@@ -1046,6 +1124,18 @@ function tomlString(source, key) {
     }
 }
 export async function readManifest(root) {
+    if (!(await exists(resolve(root, "opencomputer.toml")))) {
+        const id = agentIdFromName(basename(root));
+        return {
+            schema: 1,
+            id,
+            name: id
+                .split("-")
+                .map((part) => `${part.slice(0, 1).toUpperCase()}${part.slice(1)}`)
+                .join(" "),
+            template: "hello-world",
+        };
+    }
     const source = await readFile(resolve(root, "opencomputer.toml"), "utf8");
     const schema = Number(source.match(/^\s*schema\s*=\s*(\d+)\s*$/m)?.[1]);
     const id = tomlString(source, "id");
@@ -1065,12 +1155,10 @@ export async function findAgentRoot(startDirectory = process.cwd()) {
     let directory = resolve(startDirectory);
     for (;;) {
         const nested = resolve(directory, "opencomputer");
-        if ((await exists(resolve(directory, "opencomputer.toml"))) &&
-            (await exists(resolve(directory, "agent.ts")))) {
+        if ((await exists(resolve(directory, "agent.ts")))) {
             return directory;
         }
-        if ((await exists(resolve(nested, "opencomputer.toml"))) &&
-            (await exists(resolve(nested, "agent.ts")))) {
+        if ((await exists(resolve(nested, "agent.ts")))) {
             return nested;
         }
         for (const agentsDirectory of [
@@ -1086,8 +1174,7 @@ export async function findAgentRoot(startDirectory = process.cwd()) {
                 if (!entry.isDirectory())
                     continue;
                 const agent = resolve(agentsDirectory, entry.name);
-                if ((await exists(resolve(agent, "opencomputer.toml"))) &&
-                    (await exists(resolve(agent, "agent.ts")))) {
+                if ((await exists(resolve(agent, "agent.ts")))) {
                     detected.push(agent);
                 }
             }
@@ -1302,6 +1389,7 @@ export function useSessionData<T extends SessionDataValue>(key: string): T | und
         "opencode.json",
         "package.json",
         ".gitignore",
+        "README.md",
         "agent.ts",
         "opencomputer.ts",
         "workspace/README.md",
@@ -1531,7 +1619,7 @@ export async function assertStarterTarget(directory) {
     }
     const reserved = [
         "opencomputer/project.ts",
-        "opencomputer/agents/hello-world/opencomputer.toml",
+        "opencomputer/agents/hello-world/agent.ts",
         "package.json",
         "vite.config.ts",
         "index.html",
@@ -1551,19 +1639,45 @@ export async function initializeAgentProject(directory, project) {
     const root = resolve(directory);
     const agentRoot = resolve(root, "opencomputer", "agents", "hello-world");
     await assertStarterTarget(root);
-    const initialized = await initializeTemplateAgentProject(HELLO_WORLD_TEMPLATE, agentRoot);
+    await initializeTemplateAgentProject(HELLO_WORLD_TEMPLATE, agentRoot);
     const manifest = {
-        ...initialized.manifest,
-        ...(project ? { id: project.agentId } : {}),
+        schema: 1,
+        id: project?.agentId ?? "hello-world",
         name: "Hello World",
+        template: "hello-world",
     };
-    await writeManifest(agentRoot, manifest);
-    await rm(resolve(agentRoot, "package.json"), { force: true });
-    await rm(resolve(agentRoot, ".gitignore"), { force: true });
+    for (const path of [
+        "opencomputer.toml",
+        "opencomputer.config.ts",
+        "opencomputer.ts",
+        "opencode.json",
+        "package.json",
+        ".gitignore",
+        "README.md",
+        "tools",
+        "connections",
+        "skills",
+        "channels",
+        "workspace",
+        "evals",
+    ]) {
+        await rm(resolve(agentRoot, path), { recursive: true, force: true });
+    }
+    await writeFile(resolve(agentRoot, "agent.ts"), `import { useInput, useModel } from "@opencomputer/agent";
+
+export default function Agent() {
+  const input = useInput();
+  useModel("anthropic/claude-sonnet-4.6");
+
+  return input.text
+    ? "You are a helpful OpenComputer agent. Respond directly to: " + input.text
+    : "You are a helpful OpenComputer agent.";
+}
+`);
     await updateGitignore(root);
     await mkdir(resolve(root, "src"), { recursive: true });
     await writeFile(resolve(root, "opencomputer", "project.ts"), `export default {
-${project ? `  id: ${JSON.stringify(project.id)},\n` : ""}  name: ${JSON.stringify(project?.name ?? basename(root))},
+  name: ${JSON.stringify(project?.name ?? basename(root))},
   agents: ["hello-world"],
 };
 `);
@@ -1580,17 +1694,16 @@ ${project ? `  id: ${JSON.stringify(project.id)},\n` : ""}  name: ${JSON.stringi
             deploy: "opencomputer deploy",
         },
         dependencies: {
+            "@opencomputer/agent": "^0.2.0",
             react: "^19.2.0",
             "react-dom": "^19.2.0",
         },
         devDependencies: {
-            "@opencomputer/cli": "^0.4.1",
-            "@opencode-ai/plugin": "^1.18.4",
+            "@opencomputer/cli": "^0.4.3",
             "@types/node": "^24.0.0",
             "@types/react": "^19.2.0",
             "@types/react-dom": "^19.2.0",
             "@vitejs/plugin-react": "^6.0.0",
-            "opencode-ai": "1.18.4",
             typescript: "^5.9.0",
             vite: "^8.0.0",
         },
@@ -1616,13 +1729,17 @@ function openComputerDev() {
 }
 
 function openComputerAgent() {
-  const manifest = readFileSync(
-    resolve("opencomputer/agents/hello-world/opencomputer.toml"),
-    "utf8",
+  try {
+    const binding = JSON.parse(
+      readFileSync(resolve(".opencomputer/project.json"), "utf8"),
+    ) as { agentId?: string };
+    if (binding.agentId) return binding.agentId;
+  } catch {
+    // The production build below reports the actionable binding error.
+  }
+  throw new Error(
+    "This app is not connected to an OpenComputer project. Run npm run dev first.",
   );
-  const id = manifest.match(/^id\\s*=\\s*"([^"]+)"/m)?.[1];
-  if (!id) throw new Error("The hello-world agent manifest has no id.");
-  return id;
 }
 
 export default defineConfig(({ command }) => {
@@ -1941,22 +2058,64 @@ npm run dev:web
         manifest,
         files: [
             "opencomputer/project.ts",
-            ...initialized.files
-                .filter((path) => path !== "package.json" && path !== ".gitignore")
-                .map((path) => `opencomputer/agents/hello-world/${path}`),
+            "opencomputer/agents/hello-world/agent.ts",
             ...appFiles,
         ],
     };
 }
+function literalHookIds(source, hook) {
+    const pattern = new RegExp(`\\b${hook}\\(\\s*["']([^"']+)["']`, "g");
+    return [...source.matchAll(pattern)].map((match) => match[1]).sort();
+}
+function definedMcpServerIds(source) {
+    return [...source.matchAll(/\bdefineMcpServer\s*\(\s*\{[\s\S]*?\bid\s*:\s*["']([^"']+)["'][\s\S]*?\}\s*\)/g)].map((match) => match[1]).sort();
+}
+function definedToolIds(source) {
+    return [...source.matchAll(/\btool(?:<[^>]+>)?\s*\(\s*\{[\s\S]*?\bid\s*:\s*["']([^"']+)["'][\s\S]*?\}\s*\)/g)].map((match) => match[1]).sort();
+}
+function agentApiRuntimeSource() {
+    return `function hooks() {
+  const value = globalThis[Symbol.for("opencomputer.agent-hooks")];
+  if (!value) throw new Error("OpenComputer hooks can only run while rendering an agent");
+  return value;
+}
+function id(value, kind) {
+  const normalized = String(value).trim();
+  if (!normalized) throw new Error(kind + " requires a non-empty id");
+  return normalized;
+}
+export const connection = (value) => Object.freeze({ kind: "connection", id: id(value, "connection") });
+export const defineMcpServer = (input) => {
+  const url = new URL(input.url);
+  if (url.protocol !== "https:") throw new Error("MCP server URLs must use HTTPS");
+  return Object.freeze({ kind: "mcp", ...input, id: id(input.id, "defineMcpServer"), url: url.toString() });
+};
+export const tool = (input) => {
+  const toolId = id(input.id, "tool");
+  if (!/^[a-zA-Z0-9_-]+$/.test(toolId)) throw new Error("Invalid tool id " + JSON.stringify(toolId));
+  if (!String(input.description).trim()) throw new Error("tool requires a non-empty description");
+  if (!input.input || typeof input.input !== "object") throw new Error("tool requires a JSON Schema input object");
+  return Object.freeze({ kind: "tool", version: 1, ...input, id: toolId });
+};
+export const useInput = () => hooks().useInput();
+export const useCurrentInput = useInput;
+export const useModel = (model) => hooks().useModel(model);
+export const useTool = (tool) => hooks().useTool(tool);
+export const useSubagent = (agent) => hooks().useSubagent(agent);
+export const useConnection = (value) => hooks().useConnection(value);
+export const useMcpServer = (server) => hooks().useMcpServer(server);
+export const useSessionData = (key) => hooks().useSessionData(key);
+`;
+}
 export async function prepareAgent(root) {
     const runtime = resolve(root, ".opencomputer", "runtime");
     await rm(runtime, { recursive: true, force: true });
     await mkdir(runtime, { recursive: true });
     const agentSource = await readFile(resolve(root, "agent.ts"), "utf8");
     const reactive = /export\s+default\s+(?:async\s+)?function\b/.test(agentSource);
-    const legacyInstructions = reactive
-        ? ""
-        : await readFile(resolve(root, "instructions.md"), "utf8");
+    if (!reactive) {
+        throw new Error("agent.ts must default-export a synchronous agent function");
+    }
     await writeFile(resolve(runtime, "AGENTS.md"), `# OpenComputer runtime identity
 
 You are an OpenComputer agent. OpenCode is an internal execution detail, not
@@ -1976,7 +2135,7 @@ the product or support surface presented to users.
 - If a connection tool fails, report its exact error. Do not invent alternate
   controls or third-party support instructions.
 
-${legacyInstructions ? `# Agent instructions\n\n${legacyInstructions}` : ""}`);
+`);
     const openCodeConfig = resolve(root, "opencode.json");
     if (await exists(openCodeConfig)) {
         const parsed = JSON.parse(await readFile(openCodeConfig, "utf8"));
@@ -2008,63 +2167,104 @@ ${legacyInstructions ? `# Agent instructions\n\n${legacyInstructions}` : ""}`);
             },
         }, null, 2)}\n`);
     }
-    for (const directory of ["skills", "tools"]) {
-        const source = resolve(root, directory);
-        if (await exists(source)) {
-            await mkdir(resolve(runtime, ".opencode"), { recursive: true });
-            await cp(source, resolve(runtime, ".opencode", directory), {
-                recursive: true,
-            });
-        }
+    const skills = resolve(root, "skills");
+    if (await exists(skills)) {
+        await mkdir(resolve(runtime, ".opencode"), { recursive: true });
+        await cp(skills, resolve(runtime, ".opencode", "skills"), {
+            recursive: true,
+        });
     }
-    await mkdir(resolve(runtime, ".opencode", "tools"), { recursive: true });
-    await writeFile(resolve(runtime, ".opencode", "tools", "opencomputer-connections.ts"), connectionControlToolSource());
     const workspace = resolve(root, "workspace");
     if (await exists(workspace)) {
         await cp(workspace, runtime, { recursive: true });
     }
-    if (reactive) {
-        await writeFile(resolve(runtime, "package.json"), `${JSON.stringify({ private: true, type: "module" }, null, 2)}\n`);
-        const transpile = (source, filename) => ts.transpileModule(source, {
-            fileName: filename,
-            compilerOptions: {
-                target: ts.ScriptTarget.ES2022,
-                module: ts.ModuleKind.ESNext,
-                moduleResolution: ts.ModuleResolutionKind.Bundler,
-            },
-            reportDiagnostics: true,
-        });
-        const compiledAgent = transpile(agentSource, "agent.ts");
-        const diagnostics = compiledAgent.diagnostics ?? [];
-        if (diagnostics.some((diagnostic) => diagnostic.category === ts.DiagnosticCategory.Error)) {
-            throw new Error(`agent.ts could not be compiled: ${diagnostics
+    await writeFile(resolve(runtime, "package.json"), `${JSON.stringify({ private: true, type: "module" }, null, 2)}\n`);
+    const transpile = (source, filename) => ts.transpileModule(source, {
+        fileName: filename,
+        compilerOptions: {
+            target: ts.ScriptTarget.ES2022,
+            module: ts.ModuleKind.ESNext,
+            moduleResolution: ts.ModuleResolutionKind.Bundler,
+        },
+        reportDiagnostics: true,
+    });
+    const compiledAgent = transpile(agentSource, "agent.ts");
+    const diagnostics = compiledAgent.diagnostics ?? [];
+    if (diagnostics.some((diagnostic) => diagnostic.category === ts.DiagnosticCategory.Error)) {
+        throw new Error(`agent.ts could not be compiled: ${diagnostics
+            .map((diagnostic) => ts.flattenDiagnosticMessageText(diagnostic.messageText, " "))
+            .join("; ")}`);
+    }
+    const compiledSource = compiledAgent.outputText.replace(/(["'])@opencomputer\/agent\1/g, '"./opencomputer-agent.js"');
+    await writeFile(resolve(runtime, "agent.js"), compiledSource);
+    await writeFile(resolve(runtime, "opencomputer-agent.js"), agentApiRuntimeSource());
+    const toolSources = [
+        {
+            filename: "opencomputer-connections.ts",
+            source: connectionControlToolSource(),
+        },
+    ];
+    const sourceTools = resolve(root, "tools");
+    if (await exists(sourceTools)) {
+        const entries = await readdir(sourceTools, { withFileTypes: true });
+        for (const entry of entries) {
+            if (!entry.isFile() || !/\.[cm]?[jt]s$/.test(entry.name))
+                continue;
+            toolSources.push({
+                filename: entry.name,
+                source: await readFile(resolve(sourceTools, entry.name), "utf8"),
+            });
+        }
+    }
+    const reactiveTools = [];
+    const toolModules = [];
+    await mkdir(resolve(runtime, "tools"), { recursive: true });
+    for (const candidate of toolSources) {
+        const ids = definedToolIds(candidate.source);
+        const calls = [
+            ...candidate.source.matchAll(/\btool(?:<[^>]+>)?\s*\(/g),
+        ].length;
+        if (ids.length !== calls) {
+            throw new Error(`${candidate.filename} must give every tool() a literal string id`);
+        }
+        const compiledTool = transpile(candidate.source, candidate.filename);
+        const toolDiagnostics = compiledTool.diagnostics ?? [];
+        if (toolDiagnostics.some((diagnostic) => diagnostic.category === ts.DiagnosticCategory.Error)) {
+            throw new Error(`${candidate.filename} could not be compiled: ${toolDiagnostics
                 .map((diagnostic) => ts.flattenDiagnosticMessageText(diagnostic.messageText, " "))
                 .join("; ")}`);
         }
-        await writeFile(resolve(runtime, "agent.js"), compiledAgent.outputText);
-        const hookSource = await readFile(resolve(root, "opencomputer.ts"), "utf8");
-        await writeFile(resolve(runtime, "opencomputer.js"), transpile(hookSource, "opencomputer.ts").outputText);
-        const toolEntries = await readdir(resolve(runtime, ".opencode", "tools"), {
-            withFileTypes: true,
-        });
-        const reactiveTools = [];
-        for (const entry of toolEntries.filter((candidate) => candidate.isFile())) {
-            const stem = entry.name
-                .replace(/\.[^.]+$/, "")
-                .replace(/[^a-zA-Z0-9_]+/g, "_");
-            const source = await readFile(resolve(runtime, ".opencode", "tools", entry.name), "utf8");
-            for (const match of source.matchAll(/export\s+const\s+([a-zA-Z0-9_]+)\s*=/g)) {
-                reactiveTools.push(`${stem}_${match[1]}`);
-            }
+        const outputName = candidate.filename.replace(/\.[^.]+$/, ".js");
+        const output = compiledTool.outputText.replace(/(["'])@opencomputer\/agent\1/g, '"../opencomputer-agent.js"');
+        await writeFile(resolve(runtime, "tools", outputName), output);
+        if (ids.length > 0) {
+            reactiveTools.push(...ids);
+            toolModules.push(`../tools/${outputName}`);
         }
-        await mkdir(resolve(runtime, ".opencomputer"), { recursive: true });
-        await writeFile(resolve(runtime, ".opencomputer", "reactive.json"), `${JSON.stringify({
-            version: 1,
-            entry: "../agent.js",
-            tools: [...new Set(reactiveTools)].sort(),
-            subagents: [],
-        }, null, 2)}\n`);
     }
+    const duplicateTool = reactiveTools.find((id, index) => reactiveTools.indexOf(id) !== index);
+    if (duplicateTool) {
+        throw new Error(`Tool id ${JSON.stringify(duplicateTool)} is defined more than once`);
+    }
+    await mkdir(resolve(runtime, ".opencomputer"), { recursive: true });
+    await writeFile(resolve(runtime, ".opencomputer", "reactive.json"), `${JSON.stringify({
+        version: 2,
+        entry: "../agent.js",
+        tools: [...new Set([
+                ...reactiveTools,
+                ...literalHookIds(agentSource, "useTool"),
+            ])].sort(),
+        toolModules: toolModules.sort(),
+        subagents: literalHookIds(agentSource, "useSubagent"),
+        connections: [...new Set([
+                ...literalHookIds(agentSource, "connection"),
+                ...literalHookIds(agentSource, "useConnection"),
+            ])].sort(),
+        mcpServers: [...new Set([
+                ...definedMcpServerIds(agentSource),
+                ...literalHookIds(agentSource, "useMcpServer"),
+            ])].sort(),
+    }, null, 2)}\n`);
     return runtime;
 }
 async function collectNames(root, type) {
@@ -2126,7 +2326,7 @@ async function validateTemplateRequirements(root, manifest) {
         throw new Error("PTO calendar tools are missing. Run `opencomputer tools add calendar` before deploying.");
     }
 }
-export async function buildAgentArtifact(root) {
+export async function buildAgentArtifact(root, agentId) {
     const startedAt = performance.now();
     const manifest = await readManifest(root);
     await validateTemplateRequirements(root, manifest);
@@ -2139,7 +2339,7 @@ export async function buildAgentArtifact(root) {
         files: await collectFiles(runtime),
     }));
     return {
-        agentId: manifest.id,
+        agentId: agentId ?? manifest.id,
         name: manifest.name,
         channels,
         connections,