@ycodium-ai/agent-fake 0.2.1941

package/README.md

@@ -0,0 +1,21 @@
+# @ycodium-ai/agent-fake
+
+A minimal executor plugin. It starts no CLI and replays a fixed event script:
+
+- `startSession` emits `session.started`
+- `sendTurn` emits one `content.delta` then `turn.completed`
+- `interruptTurn` (or an aborted `AbortSignal`) ends the in-flight turn as `interrupted`
+- `readThread` returns the bookkeeping the instance recorded
+
+Two uses:
+
+1. **Template** for an `@ycodium-ai/agent-*` author: one card, `createInstance`, lease-scoped `host.process.spawn` (this fake never calls it), `ctx.log` instead of console.
+2. **Stand-in** for host orchestration tests (W1 reactors / ingestion / TurnIntent). `driverKind` is `fake`.
+
+This package is **not** in the default bundle and **not** a first-party add-grid recommended row. Load it only in tests or an explicit patch entry. Manifest permission is `{ kind: "executor" }`.
+
+Develop with `vp run --filter @ycodium-ai/agent-fake typecheck`, `build`, and `test`.
+
+## License
+
+UNLICENSED.

package/assets/icon.svg

@@ -0,0 +1,4 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 32 32" fill="none">
+  <rect x="4" y="4" width="24" height="24" rx="6" stroke="#6B7280" stroke-width="2"/>
+  <path d="M10 16h12M16 10v12" stroke="#6B7280" stroke-width="2" stroke-linecap="round"/>
+</svg>

package/dist/index.js

@@ -0,0 +1,243 @@
+// src/index.ts
+import { definePlugin } from "@ycodium-ai/plugin-api";
+
+// src/card.ts
+var FAKE_DRIVER_KIND = "fake";
+var FAKE_ASSISTANT_TEXT = "fake turn complete";
+var FAKE_CARD = {
+  driverKind: FAKE_DRIVER_KIND,
+  displayName: "Fake executor",
+  iconUrl: "./assets/icon.svg",
+  commandName: "fake",
+  launchArgs: "",
+  homeEnvVar: "",
+  environment: [],
+  install: null,
+  signIn: [],
+  deviceCodeSignInArgs: [],
+  npmPackage: "",
+  homebrewFormula: "",
+  selfUpdateArgs: [],
+  docsUrl: "",
+  setupNote: "agent-fake.setupNote",
+  defaultModel: "fake",
+  defaultTextGenerationModel: "fake",
+  customModelIdExample: "",
+  modelSlugAliases: null,
+  modelsDevProviderIds: [],
+  modelsDevSlugPrefixed: false,
+  modelSlugPrefix: "",
+  mcpTransports: null,
+  pluginManaged: true,
+  verifiedSkills: false,
+  everydayHarness: false,
+  capabilities: {
+    sessionModelSwitch: "unsupported",
+    runtimeModeSwitch: "next-turn"
+  },
+  credentialSources: [],
+  diagnostics: [],
+  configSchema: { type: "object", additionalProperties: false },
+  modelConnectivity: {
+    dialects: ["openai-chat-completions"],
+    acceptsExternalEndpoints: true
+  }
+};
+
+// src/fakeInstance.ts
+var yieldTick = () => Promise.resolve();
+var EventBus = class {
+  #queued = [];
+  #waiters = [];
+  #closed = false;
+  push(event) {
+    const waiter = this.#waiters.shift();
+    if (waiter) {
+      waiter({ done: false, value: event });
+      return;
+    }
+    this.#queued.push(event);
+  }
+  close() {
+    if (this.#closed) return;
+    this.#closed = true;
+    while (this.#waiters.length > 0) {
+      this.#waiters.shift()?.({ done: true, value: void 0 });
+    }
+  }
+  [Symbol.asyncIterator]() {
+    return {
+      next: () => {
+        const queued = this.#queued.shift();
+        if (queued !== void 0) return Promise.resolve({ done: false, value: queued });
+        if (this.#closed) return Promise.resolve({ done: true, value: void 0 });
+        return new Promise((resolve) => {
+          this.#waiters.push(resolve);
+        });
+      }
+    };
+  }
+};
+var createFakeInstance = (_config, host) => {
+  const events = new EventBus();
+  const threads = /* @__PURE__ */ new Map();
+  let seq = 0;
+  let inflight = null;
+  let disposed = false;
+  const nextId = (prefix) => `${prefix}-fake-${++seq}`;
+  const now = () => "2026-09-15T00:00:00.000Z";
+  const emit = (type, threadId, payload, extra) => {
+    events.push({
+      eventId: nextId("evt"),
+      provider: FAKE_DRIVER_KIND,
+      providerInstanceId: host.instanceId,
+      threadId,
+      createdAt: now(),
+      type,
+      payload,
+      ...extra?.turnId === void 0 ? {} : { turnId: extra.turnId }
+    });
+  };
+  const requireThread = (threadId) => {
+    const booked = threads.get(threadId);
+    if (!booked) throw new Error(`unknown thread ${threadId}`);
+    return booked;
+  };
+  const finishTurn = (booked, turnId, state, items) => {
+    booked.turns.push({ id: turnId, items });
+    const { activeTurnId: _cleared, ...idle } = booked.session;
+    booked.session = {
+      ...idle,
+      status: "idle",
+      updatedAt: now()
+    };
+    emit("turn.completed", booked.session.threadId, { state }, { turnId });
+    inflight = null;
+  };
+  const instance = {
+    probe: async () => ({
+      installed: true,
+      version: "0.0.0-fake",
+      readiness: "ready",
+      auth: { status: "unknown" }
+    }),
+    startSession: async (input, signal) => {
+      if (disposed) throw new Error("instance disposed");
+      if (signal?.aborted) throw new Error("aborted");
+      const cwd = input.cwd ?? host.workspacePath(input.threadId);
+      if (cwd.trim() === "") throw new Error("workspace path missing");
+      const createdAt = now();
+      const session = {
+        provider: FAKE_DRIVER_KIND,
+        providerInstanceId: host.instanceId,
+        status: "idle",
+        runtimeMode: input.runtimeMode,
+        cwd,
+        threadId: input.threadId,
+        createdAt,
+        updatedAt: createdAt,
+        ...input.discardResumeCursor === true || input.resumeCursor === void 0 ? {} : { resumeCursor: input.resumeCursor },
+        ...input.bindingGeneration === void 0 ? {} : { bindingGeneration: input.bindingGeneration }
+      };
+      threads.set(input.threadId, { session, turns: [] });
+      emit("session.started", input.threadId, {});
+      host.log.info("session started", { threadId: input.threadId });
+      return session;
+    },
+    sendTurn: async (input, signal) => {
+      if (disposed) throw new Error("instance disposed");
+      const booked = requireThread(input.threadId);
+      if (inflight !== null) throw new Error("turn already in flight");
+      const turnId = input.expectedTurnId ?? nextId("turn");
+      let aborted = signal?.aborted === true;
+      const onAbort = () => {
+        aborted = true;
+      };
+      signal?.addEventListener("abort", onAbort);
+      inflight = { threadId: input.threadId, turnId, abort: onAbort };
+      booked.session = {
+        ...booked.session,
+        status: "running",
+        activeTurnId: turnId,
+        updatedAt: now()
+      };
+      try {
+        await yieldTick();
+        if (aborted) {
+          finishTurn(booked, turnId, "interrupted", []);
+          return { threadId: input.threadId, turnId };
+        }
+        emit(
+          "content.delta",
+          input.threadId,
+          { streamKind: "assistant_text", delta: FAKE_ASSISTANT_TEXT },
+          { turnId }
+        );
+        await yieldTick();
+        if (aborted) {
+          finishTurn(booked, turnId, "interrupted", [
+            { kind: "assistant", text: FAKE_ASSISTANT_TEXT }
+          ]);
+          return { threadId: input.threadId, turnId };
+        }
+        finishTurn(booked, turnId, "completed", [{ kind: "assistant", text: FAKE_ASSISTANT_TEXT }]);
+        return { threadId: input.threadId, turnId };
+      } finally {
+        signal?.removeEventListener("abort", onAbort);
+        if (inflight?.turnId === turnId) inflight = null;
+      }
+    },
+    interruptTurn: async (threadId, turnId) => {
+      if (inflight === null) return;
+      if (inflight.threadId !== threadId) return;
+      if (turnId !== void 0 && inflight.turnId !== turnId) return;
+      host.log.info("interrupt turn", { threadId, turnId: inflight.turnId });
+      inflight.abort();
+    },
+    respondToRequest: async () => {
+      host.log.info("respondToRequest ignored");
+    },
+    respondToUserInput: async () => {
+      host.log.info("respondToUserInput ignored");
+    },
+    stopSession: async (threadId) => {
+      if (inflight?.threadId === threadId) inflight.abort();
+      threads.delete(threadId);
+    },
+    readThread: async (threadId) => {
+      const booked = requireThread(threadId);
+      return { threadId, turns: booked.turns };
+    },
+    events,
+    dispose: async () => {
+      disposed = true;
+      inflight?.abort();
+      inflight = null;
+      threads.clear();
+      events.close();
+    }
+  };
+  return instance;
+};
+
+// src/index.ts
+var executors = [
+  {
+    card: FAKE_CARD,
+    createInstance: async (config, host) => {
+      host.log.info("createInstance");
+      return createFakeInstance(config, host);
+    }
+  }
+];
+var index_default = definePlugin({
+  id: "agent-fake",
+  apiVersion: 2,
+  executors,
+  activate(ctx) {
+    ctx.log.info("fake executor ready");
+  }
+});
+export {
+  index_default as default
+};

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "@ycodium-ai/agent-fake",
+  "version": "0.2.1941",
+  "description": "Minimal fake executor for plugin authors and host orchestration tests.",
+  "keywords": [
+    "ycodium",
+    "ycodium-plugin"
+  ],
+  "license": "UNLICENSED",
+  "files": [
+    "dist",
+    "assets",
+    "README.md"
+  ],
+  "type": "module",
+  "publishConfig": {
+    "access": "public"
+  },
+  "devDependencies": {
+    "@types/node": "24.12.4",
+    "esbuild": "0.28.1",
+    "vite-plus": "0.2.2",
+    "@ycodium-ai/plugin-api": "0.2.1941"
+  },
+  "ycodium": {
+    "plugin": "./dist/index.js",
+    "displayName": "Fake executor",
+    "description": "Scripted executor events for templates and host tests. Not a recommended add-grid row.",
+    "icon": "./assets/icon.svg",
+    "permissions": [
+      {
+        "kind": "executor"
+      }
+    ]
+  },
+  "scripts": {
+    "build": "node build.mjs",
+    "typecheck": "tsgo --noEmit",
+    "test": "vp test run"
+  }
+}