@yaklabs-ai/plugin-sdk 0.8.4

package/dist/kay-agent-testing.js

@@ -0,0 +1,88 @@
+// packages/herd-agent/dist/testing.js
+function fauxAuthContext(overrides = {}) {
+  return {
+    async resolveToken() {
+      return { ok: false, reason: "no-connection", message: "not connected" };
+    },
+    async getActiveAccount() {
+      return void 0;
+    },
+    async listAccounts() {
+      return [];
+    },
+    async resolveExternalCli({ serviceId, schemeId }) {
+      return {
+        ok: false,
+        reason: "not-external-cli",
+        message: `${serviceId}/${schemeId} is not an external CLI scheme.`
+      };
+    },
+    ...overrides
+  };
+}
+
+// packages/plugin-sdk/dist/kay-agent/testing.js
+function unwired(name) {
+  return async () => {
+    throw new Error(`${name} is not wired in this test double; pass your own handle to exercise it`);
+  };
+}
+function fauxKayAgentCapabilities() {
+  return {
+    filesystem: {
+      readText: unwired("filesystem.readText"),
+      writeText: unwired("filesystem.writeText"),
+      mkdir: unwired("filesystem.mkdir"),
+      readDir: unwired("filesystem.readDir"),
+      stat: unwired("filesystem.stat"),
+      rename: unwired("filesystem.rename"),
+      realpath: unwired("filesystem.realpath")
+    },
+    network: { fetch: unwired("network.fetch") },
+    webSession: {
+      request: unwired("webSession.request"),
+      download: unwired("webSession.download")
+    },
+    process: { run: unwired("process.run") },
+    whiteboard: {
+      listTypes: unwired("whiteboard.listTypes"),
+      forType: () => ({
+        payload: {
+          read: unwired("whiteboard.payload.read"),
+          create: unwired("whiteboard.payload.create"),
+          replace: unwired("whiteboard.payload.replace")
+        },
+        inventory: unwired("whiteboard.inventory"),
+        inspect: unwired("whiteboard.inspect"),
+        list: unwired("whiteboard.list"),
+        read: unwired("whiteboard.read"),
+        create: unwired("whiteboard.create"),
+        update: unwired("whiteboard.update"),
+        mutate: unwired("whiteboard.mutate"),
+        remove: unwired("whiteboard.remove")
+      })
+    },
+    interceptToolCall: () => void 0,
+    // The one handle that does NOT refuse on use. `withJev`'s contract is that it always produces
+    // the baseline, so a rejecting double would make a plugin's Jev path untestable and teach the
+    // wrong lesson besides: the fallback is the normal outcome, not an error. It reaches no
+    // client, no key, and no network, which is all a double here has to guarantee. A test that
+    // wants a real Jev answer overrides this handle after the spread, like any other.
+    withJev: async (_use, fallback) => fallback(),
+    // Accepts and drops, like the registrations above: the real `publish` never throws, so a
+    // rejecting double would fail tests for a reason production never has. A test asserting what
+    // its plugin publishes overrides this handle after the spread.
+    events: { publish: () => void 0 }
+  };
+}
+function defaultTestToolContext() {
+  return { cwd: "/tmp", model: void 0 };
+}
+async function invokeToolForTest(tool, params, ctx = defaultTestToolContext()) {
+  return tool.execute("test-call", params, void 0, void 0, ctx);
+}
+export {
+  fauxAuthContext,
+  fauxKayAgentCapabilities,
+  invokeToolForTest
+};