@synsci/sdk 2.0.77 → 2.0.78-test.34098503148

package/dist/test/mcp-auth-contract.test.js

@@ -1,56 +0,0 @@
-import assert from "node:assert/strict";
-import { test } from "node:test";
-import { createOpenScienceClient } from "../src/v2/client.js";
-const pending = {
-    state: "pending",
-    authorizationUrl: "https://provider.example/authorize",
-    flowId: "flow_exact",
-};
-const settled = {
-    state: "settled",
-    result: { status: "connected" },
-};
-const resumable = {
-    pending: true,
-    authorizationUrl: "https://provider.example/authorize",
-    flowId: "flow_exact",
-};
-test("generated MCP OAuth client preserves start, pending, wait, and exact cancel requests", async () => {
-    const requests = [];
-    const responses = [pending, resumable, { status: "connected" }, { success: true }, settled];
-    const client = createOpenScienceClient({
-        baseUrl: "http://sdk.test",
-        throwOnError: true,
-        fetch: async (input) => {
-            requests.push(input instanceof Request ? input : new Request(input));
-            return Response.json(responses[requests.length - 1]);
-        },
-    });
-    const started = await client.mcp.auth.start({ name: "givemeanode" }, { throwOnError: true });
-    assert.deepEqual(started.data, pending);
-    if (started.data.state !== "pending")
-        throw new Error("Expected a pending OAuth start");
-    assert.equal(started.data.flowId, "flow_exact");
-    const resumed = await client.mcp.auth.pending({ name: "givemeanode" }, { throwOnError: true });
-    assert.deepEqual(resumed.data, resumable);
-    if (!resumed.data.pending)
-        throw new Error("Expected a resumable OAuth flow");
-    assert.equal(resumed.data.flowId, "flow_exact");
-    await client.mcp.auth.wait({ name: "givemeanode", flow_id: "flow_exact" }, { throwOnError: true });
-    await client.mcp.auth.cancel({ name: "givemeanode", flow_id: "flow_exact" }, { throwOnError: true });
-    const restarted = await client.mcp.auth.start({ name: "givemeanode" }, { throwOnError: true });
-    assert.deepEqual(restarted.data, settled);
-    if (restarted.data.state !== "settled")
-        throw new Error("Expected a settled OAuth start");
-    assert.equal(restarted.data.result.status, "connected");
-    assert.deepEqual(requests.map((request) => ({
-        method: request.method,
-        url: request.url,
-    })), [
-        { method: "POST", url: "http://sdk.test/mcp/givemeanode/auth" },
-        { method: "GET", url: "http://sdk.test/mcp/givemeanode/auth/pending" },
-        { method: "POST", url: "http://sdk.test/mcp/givemeanode/auth/wait?flow_id=flow_exact" },
-        { method: "DELETE", url: "http://sdk.test/mcp/givemeanode/auth/pending?flow_id=flow_exact" },
-        { method: "POST", url: "http://sdk.test/mcp/givemeanode/auth" },
-    ]);
-});

package/dist/test/notebook-contract.d.ts

@@ -1,38 +0,0 @@
-import type { OpenScienceClient } from "../src/v2/client.js";
-import type { NotebookExecuteData, NotebookInterruptData, NotebookKernelDeleteData, NotebookKernelInterruptData, NotebookKernelRestartData, NotebookKernelStopData, NotebookRestartData, NotebookStatusData, NotebookStopData } from "../src/v2/gen/types.gen.js";
-type Assert<T extends true> = T;
-type Owner<T> = NonNullable<T> extends {
-    sessionID: string;
-} ? true : false;
-type Field<T, K extends PropertyKey> = K extends keyof NonNullable<T> ? true : false;
-type _executeOwner = Assert<Owner<NotebookExecuteData["body"]>>;
-type _statusOwner = Assert<Owner<NotebookStatusData["query"]>>;
-type _restartOwner = Assert<Owner<NotebookRestartData["body"]>>;
-type _stopOwner = Assert<Owner<NotebookStopData["body"]>>;
-type _interruptOwner = Assert<Owner<NotebookInterruptData["body"]>>;
-type _kernelRestartOwner = Assert<Owner<NotebookKernelRestartData["body"]>>;
-type _kernelStopOwner = Assert<Owner<NotebookKernelStopData["body"]>>;
-type _kernelInterruptOwner = Assert<Owner<NotebookKernelInterruptData["body"]>>;
-type _kernelDeleteOwner = Assert<Owner<NotebookKernelDeleteData["query"]>>;
-type Notebook = OpenScienceClient["notebook"];
-type _executeMethodOwner = Assert<Field<Parameters<Notebook["execute"]>[0], "sessionID">>;
-type _statusMethodOwner = Assert<Field<Parameters<Notebook["status"]>[0], "sessionID">>;
-type _restartMethodOwner = Assert<Field<Parameters<Notebook["restart"]>[0], "sessionID">>;
-type _stopMethodOwner = Assert<Field<Parameters<Notebook["stop"]>[0], "sessionID">>;
-type _interruptMethodOwner = Assert<Field<Parameters<Notebook["interrupt"]>[0], "sessionID">>;
-type _kernelRestart = Assert<Field<Notebook["kernel"], "restart">>;
-type _kernelStop = Assert<Field<Notebook["kernel"], "stop">>;
-type _kernelInterrupt = Assert<Field<Notebook["kernel"], "interrupt">>;
-type _kernelDelete = Assert<Field<Notebook["kernel"], "delete">>;
-export declare const notebookContract: {
-    readonly execute: _executeOwner & _executeMethodOwner;
-    readonly status: _statusOwner & _statusMethodOwner;
-    readonly restart: _restartOwner & _restartMethodOwner;
-    readonly stop: _stopOwner & _stopMethodOwner;
-    readonly interrupt: _interruptOwner & _interruptMethodOwner;
-    readonly kernelRestart: _kernelRestartOwner & _kernelRestart;
-    readonly kernelStop: _kernelStopOwner & _kernelStop;
-    readonly kernelInterrupt: _kernelInterruptOwner & _kernelInterrupt;
-    readonly kernelDelete: _kernelDeleteOwner & _kernelDelete;
-};
-export {};

package/dist/test/notebook-contract.js

@@ -1,11 +0,0 @@
-export const notebookContract = {
-    execute: true,
-    status: true,
-    restart: true,
-    stop: true,
-    interrupt: true,
-    kernelRestart: true,
-    kernelStop: true,
-    kernelInterrupt: true,
-    kernelDelete: true,
-};

package/dist/test/runtime-contract.d.ts

@@ -1,19 +0,0 @@
-import { createOpenScienceRuntime, type RuntimePromptInput } from "../src/v2/runtime.js";
-import type { RuntimeEvent, RuntimeEventReplay, RuntimePromptAccepted } from "../src/v2/gen/types.gen.js";
-type Assert<T extends true> = T;
-type Equal<A, B> = (<T>() => T extends A ? 1 : 2) extends <T>() => T extends B ? 1 : 2 ? true : false;
-type _promptInput = Assert<Equal<RuntimePromptInput, {
-    sessionID: string;
-    message: string;
-    effort: "normal" | "ultra";
-}>>;
-type _promptResult = Assert<Equal<Awaited<ReturnType<ReturnType<typeof createOpenScienceRuntime>["prompt"]>>, RuntimePromptAccepted>>;
-type _replayResult = Assert<Equal<Awaited<ReturnType<ReturnType<typeof createOpenScienceRuntime>["replay"]>>, RuntimeEventReplay>>;
-type _eventsResult = Assert<Equal<ReturnType<ReturnType<typeof createOpenScienceRuntime>["events"]>, AsyncGenerator<RuntimeEvent, void, void>>>;
-export declare const runtimeContract: {
-    promptInput: _promptInput;
-    promptResult: _promptResult;
-    replayResult: _replayResult;
-    eventsResult: _eventsResult;
-};
-export {};

package/dist/test/runtime-contract.js

@@ -1,6 +0,0 @@
-export const runtimeContract = {
-    promptInput: true,
-    promptResult: true,
-    replayResult: true,
-    eventsResult: true,
-};

package/dist/test/runtime.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/test/runtime.test.js

@@ -1,203 +0,0 @@
-import assert from "node:assert/strict";
-import { describe, test } from "node:test";
-import { createOpenScienceRuntime, RuntimeEventCursorError } from "../src/v2/runtime.js";
-describe("OpenScienceRuntime", () => {
-    test("sends the strict public prompt contract and returns the accepted run", async () => {
-        let request;
-        const runtime = createOpenScienceRuntime({
-            baseUrl: "http://runtime.test",
-            fetch: async (input) => {
-                request = input instanceof Request ? input : new Request(input);
-                return Response.json({ runID: "run_public", acceptedAt: 123 }, { status: 202 });
-            },
-        });
-        assert.deepEqual(await runtime.prompt({ sessionID: "ses_public", message: "Analyze this", effort: "ultra" }), {
-            runID: "run_public",
-            acceptedAt: 123,
-        });
-        assert.equal(request?.url, "http://runtime.test/runtime/prompt");
-        assert.equal(request?.method, "POST");
-        assert.deepEqual(await request?.json(), {
-            sessionID: "ses_public",
-            message: "Analyze this",
-            effort: "ultra",
-        });
-    });
-    test("generated prompt serialization keeps normal effort in the request body", async () => {
-        let body;
-        const runtime = createOpenScienceRuntime({
-            baseUrl: "http://runtime.test",
-            fetch: async (input) => {
-                const request = input instanceof Request ? input : new Request(input);
-                body = await request.json();
-                return Response.json({ runID: "run_normal", acceptedAt: 321 }, { status: 202 });
-            },
-        });
-        await runtime.prompt({ sessionID: "ses_normal", message: "Summarize", effort: "normal" });
-        assert.deepEqual(body, { sessionID: "ses_normal", message: "Summarize", effort: "normal" });
-    });
-    test("replays from a sequence cursor and yields typed SSE events", async () => {
-        const urls = [];
-        const controller = new AbortController();
-        const event = {
-            sequence: 4,
-            sessionID: "ses_public",
-            runID: "run_public",
-            type: "runtime.completed",
-            properties: { messageID: "msg_public" },
-            time: 456,
-        };
-        const runtime = createOpenScienceRuntime({
-            baseUrl: "http://runtime.test",
-            fetch: async (input) => {
-                const request = input instanceof Request ? input : new Request(input);
-                urls.push(request.url);
-                if (request.url.includes("/replay")) {
-                    return Response.json({ events: [event], oldestSequence: 1, latestSequence: 4 });
-                }
-                return new Response(`id: 4\nevent: runtime.completed\ndata: ${JSON.stringify(event)}\n\n`, {
-                    headers: { "content-type": "text/event-stream" },
-                });
-            },
-        });
-        assert.deepEqual(await runtime.replay({ sessionID: "ses_public", afterSequence: 3 }), {
-            events: [event],
-            oldestSequence: 1,
-            latestSequence: 4,
-        });
-        const received = [];
-        for await (const item of runtime.events({ sessionID: "ses_public", afterSequence: 3, signal: controller.signal })) {
-            received.push(item);
-            controller.abort();
-        }
-        assert.deepEqual(received, [event]);
-        assert.deepEqual(urls, [
-            "http://runtime.test/runtime/events/replay?sessionID=ses_public&afterSequence=3",
-            "http://runtime.test/runtime/events?sessionID=ses_public&afterSequence=3",
-        ]);
-    });
-    test("reconnects after clean EOF with the last delivered sequence", async () => {
-        const requests = [];
-        const controller = new AbortController();
-        const event = (sequence) => ({
-            sequence,
-            sessionID: "ses_reconnect",
-            runID: "run_reconnect",
-            type: sequence === 1 ? "runtime.accepted" : "runtime.completed",
-            properties: sequence === 1 ? { effort: "normal" } : { messageID: "msg_done" },
-            time: sequence,
-        });
-        const runtime = createOpenScienceRuntime({
-            baseUrl: "http://runtime.test",
-            runtimeReconnectDelayMs: 0,
-            fetch: async (input) => {
-                const request = input instanceof Request ? input : new Request(input);
-                requests.push(request);
-                const current = event(requests.length);
-                return new Response(`id: ${current.sequence}\nevent: ${current.type}\ndata: ${JSON.stringify(current)}\n\n`, {
-                    headers: { "content-type": "text/event-stream" },
-                });
-            },
-        });
-        const received = [];
-        for await (const item of runtime.events({
-            sessionID: "ses_reconnect",
-            afterSequence: 0,
-            signal: controller.signal,
-        })) {
-            received.push(item);
-            if (received.length === 2)
-                controller.abort();
-        }
-        assert.deepEqual(received.map((item) => item.sequence), [1, 2]);
-        assert.equal(requests.length, 2);
-        assert.equal(requests[0]?.headers.get("Last-Event-ID"), "0");
-        assert.equal(requests[1]?.headers.get("Last-Event-ID"), "1");
-    });
-    test("backs off after empty clean closes and resets once events arrive", async () => {
-        const times = [];
-        const controller = new AbortController();
-        const event = {
-            sequence: 1,
-            sessionID: "ses_empty",
-            runID: "run_empty",
-            type: "runtime.accepted",
-            properties: { effort: "normal" },
-            time: 1,
-        };
-        const runtime = createOpenScienceRuntime({
-            baseUrl: "http://runtime.test",
-            runtimeReconnectDelayMs: 20,
-            fetch: async () => {
-                times.push(Date.now());
-                if (times.length === 6)
-                    controller.abort();
-                const body = times.length === 5 ? `id: 1\nevent: runtime.accepted\ndata: ${JSON.stringify(event)}\n\n` : "";
-                return new Response(body, { headers: { "content-type": "text/event-stream" } });
-            },
-        });
-        const received = [];
-        for await (const item of runtime.events({ sessionID: "ses_empty", signal: controller.signal })) {
-            received.push(item);
-        }
-        assert.equal(received.length, 1);
-        assert.equal(times.length, 6);
-        const gaps = times.slice(1).map((time, index) => time - (times[index] ?? time));
-        // Four empty closes wait 20, 40, 80, and 160 ms; the delivered event on
-        // the fifth connection resets the next wait to the 20 ms base.
-        assert.ok((gaps[3] ?? 0) >= 150, `fourth reconnect waited ${gaps[3]}ms`);
-        assert.ok((gaps[0] ?? 0) + (gaps[1] ?? 0) + (gaps[2] ?? 0) + (gaps[3] ?? 0) >= 280, `empty closes waited ${gaps}`);
-        assert.ok((gaps[4] ?? 0) < 200, `reconnect after a delivered event waited ${gaps[4]}ms`);
-    });
-    test("surfaces a retained-window conflict without retrying forever", async () => {
-        let calls = 0;
-        const runtime = createOpenScienceRuntime({
-            baseUrl: "http://runtime.test",
-            runtimeReconnectDelayMs: 0,
-            fetch: async () => {
-                calls += 1;
-                return Response.json({ error: "cursor_expired" }, { status: 409, statusText: "Conflict" });
-            },
-        });
-        await assert.rejects(async () => {
-            for await (const _ of runtime.events({ sessionID: "ses_expired", afterSequence: 1 })) {
-                // No event is expected.
-            }
-        }, RuntimeEventCursorError);
-        assert.equal(calls, 1);
-    });
-    test("settles a rejecting stream cancellation when the caller aborts", async () => {
-        const controller = new AbortController();
-        let connected = false;
-        const unhandled = [];
-        const onUnhandled = (error) => unhandled.push(error);
-        process.on("unhandledRejection", onUnhandled);
-        try {
-            const runtime = createOpenScienceRuntime({
-                baseUrl: "http://runtime.test",
-                runtimeReconnectDelayMs: 0,
-                fetch: async () => {
-                    connected = true;
-                    return new Response(new ReadableStream({
-                        pull: () => new Promise(() => { }),
-                        cancel: () => Promise.reject(new Error("upstream cancel failed")),
-                    }), { headers: { "content-type": "text/event-stream" } });
-                },
-            });
-            const consuming = (async () => {
-                for await (const _ of runtime.events({ sessionID: "ses_abort", signal: controller.signal })) {
-                    // No event is expected.
-                }
-            })();
-            while (!connected)
-                await new Promise((resolve) => setTimeout(resolve, 1));
-            controller.abort();
-            await consuming;
-            await new Promise((resolve) => setImmediate(resolve));
-            assert.deepEqual(unhandled, []);
-        }
-        finally {
-            process.off("unhandledRejection", onUnhandled);
-        }
-    });
-});