eve-hub 0.4.0 → 0.4.2

package/README.md

@@ -1,4 +1,4 @@
-# @hub/agent-kit
+# eve-hub
 
 The bot-side code every hub agent shares (milestone M3 in [`docs/architecture`](../../docs/architecture/README.md#milestones); D0, D12). Bots live in a workspace (their own repo, [`docs/workspace.md`](../../docs/workspace.md)); each keeps a one-line stub per file and the code lives here once.
 
@@ -9,14 +9,14 @@ The bot-side code every hub agent shares (milestone M3 in [`docs/architecture`](
 | `hooks/sandbox.ts` | Migrates legacy Docker sessions to the host sandbox (`defineHook`) | `agent/hooks/sandbox.ts` |
 | `instructions/main.ts`, `main-instructions.mjs` | main's instructions (`defineInstructions`), rendered at build time from the kit's `templates/main-instructions.md` + `workspace-protocol.md`, so no workspace carries a copy | `main`'s `agent/instructions.ts`; workspace-only additions in `agent/instructions/*.md` |
 | `instructions/protocol.ts` | The shared protocol alone, rendered from `templates/workspace-protocol.md` | every other bot's `agent/instructions/protocol.ts`, appended after its own `instructions.md` (who the bot is) |
-| `memory/workspace.ts`, `memory.mjs` | an eve memory slot (default export, constant `workspace` scope) whose provider recalls the workspace's `memory/<id>.md` entries, one message each, at every turn start and after compaction, only the ones whose text changed since the session last saw them, as new messages after the history; `validateMemory(root)` for a workspace's tests | every bot's (main too) `agent/memory/workspace.ts`: `export { default } from "@hub/agent-kit/memory/workspace"` |
-| `memory/bot.ts` | the same for the bot's own `agents/<bot>/memory/<id>.md` entries; the bot is found from its directory (`findBotDir`), scope is its name | every bot's `agent/memory/bot.ts`: `export { default } from "@hub/agent-kit/memory/bot"` |
+| `memory/workspace.ts`, `memory.mjs` | an eve memory slot (default export, constant `workspace` scope) whose provider recalls the workspace's `memory/<id>.md` entries, one message each, at every turn start and after compaction, only the ones whose text changed since the session last saw them, as new messages after the history; `validateMemory(root)` for a workspace's tests | every bot's (main too) `agent/memory/workspace.ts`: `export { default } from "eve-hub/memory/workspace"` |
+| `memory/bot.ts` | the same for the bot's own `agents/<bot>/memory/<id>.md` entries; the bot is found from its directory (`findBotDir`), scope is its name | every bot's `agent/memory/bot.ts`: `export { default } from "eve-hub/memory/bot"` |
 | `channels/eve-roster-user.ts` | `eveChannel({ auth: [rosterUser, localDev()], turnPolicy: "queue" })`: queued mentions, and the registry's `x-roster-user` human as a user principal | every bot's `agent/channels/eve.ts` |
 | `channels/eve.ts` | Re-exports `eve-roster-user.ts`, for stubs written before every bot shared one channel | older `agent/channels/eve.ts` stubs |
 | `tools/disabled.ts` | `disableTool()`: removes an eve default tool | the read-only preset's `agent/tools/write_file.ts` |
 | `host-sandbox.ts`, `host-browser.ts` | `HostSandbox` (the host machine is the sandbox) and each session's headless Chromium | `agent/sandbox.ts` imports `HostSandbox` |
 | `roster-model.mjs` | `bindRoster(workspace)`: `rosterModel(name, …)` (the dynamic `model` for agent.ts), `rosterLimits`, `agents` and `subagentCap`, for the `hub.workspace.json` the bot imports; `rosterModel` / `rosterLimits` read from disk for bots scaffolded before it; `createRosterModel({ agents, subagentCap })`: the same for a given roster | `bindRoster(workspace)` in agent.ts |
-| `session-limits.mjs` | `sessionLimits(roster, name)`: a bot's eve `limits` (no session timeout, per-session usage limits from `hub.workspace.json` over the default backstop) | `limits: rosterLimits("<name>")` from `@hub/agent-kit/roster-model` |
+| `session-limits.mjs` | `sessionLimits(roster, name)`: a bot's eve `limits` (no session timeout, per-session usage limits from `hub.workspace.json` over the default backstop) | `limits: rosterLimits("<name>")` from `eve-hub/roster-model` |
 | `workspace.mjs` | Reads and validates `hub.workspace.json`, assigns ports, finds a bot's workspace (`HUB_WORKSPACE`, else up from cwd) | the daemon (`lib/workspace-root.mjs`) and `roster-model.mjs` |
 | `workspace-roster.mjs` | `agents`, `humans`, `SUBAGENT_CAP` of the bot's workspace, read from disk | older subagents that resolve their capped model |
 | `bot-model.mjs`, `subagent-cap.mjs` | Model parsing/selection and the subagent cap | via `roster-model.mjs`; subagents import `subagent-cap.mjs` |
@@ -29,14 +29,14 @@ eve discovers tools, hooks, and channels by file under `agent/tools`, `agent/hoo
 
 ```ts
 // agents/<bot>/agent/tools/rename_thread.ts
-export { default } from "@hub/agent-kit/tools/rename_thread";
+export { default } from "eve-hub/tools/rename_thread";
 ```
 
 `sandbox.ts` stays a small module of its own, because each agent and subagent declares its own `environment`:
 
 ```ts
 import { defineSandbox } from "eve/sandbox";
-import { HostSandbox } from "@hub/agent-kit/host-sandbox";
+import { HostSandbox } from "eve-hub/host-sandbox";
 export const environment = HostSandbox.environment();
 export default defineSandbox(() => environment.open());
 ```
@@ -47,23 +47,18 @@ A bot's role is enforced by its files as well as its prose. `create_agent`'s `pr
 
 ## The package import (D12)
 
-1. Before spawning the bots, the daemon links the kit (`lib/workspace-link.mjs`): `<workspace>/.hub/agent-kit` and `<workspace>/node_modules/@hub/agent-kit` → `<hub>/packages/agent-kit`. If the workspace has no `eve`/`zod` of its own, they are linked to hub's install too. The daemon only replaces links it created, never a real install.
-2. The workspace's `package.json` depends on `"@hub/agent-kit": "link:.hub/agent-kit"` (`workspace init` writes it), so a later `pnpm install` keeps resolving the kit the same way.
-3. The stubs use the specifiers the `exports` map serves (`@hub/agent-kit/tools/x`, `@hub/agent-kit/host-sandbox`, `@hub/agent-kit/roster-model`, …).
+1. Before spawning the bots, the daemon links the kit (`lib/workspace-link.mjs`): `<workspace>/.hub/eve-hub` and `<workspace>/node_modules/eve-hub` → `<hub>/packages/agent-kit`. If the workspace has no `eve`/`zod` of its own, they are linked to hub's install too. The daemon only replaces links it created, never a real install.
+2. The workspace's `package.json` depends on `"eve-hub": "link:.hub/eve-hub"` (`workspace init` writes it), so a later `pnpm install` keeps resolving the kit the same way.
+3. The stubs use the specifiers the `exports` map serves (`eve-hub/tools/x`, `eve-hub/host-sandbox`, `eve-hub/roster-model`, …).
 4. `eve` and `zod` are peer dependencies. eve's bundler resolves the kit to its realpath, so the kit's own `eve` imports come from hub's install. When the workspace's eve is linked to hub's, that's one eve (verified with eve 0.69).
 
 Bump `version` when a tool's name, schema, or description, the hook's events, or the channel config changes. Hub records each agent's kit version and accepts N and N−1 (D0/D12).
 
-## Published tarball (deployed workspaces)
+## Published package (deployed workspaces)
 
-A deployed workspace (`node scripts/workspace-template.mjs <dir> <kit>`, lib/workspace-template.mjs) has no hub checkout to link, so it installs the kit from a tarball. `node packages/agent-kit/scripts/pack.mjs <outDir>` builds one: every `.ts` module compiled to `.js` + `.d.ts` in place (node won't strip types under `node_modules`), the `exports` map pointed at them, and `templates/` included. Publish it to the `hub-packages` public Blob store (vercel-internal-playground) under a content-addressed path, so a URL never changes what it serves:
+A deployed workspace (`node scripts/workspace-template.mjs <dir>`, lib/workspace-template.mjs) has no hub checkout to link, so it installs the kit from npm, published as [`eve-hub`](https://www.npmjs.com/package/eve-hub): `"eve-hub": "<version>"`. `node packages/agent-kit/scripts/pack.mjs <outDir>` builds the package: every `.ts` module compiled to `.js` + `.d.ts` in place (node won't strip types under `node_modules`), the `exports` map pointed at them, and `templates/` included.
 
-```bash
-T=$(node packages/agent-kit/scripts/pack.mjs /tmp/kit)
-H=$(shasum -a 256 "$T" | cut -c1-12)
-vercel blob put "$T" --access public --rw-token "$BLOB_READ_WRITE_TOKEN" \
-  --pathname "agent-kit/$(node -p 'require("./packages/agent-kit/package.json").version')-$H/hub-agent-kit.tgz"
-```
+`.github/workflows/publish-eve-hub.yml` publishes it on every push to main whose kit `version` npm doesn't have yet, authenticated by the repo's `NPM_TOKEN` secret (an npm automation token). Bump `version` to ship a kit change to deployed workspaces; the template pins the version this checkout carries.
 
 The template's main gets a Vercel Sandbox and only the kit stubs that run without the hub's machine (lib/workspace-template.mjs `DEPLOYED_KIT_FILES`; eve's own bash replaces the kit's). The published tarball (`scripts/pack.mjs`) leaves out the kit__worker extension, which mounts only on the hub's machine. The hub reaches each bot's eve channel with `Authorization: Bearer $BOT_TOKEN` (`bot-token.mjs`); the kit's calls to the hub (`registry-fetch.mjs`, at `ROSTER_REGISTRY_URL`) carry `Authorization: Bearer $HUB_TOKEN` and, since the hosted hub keeps Vercel Authentication on, `x-vercel-protection-bypass: $HUB_PROTECTION_BYPASS` (the hub project's automation bypass secret), each when set.
 
@@ -72,7 +67,7 @@ The template's main gets a Vercel Sandbox and only the kit stubs that run withou
 An agent opts into the app's Kit connector with `agent/connections/vercel-kit.ts`:
 
 ```ts
-export { default } from "@hub/agent-kit/connections/vercel-kit";
+export { default } from "eve-hub/connections/vercel-kit";
 ```
 
 Set `KIT_CONNECTOR` to the returned Vercel Connect connector UID in Hub's

package/hub-path.mjs

@@ -2,7 +2,7 @@
 // a kit module knows where it is (packages/agent-kit/...). eve bundles
 // authored modules into the workspace's node_modules/.cache, where
 // import.meta.url and import.meta.dirname point into the cache; there it goes
-// through the workspace's link to the kit (node_modules/@hub/agent-kit, which
+// through the workspace's link to the kit (node_modules/eve-hub, which
 // the daemon keeps). Used for hub skills (hub-skill.mjs) and the explainer
 // package that artifact builds shell out to (artifacts/types/change-explainer.mjs).
 import { existsSync, realpathSync } from "node:fs";
@@ -17,7 +17,7 @@ const hubOf = (kitDir) => join(kitDir, "..", "..");
 export function hubPath(rel, { probe = "", env = process.env, cwd = process.cwd() } = {}) {
   const here = join(hubOf(dirname(realpathSync(fileURLToPath(import.meta.url)))), rel);
   if (existsSync(join(here, probe))) return here;
-  const link = join(findWorkspaceRoot({ env, cwd }), "node_modules", "@hub", "agent-kit");
+  const link = join(findWorkspaceRoot({ env, cwd }), "node_modules", "eve-hub");
   if (!existsSync(link)) throw new Error(`${join(rel, probe)} isn't in the hub checkout at ${here}, and the workspace has no ${link} to find it through`);
   const linked = join(hubOf(realpathSync(link)), rel);
   if (existsSync(join(linked, probe))) return linked;

package/main-instructions.mjs

@@ -16,11 +16,11 @@ const templatesOf = (kitDir) => join(kitDir, "templates");
 // The templates sit next to the kit in the hub checkout. Run by node, this
 // module knows where it is. eve evaluates instructions from a bundle in the
 // workspace's node_modules/.cache, so there it goes through the workspace's
-// link to the kit (node_modules/@hub/agent-kit, which the daemon keeps).
+// link to the kit (node_modules/eve-hub, which the daemon keeps).
 export function templatesDir({ env = process.env, cwd = process.cwd() } = {}) {
   const here = templatesOf(dirname(realpathSync(fileURLToPath(import.meta.url))));
   if (existsSync(join(here, HEAD))) return here;
-  const link = join(findWorkspaceRoot({ env, cwd }), "node_modules", "@hub", "agent-kit");
+  const link = join(findWorkspaceRoot({ env, cwd }), "node_modules", "eve-hub");
   const linked = templatesOf(realpathSync(link));
   if (existsSync(join(linked, HEAD))) return linked;
   throw new Error(`main's instruction templates aren't at ${here} or ${linked} (through ${link})`);

package/model-credential.mjs

@@ -0,0 +1,44 @@
+// Hosted bots resolve model ids through the owner's refreshable Vercel sign-in.
+// HUB_TOKEN identifies a hosted bot; the credential endpoint is on its registry.
+// The hub owns expiration and refresh; Gateway rejection invalidates our cache.
+import { createHash } from "node:crypto";
+import { GatewayAuthenticationError } from "@ai-sdk/gateway";
+import { registryHeaders } from "./registry-fetch.mjs";
+
+/**
+ * The fetch the gateway sends through: the hub's current token and team on
+ * each request, and on a 401, one more try with the token the hub hands out
+ * after it is told (by sha256) which token Gateway refused.
+ */
+export function hubGatewayFetch(credentialUrl, fetchFn = (...a) => globalThis.fetch(...a), now = Date.now) {
+  let current;
+  const credential = async (rejected) => {
+    if (!rejected && current && now() < current.expiresAt) return current;
+    const headers = registryHeaders();
+    if (rejected) headers["x-rejected-token-sha256"] = createHash("sha256").update(rejected).digest("hex");
+    const response = await fetchFn(credentialUrl, { headers });
+    if (response.status === 401) {
+      const { error } = await response.json();
+      throw new GatewayAuthenticationError({ message: error });
+    }
+    if (!response.ok) throw new Error(`model credential from the hub: HTTP ${response.status} ${await response.text()}`);
+    return (current = await response.json());
+  };
+  return async (input, init) => {
+    const headers = new Headers(init?.headers);
+    const send = async (c) => {
+      headers.set("authorization", `Bearer ${c.token}`);
+      headers.set("x-vercel-ai-gateway-team", c.teamId);
+      const response = await fetchFn(input, { ...init, headers });
+      if (response.status === 401) current = undefined;
+      return response;
+    };
+    const first = await credential();
+    const response = await send(first);
+    if (response.status !== 401) return response;
+    // A streamed body can't be sent twice, but its rejected token is dropped.
+    if (init?.body != null && typeof init.body !== "string") return response;
+    await response.body?.cancel();
+    return send(await credential(first.token));
+  };
+}

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "eve-hub",
-  "version": "0.4.0",
-  "description": "Bot-side code shared by every hub agent: registry tools, the roster hook, the eve channel, the host sandbox and browser, and model helpers.",
+  "version": "0.4.2",
   "license": "Apache-2.0",
+  "description": "Bot-side code shared by every hub agent: registry tools, the roster hook, the eve channel, the host sandbox and browser, and model helpers.",
   "type": "module",
   "exports": {
     "./package.json": "./package.json",
@@ -28,6 +28,8 @@
   },
   "peerDependencies": {
     "eve": "*",
+    "ai": "^7.0.105",
+    "@ai-sdk/gateway": "^4.0.100",
     "zod": "4.5.4",
     "@vercel/connect": "^2.4.1",
     "@vercel/oidc": "4.0.0"

package/roster-model.mjs

@@ -17,6 +17,14 @@ import { CONTEXT_WINDOW, selectModel } from "./bot-model.mjs";
 import { DEFAULT_SUBAGENT_CAP } from "./subagent-cap.mjs";
 import { sessionLimits } from "./session-limits.mjs";
 import { findWorkspaceRoot, loadWorkspace, parseWorkspace } from "./workspace.mjs";
+import { createGateway } from "ai";
+import { hubGatewayFetch } from "./model-credential.mjs";
+import { registryBase } from "./registry-fetch.mjs";
+
+// Hosted, a bot's model ids resolve through the owner's sign-in from the hub
+// (model-credential.mjs); elsewhere through the default gateway.
+if (process.env.HUB_TOKEN)
+  globalThis.AI_SDK_DEFAULT_PROVIDER = createGateway({ apiKey: "hub-owner-sign-in", fetch: hubGatewayFetch(`${registryBase().replace(/\/$/, "")}/api/model-credential`) });
 
 const real = process.env.ROSTER_MODELS !== "mock";
 

package/workspace-roster.mjs

@@ -1,8 +1,8 @@
 // A workspace bot's view of its roster (hub.workspace.json), for modules that
 // need the agent list itself, e.g. a subagent resolving its capped model:
 //
-//   import { agents, SUBAGENT_CAP } from "@hub/agent-kit/workspace-roster";
-//   import { resolveSubagent } from "@hub/agent-kit/subagent-cap";
+//   import { agents, SUBAGENT_CAP } from "eve-hub/workspace-roster";
+//   import { resolveSubagent } from "eve-hub/subagent-cap";
 //
 // Read once, at
 // import (compile) time; see roster-model.mjs for how the file is found.