@pasko70/pibo 1.16.6 → 2.0.0

package/dist/agent-runtime/testing/contract.js

@@ -0,0 +1,51 @@
+import { assertAgentRuntimeSessionContract } from "../contract.js";
+function invariant(condition, message) {
+    if (!condition)
+        throw new Error(`Agent runtime contract violation: ${message}`);
+}
+export async function exerciseAgentRuntimeAdapterContract(adapter, input, prompt = "runtime adapter contract prompt") {
+    invariant(adapter.instanceId.length > 0, "configured instance id is required");
+    invariant(adapter.descriptor.id.length > 0, "adapter id is required");
+    invariant(adapter.descriptor.displayName.length > 0, "adapter display name is required");
+    invariant(adapter.enabled, `instance "${adapter.instanceId}" must be enabled for the contract run`);
+    const diagnostics = await adapter.diagnose();
+    invariant(diagnostics.every((diagnostic) => diagnostic.severity !== "error"), "enabled adapter diagnostics returned an error");
+    const validation = adapter.validateProfile({ profile: input.profile, workspace: input.workspace });
+    invariant(validation.every((diagnostic) => diagnostic.severity !== "error"), "profile validation returned an error");
+    const session = await adapter.openSession(input);
+    invariant(session.runtimeInstanceId === adapter.instanceId, "session instance id does not match adapter instance");
+    invariant(session.adapterId === adapter.descriptor.id, "session adapter id does not match descriptor");
+    invariant(session.cwd === input.workspace, "session cwd does not match open input");
+    assertAgentRuntimeSessionContract(session);
+    const binding = session.getBinding();
+    invariant(binding.piboSessionId === input.piboSession.id, "binding Pibo Session id does not match open input");
+    invariant(binding.runtimeInstanceId === adapter.instanceId, "binding runtime instance id does not match adapter");
+    invariant(binding.adapterId === adapter.descriptor.id, "binding adapter id does not match descriptor");
+    const events = [];
+    const unsubscribe = session.subscribe((event) => events.push(event));
+    try {
+        await session.prompt({ text: prompt, source: "rpc" });
+        const status = session.getStatus();
+        invariant(status.cwd === input.workspace, "status cwd does not match session cwd");
+        invariant(status.streaming === false, "session remained streaming after prompt settled");
+        const startedEvents = events.filter((event) => event.type === "turn_started");
+        const completedEvents = events.filter((event) => event.type === "turn_completed");
+        const failedEvents = events.filter((event) => event.type === "turn_failed");
+        invariant(startedEvents.length === 1, "successful prompt must emit exactly one turn_started event");
+        invariant(completedEvents.length === 1, "successful prompt must emit exactly one turn_completed event");
+        invariant(failedEvents.length === 0, "successful prompt emitted turn_failed");
+        invariant(events.indexOf(startedEvents[0]) < events.indexOf(completedEvents[0]), "turn_completed preceded turn_started");
+        const settledBinding = session.getBinding();
+        invariant(settledBinding.piboSessionId === binding.piboSessionId, "prompt changed the binding Pibo Session id");
+        invariant(settledBinding.runtimeInstanceId === binding.runtimeInstanceId, "prompt changed the binding runtime instance");
+        invariant(settledBinding.adapterId === binding.adapterId, "prompt changed the binding adapter");
+        await session.abort();
+        invariant(session.getStatus().streaming === false, "idle abort left the session streaming");
+    }
+    finally {
+        unsubscribe();
+        await session.dispose();
+        await session.dispose();
+    }
+    return { session, events };
+}

package/dist/agent-runtime/testing/fake-adapter.js

@@ -0,0 +1,192 @@
+import { createMinimalAgentRuntimeCapabilities } from "../capabilities.js";
+import { AgentRuntimeBindingMissingError } from "../errors.js";
+export class FakeAgentRuntimeSession {
+    script;
+    adapterId;
+    runtimeInstanceId;
+    cwd;
+    capabilities;
+    listeners = new Set();
+    binding;
+    streaming = false;
+    disposed = false;
+    aborted = false;
+    promptIndex = 0;
+    abortWaiters = [];
+    prompts = [];
+    disposeCalls = 0;
+    abortCalls = 0;
+    constructor(input, adapterId, script, capabilities, nativeSessionId) {
+        this.script = script;
+        this.adapterId = adapterId;
+        this.runtimeInstanceId = input.binding?.runtimeInstanceId ?? input.profile.runtimeInstanceId;
+        this.cwd = input.workspace;
+        this.capabilities = capabilities;
+        this.binding = input.binding?.state === "bound"
+            ? { ...input.binding }
+            : {
+                piboSessionId: input.piboSession.id,
+                runtimeInstanceId: this.runtimeInstanceId,
+                adapterId: this.adapterId,
+                nativeSessionId,
+                state: "bound",
+            };
+    }
+    getBinding() {
+        return structuredClone(this.binding);
+    }
+    subscribe(listener) {
+        this.listeners.add(listener);
+        return () => this.listeners.delete(listener);
+    }
+    async prompt(input) {
+        this.assertActive();
+        this.prompts.push({ ...input });
+        this.promptIndex += 1;
+        this.streaming = true;
+        this.aborted = false;
+        const turnId = `fake-turn-${this.promptIndex}`;
+        const script = typeof this.script === "function" ? this.script(input, this.promptIndex) : this.script ?? {};
+        this.emit({ type: "turn_started", turnId });
+        try {
+            if (script.waitForAbort) {
+                await new Promise((resolve) => this.abortWaiters.push(resolve));
+            }
+            if (this.aborted)
+                return;
+            for (const event of script.events ?? [])
+                this.emit(event);
+            if (script.failWith) {
+                this.emit({ type: "turn_failed", turnId, message: script.failWith });
+                throw new Error(script.failWith);
+            }
+            if (script.bindingPatchAfterPrompt) {
+                this.binding = {
+                    ...this.binding,
+                    ...structuredClone(script.bindingPatchAfterPrompt),
+                    piboSessionId: this.binding.piboSessionId,
+                    runtimeInstanceId: this.binding.runtimeInstanceId,
+                    adapterId: this.binding.adapterId,
+                };
+            }
+            this.emit({ type: "turn_completed", turnId, status: "completed" });
+        }
+        finally {
+            this.streaming = false;
+        }
+    }
+    async steer(input) {
+        this.assertActive();
+        if (!this.streaming || !this.capabilities.input.steering) {
+            throw new Error("Fake runtime is not accepting steering.");
+        }
+        this.prompts.push({ ...input });
+    }
+    async abort() {
+        this.abortCalls += 1;
+        const wasStreaming = this.streaming;
+        this.aborted = true;
+        const waiters = this.abortWaiters;
+        this.abortWaiters = [];
+        for (const resolve of waiters)
+            resolve();
+        this.streaming = false;
+        if (wasStreaming)
+            this.emit({ type: "turn_completed", turnId: `fake-turn-${this.promptIndex}`, status: "aborted" });
+    }
+    async dispose() {
+        this.disposeCalls += 1;
+        if (this.disposed)
+            return;
+        this.disposed = true;
+        await this.abort();
+        this.listeners.clear();
+    }
+    getStatus() {
+        return {
+            streaming: this.disposed ? false : this.streaming,
+            enabledTools: [],
+            cwd: this.cwd,
+        };
+    }
+    emit(event) {
+        for (const listener of this.listeners)
+            listener(event);
+    }
+    assertActive() {
+        if (this.disposed)
+            throw new Error("Fake runtime session is disposed.");
+    }
+}
+export class FakeAgentRuntimeAdapter {
+    instanceId;
+    descriptor;
+    options;
+    config;
+    displayName;
+    enabled;
+    sessions = [];
+    openInputs = [];
+    nextNativeSession = 1;
+    constructor(instanceId, descriptor, config, displayName, enabled, options) {
+        this.instanceId = instanceId;
+        this.descriptor = descriptor;
+        this.options = options;
+        this.config = structuredClone(config);
+        this.displayName = displayName ?? descriptor.displayName;
+        this.enabled = enabled;
+    }
+    async diagnose() {
+        return [...(this.options.diagnostics ?? [])];
+    }
+    validateProfile(_input) {
+        return [];
+    }
+    async openSession(input) {
+        this.openInputs.push(input);
+        const script = typeof this.options.script === "function"
+            ? this.options.script({ text: "", source: "rpc" }, 0)
+            : this.options.script;
+        if (script?.missingNativeSession && input.binding?.state === "bound") {
+            throw new AgentRuntimeBindingMissingError(input.piboSession.id, this.instanceId, input.binding.nativeSessionId);
+        }
+        const nativeSessionId = input.binding?.nativeSessionId ?? `fake-native-${this.nextNativeSession++}`;
+        const normalizedInput = {
+            ...input,
+            binding: input.binding
+                ? { ...input.binding, adapterId: this.descriptor.id, runtimeInstanceId: this.instanceId }
+                : undefined,
+        };
+        const session = new FakeAgentRuntimeSession(normalizedInput, this.descriptor.id, this.options.script, this.descriptor.capabilities, nativeSessionId);
+        this.sessions.push(session);
+        return session;
+    }
+}
+export function createFakeAgentRuntimeDriver(options = {}) {
+    const adapterId = options.adapterId ?? "fake";
+    const descriptor = {
+        id: adapterId,
+        displayName: options.displayName ?? "Fake Agent Runtime",
+        transport: "embedded",
+        configSchema: {
+            type: "object",
+            additionalProperties: false,
+        },
+        capabilities: options.capabilities ?? createMinimalAgentRuntimeCapabilities(),
+        supportsMultipleInstances: true,
+    };
+    return {
+        descriptor,
+        defaultConfig: () => ({}),
+        parseConfig(value) {
+            if (!value || typeof value !== "object" || Array.isArray(value))
+                throw new Error("config must be an object");
+            if (Object.keys(value).length > 0)
+                throw new Error("fake runtime config does not accept instance fields");
+            return {};
+        },
+        create(input) {
+            return new FakeAgentRuntimeAdapter(input.instanceId, descriptor, input.config, input.displayName, input.enabled, options);
+        },
+    };
+}

package/dist/agent-runtime/types.js

@@ -0,0 +1,3 @@
+export function isAgentRuntimeSemanticEvent(value) {
+    return Boolean(value && typeof value === "object" && typeof value.type === "string");
+}