@synsci/sdk 2.0.77 → 2.0.78-test.34098503148

package/dist/src/v2/gen/sdk.gen.js

@@ -1904,6 +1904,7 @@ export class Session extends HeyApiClient {
                     { in: "body", key: "parentID" },
                     { in: "body", key: "title" },
                     { in: "body", key: "permission" },
+                    { in: "body", key: "workspace" },
                 ],
             },
         ]);
@@ -2586,7 +2587,16 @@ export class Runtime extends HeyApiClient {
                 args: [
                     { in: "query", key: "directory" },
                     { in: "body", key: "sessionID" },
+                    { in: "body", key: "messageID" },
+                    { in: "body", key: "model" },
+                    { in: "body", key: "variant" },
+                    { in: "body", key: "tier" },
+                    { in: "body", key: "context" },
+                    { in: "body", key: "delegation" },
+                    { in: "body", key: "delegationSettings" },
+                    { in: "body", key: "requestID" },
                     { in: "body", key: "message" },
+                    { in: "body", key: "parts" },
                     { in: "body", key: "effort" },
                 ],
             },
@@ -2602,6 +2612,109 @@ export class Runtime extends HeyApiClient {
             },
         });
     }
+    /**
+     * Cancel one research run
+     *
+     * Cancellation is scoped to the run ID. Repeating it cannot stop a later run. Running tools may need time to settle; read the run receipt for terminal state.
+     */
+    cancel(parameters, options) {
+        const params = buildClientParams([parameters], [
+            {
+                args: [
+                    { in: "query", key: "directory" },
+                    { in: "body", key: "sessionID" },
+                    { in: "body", key: "runID" },
+                ],
+            },
+        ]);
+        return (options?.client ?? this.client).post({
+            url: "/runtime/cancel",
+            ...options,
+            ...params,
+            headers: {
+                "Content-Type": "application/json",
+                ...options?.headers,
+                ...params.headers,
+            },
+        });
+    }
+    /**
+     * Resolve a pending runtime decision
+     *
+     * Retries of an identical decision return its stored receipt. A conflicting response is rejected. Only live requests on the connected runtime can be resolved; an indeterminate receipt requires inspecting current state rather than repeating the action.
+     */
+    decide(parameters, options) {
+        const params = buildClientParams([parameters], [
+            {
+                args: [
+                    { in: "query", key: "directory" },
+                    { key: "runtimeDecisionInput", map: "body" },
+                ],
+            },
+        ]);
+        return (options?.client ?? this.client).post({
+            url: "/runtime/decision",
+            ...options,
+            ...params,
+            headers: {
+                "Content-Type": "application/json",
+                ...options?.headers,
+                ...params.headers,
+            },
+        });
+    }
+    /**
+     * Get supported runtime protocol
+     */
+    capabilities(parameters, options) {
+        const params = buildClientParams([parameters], [{ args: [{ in: "query", key: "directory" }] }]);
+        return (options?.client ?? this.client).get({
+            url: "/runtime/capabilities",
+            ...options,
+            ...params,
+        });
+    }
+    /**
+     * Get a durable research run
+     *
+     * Returns the authoritative run receipt and terminal result reference, independently of event retention. A dead runtime is interrupted and never automatically retried.
+     */
+    getRun(parameters, options) {
+        const params = buildClientParams([parameters], [
+            {
+                args: [
+                    { in: "query", key: "directory" },
+                    { in: "query", key: "sessionID" },
+                    { in: "query", key: "runID" },
+                ],
+            },
+        ]);
+        return (options?.client ?? this.client).get({
+            url: "/runtime/run",
+            ...options,
+            ...params,
+        });
+    }
+    /**
+     * Resynchronize a research session
+     *
+     * Returns durable run receipts, an event cursor and live pending decisions belonging to this server process. Replayed decision events are historical; only pending requests in a fresh snapshot are actionable.
+     */
+    snapshot(parameters, options) {
+        const params = buildClientParams([parameters], [
+            {
+                args: [
+                    { in: "query", key: "directory" },
+                    { in: "query", key: "sessionID" },
+                ],
+            },
+        ]);
+        return (options?.client ?? this.client).get({
+            url: "/runtime/snapshot",
+            ...options,
+            ...params,
+        });
+    }
     /**
      * Replay research run events
      *

package/dist/src/v2/gen/types.gen.d.ts

@@ -366,34 +366,6 @@ export type TextPart = {
         [key: string]: unknown;
     };
 };
-export type SubtaskPart = {
-    id: string;
-    sessionID: string;
-    messageID: string;
-    type: "subtask";
-    prompt: string;
-    description: string;
-    agent: string;
-    model?: {
-        providerID: string;
-        modelID: string;
-    };
-    command?: string;
-};
-export type ReasoningPart = {
-    id: string;
-    sessionID: string;
-    messageID: string;
-    type: "reasoning";
-    text: string;
-    metadata?: {
-        [key: string]: unknown;
-    };
-    time: {
-        start: number;
-        end?: number;
-    };
-};
 export type FilePartSourceText = {
     value: string;
     start: number;
@@ -429,6 +401,42 @@ export type ResourceSource = {
     uri: string;
 };
 export type FilePartSource = FileSource | SymbolSource | ResourceSource;
+export type SubtaskAttachment = {
+    type: "file";
+    mime: string;
+    filename?: string;
+    url: string;
+    source?: FilePartSource;
+};
+export type SubtaskPart = {
+    id: string;
+    sessionID: string;
+    messageID: string;
+    type: "subtask";
+    prompt: string;
+    description: string;
+    agent: string;
+    model?: {
+        providerID: string;
+        modelID: string;
+    };
+    command?: string;
+    attachments?: Array<SubtaskAttachment>;
+};
+export type ReasoningPart = {
+    id: string;
+    sessionID: string;
+    messageID: string;
+    type: "reasoning";
+    text: string;
+    metadata?: {
+        [key: string]: unknown;
+    };
+    time: {
+        start: number;
+        end?: number;
+    };
+};
 export type FilePart = {
     id: string;
     sessionID: string;
@@ -624,6 +632,13 @@ export type EventPermissionAsked = {
     type: "permission.asked";
     properties: PermissionRequest;
 };
+export type EventPermissionCancelled = {
+    type: "permission.cancelled";
+    properties: {
+        sessionID: string;
+        requestID: string;
+    };
+};
 export type EventPermissionReplied = {
     type: "permission.replied";
     properties: {
@@ -775,6 +790,13 @@ export type EventQuestionReplied = {
         answers: Array<QuestionAnswer>;
     };
 };
+export type EventQuestionCancelled = {
+    type: "question.cancelled";
+    properties: {
+        sessionID: string;
+        requestID: string;
+    };
+};
 export type EventQuestionRejected = {
     type: "question.rejected";
     properties: {
@@ -847,6 +869,10 @@ export type Session = {
     slug: string;
     projectID: string;
     directory: string;
+    /**
+     * Default tool directory: owned scratch or the existing project directory.
+     */
+    workspace?: "isolated" | "project";
     parentID?: string;
     summary?: {
         additions: number;
@@ -998,7 +1024,7 @@ export type EventWorktreeFailed = {
         message: string;
     };
 };
-export type Event = EventServerConnected | EventGlobalDisposed | EventInstallationUpdated | EventInstallationUpdateAvailable | EventProjectUpdated | EventServerInstanceDisposed | EventProjectTrustChanged | EventAccountUpdated | EventLspClientDiagnostics | EventLspUpdated | EventFileWatcherUpdated | EventSessionFilesystemChanged | EventProjectAccessChanged | EventVcsBranchUpdated | EventMessageUpdated | EventMessageRemoved | EventMessagePartUpdated | EventMessagePartRemoved | EventPermissionAsked | EventPermissionReplied | EventSkillUpdated | EventSessionContext | EventSessionCompaction | EventSessionRequestProgress | EventSessionStatus | EventSessionIdle | EventQuestionAsked | EventQuestionReplied | EventQuestionRejected | EventSessionCompacted | EventTodoUpdated | EventMcpToolsChanged | EventMcpBrowserOpenFailed | EventCommandExecuted | EventSessionCreated | EventSessionUpdated | EventSessionDeleted | EventSessionDiff | EventSessionError | EventFileEdited | EventPtyCreated | EventPtyUpdated | EventPtyExited | EventPtyDeleted | EventWorktreeReady | EventWorktreeFailed;
+export type Event = EventServerConnected | EventGlobalDisposed | EventInstallationUpdated | EventInstallationUpdateAvailable | EventProjectUpdated | EventServerInstanceDisposed | EventProjectTrustChanged | EventAccountUpdated | EventLspClientDiagnostics | EventLspUpdated | EventFileWatcherUpdated | EventSessionFilesystemChanged | EventProjectAccessChanged | EventVcsBranchUpdated | EventMessageUpdated | EventMessageRemoved | EventMessagePartUpdated | EventMessagePartRemoved | EventPermissionAsked | EventPermissionCancelled | EventPermissionReplied | EventSkillUpdated | EventSessionContext | EventSessionCompaction | EventSessionRequestProgress | EventSessionStatus | EventSessionIdle | EventQuestionAsked | EventQuestionReplied | EventQuestionCancelled | EventQuestionRejected | EventSessionCompacted | EventTodoUpdated | EventMcpToolsChanged | EventMcpBrowserOpenFailed | EventCommandExecuted | EventSessionCreated | EventSessionUpdated | EventSessionDeleted | EventSessionDiff | EventSessionError | EventFileEdited | EventPtyCreated | EventPtyUpdated | EventPtyExited | EventPtyDeleted | EventWorktreeReady | EventWorktreeFailed;
 export type GlobalEvent = {
     directory: string;
     payload: Event;
@@ -2139,11 +2165,68 @@ export type SubtaskPartInput = {
         modelID: string;
     };
     command?: string;
+    attachments?: Array<SubtaskAttachment>;
 };
 export type RuntimePromptAccepted = {
     runID: string;
     acceptedAt: number;
 };
+export type RuntimeRun = {
+    runID: string;
+    sessionID: string;
+    requestID?: string;
+    messageID: string;
+    state: "accepted" | "running" | "completed" | "failed" | "cancelled" | "interrupted";
+    acceptedAt: number;
+    updatedAt: number;
+    completedAt?: number;
+    resultMessageID?: string;
+    error?: {
+        code: string;
+        message: string;
+    };
+};
+export type RuntimeDecisionResult = {
+    sessionID: string;
+    requestID: string;
+    status: "resolved" | "indeterminate";
+    decidedAt: number;
+};
+export type RuntimeDecisionInput = {
+    sessionID: string;
+    kind: "permission";
+    requestID: string;
+    reply: "once" | "session" | "project" | "always" | "reject";
+    message?: string;
+} | {
+    sessionID: string;
+    kind: "question";
+    requestID: string;
+    answers: Array<QuestionAnswer>;
+} | {
+    sessionID: string;
+    kind: "question_reject";
+    requestID: string;
+};
+export type RuntimeCapabilities = {
+    protocolVersion: "1.0";
+    serverVersion: string;
+    idempotentPrompts: true;
+    richInputs: true;
+    runSnapshots: true;
+    eventRetention: number;
+    crashRecovery: "interrupt";
+    decisionScope: "connected_runtime";
+};
+export type RuntimeSnapshot = {
+    sessionID: string;
+    runs: Array<RuntimeRun>;
+    oldestSequence: number;
+    latestSequence: number;
+    permissions: Array<PermissionRequest>;
+    questions: Array<QuestionRequest>;
+    decisionScope: "connected_runtime";
+};
 export type RuntimeEvent = {
     sequence: number;
     sessionID: string;
@@ -8273,6 +8356,7 @@ export type SessionCreateData = {
         parentID?: string;
         title?: string;
         permission?: PermissionRuleset;
+        workspace?: "isolated" | "project";
     };
     path?: never;
     query?: {
@@ -9726,7 +9810,26 @@ export type PermissionRespondResponse = PermissionRespondResponses[keyof Permiss
 export type RuntimePromptData = {
     body?: {
         sessionID: string;
-        message: string;
+        messageID?: string;
+        model?: {
+            providerID: string;
+            modelID: string;
+        };
+        variant?: string;
+        tier?: string;
+        context?: number;
+        delegation?: boolean;
+        delegationSettings?: {
+            level?: "off" | "light" | "standard" | "high";
+            workerModel?: {
+                providerID: string;
+                modelID: string;
+            };
+            autonomy?: "interactive" | "balanced" | "autonomous";
+        };
+        requestID?: string;
+        message?: string;
+        parts?: Array<TextPartInput | FilePartInput | AgentPartInput | ConversationPartInput | SubtaskPartInput>;
         effort: "normal" | "ultra";
     };
     path?: never;
@@ -9752,6 +9855,119 @@ export type RuntimePromptResponses = {
     202: RuntimePromptAccepted;
 };
 export type RuntimePromptResponse = RuntimePromptResponses[keyof RuntimePromptResponses];
+export type RuntimeCancelData = {
+    body?: {
+        sessionID: string;
+        runID: string;
+    };
+    path?: never;
+    query?: {
+        directory?: string;
+    };
+    url: "/runtime/cancel";
+};
+export type RuntimeCancelErrors = {
+    /**
+     * Session or run not found
+     */
+    404: unknown;
+};
+export type RuntimeCancelResponses = {
+    /**
+     * Current run state
+     */
+    200: RuntimeRun;
+};
+export type RuntimeCancelResponse = RuntimeCancelResponses[keyof RuntimeCancelResponses];
+export type RuntimeDecideData = {
+    body?: RuntimeDecisionInput;
+    path?: never;
+    query?: {
+        directory?: string;
+    };
+    url: "/runtime/decision";
+};
+export type RuntimeDecideErrors = {
+    /**
+     * Invalid answer
+     */
+    400: unknown;
+    /**
+     * Session not found
+     */
+    404: unknown;
+    /**
+     * Conflicting or expired decision
+     */
+    409: unknown;
+};
+export type RuntimeDecideResponses = {
+    /**
+     * Decision receipt
+     */
+    200: RuntimeDecisionResult;
+};
+export type RuntimeDecideResponse = RuntimeDecideResponses[keyof RuntimeDecideResponses];
+export type RuntimeCapabilitiesData = {
+    body?: never;
+    path?: never;
+    query?: {
+        directory?: string;
+    };
+    url: "/runtime/capabilities";
+};
+export type RuntimeCapabilitiesResponses = {
+    /**
+     * Runtime capabilities
+     */
+    200: RuntimeCapabilities;
+};
+export type RuntimeCapabilitiesResponse = RuntimeCapabilitiesResponses[keyof RuntimeCapabilitiesResponses];
+export type RuntimeGetRunData = {
+    body?: never;
+    path?: never;
+    query: {
+        directory?: string;
+        sessionID: string;
+        runID: string;
+    };
+    url: "/runtime/run";
+};
+export type RuntimeGetRunErrors = {
+    /**
+     * Session or run not found
+     */
+    404: unknown;
+};
+export type RuntimeGetRunResponses = {
+    /**
+     * Research run
+     */
+    200: RuntimeRun;
+};
+export type RuntimeGetRunResponse = RuntimeGetRunResponses[keyof RuntimeGetRunResponses];
+export type RuntimeSnapshotData = {
+    body?: never;
+    path?: never;
+    query: {
+        directory?: string;
+        sessionID: string;
+    };
+    url: "/runtime/snapshot";
+};
+export type RuntimeSnapshotErrors = {
+    /**
+     * Session not found
+     */
+    404: unknown;
+};
+export type RuntimeSnapshotResponses = {
+    /**
+     * Runtime snapshot
+     */
+    200: RuntimeSnapshot;
+};
+export type RuntimeSnapshotResponse = RuntimeSnapshotResponses[keyof RuntimeSnapshotResponses];
 export type RuntimeReplayData = {
     body?: never;
     path?: never;

package/dist/src/v2/index.d.ts

@@ -6,6 +6,7 @@ export declare function createOpenScience(options?: ServerOptions): Promise<{
     client: import("./client.js").OpenScienceClient;
     server: {
         url: string;
-        close(): void;
+        pid: number;
+        close: () => Promise<void>;
     };
 }>;

package/dist/src/v2/index.js

@@ -3,11 +3,14 @@ export * from "./server.js";
 export * from "./runtime.js";
 import { createOpenScienceClient } from "./client.js";
 import { createOpenScienceServer } from "./server.js";
+import { serverClientOptions } from "../server-process.js";
 export async function createOpenScience(options) {
+    const connection = serverClientOptions(options);
     const server = await createOpenScienceServer({
         ...options,
     });
     const client = createOpenScienceClient({
+        ...connection,
         baseUrl: server.url,
     });
     return {

package/dist/src/v2/runtime.d.ts

@@ -1,5 +1,5 @@
 import { type OpenScienceClientConfig } from "./client.js";
-import type { RuntimeEvent, RuntimeEventReplay, RuntimePromptAccepted, RuntimePromptData } from "./gen/types.gen.js";
+import type { RuntimeEvent, RuntimeEventReplay, RuntimePromptAccepted, RuntimePromptData, RuntimeCapabilities, RuntimeRun, RuntimeSnapshot, RuntimeDecisionInput, RuntimeDecisionResult } from "./gen/types.gen.js";
 export type RuntimePromptInput = NonNullable<RuntimePromptData["body"]>;
 export type RuntimeEventInput = {
     sessionID: string;
@@ -33,6 +33,27 @@ export declare class OpenScienceRuntime {
     #private;
     constructor(config?: OpenScienceRuntimeConfig);
     prompt(input: RuntimePromptInput): Promise<RuntimePromptAccepted>;
+    capabilities(): Promise<RuntimeCapabilities>;
+    getRun(input: {
+        sessionID: string;
+        runID: string;
+    }): Promise<RuntimeRun>;
+    snapshot(input: {
+        sessionID: string;
+    }): Promise<RuntimeSnapshot>;
+    cancel(input: {
+        sessionID: string;
+        runID: string;
+    }): Promise<RuntimeRun>;
+    decide(input: RuntimeDecisionInput): Promise<RuntimeDecisionResult>;
+    /** Snapshot reads survive event eviction. Waiting never submits new work or
+     * resolves a decision: callers can surface pending cards through snapshot. */
+    wait(input: {
+        sessionID: string;
+        runID: string;
+        signal?: AbortSignal;
+        intervalMs?: number;
+    }): Promise<RuntimeRun>;
     replay(input: Omit<RuntimeEventInput, "signal">): Promise<RuntimeEventReplay>;
     events(input: RuntimeEventInput): AsyncGenerator<RuntimeEvent, void, void>;
 }

package/dist/src/v2/runtime.js

@@ -49,6 +49,37 @@ export class OpenScienceRuntime {
         })
             .then((result) => result.data);
     }
+    capabilities() {
+        return this.#client.runtime.capabilities(undefined, { throwOnError: true }).then((result) => result.data);
+    }
+    getRun(input) {
+        return this.#client.runtime.getRun(input, { throwOnError: true }).then((result) => result.data);
+    }
+    snapshot(input) {
+        return this.#client.runtime.snapshot(input, { throwOnError: true }).then((result) => result.data);
+    }
+    cancel(input) {
+        return this.#client.runtime.cancel(input, { throwOnError: true }).then((result) => result.data);
+    }
+    decide(input) {
+        return this.#client.runtime
+            .decide({ runtimeDecisionInput: input }, { throwOnError: true })
+            .then((result) => result.data);
+    }
+    /** Snapshot reads survive event eviction. Waiting never submits new work or
+     * resolves a decision: callers can surface pending cards through snapshot. */
+    async wait(input) {
+        const interval = input.intervalMs ?? 1000;
+        if (!Number.isFinite(interval) || interval < 10)
+            throw new Error("Run polling interval must be at least 10 ms");
+        for (;;) {
+            input.signal?.throwIfAborted();
+            const result = await this.#client.runtime.getRun({ sessionID: input.sessionID, runID: input.runID }, { throwOnError: true, signal: input.signal });
+            if (result.data.state !== "accepted" && result.data.state !== "running")
+                return result.data;
+            await waitForReconnect(interval, input.signal);
+        }
+    }
     replay(input) {
         return this.#client.runtime
             .replay(input, {
@@ -75,6 +106,12 @@ export class OpenScienceRuntime {
                 },
             });
             for await (const event of result.stream) {
+                if (event.sessionID !== input.sessionID || !Number.isSafeInteger(event.sequence) || event.sequence < 1)
+                    throw new RuntimeEventCursorError("The runtime returned an invalid session or sequence");
+                if (lastSequence !== undefined && event.sequence <= lastSequence)
+                    continue;
+                if (lastSequence !== undefined && event.sequence !== lastSequence + 1)
+                    throw new RuntimeEventCursorError("The runtime event stream has a gap; refresh the session snapshot");
                 lastSequence = event.sequence;
                 failures = 0;
                 delivered = true;

package/dist/src/v2/server.d.ts

@@ -1,12 +1,10 @@
-import { type Config } from "./gen/types.gen.js";
-export type ServerOptions = {
-    hostname?: string;
-    port?: number;
-    signal?: AbortSignal;
-    timeout?: number;
+import type { Config } from "./gen/types.gen.js";
+import { type ServerProcessOptions } from "../server-process.js";
+export type ServerOptions = ServerProcessOptions & {
     config?: Config;
 };
 export declare function createOpenScienceServer(options?: ServerOptions): Promise<{
     url: string;
-    close(): void;
+    pid: number;
+    close: () => Promise<void>;
 }>;

package/dist/src/v2/server.js

@@ -1,68 +1,4 @@
-import { spawn } from "node:child_process";
-export async function createOpenScienceServer(options) {
-    options = Object.assign({
-        hostname: "127.0.0.1",
-        port: 4096,
-        timeout: 5000,
-    }, options ?? {});
-    const args = [`serve`, `--port=${options.port}`];
-    if (options.config?.logLevel)
-        args.push(`--log-level=${options.config.logLevel}`);
-    const proc = spawn(`openscience`, args, {
-        signal: options.signal,
-        env: {
-            ...process.env,
-            OPENSCIENCE_CONFIG_CONTENT: JSON.stringify(options.config ?? {}),
-        },
-    });
-    const url = await new Promise((resolve, reject) => {
-        const id = setTimeout(() => {
-            reject(new Error(`Timeout waiting for server to start after ${options.timeout}ms`));
-        }, options.timeout);
-        let output = "";
-        proc.stdout?.on("data", (chunk) => {
-            output += chunk.toString();
-            const lines = output.split("\n");
-            for (const line of lines) {
-                if (line.startsWith("openscience server listening")) {
-                    const match = line.match(/on\s+(https?:\/\/[^\s]+)/);
-                    if (!match) {
-                        clearTimeout(id);
-                        reject(new Error(`Failed to parse server url from output: ${line}`));
-                        return;
-                    }
-                    clearTimeout(id);
-                    resolve(match[1]);
-                    return;
-                }
-            }
-        });
-        proc.stderr?.on("data", (chunk) => {
-            output += chunk.toString();
-        });
-        proc.on("exit", (code) => {
-            clearTimeout(id);
-            let msg = `Server exited with code ${code}`;
-            if (output.trim()) {
-                msg += `\nServer output: ${output}`;
-            }
-            reject(new Error(msg));
-        });
-        proc.on("error", (error) => {
-            clearTimeout(id);
-            reject(error);
-        });
-        if (options.signal) {
-            options.signal.addEventListener("abort", () => {
-                clearTimeout(id);
-                reject(new Error("Aborted"));
-            });
-        }
-    });
-    return {
-        url,
-        close() {
-            proc.kill();
-        },
-    };
+import { startServer } from "../server-process.js";
+export function createOpenScienceServer(options) {
+    return startServer(options);
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
   "name": "@synsci/sdk",
-  "version": "2.0.77",
+  "version": "2.0.78-test.34098503148",
   "type": "module",
   "license": "Apache-2.0",
   "scripts": {

package/dist/test/mcp-auth-contract.test.d.ts

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