@stage-labs/metro 0.1.0-beta.30 → 0.1.0-beta.32

package/runtime/node_modules/@metro-labs/mcp/src/db/file-source.ts

@@ -0,0 +1,152 @@
+import { existsSync, readdirSync, readFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { AGENT_NAME_RE, ID_RE } from './ids.js';
+import { STATIONS, type StationName } from './schema.js';
+import type { LoadedAccount, LoadedAgent, StationSource } from './materialize.js';
+
+export const AGENT_FILE = 'agent.json';
+
+const KEY_RE = /^mk_[A-Za-z0-9_-]{43}$/;
+const ADDRESS_RE = /^0x[0-9a-f]{40}$/;
+const STATION_NAMES = new Set<string>(STATIONS);
+
+export class AgentFileError extends Error {}
+
+export interface AgentFile {
+  version: 1;
+  id: string;
+  name: string;
+  key: string | null;
+  owner: string | null;
+  stations: LoadedAccount[];
+}
+
+export function agentsDir(): string {
+  const explicit = process.env.METRO_AGENTS_DIR?.trim();
+  return explicit !== undefined && explicit !== ''
+    ? explicit
+    : join(homedir(), '.metro', 'agents');
+}
+
+const isRecord = (v: unknown): v is Record<string, unknown> =>
+  typeof v === 'object' && v !== null && !Array.isArray(v);
+
+function fail(path: string, reason: string): never {
+  throw new AgentFileError(`${path}: ${reason}`);
+}
+
+function isStationName(value: unknown): value is StationName {
+  return typeof value === 'string' && STATION_NAMES.has(value);
+}
+
+function allowlistOf(raw: unknown, path: string, where: string): string[] | null {
+  if (raw === null || raw === undefined) return null;
+  if (!Array.isArray(raw)) fail(path, `${where}.allowlist is not a list of strings`);
+  const list = raw.filter((entry): entry is string => typeof entry === 'string');
+  if (list.length !== raw.length)
+    fail(path, `${where}.allowlist is not a list of strings`);
+  return list;
+}
+
+function stationOf(raw: unknown, path: string, index: number): LoadedAccount {
+  const where = `stations[${String(index)}]`;
+  if (!isRecord(raw)) fail(path, `${where} is not an object`);
+  const { station, id, config } = raw;
+  if (!isStationName(station)) fail(path, `${where}.station is not a known station`);
+  if (typeof id !== 'string' || !ID_RE.test(id))
+    fail(path, `${where}.id is not an 11-character id`);
+  if (!isRecord(config)) fail(path, `${where}.config is not an object`);
+  return { station, id, allowlist: allowlistOf(raw.allowlist, path, where), config };
+}
+
+function optionalMatch(
+  value: unknown,
+  re: RegExp,
+  path: string,
+  what: string,
+): string | null {
+  if (value === null || value === undefined) return null;
+  if (typeof value !== 'string' || !re.test(value)) fail(path, what);
+  return value;
+}
+
+export function parseAgentFile(raw: string, path: string): AgentFile {
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    fail(path, 'is not valid JSON');
+  }
+  if (!isRecord(parsed)) fail(path, 'is not a JSON object');
+  if (parsed.version !== 1) fail(path, 'version must be 1');
+  const { id, name, stations } = parsed;
+  if (typeof id !== 'string' || !ID_RE.test(id))
+    fail(path, 'id is not an 11-character id');
+  if (typeof name !== 'string' || !AGENT_NAME_RE.test(name))
+    fail(path, 'name is not a valid agent name');
+  const key = optionalMatch(parsed.key, KEY_RE, path, 'key is not an mk_ key');
+  const owner = optionalMatch(
+    parsed.owner,
+    ADDRESS_RE,
+    path,
+    'owner is not a lowercase Ethereum address',
+  );
+  if (!Array.isArray(stations)) fail(path, 'stations is not a list');
+  return {
+    version: 1,
+    id,
+    name,
+    key,
+    owner,
+    stations: stations.map((s, i) => stationOf(s, path, i)),
+  };
+}
+
+export function readAgentFile(path: string): AgentFile {
+  let raw: string;
+  try {
+    raw = readFileSync(path, 'utf8');
+  } catch {
+    fail(path, 'cannot be read');
+  }
+  return parseAgentFile(raw, path);
+}
+
+export function listAgentFiles(dir = agentsDir()): string[] {
+  if (!existsSync(dir)) return [];
+  return readdirSync(dir, { withFileTypes: true })
+    .filter((entry) => entry.isDirectory())
+    .map((entry) => join(dir, entry.name, AGENT_FILE))
+    .filter((path) => existsSync(path))
+    .sort();
+}
+
+function assertUnique(agents: AgentFile[], paths: string[]): void {
+  const ids = new Map<string, string>();
+  const keys = new Map<string, string>();
+  agents.forEach((agent, i) => {
+    const path = paths[i] ?? '';
+    const sameId = ids.get(agent.id);
+    if (sameId !== undefined) fail(path, `id ${agent.id} is already used by ${sameId}`);
+    ids.set(agent.id, path);
+    if (agent.key === null) return;
+    const sameKey = keys.get(agent.key);
+    if (sameKey !== undefined) fail(path, `its key is already used by ${sameKey}`);
+    keys.set(agent.key, path);
+  });
+}
+
+export function loadFileAgents(dir = agentsDir()): LoadedAgent[] {
+  const paths = listAgentFiles(dir);
+  const agents = paths.map(readAgentFile);
+  assertUnique(agents, paths);
+  return agents.map((agent) => ({
+    id: agent.id,
+    name: agent.name,
+    key: agent.key,
+    accounts: agent.stations,
+  }));
+}
+
+export const fileSource: StationSource = () => Promise.resolve(loadFileAgents());

package/runtime/node_modules/@metro-labs/mcp/src/db/ids.ts

@@ -17,3 +17,5 @@ export function parseId(raw: unknown): string | null {
   if (typeof raw !== 'string') return null;
   return ID_RE.test(raw) ? raw : null;
 }
+
+export const AGENT_NAME_RE = /^[A-Za-z0-9][A-Za-z0-9_-]{1,31}$/;

package/runtime/node_modules/@metro-labs/mcp/src/db/materialize.ts

@@ -11,6 +11,7 @@ import { join } from 'node:path';
 import { eq } from 'drizzle-orm';
 import { log } from '../daemon/log.js';
 import { writeSecure } from '../daemon/secure-fs.js';
+import { isLocalMode, trainsDir } from '../daemon/paths.js';
 import { closeDb, databaseUrl, getDb } from './client.js';
 import {
   setAgentMap,
@@ -44,7 +45,6 @@ export interface LoadedAgent {
 }
 
 const METRO_DIR = join(homedir(), '.metro');
-const TRAINS_DIR = process.env.METRO_TRAINS_DIR ?? join(METRO_DIR, 'trains');
 
 const STATION_TARGETS: Record<StationName, StationTarget> = {
   xmtp: {
@@ -209,7 +209,7 @@ function trainConfig(
 }
 
 function trainStubPath(station: StationName): string {
-  return join(TRAINS_DIR, `${station}.ts`);
+  return join(trainsDir(), `${station}.ts`);
 }
 
 function currentText(path: string): string | null {
@@ -230,7 +230,7 @@ export const isLocalRuntime = (): boolean =>
   (process.env.METRO_RUN_TOKEN?.trim() ?? '') !== '';
 
 export const stationRunsHere = (station: StationName): boolean =>
-  isLocalRuntime() || !MOVABLE_STATIONS.has(station);
+  isLocalRuntime() || isLocalMode() || !MOVABLE_STATIONS.has(station);
 
 interface WrittenStations {
   active: Map<StationName, number>;
@@ -239,7 +239,7 @@ interface WrittenStations {
 
 function writeStations(list: LoadedAgent[]): WrittenStations {
   mkdirSync(METRO_DIR, { recursive: true });
-  mkdirSync(TRAINS_DIR, { recursive: true });
+  mkdirSync(trainsDir(), { recursive: true });
 
   const byStation = new Map<StationName, LoadedAccount[]>();
   const map: AgentMap = {};
@@ -331,12 +331,21 @@ async function loadAndWrite(
   return { ...writeStations(list), agents: list.length };
 }
 
-export async function materializeFrom(source: StationSource): Promise<void> {
+export interface MaterializeOptions {
+  allowEmpty?: boolean;
+}
+
+export async function materializeFrom(
+  source: StationSource,
+  opts: MaterializeOptions = {},
+): Promise<void> {
   const { active, agents: found } = await loadAndWrite(source);
 
-  if (found === 0) throw new Error('no agents found — nothing to materialize');
+  if (found === 0 && opts.allowEmpty !== true)
+    throw new Error('no agents found — nothing to materialize');
+  const removed = pruneStations(active);
   log.info(
-    { stations: stationLabels(active), agents: found },
+    { stations: stationLabels(active), agents: found, removed },
     'materialized station accounts',
   );
 }

package/runtime/node_modules/@metro-labs/mcp/src/db/projects.ts

@@ -1,4 +1,8 @@
-import { ensureUser, normalizeEmail, userIdForEmail } from './users.js';
+import {
+  ensureUserByAddress,
+  normalizeAddress,
+  userIdForSubject,
+} from './users.js';
 import { and, asc, eq } from 'drizzle-orm';
 import { ApiError } from '../daemon/api-error.js';
 import { getDb } from './client.js';
@@ -17,7 +21,8 @@ export interface Project {
 
 export interface Member {
   id: string;
-  email: string;
+  address: string | null;
+  email: string | null;
   role: ProjectRole;
   owner: boolean;
 }
@@ -50,10 +55,10 @@ export interface Access {
 }
 
 export async function memberAccessOrThrow(
-  email: string,
+  subject: string,
   projectId: string,
 ): Promise<Access> {
-  const userId = await userIdForEmail(email);
+  const userId = await userIdForSubject(subject);
   if (userId === null) throw missing();
   const rows = await getDb()
     .select({
@@ -79,10 +84,10 @@ export async function memberAccessOrThrow(
 }
 
 export async function projectIdOrThrow(
-  email: string,
+  subject: string,
   projectId: string,
 ): Promise<string> {
-  return (await memberAccessOrThrow(email, projectId)).projectId;
+  return (await memberAccessOrThrow(subject, projectId)).projectId;
 }
 
 async function addMemberRow(
@@ -111,14 +116,14 @@ export async function ensureDefaultProject(userId: string): Promise<string> {
   return id;
 }
 
-export async function ensureUserWithProject(rawEmail: string): Promise<string> {
-  const userId = await ensureUser(rawEmail);
+export async function ensureUserWithProject(address: string): Promise<string> {
+  const userId = await ensureUserByAddress(address);
   await ensureDefaultProject(userId);
   return userId;
 }
 
-export async function listProjectsForEmail(email: string): Promise<Project[]> {
-  const userId = await userIdForEmail(email);
+export async function listProjectsForUser(subject: string): Promise<Project[]> {
+  const userId = await userIdForSubject(subject);
   if (userId === null) return [];
   const rows = await getDb()
     .select({
@@ -141,25 +146,26 @@ export async function listProjectsForEmail(email: string): Promise<Project[]> {
   }));
 }
 
-export async function createProjectForEmail(
-  email: string,
+export async function createProjectForUser(
+  subject: string,
   raw: unknown,
 ): Promise<Project> {
   const name = projectName(raw);
-  const userId = await ensureUser(email);
+  const userId = await userIdForSubject(subject);
+  if (userId === null) throw new ProjectError('unknown account', 401);
   const id = newId();
   await getDb().insert(projects).values({ id, name, ownerId: userId });
   await addMemberRow(id, userId, 'admin');
   return { id, name, isDefault: false, owner: true, role: 'admin' };
 }
 
-export async function renameProjectForEmail(
-  email: string,
+export async function renameProjectForUser(
+  subject: string,
   projectId: string,
   raw: unknown,
 ): Promise<Project> {
   const name = projectName(raw);
-  const access = await memberAccessOrThrow(email, projectId);
+  const access = await memberAccessOrThrow(subject, projectId);
   if (access.role !== 'admin')
     throw forbidden('only an admin can rename a project');
   await getDb()
@@ -175,11 +181,11 @@ export async function renameProjectForEmail(
   };
 }
 
-export async function deleteProjectForEmail(
-  email: string,
+export async function deleteProjectForUser(
+  subject: string,
   projectId: string,
 ): Promise<{ id: string; name: string }> {
-  const access = await memberAccessOrThrow(email, projectId);
+  const access = await memberAccessOrThrow(subject, projectId);
   if (access.ownerId !== access.userId)
     throw forbidden('only the owner can delete a project');
   if (access.isDefault)
@@ -188,21 +194,22 @@ export async function deleteProjectForEmail(
     await getDb().delete(projects).where(eq(projects.id, access.projectId));
   } catch {
     throw new ProjectError(
-      'this project still holds agents, connectors or collections',
+      'this project still holds agents or connectors',
       409,
     );
   }
   return { id: access.projectId, name: access.name };
 }
 
-export async function listMembersForEmail(
-  email: string,
+export async function listMembersForUser(
+  subject: string,
   projectId: string,
 ): Promise<Member[]> {
-  const access = await memberAccessOrThrow(email, projectId);
+  const access = await memberAccessOrThrow(subject, projectId);
   const rows = await getDb()
     .select({
       id: projectMembers.id,
+      address: users.address,
       email: users.email,
       role: projectMembers.role,
       userId: projectMembers.userId,
@@ -213,6 +220,7 @@ export async function listMembersForEmail(
     .orderBy(asc(projectMembers.id));
   return rows.map((r) => ({
     id: r.id,
+    address: r.address,
     email: r.email,
     role: r.role,
     owner: r.userId === access.ownerId,
@@ -225,29 +233,30 @@ function readRole(raw: unknown): ProjectRole {
 }
 
 async function adminAccessOrThrow(
-  email: string,
+  subject: string,
   projectId: string,
 ): Promise<Access> {
-  const access = await memberAccessOrThrow(email, projectId);
+  const access = await memberAccessOrThrow(subject, projectId);
   if (access.role !== 'admin')
     throw forbidden('only an admin can manage members');
   return access;
 }
 
-export async function addMemberForEmail(
-  email: string,
+export async function addMemberForUser(
+  subject: string,
   projectId: string,
   raw: unknown,
   rawRole: unknown,
 ): Promise<Member[]> {
-  const access = await adminAccessOrThrow(email, projectId);
+  const access = await adminAccessOrThrow(subject, projectId);
   const role = readRole(rawRole);
-  const invited = normalizeEmail(typeof raw === 'string' ? raw : '');
-  if (invited === '') throw new ProjectError('an email is required', 400);
-  const invitedId = await ensureUser(invited);
+  const invited = normalizeAddress(typeof raw === 'string' ? raw : '');
+  if (invited === null)
+    throw new ProjectError('an Ethereum address is required', 400);
+  const invitedId = await ensureUserByAddress(invited);
   await ensureDefaultProject(invitedId);
   await addMemberRow(access.projectId, invitedId, role);
-  return listMembersForEmail(email, projectId);
+  return listMembersForUser(subject, projectId);
 }
 
 async function memberRowOrThrow(
@@ -268,13 +277,13 @@ async function memberRowOrThrow(
   return row;
 }
 
-export async function setMemberRoleForEmail(
-  email: string,
+export async function setMemberRoleForUser(
+  subject: string,
   projectId: string,
   memberId: string,
   rawRole: unknown,
 ): Promise<Member[]> {
-  const access = await adminAccessOrThrow(email, projectId);
+  const access = await adminAccessOrThrow(subject, projectId);
   const role = readRole(rawRole);
   const member = await memberRowOrThrow(access.projectId, memberId);
   if (member.userId === access.ownerId)
@@ -283,18 +292,18 @@ export async function setMemberRoleForEmail(
     .update(projectMembers)
     .set({ role })
     .where(eq(projectMembers.id, memberId));
-  return listMembersForEmail(email, projectId);
+  return listMembersForUser(subject, projectId);
 }
 
-export async function removeMemberForEmail(
-  email: string,
+export async function removeMemberForUser(
+  subject: string,
   projectId: string,
   memberId: string,
 ): Promise<Member[]> {
-  const access = await adminAccessOrThrow(email, projectId);
+  const access = await adminAccessOrThrow(subject, projectId);
   const member = await memberRowOrThrow(access.projectId, memberId);
   if (member.userId === access.ownerId)
     throw forbidden('the owner cannot be removed from their own project');
   await getDb().delete(projectMembers).where(eq(projectMembers.id, memberId));
-  return listMembersForEmail(email, projectId);
+  return listMembersForUser(subject, projectId);
 }

package/runtime/node_modules/@metro-labs/mcp/src/db/runtime-admin.ts

@@ -1,31 +1,24 @@
 import { ownedAgentOrThrow } from './agent-admin.js';
-import { ApiError } from '../daemon/api-error.js';
-import { mintRunCode } from '../daemon/run-pair.js';
+import { mintAgentCode } from '../daemon/agent-pair.js';
 import { loadAllStationsFor, unmovableStations } from './materialize.js';
 import { releaseRuntime } from './runtimes.js';
 
-export async function mintRuntimeCodeForEmail(
-  email: string,
+export async function mintAgentCodeForUser(
+  subject: string,
   agentId: string,
-): Promise<{ code: string; expiresAt: number }> {
-  const { agent } = await ownedAgentOrThrow(email, agentId);
-  const blocked = unmovableStations(await loadAllStationsFor(agent.id));
-  if (blocked.length > 0)
-    throw new ApiError(
-      `'${agent.name}' holds ${blocked.join(', ')}, which only runs on metro ` +
-        'because a webhook url has to be publicly reachable. Its deliveries ' +
-        'would arrive at metro while this agent listens on your machine, so ' +
-        'they would be dropped. Detach it, or attach it to a second agent that ' +
-        'stays on metro, then authorize this one.',
-      409,
-    );
-  return mintRunCode({ email, agentId: agent.id });
+): Promise<{ code: string; expiresAt: number; agent: string }> {
+  const { agent } = await ownedAgentOrThrow(subject, agentId);
+  return { ...mintAgentCode({ subject, agentId: agent.id }), agent: agent.name };
 }
 
-export async function releaseRuntimeForEmail(
-  email: string,
+export async function blockedStationsFor(agentId: string): Promise<string[]> {
+  return unmovableStations(await loadAllStationsFor(agentId));
+}
+
+export async function releaseRuntimeForUser(
+  subject: string,
   agentId: string,
 ): Promise<void> {
-  const { agent } = await ownedAgentOrThrow(email, agentId);
+  const { agent } = await ownedAgentOrThrow(subject, agentId);
   await releaseRuntime(agent.id);
 }

package/runtime/node_modules/@metro-labs/mcp/src/db/schema.ts

@@ -19,7 +19,8 @@ export type StationName = (typeof STATIONS)[number];
 
 export const users = pgTable('users', {
   id: text('id').primaryKey(),
-  email: text('email').notNull().unique(),
+  email: text('email').unique(),
+  address: text('address').unique(),
 });
 
 export const PROJECT_ROLES = ['admin', 'member'] as const;
@@ -97,34 +98,20 @@ export const connectors = pgTable(
   },
 );
 
-export const collections = pgTable(
-  'collections',
+export const agentConnectors = pgTable(
+  'agent_connectors',
   {
     id: text('id').primaryKey(),
-    projectId: text('project_id')
-      .notNull()
-      .references(() => projects.id, { onDelete: 'restrict' }),
-    name: text('name').notNull(),
-  },
-  (t) => [
-    unique('collections_project_id_name_unique').on(t.projectId, t.name),
-  ],
-);
-
-export const collectionItems = pgTable(
-  'collection_items',
-  {
-    id: text('id').primaryKey(),
-    collectionId: text('collection_id')
+    agentId: text('agent_id')
       .notNull()
-      .references(() => collections.id, { onDelete: 'cascade' }),
+      .references(() => agents.id, { onDelete: 'cascade' }),
     connectorId: text('connector_id')
       .notNull()
       .references(() => connectors.id, { onDelete: 'cascade' }),
   },
   (t) => [
-    unique('collection_items_collection_id_connector_id_unique').on(
-      t.collectionId,
+    unique('agent_connectors_agent_id_connector_id_unique').on(
+      t.agentId,
       t.connectorId,
     ),
   ],

package/runtime/node_modules/@metro-labs/mcp/src/db/users.ts

@@ -1,34 +1,47 @@
-import { eq } from 'drizzle-orm';
+import { eq, type SQL } from 'drizzle-orm';
 import { ApiError } from '../daemon/api-error.js';
 import { getDb } from './client.js';
 import { newId } from './ids.js';
 import { users } from './schema.js';
 
 const UNIQUE_VIOLATION = '23505';
+const ADDRESS_RE = /^0x[0-9a-f]{40}$/;
 
 export class UserError extends ApiError {}
 
+const CAUSE_DEPTH = 5;
+
 export function isUniqueViolation(err: unknown): boolean {
-  return (
-    typeof err === 'object' &&
-    err !== null &&
-    (err as { code?: unknown }).code === UNIQUE_VIOLATION
-  );
+  let current: unknown = err;
+  for (let depth = 0; depth < CAUSE_DEPTH; depth += 1) {
+    if (typeof current !== 'object' || current === null) return false;
+    const { code, cause } = current as { code?: unknown; cause?: unknown };
+    if (code === UNIQUE_VIOLATION) return true;
+    current = cause;
+  }
+  return false;
 }
 
 export function normalizeEmail(raw: string): string {
   return raw.trim().toLowerCase();
 }
 
-export async function userIdForEmail(rawEmail: string): Promise<string | null> {
-  const email = normalizeEmail(rawEmail);
-  const rows = await getDb()
-    .select({ id: users.id })
-    .from(users)
-    .where(eq(users.email, email));
+export function normalizeAddress(raw: string): string | null {
+  const address = raw.trim().toLowerCase();
+  return ADDRESS_RE.test(address) ? address : null;
+}
+
+async function userIdWhere(where: SQL): Promise<string | null> {
+  const rows = await getDb().select({ id: users.id }).from(users).where(where);
   return rows[0]?.id ?? null;
 }
 
+export async function userIdForSubject(subject: string): Promise<string | null> {
+  const address = normalizeAddress(subject);
+  if (address !== null) return userIdWhere(eq(users.address, address));
+  return userIdWhere(eq(users.email, normalizeEmail(subject)));
+}
+
 export async function resolveUserId(
   insert: () => Promise<string | undefined>,
   lookup: () => Promise<string | null>,
@@ -41,17 +54,19 @@ export async function resolveUserId(
   return existing;
 }
 
-export async function ensureUser(rawEmail: string): Promise<string> {
-  const email = normalizeEmail(rawEmail);
+export async function ensureUserByAddress(raw: string): Promise<string> {
+  const address = normalizeAddress(raw);
+  if (address === null)
+    throw new UserError('an Ethereum address is required', 400);
   return resolveUserId(
     async () => {
       const rows = await getDb()
         .insert(users)
-        .values({ id: newId(), email })
-        .onConflictDoNothing({ target: users.email })
+        .values({ id: newId(), address })
+        .onConflictDoNothing({ target: users.address })
         .returning({ id: users.id });
       return rows[0]?.id;
     },
-    () => userIdForEmail(email),
+    () => userIdWhere(eq(users.address, address)),
   );
 }

package/runtime/node_modules/@metro-labs/mcp/src/mcp/request-identity.ts

@@ -5,7 +5,7 @@ import { agentIdForKey } from '../db/key-map.js';
 
 export type RequestIdentity =
   | { kind: 'agent'; agentId: string }
-  | { kind: 'google'; email: string; agentIds: string[] };
+  | { kind: 'session'; subject: string; agentIds: string[] };
 
 const storage = new AsyncLocalStorage<RequestIdentity>();
 
@@ -55,8 +55,8 @@ export function authenticate(
 
   if (cfg.sessionSecret !== '' && looksLikeJwt(token)) {
     try {
-      const { email, agentIds } = verifySession(token, cfg.sessionSecret);
-      return { kind: 'google', email, agentIds };
+      const { subject, agentIds } = verifySession(token, cfg.sessionSecret);
+      return { kind: 'session', subject, agentIds };
     } catch {
       return null;
     }
@@ -67,7 +67,7 @@ export function authenticate(
 export function allowedAgents(
   identity: RequestIdentity | undefined,
 ): Set<string> {
-  if (identity?.kind === 'google') return new Set(identity.agentIds);
+  if (identity?.kind === 'session') return new Set(identity.agentIds);
   if (identity?.kind === 'agent') return new Set([identity.agentId]);
   return new Set();
 }

package/runtime/node_modules/@metro-labs/mcp/src/mcp/session-route.ts

@@ -3,7 +3,7 @@ import { allowedAgents, type RequestIdentity } from './request-identity.js';
 export function sessionScopeKey(identity: RequestIdentity): string {
   const ids = [...allowedAgents(identity)].sort();
   if (ids.length > 0) return `${AGENTS_PREFIX}${ids.join(',')}`;
-  return `email:${identity.kind === 'google' ? identity.email : identity.agentId}`;
+  return `user:${identity.kind === 'session' ? identity.subject : identity.agentId}`;
 }
 
 const AGENTS_PREFIX = 'agents:';

package/runtime/runtime.json

@@ -1,3 +1,3 @@
 {
-  "version": "0.1.0-beta.30"
+  "version": "0.1.0-beta.32"
 }