@vibevibes/mcp 0.4.1 → 0.6.0

package/dist/index.js

@@ -316,11 +316,9 @@ and returns available tools, current state, participants, and the browser URL.
 
 Call this first, then use act to interact. The stop hook keeps you present.`, {
     url: z.string().optional().describe("Server URL to connect to. Defaults to the MCP server's configured URL."),
-    role: z.string().optional().describe("Preferred participant slot role to request (e.g. 'Blue Tank', 'Red ADC'). Server assigns the first available slot if omitted."),
-    subscription: z.enum(["all", "phase"]).optional().describe("Event subscription mode. 'all' (default) wakes on every event. 'phase' wakes only on phase changes — use for orchestrator agents."),
-    agentMode: z.enum(["behavior", "manual", "hybrid"]).optional().describe("Agent operating mode. 'behavior': autonomous via tick engine (no stop hook). 'manual': all decisions via act(). 'hybrid' (default): both behaviors and act()."),
-    metadata: z.record(z.string()).optional().describe("Arbitrary metadata (model, team, tags). Flows to server and viewer. E.g. { model: 'haiku', team: 'blue' }"),
-}, async ({ url, role: requestedRole, subscription, agentMode, metadata }) => {
+    role: z.string().optional().describe("Preferred participant slot role to request."),
+    metadata: z.record(z.string()).optional().describe("Arbitrary metadata. Flows to server and viewer."),
+}, async ({ url, role: requestedRole, metadata }) => {
     try {
         if (url) {
             SERVER_URL = url.replace(/\/$/, "");
@@ -381,8 +379,6 @@ Call this first, then use act to interact. The stop hook keeps you present.`, {
             const joinBody = { username: id, actorType: "ai", owner: id };
             if (requestedRole)
                 joinBody.role = requestedRole;
-            if (agentMode)
-                joinBody.agentMode = agentMode;
             if (metadata && Object.keys(metadata).length > 0)
                 joinBody.metadata = metadata;
             joinData = await fetchJSON("/join", {
@@ -403,12 +399,6 @@ Call this first, then use act to interact. The stop hook keeps you present.`, {
                 actorId: joinData.actorId,
                 role: joinData.role || undefined,
             };
-            if (subscription && subscription !== "all") {
-                sessionData.subscription = subscription;
-            }
-            if (agentMode) {
-                sessionData.agentMode = agentMode;
-            }
             writeFileSync(resolve(AGENTS_DIR, `${id}.json`), JSON.stringify(sessionData, null, 2));
             identity = { actorId: joinData.actorId, owner: id, id };
             currentActorId = joinData.actorId;
@@ -475,16 +465,7 @@ Call this first, then use act to interact. The stop hook keeps you present.`, {
         if (unfilledSlots.length > 0) {
             outputParts.push(`UNFILLED AI SLOTS (autoSpawn):`, ...unfilledSlots.map(s => `  - ${s.role} (max ${s.maxInstances ?? 1})`), ``, `These roles need AI agents. Spawn independent teammates — each gets its own MCP session and identity.`, `  Agent(subagent_type="general-purpose", model="sonnet", run_in_background=true,`, `    prompt="Call connect with role='ROLE'. Then play your role.")`, ``);
         }
-        // Mode-specific instructions
-        if (agentMode === "behavior") {
-            outputParts.push(`BEHAVIOR MODE:`, `  You are a behavior-only agent. All actions run autonomously via the tick engine.`, `  No stop hook — you will NOT receive wake-up events.`, `  Set up behaviors now, then disconnect. The tick engine runs them automatically.`, ``);
-        }
-        else if (agentMode === "manual") {
-            outputParts.push(`MANUAL MODE:`, `  You are a manual agent. Use act() for all decisions. No behaviors.`, `  The stop hook keeps you present — use act to interact.`, `  Use act() to interact. The stop hook keeps you present.`, ``);
-        }
-        else {
-            outputParts.push(`FAST BRAIN / SLOW BRAIN:`, `  Fast brain: Register behaviors via _behavior.set for reactive, per-tick actions that run automatically.`, `  Slow brain: Use act() for strategic decisions and adapting to new situations.`, `  Set up your fast brain FIRST, then use your slow brain to observe and adapt.`, `  Use act() to interact. The stop hook keeps you present.`, ``, `You are now a live participant. The stop hook keeps you present — use act to interact.`);
-        }
+        outputParts.push(`Use act() to interact. The stop hook keeps you present.`);
         // Register the stop hook so Claude Code wakes us on events
         ensureStopHook();
         return { content: [{ type: "text", text: outputParts.filter(Boolean).join("\n") }] };

package/dist/server.js

@@ -15,8 +15,6 @@ import { ZodError } from "zod";
 import { EventEmitter } from "events";
 import { bundleForServer, bundleForClient, evalServerBundle, validateClientBundle } from "./bundler.js";
 import { zodToJsonSchema } from "zod-to-json-schema";
-import { TickEngine } from "./tick-engine.js";
-import { isProtocolExperience, loadProtocolManifest, createProtocolModule, SubprocessExecutor } from "./protocol.js";
 function formatZodError(err, toolName, tool) {
     const issues = err.issues.map((issue) => {
         const path = issue.path.length > 0 ? `'${issue.path.join(".")}'` : "input";
@@ -195,8 +193,6 @@ class Room {
             const detail = {
                 actorId, type: p.type, role: p.role, owner: p.owner,
             };
-            if (p.agentMode)
-                detail.agentMode = p.agentMode;
             if (p.metadata && Object.keys(p.metadata).length > 0)
                 detail.metadata = p.metadata;
             return detail;
@@ -224,7 +220,6 @@ const HISTORY_MAX_LIMIT = 200;
 const DEFAULT_STREAM_RATE_LIMIT = 60;
 const STREAM_RATE_WINDOW_MS = 1000;
 const EVENT_BATCH_DEBOUNCE_MS = 50;
-const DEFAULT_TICK_RATE_MS = 50;
 const MAX_BATCH_CALLS = 10;
 const LONG_POLL_MAX_TIMEOUT_MS = 55000;
 const AGENT_CONTEXT_MAX_TIMEOUT_MS = 10000;
@@ -255,7 +250,6 @@ function defaultObserve(state, _event, _actorId) {
 let PORT = parseInt(process.env.PORT || String(DEFAULT_PORT), 10);
 let publicUrl = null;
 let room;
-let tickEngine = null;
 let _actorCounter = 0;
 const roomEvents = new EventEmitter();
 roomEvents.setMaxListeners(ROOM_EVENTS_MAX_LISTENERS);
@@ -347,9 +341,6 @@ function experienceNotLoadedError() {
 }
 // ── Experience discovery & loading ──────────────────────────
 function discoverEntryPath() {
-    const manifestPath = path.join(PROJECT_ROOT, "manifest.json");
-    if (fs.existsSync(manifestPath))
-        return manifestPath;
     const tsxPath = path.join(PROJECT_ROOT, "src", "index.tsx");
     if (fs.existsSync(tsxPath))
         return tsxPath;
@@ -357,15 +348,10 @@ function discoverEntryPath() {
     if (fs.existsSync(rootTsx))
         return rootTsx;
     throw new Error(`No experience found in ${PROJECT_ROOT}. ` +
-        `Create a manifest.json (protocol) or src/index.tsx (TypeScript).`);
+        `Create src/index.tsx (TypeScript).`);
 }
-const protocolExecutors = new Map();
 async function loadExperience() {
     const entryPath = discoverEntryPath();
-    if (isProtocolExperience(entryPath)) {
-        await loadProtocolExperience(entryPath);
-        return;
-    }
     const [sCode, cCode] = await Promise.all([
         bundleForServer(entryPath),
         bundleForClient(entryPath),
@@ -387,48 +373,6 @@ async function loadExperience() {
     };
     experienceError = null;
 }
-async function loadProtocolExperience(manifestPath) {
-    const manifestDir = path.dirname(manifestPath);
-    const manifest = loadProtocolManifest(manifestPath);
-    const existing = protocolExecutors.get(manifest.id);
-    if (existing)
-        existing.stop();
-    const executor = new SubprocessExecutor(manifest.toolProcess.command, manifest.toolProcess.args || [], manifestDir);
-    executor.start();
-    protocolExecutors.set(manifest.id, executor);
-    try {
-        await executor.send("init", { experienceId: manifest.id }, 5000);
-    }
-    catch { }
-    const mod = createProtocolModule(manifest, executor, manifestDir);
-    loadedExperience = {
-        module: mod,
-        clientBundle: "",
-        serverCode: JSON.stringify(manifest),
-        loadedAt: Date.now(),
-        sourcePath: manifestPath,
-    };
-    experienceError = null;
-    console.log(`[protocol] Loaded ${manifest.title} (${manifest.id}) — ${manifest.tools.length} tools`);
-}
-// ── Tick Engine lifecycle ──────────────────────────────────
-function maybeStartTickEngine() {
-    if (!loadedExperience)
-        return;
-    const manifest = loadedExperience.module?.manifest;
-    if (manifest?.netcode !== "tick")
-        return;
-    stopTickEngine();
-    const tickRateMs = manifest.tickRateMs || DEFAULT_TICK_RATE_MS;
-    tickEngine = new TickEngine(room, loadedExperience, roomEvents, tickRateMs);
-    tickEngine.start();
-}
-function stopTickEngine() {
-    if (tickEngine) {
-        tickEngine.stop();
-        tickEngine = null;
-    }
-}
 // ── Express app ────────────────────────────────────────────
 const app = express();
 app.use(express.json({ limit: JSON_BODY_LIMIT }));
@@ -581,11 +525,9 @@ app.post("/join", (req, res) => {
         res.status(500).json({ error: experienceNotLoadedError() });
         return;
     }
-    const { username = "user", actorType: rawActorType = "human", owner, role: requestedRole, agentMode: rawAgentMode, metadata: rawMetadata } = req.body;
+    const { username = "user", actorType: rawActorType = "human", owner, role: requestedRole, metadata: rawMetadata } = req.body;
     const actorType = rawActorType === "ai" ? "ai" : "human";
     const resolvedOwner = owner || username;
-    const VALID_AGENT_MODES = ["behavior", "manual", "hybrid"];
-    const agentMode = actorType === "ai" && typeof rawAgentMode === "string" && VALID_AGENT_MODES.includes(rawAgentMode) ? rawAgentMode : undefined;
     let metadata;
     if (rawMetadata && typeof rawMetadata === "object" && !Array.isArray(rawMetadata)) {
         metadata = {};
@@ -719,8 +661,6 @@ app.post("/join", (req, res) => {
         participant.systemPrompt = slotSystemPrompt;
     if (!slotRole && requestedRole)
         participant.role = requestedRole;
-    if (agentMode)
-        participant.agentMode = agentMode;
     if (metadata)
         participant.metadata = metadata;
     room.participants.set(actorId, participant);
@@ -925,11 +865,6 @@ async function executeTool(toolName, actorId, input = {}, owner, expiredFlag) {
         observation,
     });
     roomEvents.emit("room");
-    const baseTool = toolName.includes(':') ? toolName.split(':').pop() : toolName;
-    if (baseTool.startsWith("_behavior.")) {
-        if (tickEngine)
-            tickEngine.markDirty();
-    }
     return { tool: toolName, output, observation };
 }
 // ── Single tool HTTP endpoint ───────────────────────────────
@@ -1197,8 +1132,6 @@ app.get("/agent-context", (req, res) => {
         return room.events.filter(e => {
             if (requestingOwner && e.owner === requestingOwner)
                 return false;
-            if (e.actorId === "_tick-engine" || e.owner === "_system")
-                return false;
             return e.ts > since;
         }).sort((a, b) => a.ts - b.ts);
     };
@@ -1250,7 +1183,6 @@ app.get("/agent-context", (req, res) => {
             lastError,
             browserErrors: recentBrowserErrors.length > 0 ? recentBrowserErrors : undefined,
             participants: room.participantList(),
-            tickEngine: tickEngine ? { enabled: true, tickCount: tickEngine.getStatus().tickCount } : undefined,
             eventCursor,
         };
     };
@@ -1394,10 +1326,8 @@ app.post("/reset", (_req, res) => {
 // ── Sync (re-bundle) ──────────────────────────────────────
 app.post("/sync", async (_req, res) => {
     try {
-        stopTickEngine();
         await loadExperience();
         room.broadcastToAll({ type: "experience_updated" });
-        maybeStartTickEngine();
         const mod = getModule();
         res.json({ synced: true, title: mod?.manifest?.title });
     }
@@ -1422,14 +1352,6 @@ app.get("/experiences", async (_req, res) => {
             tags: mod.manifest.tags,
         }]);
 });
-// ── Tick status ────────────────────────────────────────────
-app.get("/tick-status", (_req, res) => {
-    if (!tickEngine) {
-        res.json({ enabled: false, tickRateMs: 0, tickCount: 0, behaviorsTotal: 0, behaviorsEnabled: 0, lastTick: null });
-        return;
-    }
-    res.json(tickEngine.getStatus());
-});
 // ── MCP config ─────────────────────────────────────────────
 app.get("/mcp-config", (_req, res) => {
     const serverUrl = getBaseUrl();
@@ -1447,21 +1369,6 @@ app.get("/mcp-config", (_req, res) => {
         ],
     });
 });
-// ── Protocol experience HTML canvas ───────────────────────
-app.get("/canvas", async (_req, res) => {
-    if (!loadedExperience) {
-        res.status(500).json({ error: experienceNotLoadedError() });
-        return;
-    }
-    const canvasPath = loadedExperience.module?._canvasPath;
-    if (!canvasPath) {
-        res.status(404).json({ error: "This experience has no HTML canvas" });
-        return;
-    }
-    res.setHeader("Content-Type", "text/html");
-    setNoCacheHeaders(res);
-    res.sendFile(canvasPath);
-});
 // ── Catch-all: serve viewer ─────────────────────────────────
 app.get("*", (req, res, next) => {
     if (req.path.startsWith("/tools/") || req.path.startsWith("/viewer/") ||
@@ -1508,7 +1415,6 @@ export async function startServer(config) {
     const mod = getModule();
     const initialState = resolveInitialState(mod);
     room = new Room(mod.manifest.id, initialState);
-    maybeStartTickEngine();
     console.log(`  Experience: ${mod.manifest.id}`);
     const server = http.createServer(app);
     const wss = new WebSocketServer({ server, maxPayload: WS_MAX_PAYLOAD_BYTES });
@@ -1819,8 +1725,6 @@ export async function startServer(config) {
         for (const [actorId, p] of room.participants) {
             if (p.type !== "ai")
                 continue;
-            if (p.agentMode === "behavior")
-                continue;
             const lastSeen = p.lastPollAt || p.joinedAt;
             if (now - lastSeen > AI_HEARTBEAT_TIMEOUT_MS)
                 toEvict.push(actorId);
@@ -1848,11 +1752,9 @@ export async function startServer(config) {
         }
         debounceTimer = setTimeout(async () => {
             console.log(`\nFile changed${filename ? ` (${filename})` : ""}, rebuilding...`);
-            stopTickEngine();
             try {
                 await loadExperience();
                 room.broadcastToAll({ type: "experience_updated" });
-                maybeStartTickEngine();
                 smokeTestClientBundle(PORT);
                 console.log("Hot reload complete.");
             }
@@ -1860,7 +1762,6 @@ export async function startServer(config) {
                 experienceError = toErrorMessage(err);
                 console.error("Hot reload failed:", toErrorMessage(err));
                 room.broadcastToAll({ type: "build_error", error: toErrorMessage(err) });
-                maybeStartTickEngine();
             }
             finally {
                 if (rebuildingResolve) {

package/hooks/logic.js

@@ -92,10 +92,7 @@ export function formatPrompt(ctx) {
     }
     // ── 3. Events (what happened since last wake-up) ──────
     if (ctx.events && ctx.events.length > 0) {
-        // Filter out noise: _behavior.* (setup), tick engine events (_tick-engine / _system)
-        const visibleEvents = ctx.events.filter((e) => !(e.tool || "").startsWith("_behavior.") &&
-            e.actorId !== "_tick-engine" &&
-            e.owner !== "_system");
+        const visibleEvents = ctx.events;
         if (visibleEvents.length > 0) {
             for (const e of visibleEvents) {
                 const actor = e.role || e.owner || (e.actorId ? e.actorId.split("-")[0] : "?");
@@ -115,16 +112,6 @@ export function formatPrompt(ctx) {
             parts.push(`  ${roomId} (${info.experience}, ${p} participant${p !== 1 ? "s" : ""})`);
         }
     }
-    // Tick engine status — only show if something interesting
-    if (ctx.tickEngines) {
-        const activeEngines = Object.entries(ctx.tickEngines).filter(([, status]) => status.enabled && status.behaviorsActive > 0);
-        if (activeEngines.length > 0) {
-            parts.push("");
-            for (const [roomId, status] of activeEngines) {
-                parts.push(`Tick engine [${roomId}]: ${status.behaviorsActive} behavior(s) active, ${status.tickCount} ticks`);
-            }
-        }
-    }
     // Participants (deduplicated)
     if (ctx.participants && ctx.participants.length > 0) {
         const unique = [...new Set(ctx.participants)];
@@ -139,18 +126,10 @@ export function formatPrompt(ctx) {
  * Returns null to allow exit (no state file = not in agent mode).
  * Returns a StopDecision to block exit and feed context to Claude.
  */
-export function makeDecision(ctx, iteration, agentState) {
-    // No state file — allow normal exit
+export function makeDecision(ctx, iteration) {
     if (ctx === null)
         return null;
-    // Behavior-only agents never produce stop decisions — they run autonomously via tick engine
-    if (agentState?.agentMode === "behavior")
-        return null;
-    // Only count non-system events (tick engine events are noise)
-    const realEvents = ctx.events?.filter((e) => !(e.tool || "").startsWith("_behavior.") &&
-        e.actorId !== "_tick-engine" &&
-        e.owner !== "_system") || [];
-    const hasEvents = realEvents.length > 0;
+    const hasEvents = (ctx.events?.length || 0) > 0;
     const hasError = !!ctx.lastError;
     const hasBrowserErrors = ctx.browserErrors != null && ctx.browserErrors.length > 0;
     const hasObserveError = !!ctx.observeError;

package/hooks/stop-hook.js

@@ -165,13 +165,7 @@ async function main() {
     }
     // In-memory cursor per agent (not written to disk)
     const cursors = new Map(); // actorId → lastEventCursor
-    // Track last-seen phase per agent for subscription: "phase" filtering
-    const lastPhase = new Map(); // owner → last phase value
-    // Build the list of OUR agents from agent files (not all AI agents on server).
-    // Each Claude Code workspace only polls its own agents — prevents cross-terminal
-    // observation merging that causes identity confusion (wrong myClaimedHero, wrong role).
-    // Reuse the already-loaded agents array — reconciliation may have deleted stale files,
-    // so filter to only those whose files still exist on disk.
+    // Build the list of OUR agents from agent files.
     const ourAgents = agents
         .filter(a => existsSync(resolve(AGENTS_DIR, a._filename || `${a.owner}.json`)))
         .map((a) => ({
@@ -182,16 +176,7 @@ async function main() {
         _filename: a._filename,
         serverUrl: a.serverUrl || session.serverUrl,
         roomId: a.roomId || undefined,
-        subscription: a.subscription || "all",
-        agentMode: a.agentMode || undefined,
-        lastPhase: a.lastPhase,
     }));
-    // Initialize lastPhase from persisted agent files (survives across invocations)
-    for (const agent of ourAgents) {
-        if (agent.subscription === "phase" && agent.lastPhase !== undefined) {
-            lastPhase.set(agent.owner, agent.lastPhase ?? null);
-        }
-    }
     if (ourAgents.length === 0) {
         cleanupAndExit(agents.map(a => a._filename || `${a.owner}.json`));
         return;
@@ -242,68 +227,13 @@ async function main() {
             r.ctx.lastError ||
             r.ctx.observeError ||
             (r.ctx.browserErrors != null && r.ctx.browserErrors.length > 0)));
-        // Filter out behavior-only agents — they run autonomously via tick engine, never need waking
-        live = live.filter((r) => r.agent.agentMode !== "behavior");
-        // Apply subscription filtering: "phase" agents only wake on phase changes or errors
-        live = live.filter((r) => {
-            if (r.agent.subscription !== "phase")
-                return true; // "all" passes through
-            // Always extract and persist current phase (even on error wakeups)
-            const currentPhase = typeof r.ctx?.observation?.phase === "string"
-                ? r.ctx.observation.phase : null;
-            const prevPhase = lastPhase.get(r.agent.owner) ?? null;
-            lastPhase.set(r.agent.owner, currentPhase);
-            // Always wake on errors
-            if (r.ctx?.lastError || r.ctx?.observeError ||
-                (r.ctx?.browserErrors != null && r.ctx.browserErrors.length > 0))
-                return true;
-            // Phase changed — wake
-            if (currentPhase !== prevPhase)
-                return true;
-            // Check for phase-related events from agent's own room only
-            const phaseEvents = r.ctx?.events?.filter((e) => {
-                if (e.roomId && r.agent.roomId && e.roomId !== r.agent.roomId)
-                    return false;
-                return /phase|start|reset|end|finish/i.test(e.tool || "");
-            }) || [];
-            if (phaseEvents.length > 0)
-                return true;
-            return false; // Not a phase change — skip
-        });
-        // Persist lastPhase for phase-subscription agents across invocations.
-        // Update agent.lastPhase in memory (bumpIteration writes it for woken agents).
-        // For filtered-out agents, write to disk here so next invocation sees the correct phase.
-        const liveOwners = new Set(live.map((r) => r.agent.owner));
-        for (const { agent } of results) {
-            if (agent.subscription !== "phase")
-                continue;
-            if (!lastPhase.has(agent.owner))
-                continue;
-            const phaseVal = lastPhase.get(agent.owner) ?? null;
-            agent.lastPhase = phaseVal;
-            if (!liveOwners.has(agent.owner)) {
-                try {
-                    const filePath = resolve(AGENTS_DIR, agent._filename || `${agent.owner}.json`);
-                    const data = { ...agent };
-                    delete data._filename;
-                    writeFileSync(filePath, JSON.stringify(data, null, 2));
-                }
-                catch { /* Non-fatal — best-effort persistence */ }
-            }
-        }
         if (live.length > 0) {
             if (live.length > 1) {
                 process.stderr.write(`[vibevibes] Warning: ${live.length} agent files found but expected 1. Using first agent only.\n`);
             }
             const { agent, ctx } = live[0];
             const iteration = doneOwners.has(agent.owner) ? (agent.iteration || 0) + 1 : bumpIteration(agent);
-            const agentState = {
-                roomId: agent.roomId || session.roomId,
-                role: agent.role,
-                iteration,
-                agentMode: agent.agentMode,
-            };
-            const decision = makeDecision(ctx, iteration, agentState);
+            const decision = makeDecision(ctx, iteration);
             if (decision) {
                 process.stdout.write(JSON.stringify(decision));
             }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vibevibes/mcp",
-  "version": "0.4.1",
+  "version": "0.6.0",
   "description": "MCP server + runtime engine for vibevibes experiences",
   "type": "module",
   "main": "dist/index.js",

package/dist/protocol.d.ts

@@ -1,85 +0,0 @@
-/**
- * Protocol experience support.
- *
- * Loads experiences defined as manifest.json + subprocess tool handler.
- * The subprocess communicates via newline-delimited JSON over stdin/stdout.
- */
-import type { ExperienceModule } from "@vibevibes/sdk";
-export interface ProtocolManifest {
-    id: string;
-    version: string;
-    title: string;
-    description?: string;
-    initialState?: Record<string, any>;
-    tools: ProtocolToolDef[];
-    toolProcess: {
-        command: string;
-        args?: string[];
-    };
-    agents?: Array<{
-        role: string;
-        systemPrompt: string;
-        allowedTools?: string[];
-        autoSpawn?: boolean;
-        maxInstances?: number;
-    }>;
-    observe?: {
-        exclude?: string[];
-        include?: string[];
-    };
-    canvas?: string;
-    netcode?: "default" | "tick";
-    tickRateMs?: number;
-    streams?: Array<{
-        name: string;
-        input_schema: Record<string, any>;
-        rateLimit?: number;
-    }>;
-}
-interface ProtocolToolDef {
-    name: string;
-    description: string;
-    input_schema: Record<string, any>;
-    risk?: "low" | "medium" | "high";
-}
-interface RpcRequest {
-    id: string;
-    method: "tool" | "observe" | "stream" | "init" | "ping";
-    params: Record<string, any>;
-}
-interface RpcResponse {
-    id: string;
-    result?: Record<string, any>;
-    error?: {
-        message: string;
-        code?: string;
-    };
-}
-export declare class SubprocessExecutor {
-    private proc;
-    private pending;
-    private buffer;
-    private seq;
-    private command;
-    private args;
-    private cwd;
-    private restarting;
-    constructor(command: string, args: string[], cwd: string);
-    start(): void;
-    stop(): void;
-    private processBuffer;
-    send(method: RpcRequest["method"], params: Record<string, any>, timeoutMs?: number): Promise<RpcResponse>;
-    get running(): boolean;
-}
-export declare function isProtocolExperience(entryPath: string): boolean;
-export declare function loadProtocolManifest(manifestPath: string): ProtocolManifest;
-/**
- * Create a synthetic ExperienceModule from a protocol manifest.
- * Tool handlers proxy calls to the subprocess executor.
- */
-export declare function createProtocolModule(manifest: ProtocolManifest, executor: SubprocessExecutor, manifestDir: string): ExperienceModule & {
-    initialState?: Record<string, any>;
-    _executor: SubprocessExecutor;
-    _canvasPath?: string;
-};
-export {};

package/dist/protocol.js

@@ -1,240 +0,0 @@
-/**
- * Protocol experience support.
- *
- * Loads experiences defined as manifest.json + subprocess tool handler.
- * The subprocess communicates via newline-delimited JSON over stdin/stdout.
- */
-import { spawn } from "child_process";
-import * as path from "path";
-import * as fs from "fs";
-// ── Subprocess executor ─────────────────────────────────────────────────
-export class SubprocessExecutor {
-    proc = null;
-    pending = new Map();
-    buffer = "";
-    seq = 0;
-    command;
-    args;
-    cwd;
-    restarting = false;
-    constructor(command, args, cwd) {
-        this.command = command;
-        this.args = args;
-        this.cwd = cwd;
-    }
-    start() {
-        if (this.proc)
-            return;
-        this.proc = spawn(this.command, this.args, {
-            cwd: this.cwd,
-            stdio: ["pipe", "pipe", "pipe"],
-            env: { ...process.env },
-        });
-        this.proc.stdout.on("data", (chunk) => {
-            this.buffer += chunk.toString();
-            this.processBuffer();
-        });
-        this.proc.stderr.on("data", (chunk) => {
-            const msg = chunk.toString().trim();
-            if (msg)
-                console.error(`[protocol:${this.command}] ${msg}`);
-        });
-        this.proc.on("exit", (code) => {
-            console.warn(`[protocol] Tool process exited with code ${code}`);
-            this.proc = null;
-            // Reject all pending requests
-            for (const [id, p] of this.pending) {
-                p.reject(new Error(`Tool process exited (code ${code})`));
-                clearTimeout(p.timer);
-            }
-            this.pending.clear();
-            this.buffer = "";
-            // Auto-restart after a short delay
-            if (!this.restarting) {
-                this.restarting = true;
-                setTimeout(() => {
-                    this.restarting = false;
-                    try {
-                        this.start();
-                    }
-                    catch { }
-                }, 1000);
-            }
-        });
-        this.proc.on("error", (err) => {
-            console.error(`[protocol] Failed to spawn tool process: ${err.message}`);
-        });
-    }
-    stop() {
-        this.restarting = true; // Prevent auto-restart
-        if (this.proc) {
-            this.proc.kill();
-            this.proc = null;
-        }
-        for (const [, p] of this.pending) {
-            p.reject(new Error("Executor stopped"));
-            clearTimeout(p.timer);
-        }
-        this.pending.clear();
-    }
-    processBuffer() {
-        const lines = this.buffer.split("\n");
-        this.buffer = lines.pop() || "";
-        for (const line of lines) {
-            const trimmed = line.trim();
-            if (!trimmed)
-                continue;
-            try {
-                const response = JSON.parse(trimmed);
-                const pending = this.pending.get(response.id);
-                if (pending) {
-                    clearTimeout(pending.timer);
-                    this.pending.delete(response.id);
-                    pending.resolve(response);
-                }
-            }
-            catch {
-                console.warn(`[protocol] Invalid JSON from tool process: ${trimmed.slice(0, 200)}`);
-            }
-        }
-    }
-    async send(method, params, timeoutMs = 10000) {
-        if (!this.proc?.stdin?.writable) {
-            throw new Error("Tool process not running");
-        }
-        const id = `req-${++this.seq}`;
-        const request = { id, method, params };
-        return new Promise((resolve, reject) => {
-            const timer = setTimeout(() => {
-                this.pending.delete(id);
-                reject(new Error(`Tool process timeout after ${timeoutMs}ms`));
-            }, timeoutMs);
-            this.pending.set(id, { resolve, reject, timer });
-            try {
-                this.proc.stdin.write(JSON.stringify(request) + "\n");
-            }
-            catch (err) {
-                clearTimeout(timer);
-                this.pending.delete(id);
-                reject(err instanceof Error ? err : new Error(String(err)));
-            }
-        });
-    }
-    get running() {
-        return this.proc !== null && !this.proc.killed;
-    }
-}
-// ── Load a protocol experience ──────────────────────────────────────────
-export function isProtocolExperience(entryPath) {
-    return entryPath.endsWith("manifest.json");
-}
-export function loadProtocolManifest(manifestPath) {
-    const raw = fs.readFileSync(manifestPath, "utf-8");
-    const manifest = JSON.parse(raw);
-    if (!manifest.id)
-        throw new Error("manifest.json: id is required");
-    if (!manifest.version)
-        throw new Error("manifest.json: version is required");
-    if (!manifest.title)
-        throw new Error("manifest.json: title is required");
-    if (!manifest.toolProcess)
-        throw new Error("manifest.json: toolProcess is required");
-    if (!Array.isArray(manifest.tools))
-        throw new Error("manifest.json: tools must be an array");
-    return manifest;
-}
-/**
- * Create a synthetic ExperienceModule from a protocol manifest.
- * Tool handlers proxy calls to the subprocess executor.
- */
-export function createProtocolModule(manifest, executor, manifestDir) {
-    // Create tool defs with handlers that proxy to the subprocess
-    const tools = manifest.tools.map((t) => ({
-        name: t.name,
-        description: t.description,
-        // Use a plain object as input_schema with a parse method for compatibility
-        input_schema: createJsonSchemaValidator(t.input_schema),
-        risk: (t.risk || "low"),
-        capabilities_required: ["state.write"],
-        handler: async (ctx, input) => {
-            const response = await executor.send("tool", {
-                tool: t.name,
-                input,
-                state: ctx.state,
-                actorId: ctx.actorId,
-                roomId: ctx.roomId,
-                timestamp: ctx.timestamp,
-            });
-            if (response.error) {
-                throw new Error(response.error.message);
-            }
-            if (response.result?.state) {
-                ctx.setState(response.result.state);
-            }
-            return response.result?.output ?? {};
-        },
-    }));
-    // Build observe function if manifest specifies observation config
-    let observe;
-    if (manifest.observe) {
-        const { exclude, include } = manifest.observe;
-        observe = (state, _event, _actorId) => {
-            if (include) {
-                const filtered = {};
-                for (const key of include) {
-                    if (key in state)
-                        filtered[key] = state[key];
-                }
-                return filtered;
-            }
-            if (exclude) {
-                const filtered = { ...state };
-                for (const key of exclude) {
-                    delete filtered[key];
-                }
-                return filtered;
-            }
-            return state;
-        };
-    }
-    // Resolve canvas path
-    const canvasFile = manifest.canvas || "index.html";
-    const canvasPath = path.resolve(manifestDir, canvasFile);
-    const hasCanvas = fs.existsSync(canvasPath);
-    return {
-        manifest: {
-            id: manifest.id,
-            version: manifest.version,
-            title: manifest.title,
-            description: manifest.description || "",
-            requested_capabilities: ["state.write"],
-            agentSlots: manifest.agents,
-            participantSlots: manifest.agents?.map((a) => ({ ...a, type: "ai" })),
-            netcode: manifest.netcode,
-            tickRateMs: manifest.tickRateMs,
-        },
-        Canvas: (() => null), // Protocol experiences use HTML canvas, not React
-        tools,
-        observe,
-        initialState: manifest.initialState ?? {},
-        _executor: executor,
-        _canvasPath: hasCanvas ? canvasPath : undefined,
-    };
-}
-/**
- * Create a minimal Zod-compatible validator from a JSON Schema.
- * Only needs .parse() for the server's input validation.
- */
-function createJsonSchemaValidator(schema) {
-    return {
-        parse: (input) => {
-            // Basic type validation for protocol experiences
-            if (schema.type === "object" && typeof input !== "object") {
-                throw new Error("Expected object input");
-            }
-            return input;
-        },
-        // Expose the raw JSON Schema for tool listing
-        _jsonSchema: schema,
-    };
-}

package/dist/tick-engine.d.ts

@@ -1,81 +0,0 @@
-/**
- * Tick Engine — server-side tick loop for experiences with netcode: "tick".
- *
- * Runs at a fixed tick rate, executing tool calls from the tick context.
- * The tick engine provides the timing infrastructure; experiences define
- * what happens each tick via their tool handlers.
- */
-import type { ToolCtx, ToolEvent } from "@vibevibes/sdk";
-import type { EventEmitter } from "events";
-/** ToolEvent extended with observation field (computed server-side after tool execution). */
-interface TickToolEvent extends ToolEvent {
-    observation?: Record<string, unknown>;
-}
-/** Minimal Room interface — what the tick engine needs from a room. */
-export interface TickRoom {
-    readonly id: string;
-    readonly experienceId: string;
-    readonly config: Record<string, unknown>;
-    sharedState: Record<string, unknown>;
-    participantList(): string[];
-    broadcastToAll(message: Record<string, unknown>): void;
-    broadcastStateUpdate?(extra: {
-        changedBy: string;
-        tick?: unknown;
-    }, forceFullState?: boolean): void;
-    appendEvent(event: TickToolEvent): void;
-    enqueueExecution<T>(fn: () => Promise<T>): Promise<T>;
-}
-/** Minimal experience interface — what the tick engine needs. */
-export interface TickExperience {
-    module: {
-        manifest: {
-            id: string;
-        };
-        tools: Array<{
-            name: string;
-            input_schema?: {
-                parse?: (input: unknown) => unknown;
-            };
-            handler: (ctx: ToolCtx, input: unknown) => Promise<unknown>;
-        }>;
-        observe?: (state: Record<string, unknown>, event: TickToolEvent, actorId: string) => Record<string, unknown>;
-    };
-}
-export declare class TickEngine {
-    private room;
-    private experience;
-    private roomEvents;
-    private interval;
-    private tickCount;
-    private tickRateMs;
-    private startedAt;
-    private _running;
-    private _stopped;
-    private _stateSetThisTick;
-    constructor(room: TickRoom, experience: TickExperience, roomEvents: EventEmitter, tickRateMs?: number);
-    /** Start the tick loop. Uses self-correcting setTimeout to prevent timing drift. */
-    start(): void;
-    /** Schedule the next tick with drift correction. */
-    private scheduleNext;
-    /** Stop the tick loop. */
-    stop(): void;
-    /** Mark dirty — no-op in simplified engine, kept for API compat. */
-    markDirty(): void;
-    /** Get current tick status. */
-    getStatus(): {
-        enabled: boolean;
-        tickRateMs: number;
-        tickCount: number;
-    };
-    /** Execute one tick cycle. */
-    private tick;
-    /** Execute a tool call internally (no HTTP round-trip). */
-    executeTool(toolName: string, input: Record<string, unknown>, callerActorId?: string, expiredFlag?: {
-        value: boolean;
-    }): Promise<{
-        output?: unknown;
-        error?: string;
-    }>;
-}
-export {};

package/dist/tick-engine.js

@@ -1,151 +0,0 @@
-/**
- * Tick Engine — server-side tick loop for experiences with netcode: "tick".
- *
- * Runs at a fixed tick rate, executing tool calls from the tick context.
- * The tick engine provides the timing infrastructure; experiences define
- * what happens each tick via their tool handlers.
- */
-// ── Tick Engine ───────────────────────────────────────────────────────────────
-const TICK_ACTOR_ID = "_tick-engine";
-const TICK_OWNER = "_system";
-export class TickEngine {
-    room;
-    experience;
-    roomEvents;
-    interval = null;
-    tickCount = 0;
-    tickRateMs;
-    startedAt = 0;
-    _running = false;
-    _stopped = false;
-    _stateSetThisTick = false;
-    constructor(room, experience, roomEvents, tickRateMs = 50) {
-        this.room = room;
-        this.experience = experience;
-        this.roomEvents = roomEvents;
-        this.tickRateMs = tickRateMs;
-    }
-    /** Start the tick loop. Uses self-correcting setTimeout to prevent timing drift. */
-    start() {
-        if (this.interval)
-            return;
-        this._stopped = false;
-        this.tickCount = 0;
-        this.startedAt = Date.now();
-        this.scheduleNext();
-    }
-    /** Schedule the next tick with drift correction. */
-    scheduleNext() {
-        if (this._stopped)
-            return;
-        const expected = this.startedAt + (this.tickCount + 1) * this.tickRateMs;
-        const delay = Math.max(0, expected - Date.now());
-        this.interval = setTimeout(() => {
-            this.tick().then(() => this.scheduleNext(), () => this.scheduleNext());
-        }, delay);
-    }
-    /** Stop the tick loop. */
-    stop() {
-        this._stopped = true;
-        this._running = false;
-        if (this.interval) {
-            clearTimeout(this.interval);
-            this.interval = null;
-        }
-    }
-    /** Mark dirty — no-op in simplified engine, kept for API compat. */
-    markDirty() { }
-    /** Get current tick status. */
-    getStatus() {
-        return {
-            enabled: this.interval !== null,
-            tickRateMs: this.tickRateMs,
-            tickCount: this.tickCount,
-        };
-    }
-    /** Execute one tick cycle. */
-    async tick() {
-        if (this._running)
-            return;
-        this._running = true;
-        try {
-            this.tickCount++;
-        }
-        finally {
-            this._running = false;
-        }
-    }
-    /** Execute a tool call internally (no HTTP round-trip). */
-    async executeTool(toolName, input, callerActorId, expiredFlag) {
-        const tool = this.experience.module.tools.find((t) => t.name === toolName);
-        if (!tool) {
-            return { error: `Tool '${toolName}' not found` };
-        }
-        const actorId = callerActorId || TICK_ACTOR_ID;
-        const owner = callerActorId || TICK_OWNER;
-        try {
-            let validatedInput = input;
-            if (tool.input_schema?.parse) {
-                validatedInput = tool.input_schema.parse(input);
-            }
-            const self = this;
-            const ctxBase = {
-                roomId: this.room.id,
-                actorId,
-                owner,
-                state: null,
-                setState: (newState) => {
-                    if (expiredFlag?.value)
-                        return;
-                    self.room.sharedState = newState;
-                    self._stateSetThisTick = true;
-                },
-                timestamp: Date.now(),
-                memory: {},
-                setMemory: () => { },
-            };
-            Object.defineProperty(ctxBase, 'state', {
-                get() { return self.room.sharedState; },
-                enumerable: true,
-                configurable: true,
-            });
-            const ctx = ctxBase;
-            const output = await tool.handler(ctx, validatedInput);
-            const event = {
-                id: `tick-${this.tickCount}-${toolName}-${Math.random().toString(36).slice(2, 6)}`,
-                ts: Date.now(),
-                actorId: TICK_ACTOR_ID,
-                owner: TICK_OWNER,
-                tool: toolName,
-                input: validatedInput,
-                output,
-            };
-            if (this.experience.module.observe) {
-                try {
-                    event.observation = this.experience.module.observe(this.room.sharedState, event, actorId);
-                }
-                catch {
-                    // Don't fail tick if observe throws
-                }
-            }
-            this.room.appendEvent(event);
-            this.roomEvents.emit(`room:${this.room.id}`);
-            return { output };
-        }
-        catch (err) {
-            const errorMsg = err instanceof Error ? err.message : String(err);
-            const event = {
-                id: `tick-${this.tickCount}-${toolName}-${Math.random().toString(36).slice(2, 6)}`,
-                ts: Date.now(),
-                actorId: TICK_ACTOR_ID,
-                owner: TICK_OWNER,
-                tool: toolName,
-                input,
-                error: errorMsg,
-            };
-            this.room.appendEvent(event);
-            this.roomEvents.emit(`room:${this.room.id}`);
-            return { error: errorMsg };
-        }
-    }
-}