@rynx-ai/daemon 0.1.11-beta.1 → 0.1.11-beta.3

package/dist/plugin-host-rpc.d.ts

@@ -1,4 +1,4 @@
-import { type AgentCapabilities, type AgentSessionStore, type ConversationRuntime, type SessionRegistry } from "@rynx-ai/core";
+import { type AdmissionReservation, type AgentSpec, type AgentCapabilities, type AgentRuntimeId, type AgentSessionStore, type ConversationRuntime, type ResolvedExecutionSnapshot, type SessionRegistry, type SessionWorkspaceSnapshot } from "@rynx-ai/core";
 import { type PluginAgentSummary, type PluginCapability, type PluginHostEvent, type PluginResolvedSessionExecution, type PluginSessionExecutionSnapshot, type PluginSessionInteractionResolveDisposition } from "@rynx-ai/plugin-sdk";
 import type { SessionInteractionResolution } from "@rynx-ai/protocol";
 import { PluginRunnerError } from "@rynx-ai/plugin-runner";
@@ -12,6 +12,24 @@ export interface PluginAgentCatalogHost {
         session: PluginSessionExecutionSnapshot;
     }): Promise<PluginResolvedSessionExecution>;
 }
+/** Mutable launch selectors are accepted only at the Host boundary. The
+ * resolver turns them into immutable Session-owned snapshots before a registry
+ * row is created; none of these selectors are persisted on the Session. */
+export interface PluginSessionLaunchSelection {
+    projectId?: string;
+    managedCwd?: string;
+    workspace?: SessionWorkspaceSnapshot;
+    agent?: string;
+    config?: AgentSpec;
+    provider?: AgentRuntimeId;
+    model?: string;
+    reasoningEffort?: string;
+    title?: string;
+}
+export interface PluginResolvedSessionLaunch {
+    workspace: SessionWorkspaceSnapshot;
+    execution: ResolvedExecutionSnapshot;
+}
 export interface PluginHostServices {
     installationId: string;
     installationProof: {
@@ -24,18 +42,42 @@ export interface PluginHostServices {
     sessionStore: AgentSessionStore;
     sessionRegistry: SessionRegistry;
     agentCatalog: PluginAgentCatalogHost;
+    sessionLaunch: {
+        resolve(input: PluginSessionLaunchSelection): Promise<PluginResolvedSessionLaunch>;
+    };
     interruptSession?(sessionId: string): Promise<boolean>;
+    terminateSession?(sessionId: string): Promise<boolean>;
     resolveSessionInteraction?(sessionId: string, interactionId: string, resolution: SessionInteractionResolution): Promise<{
         disposition: PluginSessionInteractionResolveDisposition;
     }>;
+    sessionFork?(input: {
+        sourceSessionId: string;
+        operationId: string;
+        title?: string;
+    }): Promise<{
+        sessionId: string;
+        disposition: "created" | "replayed";
+    }>;
+    admissionOpen?: () => boolean;
+    admissionReserve?: () => AdmissionReservation | undefined;
 }
 export interface PluginHostRpcOptions {
+    /** Manifest id returned by host.info. */
     pluginId: string;
+    /** Marketplace-qualified principal used for ownership and proof scopes. */
+    principalId?: string;
     daemonInstanceId: string;
-    grants: readonly PluginCapability[];
+    productVersion: string;
+    cliVersion: string;
+    capabilities: readonly PluginCapability[];
     services: PluginHostServices;
+    /** Canonical plugin-owned root permitted for the Workspace plugin's isolated
+     * Session directory. Omitted for every other plugin. */
+    managedWorkspaceRoot?: string;
     /** Resolving this promise is the stream's backpressure acknowledgement. */
     emit(event: PluginHostEvent): void | Promise<void>;
+    /** Bounded graceful-stop window used while disposing this Host. */
+    disposeForceAfterMs?: number;
 }
 /**
  * One authenticated plugin's capability-gated Host RPC surface.
@@ -46,19 +88,30 @@ export interface PluginHostRpcOptions {
  */
 export declare class PluginHostRpc {
     private readonly pluginId;
+    private readonly principalId;
     private readonly daemonInstanceId;
-    private readonly grants;
+    private readonly productVersion;
+    private readonly cliVersion;
+    private readonly capabilities;
     private readonly services;
+    private readonly managedWorkspaceRoot;
     private readonly emit;
+    private readonly disposeForceAfterMs;
     private readonly activeRuns;
     private readonly activeSessionRuns;
     private readonly activeRunsByOperation;
     private disposed;
+    private disposePromise?;
     constructor(options: PluginHostRpcOptions);
-    call(method: string, params: unknown): Promise<unknown>;
+    call(method: string, params: unknown, signal?: AbortSignal): Promise<unknown>;
     dispose(): Promise<void>;
     private ensureSession;
+    private ensureSessionAdmitted;
+    private resolveManagedWorkspace;
+    private resolveWorkspaceSnapshot;
+    private sessionEnsureResult;
     private runSession;
+    private runSessionAdmitted;
     private pumpRun;
     private releaseRun;
     private steerSession;
@@ -72,6 +125,9 @@ export declare class PluginHostRpc {
     private withOwnedSession;
     private resolveSessionInteraction;
     private forkSession;
+    private forkSessionAdmitted;
+    private reserveAdmission;
+    private withAdmission;
     private setSessionTitle;
     private resolveAgentExecution;
     private issueControlLink;

package/dist/plugin-host-rpc.js

@@ -1,8 +1,10 @@
 import { createHash, randomUUID } from "node:crypto";
-import { AgentRuntimeError, agentSpecSchema, SteerController, } from "@rynx-ai/core";
+import { realpath, stat } from "node:fs/promises";
+import path from "node:path";
+import { AgentRuntimeError, agentSpecSchema, resolvedExecutionSnapshotSchema, sessionWorkspaceSnapshotSchema, SteerController, } from "@rynx-ai/core";
 import { PLUGIN_HOST_MAX_ACTIVE_RUNS, } from "@rynx-ai/plugin-sdk";
 import { PluginRunnerError } from "@rynx-ai/plugin-runner";
-import { ensurePluginSessionLaunch, SessionLaunchOperationConflictError, SessionLaunchOperationTargetDeletedError, } from "./session-launch-operations.js";
+import { ensurePluginSessionLaunch, replayPluginSessionLaunch, SessionLaunchOperationConflictError, SessionLaunchOperationTargetDeletedError, } from "./session-launch-operations.js";
 import { createControlLink } from "./control-link-store.js";
 const MAX_MESSAGE_LENGTH = 1_000_000;
 /** Leaves ample room for the RPC envelope below the runner's 1 MiB line cap. */
@@ -43,42 +45,58 @@ const METHOD_CAPABILITY = {
  */
 export class PluginHostRpc {
     pluginId;
+    principalId;
     daemonInstanceId;
-    grants;
+    productVersion;
+    cliVersion;
+    capabilities;
     services;
+    managedWorkspaceRoot;
     emit;
+    disposeForceAfterMs;
     activeRuns = new Map();
     activeSessionRuns = new Map();
     activeRunsByOperation = new Map();
     disposed = false;
+    disposePromise;
     constructor(options) {
         this.pluginId = requiredString(options.pluginId, "pluginId", 64);
+        this.principalId = requiredString(options.principalId ?? options.pluginId, "principalId", 160);
         this.daemonInstanceId = requiredString(options.daemonInstanceId, "daemonInstanceId", 128);
-        this.grants = new Set(options.grants);
+        this.productVersion = requiredString(options.productVersion, "productVersion", 128);
+        this.cliVersion = requiredString(options.cliVersion, "cliVersion", 128);
+        this.capabilities = new Set(options.capabilities);
         this.services = options.services;
+        this.managedWorkspaceRoot = options.managedWorkspaceRoot
+            ? path.resolve(options.managedWorkspaceRoot)
+            : undefined;
         this.emit = options.emit;
+        this.disposeForceAfterMs = options.disposeForceAfterMs ?? 10_000;
     }
-    async call(method, params) {
+    async call(method, params, signal) {
         if (this.disposed)
             throw new PluginHostCallError("HOST_CLOSED", "plugin host is closed");
+        throwIfHostCallAborted(signal);
         if (method === "host.info") {
             return {
                 pluginId: this.pluginId,
                 installationId: this.services.installationId,
                 daemonInstanceId: this.daemonInstanceId,
+                productVersion: this.productVersion,
+                cliVersion: this.cliVersion,
                 installationProof: {
                     algorithm: this.services.installationProof.algorithm,
                     publicKey: this.services.installationProof.publicKey,
                 },
                 protocolVersion: 1,
-                grants: [...this.grants],
+                capabilities: [...this.capabilities],
             };
         }
         const capability = METHOD_CAPABILITY[method];
         if (!capability)
             throw new PluginHostCallError("METHOD_NOT_FOUND", `unknown host method: ${method}`);
-        if (!this.grants.has(capability)) {
-            throw new PluginHostCallError("CAPABILITY_DENIED", `host method ${method} requires capability ${capability}`);
+        if (!this.capabilities.has(capability)) {
+            throw new PluginHostCallError("CAPABILITY_NOT_DECLARED", `host method ${method} is missing manifest capability ${capability}`);
         }
         try {
             switch (method) {
@@ -87,7 +105,7 @@ export class PluginHostRpc {
                     return {
                         algorithm: this.services.installationProof.algorithm,
                         publicKey: this.services.installationProof.publicKey,
-                        signature: this.services.installationProof.sign(this.pluginId, challenge),
+                        signature: this.services.installationProof.sign(this.principalId, challenge),
                     };
                 }
                 case "agent.catalog.list":
@@ -97,9 +115,9 @@ export class PluginHostRpc {
                 case "agent.execution.resolve":
                     return await this.resolveAgentExecution(params);
                 case "session.ensure":
-                    return this.ensureSession(params);
+                    return await this.ensureSession(params);
                 case "session.run":
-                    return await this.runSession(params);
+                    return await this.runSession(params, signal);
                 case "session.steer":
                     return this.steerSession(params);
                 case "session.interrupt":
@@ -142,40 +160,162 @@ export class PluginHostRpc {
         }
     }
     async dispose() {
-        if (this.disposed)
-            return;
+        if (this.disposePromise)
+            return this.disposePromise;
         this.disposed = true;
         const runs = [...this.activeRuns.values()];
-        this.activeRuns.clear();
-        this.activeSessionRuns.clear();
-        this.activeRunsByOperation.clear();
-        for (const run of runs) {
-            run.interruptRequested = true;
-            if (run.interruptResult && await run.interruptResult.catch(() => false))
-                continue;
-            if (this.services.interruptSession) {
-                await this.services.interruptSession(run.sessionId).catch(() => false);
-            }
-            else {
-                run.abort.abort();
+        this.disposePromise = (async () => {
+            const stopped = await Promise.allSettled(runs.map(async (run) => {
+                if (this.activeRuns.get(run.runId) !== run)
+                    return;
+                run.interruptRequested = true;
+                const graceful = run.interruptResult ?? (this.services.interruptSession
+                    ? Promise.resolve().then(() => this.services.interruptSession(run.sessionId))
+                    : Promise.resolve().then(() => {
+                        run.abort.abort();
+                        return false;
+                    }));
+                const authoritative = forceStoppedInterrupt(graceful, this.disposeForceAfterMs, () => this.services.terminateSession?.(run.sessionId) ?? Promise.resolve(false));
+                run.interruptResult = authoritative;
+                if (!(await authoritative)) {
+                    throw new Error(`could not prove Session ${run.sessionId} stopped`);
+                }
+                this.releaseRun(run);
+            }));
+            const failures = stopped
+                .filter((result) => result.status === "rejected")
+                .map((result) => result.reason);
+            if (failures.length > 0) {
+                throw new AggregateError(failures, "plugin Host could not stop every active run");
             }
-        }
+        })();
+        return this.disposePromise;
+    }
+    async ensureSession(params) {
+        return this.withAdmission(() => this.ensureSessionAdmitted(params));
     }
-    ensureSession(params) {
+    async ensureSessionAdmitted(params) {
         const input = record(params);
         const scopeId = requiredString(input.scopeId, "scopeId", 512);
         const operationId = requiredString(input.operationId, "operationId", 512);
-        const session = sessionLaunchMeta(input.session);
-        const requestHash = hashCanonicalJson(session);
-        return ensurePluginSessionLaunch({
-            pluginId: this.pluginId,
+        const parsedSelection = sessionLaunchSelection(input.session);
+        if (parsedSelection.managedCwd && !this.managedWorkspaceRoot) {
+            throw new PluginHostCallError("INVALID_PARAMS", "session.managedCwd is reserved for the built-in Workspace plugin");
+        }
+        const rawRequestHash = hashCanonicalJson(parsedSelection);
+        const replay = replayPluginSessionLaunch({
+            pluginId: this.principalId,
+            scopeId,
+            operationId,
+            requestHash: rawRequestHash,
+            allowRequestHashMismatch: true,
+        });
+        if (replay)
+            return this.sessionEnsureResult(replay);
+        const selection = parsedSelection.managedCwd
+            ? {
+                ...parsedSelection,
+                managedCwd: await this.resolveManagedWorkspace(parsedSelection.managedCwd),
+            }
+            : parsedSelection.workspace
+                ? {
+                    ...parsedSelection,
+                    workspace: await this.resolveWorkspaceSnapshot(parsedSelection.workspace),
+                }
+                : parsedSelection;
+        const requestHash = hashCanonicalJson(selection);
+        const canonicalReplay = replayPluginSessionLaunch({
+            pluginId: this.principalId,
             scopeId,
             operationId,
             requestHash,
-            session,
         });
+        if (canonicalReplay)
+            return this.sessionEnsureResult(canonicalReplay);
+        const resolved = await this.services.sessionLaunch.resolve(selection);
+        const ensured = ensurePluginSessionLaunch({
+            pluginId: this.principalId,
+            scopeId,
+            operationId,
+            requestHash,
+            rawRequestHash,
+            session: {
+                workspace: sessionWorkspaceSnapshotSchema.parse(resolved.workspace),
+                execution: resolvedExecutionSnapshotSchema.parse(resolved.execution),
+                ...(selection.title ? { title: selection.title } : {}),
+            },
+        });
+        return this.sessionEnsureResult(ensured);
+    }
+    async resolveManagedWorkspace(directory) {
+        const root = this.managedWorkspaceRoot;
+        if (!root) {
+            throw new PluginHostCallError("INVALID_PARAMS", "session.managedCwd is reserved for the built-in Workspace plugin");
+        }
+        if (!path.isAbsolute(directory)) {
+            throw new PluginHostCallError("INVALID_PARAMS", "session.managedCwd must be absolute");
+        }
+        let canonicalRoot;
+        let canonicalDirectory;
+        try {
+            [canonicalRoot, canonicalDirectory] = await Promise.all([
+                realpath(root),
+                realpath(directory),
+            ]);
+        }
+        catch {
+            throw new PluginHostCallError("INVALID_PARAMS", "session.managedCwd must be an existing plugin-managed directory");
+        }
+        const relative = path.relative(canonicalRoot, canonicalDirectory);
+        if (relative === ".." ||
+            relative.startsWith(`..${path.sep}`) ||
+            path.isAbsolute(relative)) {
+            throw new PluginHostCallError("INVALID_PARAMS", "session.managedCwd escapes the plugin-managed workspace root");
+        }
+        return canonicalDirectory;
+    }
+    async resolveWorkspaceSnapshot(workspace) {
+        const directories = [workspace.cwd, ...workspace.allowedDirs];
+        if (directories.some((directory) => !path.isAbsolute(directory))) {
+            throw new PluginHostCallError("INVALID_PARAMS", "session.workspace paths must be absolute");
+        }
+        let canonical;
+        try {
+            canonical = await Promise.all(directories.map(async (directory) => {
+                const resolved = await realpath(directory);
+                if (!(await stat(resolved)).isDirectory()) {
+                    throw new Error("not a directory");
+                }
+                return resolved;
+            }));
+        }
+        catch {
+            throw new PluginHostCallError("INVALID_PARAMS", "session.workspace paths must be existing directories");
+        }
+        const parsed = sessionWorkspaceSnapshotSchema.safeParse({
+            cwd: canonical[0],
+            allowedDirs: canonical.slice(1),
+        });
+        if (!parsed.success) {
+            throw new PluginHostCallError("INVALID_PARAMS", `invalid session.workspace: ${parsed.error.issues[0]?.message ?? "invalid snapshot"}`);
+        }
+        return parsed.data;
+    }
+    sessionEnsureResult(result) {
+        const session = this.ownedSession(result.sessionId);
+        return {
+            ...result,
+            execution: {
+                provider: session.execution.provider,
+                model: session.execution.model,
+                reasoningEffort: session.execution.reasoningEffort,
+            },
+        };
+    }
+    async runSession(params, signal) {
+        return this.withAdmission(() => this.runSessionAdmitted(params, signal));
     }
-    async runSession(params) {
+    async runSessionAdmitted(params, signal) {
         const input = record(params);
         const sessionId = requiredSessionId(input);
         const operationId = optionalString(input.operationId, "operationId", 512);
@@ -191,6 +331,12 @@ export class PluginHostRpc {
         }
         const message = requiredText(input.message, "message", MAX_MESSAGE_LENGTH);
         const abort = new AbortController();
+        const cancel = () => abort.abort(signal?.reason);
+        if (signal?.aborted) {
+            cancel();
+            throwIfHostCallAborted(signal);
+        }
+        signal?.addEventListener("abort", cancel, { once: true });
         const steer = new SteerController();
         const runId = randomUUID();
         const run = {
@@ -210,23 +356,23 @@ export class PluginHostRpc {
             started = await this.services.conversationRuntime.runLive({
                 message,
                 threadId: sessionId,
-                provider: optionalRuntimeValue(input.provider),
-                model: optionalString(input.model, "model", 256) ?? session.model,
-                reasoningEffort: optionalString(input.reasoningEffort, "reasoningEffort", 128) ?? session.reasoningEffort,
-                cwd: optionalString(input.cwd, "cwd", 16_384),
-                agentName: optionalAgentId(input.agent, "agent") ?? session.agent,
-                agentSpec: session.config,
+                workspace: session.workspace,
+                execution: session.execution,
                 signal: abort.signal,
                 steer,
-                developerInstructions: optionalString(input.developerInstructions, "developerInstructions", 200_000),
             });
         }
         catch (error) {
             this.releaseRun(run);
             throw error;
         }
-        if (this.disposed || this.activeRuns.get(runId) !== run) {
+        finally {
+            signal?.removeEventListener("abort", cancel);
+        }
+        if (signal?.aborted || this.disposed || this.activeRuns.get(runId) !== run) {
+            abort.abort(signal?.reason);
             this.releaseRun(run);
+            throwIfHostCallAborted(signal);
             throw new PluginHostCallError("HOST_CLOSED", "plugin host is closed");
         }
         // Let the RPC transport write the request response before stream events are
@@ -338,6 +484,10 @@ export class PluginHostRpc {
     async interruptRun(params) {
         const input = record(params);
         const run = this.activeRunByIdentity(input);
+        const forceAfterMs = optionalPositiveNumber(input.forceAfterMs, "forceAfterMs");
+        if (forceAfterMs !== undefined && forceAfterMs > 30_000) {
+            throw new PluginHostCallError("INVALID_PARAMS", "forceAfterMs must not exceed 30000");
+        }
         if (run.interruptResult) {
             return { interrupted: await run.interruptResult };
         }
@@ -345,7 +495,7 @@ export class PluginHostRpc {
         // the authoritative stop is pending wait for its result: true suppresses
         // them, while false/error lets genuine native progress/terminal continue.
         run.interruptRequested = true;
-        const interruptResult = this.services.interruptSession
+        const graceful = this.services.interruptSession
             // ConversationRuntime wires AbortSignal to this same native operation.
             // Invoke it directly once so this boolean is the authoritative result;
             // aborting first would trigger a duplicate, unobserved interrupt.
@@ -356,6 +506,9 @@ export class PluginHostRpc {
                 // effort and cannot prove that native execution stopped.
                 return false;
             });
+        const interruptResult = forceAfterMs === undefined
+            ? graceful
+            : forceStoppedInterrupt(graceful, forceAfterMs, () => this.services.terminateSession?.(run.sessionId) ?? Promise.resolve(false));
         run.interruptResult = interruptResult;
         try {
             const interrupted = await interruptResult;
@@ -437,12 +590,40 @@ export class PluginHostRpc {
         return await resolve(sessionId, interactionId, resolution);
     }
     async forkSession(params) {
+        return this.withAdmission(() => this.forkSessionAdmitted(params));
+    }
+    async forkSessionAdmitted(params) {
         const input = record(params);
-        const fromSessionId = requiredString(input.fromSessionId, "fromSessionId", 512);
-        const toSessionId = requiredString(input.toSessionId, "toSessionId", 512);
-        this.ownedSession(fromSessionId);
-        this.ownedSession(toSessionId);
-        return await this.services.capabilities.forkSession(fromSessionId, toSessionId);
+        const sourceSessionId = requiredString(input.sourceSessionId, "sourceSessionId", 512);
+        const operationId = requiredString(input.operationId, "operationId", 512);
+        const title = optionalString(input.title, "title", 1_000);
+        this.ownedSession(sourceSessionId);
+        if (!this.services.sessionFork) {
+            throw new PluginHostCallError("HOST_CALL_FAILED", "Session fork is unavailable");
+        }
+        return await this.services.sessionFork({
+            sourceSessionId,
+            operationId: `${this.principalId}:${operationId}`,
+            ...(title ? { title } : {}),
+        });
+    }
+    reserveAdmission() {
+        const reservation = this.services.admissionReserve?.();
+        if (reservation)
+            return reservation;
+        if (!this.services.admissionReserve && this.services.admissionOpen?.() !== false) {
+            return { release() { } };
+        }
+        throw new PluginHostCallError("HOST_CALL_FAILED", "daemon maintenance is in progress", true);
+    }
+    async withAdmission(operation) {
+        const reservation = this.reserveAdmission();
+        try {
+            return await operation();
+        }
+        finally {
+            reservation.release();
+        }
     }
     setSessionTitle(params) {
         const input = record(params);
@@ -466,7 +647,7 @@ export class PluginHostRpc {
         this.ownedSession(sessionId);
         const ttlSeconds = optionalPositiveNumber(input.ttlSeconds, "ttlSeconds");
         return createControlLink({
-            pluginId: this.pluginId,
+            pluginId: this.principalId,
             sessionId,
             ...(ttlSeconds === undefined ? {} : { ttlMs: ttlSeconds * 1_000 }),
         });
@@ -479,9 +660,24 @@ export class PluginHostRpc {
         return session;
     }
     isOwned(session) {
-        return session.source === `plugin:${this.pluginId}`;
+        const seen = new Set();
+        let current = session;
+        while (current && !seen.has(current.id)) {
+            if (current.source === `plugin:${this.principalId}`)
+                return true;
+            seen.add(current.id);
+            current = current.forkedFromSessionId
+                ? this.services.sessionRegistry.get(current.forkedFromSessionId)
+                : undefined;
+        }
+        return false;
     }
 }
+function throwIfHostCallAborted(signal) {
+    if (!signal?.aborted)
+        return;
+    throw new PluginHostCallError("REQUEST_CANCELLED", "plugin host request was cancelled");
+}
 export class PluginHostCallError extends PluginRunnerError {
     retryable;
     data;
@@ -512,22 +708,50 @@ function toHostCallError(error) {
     }
     return new PluginHostCallError("HOST_CALL_FAILED", error instanceof Error ? error.message : String(error));
 }
-function sessionLaunchMeta(value) {
+function sessionLaunchSelection(value) {
     const input = record(value);
     assertJsonValue(input, "session");
+    const projectId = optionalString(input.projectId, "session.projectId", 512);
+    const managedCwd = optionalString(input.managedCwd, "session.managedCwd", 16_384);
+    const workspace = optionalSessionWorkspace(input.workspace);
     const agent = optionalAgentId(input.agent, "session.agent");
     const config = input.config === undefined ? undefined : agentSpecSchema.parse(input.config);
+    const provider = optionalRuntimeValue(input.provider);
     const model = optionalString(input.model, "session.model", 256);
     const reasoningEffort = optionalString(input.reasoningEffort, "session.reasoningEffort", 128);
     const title = optionalString(input.title, "session.title", 1_000);
+    if (Number(Boolean(projectId)) + Number(Boolean(managedCwd)) + Number(Boolean(workspace)) > 1) {
+        throw new PluginHostCallError("INVALID_PARAMS", "session.projectId, session.managedCwd, and session.workspace are mutually exclusive");
+    }
+    if (Number(Boolean(agent)) +
+        Number(Boolean(config)) +
+        Number(Boolean(provider)) >
+        1) {
+        throw new PluginHostCallError("INVALID_PARAMS", "session.agent, session.config, and session.provider are mutually exclusive");
+    }
     return {
+        ...(projectId ? { projectId } : {}),
+        ...(managedCwd ? { managedCwd } : {}),
+        ...(workspace ? { workspace } : {}),
         ...(agent ? { agent } : {}),
         ...(config ? { config } : {}),
+        ...(provider ? { provider } : {}),
         ...(model ? { model } : {}),
         ...(reasoningEffort ? { reasoningEffort } : {}),
         ...(title ? { title } : {}),
     };
 }
+function optionalSessionWorkspace(value) {
+    if (value === undefined)
+        return undefined;
+    const input = record(value);
+    const cwd = requiredPathString(input.cwd, "session.workspace.cwd", 16_384);
+    if (!Array.isArray(input.allowedDirs) || input.allowedDirs.length === 0) {
+        throw new PluginHostCallError("INVALID_PARAMS", "session.workspace.allowedDirs must be a non-empty string array");
+    }
+    const allowedDirs = input.allowedDirs.map((directory, index) => requiredPathString(directory, `session.workspace.allowedDirs[${index}]`, 16_384));
+    return { cwd, allowedDirs };
+}
 function sessionExecutionSnapshot(value) {
     const input = record(value);
     const runtime = optionalRuntimeValue(input.runtime);
@@ -608,6 +832,15 @@ function requiredString(value, label, maxLength) {
     }
     return value.trim();
 }
+function requiredPathString(value, label, maxLength) {
+    if (typeof value !== "string" || !value.trim()) {
+        throw new PluginHostCallError("INVALID_PARAMS", `${label} is required`);
+    }
+    if (value.length > maxLength) {
+        throw new PluginHostCallError("INVALID_PARAMS", `${label} is too long`);
+    }
+    return value;
+}
 function requiredText(value, label, maxLength) {
     if (typeof value !== "string" || !value.trim()) {
         throw new PluginHostCallError("INVALID_PARAMS", `${label} is required`);
@@ -648,6 +881,23 @@ function optionalPositiveNumber(value, label) {
     }
     return value;
 }
+async function forceStoppedInterrupt(graceful, forceAfterMs, terminate) {
+    let timer;
+    const graceExpired = new Promise((resolve) => {
+        timer = setTimeout(() => resolve(false), forceAfterMs);
+        timer.unref?.();
+    });
+    try {
+        if (await Promise.race([graceful.catch(() => false), graceExpired])) {
+            return true;
+        }
+    }
+    finally {
+        if (timer)
+            clearTimeout(timer);
+    }
+    return terminate();
+}
 function assertJsonValue(value, label, seen = new Set()) {
     if (value === null || typeof value === "string" || typeof value === "boolean")
         return;