@rigkit/sdk 0.2.2 → 0.2.4

package/README.md

@@ -8,7 +8,7 @@ Configs should import authoring helpers from this package:
 import { env, workflow } from "@rigkit/sdk";
 ```
 
-Task handlers receive `runtime.log(message, options)` for structured step logs.
+Task handlers receive `step.log(message, options)` for structured step logs. Pass `step.log` to SDKs that accept a logger callback.
 Those events stream over the runtime run session and are rendered by interactive
 hosts such as the `rig` terminal run timeline.
 Provider VM commands can also report incremental stdout/stderr through

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rigkit/sdk",
-  "version": "0.2.2",
+  "version": "0.2.4",
   "type": "module",
   "repository": {
     "type": "git",
@@ -23,8 +23,8 @@
     "@effect/platform": "0.96.1",
     "@effect/platform-bun": "0.89.0",
     "effect": "^3.21.2",
-    "@rigkit/engine": "0.2.2",
-    "@rigkit/runtime-client": "0.2.2"
+    "@rigkit/engine": "0.2.4",
+    "@rigkit/runtime-client": "0.2.4"
   },
   "devDependencies": {
     "@types/bun": "latest",

package/src/host.ts

@@ -1,8 +1,17 @@
+export type HostCapabilityLogOptions = {
+  stream?: "stdout" | "stderr" | "info";
+  label?: string;
+};
+
+export type HostCapabilityContext = {
+  log(data: string, options?: HostCapabilityLogOptions): void;
+};
+
 export type HostCapabilityDefinition<Input = unknown, Result = unknown> = {
   readonly schemaHash?: string;
   readonly input?: unknown;
   readonly output?: unknown;
-  readonly handle: (params: Input) => Result | Promise<Result>;
+  readonly handle: (params: Input, context?: HostCapabilityContext) => Result | Promise<Result>;
 };
 
 export type HostCapabilityHandler<Input = unknown, Result = unknown> =

package/src/index.test.ts

@@ -16,7 +16,7 @@ import { defineHostCapabilities, defineHostCapability } from "./host.ts";
 
 describe("@rigkit/sdk package boundary", () => {
   test("exports authoring API and project runtime entrypoints", () => {
-    expect(RIGKIT_SDK_VERSION).toBe("0.2.2");
+    expect(RIGKIT_SDK_VERSION).toBe("0.2.4");
     expect(env).toBeTypeOf("function");
     expect(env.secret).toBeTypeOf("function");
     expect(defineConfig).toBeTypeOf("function");

package/src/index.ts

@@ -19,12 +19,10 @@ export {
   DEFAULT_IDLE_MS,
   RIGKIT_RUNTIME_VERSION,
   createRuntimeStateService,
-  HostCapabilityRequirementEffectSchema,
   HostCommandRequestEffectSchema,
   HostCommandRequestSchema,
   HostCommandResultEffectSchema,
   HostCommandResultSchema,
-  HostMethodRequirementEffectSchema,
   HostResponseEffectSchema,
   HostResponseSchema,
   OkResponseEffectSchema,

package/src/runtime/api.ts

@@ -3,8 +3,6 @@ import { runtimeControlApi } from "@rigkit/runtime-client";
 
 export {
   RuntimeControlHealthEffectSchema as RuntimeHealthEffectSchema,
-  RuntimeControlHostCapabilityRequirementEffectSchema as HostCapabilityRequirementEffectSchema,
-  RuntimeControlHostMethodRequirementEffectSchema as HostMethodRequirementEffectSchema,
   RuntimeControlMetadataEffectSchema as RuntimeMetadataEffectSchema,
   RuntimeControlOkResponseEffectSchema as OkResponseEffectSchema,
   RuntimeControlOperationCliEffectSchema as RuntimeOperationCliEffectSchema,

package/src/runtime/app.test.ts

@@ -237,11 +237,10 @@ describe("runtime HTTP app", () => {
       scheme: "bearer",
     });
     expect(body.components.schemas.RuntimeOperation.required).toContain("inputSchema");
-    expect(body.components.schemas.Workspace.required).toContain("data");
+    expect(body.components.schemas.Workspace.required).toContain("ctx");
     expect(body.components.schemas.OperationsManifest.required).toEqual([
-      "hostMethods",
-      "hostCapabilities",
       "operations",
+      "workspaceOperations",
     ]);
   });
 
@@ -277,7 +276,6 @@ describe("runtime HTTP app", () => {
           kind: "command",
           title: "SSH",
           description: "Get an SSH command",
-          requiredHostMethods: [{ id: "host.command.run", modes: ["interactive"] }],
           inputFields: [
             { kind: "string", name: "workflow", required: false },
             { kind: "string", name: "workspaceOrVmId", position: 0, required: true },
@@ -299,9 +297,6 @@ describe("runtime HTTP app", () => {
           source: "config",
           title: "Open",
           description: "Open a workspace",
-          createsWorkspace: false,
-          requiredHostMethods: [{ id: "host.command.run", modes: ["interactive"] }],
-          requiredHostCapabilities: [{ id: "cmux.open", schemaHash: "sha256:cmux-open-schema" }],
           inputFields: [
             {
               kind: "workspace",
@@ -319,33 +314,47 @@ describe("runtime HTTP app", () => {
             },
           ],
         },
+        {
+          workflow: "",
+          id: "create",
+          source: "core",
+          kind: "command",
+          createsWorkspace: true,
+          inputFields: [{ kind: "string", name: "name", required: true }],
+        },
+      ],
+      listRuntimeWorkspaceOperations: () => [
         {
           workflow: "test",
-          id: "fork",
+          id: "remove",
+          source: "core",
+          kind: "workspace-action",
+          title: "Remove",
+          description: "Remove a workspace",
+          inputFields: [],
+        },
+        {
+          workflow: "test",
+          id: "open-cmux",
           source: "config",
-          createsWorkspace: true,
+          kind: "workspace-action",
+          title: "Open cmux",
+          description: "Open a workspace in cmux",
           inputFields: [],
         },
       ],
     } as any);
 
     const operation = manifest.operations.find((item) => item.id === "open");
-    const forkOperation = manifest.operations.find((item) => item.id === "fork");
+    const createOperation = manifest.operations.find((item) => item.id === "create");
     const sshOperation = manifest.operations.find((item) => item.id === "ssh");
+    const cmuxOperation = manifest.workspaceOperations.find((item) => item.id === "open-cmux");
     const inputSchema = operation?.inputSchema as any;
     const sshInputSchema = sshOperation?.inputSchema as any;
 
     expect(operation?.source).toBe("config");
     expect(operation?.kind).toBe("workspace-action");
-    expect(operation?.requiredHostMethods).toEqual([
-      { id: "host.command.run", modes: ["interactive"] },
-    ]);
-    expect(operation?.requiredHostCapabilities).toEqual([
-      { id: "cmux.open", schemaHash: "sha256:cmux-open-schema" },
-    ]);
-    expect(manifest.hostCapabilities.optional).toEqual([
-      { id: "cmux.open", schemaHash: "sha256:cmux-open-schema" },
-    ]);
+    expect(cmuxOperation?.id).toBe("open-cmux");
     expect(operation?.cli?.positionals).toEqual([{ name: "workspace", index: 0 }]);
     expect(operation?.cli?.options).toEqual([
       { name: "rebuild", flag: "--rebuild", required: false, type: "boolean" },
@@ -361,9 +370,9 @@ describe("runtime HTTP app", () => {
       default: false,
       description: "Rebuild before opening",
     });
-    expect(forkOperation?.source).toBe("config");
-    expect(forkOperation?.createsWorkspace).toBe(true);
-    expect(manifest.operations.some((item) => item.id === "create")).toBe(false);
+    expect(createOperation?.source).toBe("core");
+    expect(createOperation?.createsWorkspace).toBe(true);
+    expect(manifest.workspaceOperations.map((item) => item.id)).toEqual(["remove", "open-cmux"]);
     expect(sshOperation?.cli?.options?.find((item) => item.name === "print")).toEqual({
       name: "print",
       flag: "--print",
@@ -407,7 +416,7 @@ describe("runtime HTTP app", () => {
       `
         import { defineConfig, sequence } from "${import.meta.dir}/../../../engine/src/index.ts";
 
-        const root = sequence("session-test").step("noop", async () => ({ ok: true }));
+        const root = sequence("session-test").step("noop", async () => ({ ctx: { ok: true } }));
 
         export default defineConfig({
           providers: {},
@@ -447,8 +456,6 @@ describe("runtime HTTP app", () => {
 
       expect(ack?.operation).toEqual({
         id: "plan",
-        requiredHostCapabilities: [],
-        requiredHostMethods: [],
       });
       expect(messages.some((message) => message.type === "heartbeat.ack")).toBe(true);
       expect(messages.some((message) => message.type === "run.completed")).toBe(true);
@@ -457,21 +464,24 @@ describe("runtime HTTP app", () => {
     }
   });
 
-  test("exposes persisted workspace payload as workspace data", async () => {
-    const projectDir = mkdtempSync(join(tmpdir(), "rigkit-runtime-workspace-data-"));
+  test("exposes persisted workspace payload as workspace context", async () => {
+    const projectDir = mkdtempSync(join(tmpdir(), "rigkit-runtime-workspace-ctx-"));
     const configPath = join(projectDir, "rig.config.ts");
     writeFileSync(
       configPath,
       `
         import { defineConfig, sequence } from "${import.meta.dir}/../../../engine/src/index.ts";
 
-        const root = sequence("workspace-data")
-          .step("prepare", async () => ({ repoPath: "/workspace/repo" }))
-          .create(async ({ ctx, name }) => ({
-            name,
-            resourceId: "resource-" + name,
-            repoPath: ctx.repoPath,
-          }));
+        const root = sequence("workspace-ctx")
+          .step("prepare", async () => ({ ctx: { repoPath: "/workspace/repo" } }))
+          .workspace({
+            create: async ({ workflow, workspace }) => ({
+              name: workspace.name,
+              vmId: "vm-" + workspace.name,
+              repoPath: workflow.ctx.repoPath,
+            }),
+            remove: async () => {},
+          });
 
         export default defineConfig({
           providers: {},
@@ -481,7 +491,7 @@ describe("runtime HTTP app", () => {
     );
 
     const server = await serveRuntime({
-      projectId: "project-workspace-data-test",
+      projectId: "project-workspace-ctx-test",
       projectDir,
       configPath,
       statePath: join(projectDir, "state.sqlite"),
@@ -505,14 +515,13 @@ describe("runtime HTTP app", () => {
 
       const { workspaces } = await fetch(new URL("/workspaces", server.url), {
         headers: { authorization: `Bearer ${server.token}` },
-      }).then((response) => response.json() as Promise<{ workspaces: Array<{ data: Record<string, unknown>; metadata: Record<string, unknown> }> }>);
+      }).then((response) => response.json() as Promise<{ workspaces: Array<{ ctx: Record<string, unknown> }> }>);
 
-      expect(workspaces[0]?.data).toEqual({
+      expect(workspaces[0]?.ctx).toEqual({
         name: "demo",
-        resourceId: "resource-demo",
+        vmId: "vm-demo",
         repoPath: "/workspace/repo",
       });
-      expect(workspaces[0]?.metadata).toEqual(workspaces[0]?.data);
     } finally {
       server.stop();
     }
@@ -527,8 +536,11 @@ describe("runtime HTTP app", () => {
         import { defineConfig, sequence } from "${import.meta.dir}/../../../engine/src/index.ts";
 
         const root = sequence("validation")
-          .step("prepare", async () => ({ ok: true }))
-          .create(async ({ name }) => ({ name, resourceId: "resource-" + name }));
+          .step("prepare", async () => ({ ctx: { ok: true } }))
+          .workspace({
+            create: async ({ workspace }) => ({ name: workspace.name, vmId: "vm-" + workspace.name }),
+            remove: async () => {},
+          });
 
         export default defineConfig({
           providers: {},
@@ -574,46 +586,9 @@ describe("runtime HTTP app", () => {
     }
   });
 
-  test("fails run sessions when host hello lacks required methods or capabilities", async () => {
-    const { server, projectDir } = await serveRuntimeFixture("rigkit-runtime-required-host-", `
-      const root = sequence("required-host").operation("needs-host", {
-        requiredHostMethods: [{ id: "host.command.run", modes: ["capture"] }],
-        requiredHostCapabilities: [{ id: "cmux.open", schemaHash: "sha256:cmux-open-schema" }],
-        run: async () => await new Promise(() => {}),
-      });
-
-      export default defineConfig({
-        providers: {},
-        workflows: { root },
-      });
-    `);
-
-    try {
-      const started = await startRun(server, "needs-host");
-      const messages = await collectSessionMessages(
-        new URL(started.sessionUrl, server.url),
-        server.token,
-        {
-          done: (items) => items.some((item) => item.type === "run.failed"),
-        },
-      );
-      const failed = messages.find((message) => message.type === "run.failed");
-      const message = String(failed?.error?.message ?? "");
-
-      expect(failed?.error?.code).toBe("HOST_REQUEST_FAILED");
-      expect(message).toContain("host method host.command.run:capture");
-      expect(message).toContain("host capability cmux.open@sha256:cmux-open-schema");
-      expect(messages.some((item) => item.type === "hello.ack")).toBe(false);
-    } finally {
-      server.stop();
-      rmSync(projectDir, { recursive: true, force: true });
-    }
-  });
-
   test("bridges typed host capability requests over run sessions", async () => {
     const { server, projectDir } = await serveRuntimeFixture("rigkit-runtime-capability-", `
       const root = sequence("capability-test").operation("open", {
-        requiredHostCapabilities: [{ id: "cmux.open", schemaHash: "sha256:cmux-open-schema" }],
         run: async ({ local }) => await local.requestCapability("cmux.open", { name: "demo" }),
       });
 
@@ -659,7 +634,6 @@ describe("runtime HTTP app", () => {
   test("resolves host capability resource lifetimes from session close reports", async () => {
     const { server, projectDir } = await serveRuntimeFixture("rigkit-runtime-capability-close-", `
       const root = sequence("capability-close-test").operation("open", {
-        requiredHostCapabilities: [{ id: "cmux.open", schemaHash: "sha256:cmux-open-schema" }],
         run: async ({ local }) => {
           if (!local.requestCapabilitySession) throw new Error("requestCapabilitySession unavailable");
           const session = await local.requestCapabilitySession("cmux.open", { name: "demo" });
@@ -708,7 +682,6 @@ describe("runtime HTTP app", () => {
   test("keeps host-owned capability runs attached until the host cancels", async () => {
     const { server, projectDir } = await serveRuntimeFixture("rigkit-runtime-capability-attached-", `
       const root = sequence("capability-attached-test").operation("open", {
-        requiredHostCapabilities: [{ id: "cmux.open", schemaHash: "sha256:cmux-open-schema" }],
         run: async ({ local }) => {
           await local.requestCapability("cmux.open", { name: "demo" });
           await new Promise(() => {});
@@ -755,7 +728,6 @@ describe("runtime HTTP app", () => {
   test("turns host response errors into typed host request failures", async () => {
     const { server, projectDir } = await serveRuntimeFixture("rigkit-runtime-capability-error-", `
       const root = sequence("capability-error-test").operation("cmux-open", {
-        requiredHostCapabilities: [{ id: "cmux.open", schemaHash: "sha256:cmux-open-schema" }],
         run: async ({ local }) => await local.requestCapability("cmux.open", { name: "demo" }),
       });
 
@@ -834,7 +806,7 @@ function writeNoopConfig(projectDir: string): void {
     `
       import { defineConfig, sequence } from "${import.meta.dir}/../../../engine/src/index.ts";
 
-      const root = sequence("noop").step("ready", async () => ({ ready: true }));
+      const root = sequence("noop").step("ready", async () => ({ ctx: { ready: true } }));
 
       export default defineConfig({
         providers: {},

package/src/runtime/control.ts

@@ -9,6 +9,7 @@ import {
   type HostResponse,
   type RunOperationRequest,
   type RuntimeOperation,
+  type RuntimeOperationsManifest,
 } from "./protocol.ts";
 import {
   createRun,
@@ -87,10 +88,10 @@ export function runtimeRuns(store: RunStore) {
 export async function startRuntimeRun(state: RuntimeAppState, body: RunOperationRequest) {
   const engine = await loadEngine(state.context);
   const manifest = operationManifestFor(engine);
-  const operation = findRuntimeOperation(manifest.operations, body.operation);
-  if (!operation) throw new RuntimeControlHttpError(400, `Unknown operation ${body.operation}`);
+  const resolved = resolveRuntimeOperation(manifest, body.operation);
+  if (!resolved) throw new RuntimeControlHttpError(400, `Unknown operation ${body.operation}`);
 
-  const run = createRun(operation.id, body.input ?? {}, operation);
+  const run = createRun(resolved.runOperation, body.input ?? {}, resolved.operation);
   state.store.runs.set(run.id, run);
   runOperation(run, state.store, state.context);
 
@@ -144,16 +145,46 @@ export function runtimeControlErrorStatus(error: unknown): number {
   return 500;
 }
 
-function findRuntimeOperation(operations: RuntimeOperation[], requestedOperation: string): RuntimeOperation | undefined {
-  return operations.find((operation) =>
+function resolveRuntimeOperation(
+  manifest: RuntimeOperationsManifest,
+  requestedOperation: string,
+): { operation: RuntimeOperation; runOperation: string } | undefined {
+  const workspaceOperation = parseWorkspaceOperationId(requestedOperation);
+  if (workspaceOperation) {
+    const operation = manifest.workspaceOperations.find((item) => item.id === workspaceOperation.operation);
+    return operation ? { operation, runOperation: requestedOperation } : undefined;
+  }
+
+  const operation = manifest.operations.find((operation) =>
     operation.id === requestedOperation || operation.aliases?.includes(requestedOperation)
   );
+  return operation ? { operation, runOperation: operation.id } : undefined;
+}
+
+function parseWorkspaceOperationId(value: string): { workspace: string; operation: string } | undefined {
+  const slash = value.indexOf("/");
+  if (slash <= 0 || slash === value.length - 1) return undefined;
+  return {
+    workspace: value.slice(0, slash),
+    operation: value.slice(slash + 1),
+  };
 }
 
-function runtimeWorkspace(workspace: WorkspaceRecord): WorkspaceRecord & { data: WorkspaceRecord["metadata"] } {
+function runtimeWorkspace(workspace: WorkspaceRecord): {
+  id: string;
+  name: string;
+  workflow: string;
+  ctx: WorkspaceRecord["ctx"];
+  createdAt: string;
+  updatedAt: string;
+} {
   return {
-    ...workspace,
-    data: workspace.metadata,
+    id: workspace.id,
+    name: workspace.name,
+    workflow: workspace.workflow,
+    ctx: workspace.ctx,
+    createdAt: workspace.createdAt,
+    updatedAt: workspace.updatedAt,
   };
 }
 

package/src/runtime/index.ts

@@ -35,8 +35,6 @@ export {
   type RuntimeStateServiceOptions,
 } from "./state.ts";
 export {
-  HostCapabilityRequirementEffectSchema,
-  HostMethodRequirementEffectSchema,
   OkResponseEffectSchema,
   OperationsManifestEffectSchema,
   ProjectInfoEffectSchema,

package/src/runtime/operations.ts

@@ -3,6 +3,7 @@ import {
   type DevMachineEngine,
   type EngineOperationSummary,
   type JsonValue,
+  type LocalHostCapabilityRequestOptions,
 } from "@rigkit/engine";
 import { normalizeRuntimeRunError } from "./errors.ts";
 import {
@@ -83,10 +84,18 @@ async function executeOperation(run: RunRecord, store: RunStore, options: Engine
         const result = await requestHost(store, run, "host.command.run", command);
         return HostCommandResultSchema.parse(result);
       },
-      requestCapability: async <Result = unknown>(capability: string, params: unknown) =>
-        await requestHostCapability(store, run, capability, params) as Result,
-      requestCapabilitySession: async <Result = unknown>(capability: string, params: unknown) =>
-        await requestHostCapabilitySession<Result>(store, run, capability, params),
+      requestCapability: async <Result = unknown>(
+        capability: string,
+        params: unknown,
+        requestOptions?: LocalHostCapabilityRequestOptions,
+      ) =>
+        await requestHostCapability(store, run, capability, params, requestOptions) as Result,
+      requestCapabilitySession: async <Result = unknown>(
+        capability: string,
+        params: unknown,
+        requestOptions?: LocalHostCapabilityRequestOptions,
+      ) =>
+        await requestHostCapabilitySession<Result>(store, run, capability, params, requestOptions),
     },
   });
   engine.onEvent((event) => emitRunEvent(run, event));
@@ -100,6 +109,12 @@ export function operationsFor(engine: DevMachineEngine): RuntimeOperation[] {
   return engine.listRuntimeOperations().map((operation) => runtimeOperationForEngineOperation(engine, operation));
 }
 
+export function workspaceOperationsFor(engine: DevMachineEngine): RuntimeOperation[] {
+  return engine.listRuntimeWorkspaceOperations().map((operation) =>
+    runtimeOperationForEngineOperation(engine, operation)
+  );
+}
+
 function runtimeOperationForEngineOperation(engine: DevMachineEngine, operation: EngineOperationSummary): RuntimeOperation {
   const required = operation.inputFields
     .filter((field) => field.required ?? true)
@@ -116,14 +131,6 @@ function runtimeOperationForEngineOperation(engine: DevMachineEngine, operation:
     title: operation.title ?? titleize(operation.id),
     description: operation.description ?? "",
     createsWorkspace: operation.createsWorkspace,
-    requiredHostMethods: operation.requiredHostMethods?.map((method) => ({
-      id: method.id,
-      ...(method.modes?.length ? { modes: [...method.modes] } : {}),
-    })),
-    requiredHostCapabilities: operation.requiredHostCapabilities?.map((capability) => ({
-      id: capability.id,
-      ...(capability.schemaHash ? { schemaHash: capability.schemaHash } : {}),
-    })),
     cli: operation.cli ? cloneOperationCli(operation.cli) : cliForFields(operation.inputFields),
     inputSchema: objectSchema(properties, required),
   };
@@ -188,60 +195,13 @@ function cliForFields(fields: EngineOperationSummary["inputFields"]): NonNullabl
 
 export function operationManifestFor(engine: DevMachineEngine): RuntimeOperationsManifest {
   const operations = operationsFor(engine);
+  const workspaceOperations = workspaceOperationsFor(engine);
   return {
-    hostMethods: {
-      known: [
-        { id: "message.show" },
-        { id: "prompt.text" },
-        { id: "prompt.confirm" },
-        { id: "prompt.select" },
-        { id: "open.external" },
-        { id: "host.command.run", modes: ["capture", "interactive"] },
-      ],
-      requiredByOperations: Object.fromEntries(
-        operations
-          .filter((operation) => operation.requiredHostMethods?.length)
-          .map((operation) => [
-            operation.id,
-            operation.requiredHostMethods!.flatMap((method) =>
-              method.modes?.length
-                ? method.modes.map((mode) => `${method.id}:${mode}`)
-                : [method.id]
-            ),
-          ]),
-      ),
-    },
-    hostCapabilities: {
-      optional: dedupeHostCapabilities(
-        operations.flatMap((operation) => operation.requiredHostCapabilities ?? []),
-      ),
-      requiredByOperations: Object.fromEntries(
-        operations
-          .filter((operation) => operation.requiredHostCapabilities?.length)
-          .map((operation) => [operation.id, operation.requiredHostCapabilities!.map((capability) => capability.id)]),
-      ),
-    },
     operations,
+    workspaceOperations,
   };
 }
 
-function dedupeHostCapabilities(
-  capabilities: Array<{ id: string; schemaHash?: string }>,
-): Array<{ id: string; schemaHash?: string }> {
-  const seen = new Set<string>();
-  const deduped: Array<{ id: string; schemaHash?: string }> = [];
-  for (const capability of capabilities) {
-    const key = capability.schemaHash ? `${capability.id}\0${capability.schemaHash}` : capability.id;
-    if (seen.has(key)) continue;
-    seen.add(key);
-    deduped.push({
-      id: capability.id,
-      ...(capability.schemaHash ? { schemaHash: capability.schemaHash } : {}),
-    });
-  }
-  return deduped;
-}
-
 function workflowJsonSchema(workflows: string[]): JsonSchema {
   return workflows.length > 0
     ? { type: "string", enum: workflows }

package/src/runtime/protocol.ts

@@ -2,7 +2,7 @@ import { Schema } from "effect";
 import type { WorkflowEvent } from "@rigkit/engine";
 
 export const RUNTIME_API_VERSION = 1;
-export const RUNTIME_PROTOCOL_HASH = "sha256:6dc28b06c95c98d310db445f1b19aef478cd828f11287467fe261483dfde4f81";
+export const RUNTIME_PROTOCOL_HASH = "sha256:ac8d4a503b56c15b333ea51f57ab1f6fca776bea93f498120b10ab601cc0960a";
 export const DEFAULT_IDLE_MS = 30 * 60 * 1000;
 
 export class RuntimeProtocolSchemaError extends Error {
@@ -99,6 +99,7 @@ export type HostCapabilityRequestEvent = {
   type: "host.capability.request";
   requestId: string;
   id: string;
+  nodePath?: string;
   capability: string;
   params: unknown;
 };
@@ -147,16 +148,6 @@ export type RuntimeOperationCli = {
   options?: RuntimeOperationCliOption[];
 };
 
-export type RuntimeHostMethodRequirement = {
-  id: string;
-  modes?: string[];
-};
-
-export type RuntimeHostCapabilityRequirement = {
-  id: string;
-  schemaHash?: string;
-};
-
 export type RuntimeOperation = {
   id: string;
   aliases?: string[];
@@ -165,22 +156,13 @@ export type RuntimeOperation = {
   title: string;
   description: string;
   createsWorkspace?: boolean;
-  requiredHostMethods?: RuntimeHostMethodRequirement[];
-  requiredHostCapabilities?: RuntimeHostCapabilityRequirement[];
   cli?: RuntimeOperationCli;
   inputSchema: JsonSchema;
 };
 
 export type RuntimeOperationsManifest = {
-  hostMethods: {
-    known: RuntimeHostMethodRequirement[];
-    requiredByOperations: Record<string, string[]>;
-  };
-  hostCapabilities: {
-    optional: RuntimeHostCapabilityRequirement[];
-    requiredByOperations: Record<string, string[]>;
-  };
   operations: RuntimeOperation[];
+  workspaceOperations: RuntimeOperation[];
 };
 
 export function objectSchema(properties: Record<string, unknown>, required: string[] = []): JsonSchema {

package/src/runtime/runs.ts

@@ -21,6 +21,10 @@ export type HostCapabilitySessionResult<Result = unknown> = {
   closed: Promise<void>;
 };
 
+export type HostCapabilityRequestOptions = {
+  nodePath?: string;
+};
+
 export type RunRecord = {
   id: string;
   operation: string;
@@ -197,8 +201,9 @@ export function requestHostCapability(
   run: RunRecord,
   capability: string,
   params: unknown,
+  options: HostCapabilityRequestOptions = {},
 ): Promise<unknown> {
-  const { requestId } = emitHostCapabilityRequest(run, capability, params);
+  const { requestId } = emitHostCapabilityRequest(run, capability, params, options);
   return waitForHostResponse(store, requestId);
 }
 
@@ -207,8 +212,9 @@ export async function requestHostCapabilitySession<Result = unknown>(
   run: RunRecord,
   capability: string,
   params: unknown,
+  options: HostCapabilityRequestOptions = {},
 ): Promise<HostCapabilitySessionResult<Result>> {
-  const { requestId } = emitHostCapabilityRequest(run, capability, params);
+  const { requestId } = emitHostCapabilityRequest(run, capability, params, options);
   const closed = new Promise<void>((resolveClosed, rejectClosed) => {
     store.hostCapabilityResources.set(requestId, { resolveClosed, rejectClosed });
     run.pendingHostCapabilityResourceIds.add(requestId);
@@ -234,6 +240,7 @@ function emitHostCapabilityRequest(
   run: RunRecord,
   capability: string,
   params: unknown,
+  options: HostCapabilityRequestOptions = {},
 ): { requestId: string } {
   if (run.status !== "running") {
     throw new RuntimeHostRequestError({
@@ -243,7 +250,14 @@ function emitHostCapabilityRequest(
   }
   const requestId = `cap_req_${crypto.randomUUID()}`;
   run.pendingHostRequestIds.add(requestId);
-  emitRunEvent(run, { type: "host.capability.request", requestId, id: requestId, capability, params });
+  emitRunEvent(run, {
+    type: "host.capability.request",
+    requestId,
+    id: requestId,
+    ...(options.nodePath ? { nodePath: options.nodePath } : {}),
+    capability,
+    params,
+  });
   return { requestId };
 }
 

package/src/runtime/sessions.ts

@@ -81,19 +81,6 @@ function openRunSession(
       const message = parseSessionMessage(value);
       if (!message) return;
       if (message.type === "hello") {
-        const unsupported = unsupportedSessionRequirements(message, run.operationDefinition);
-        if (unsupported.length > 0) {
-          failRun(
-            run,
-            new RuntimeHostRequestError({
-              message: `Host does not support required ${unsupported.join(", ")}`,
-            }),
-            state.store,
-          );
-          acknowledged = true;
-          sendBacklog();
-          return;
-        }
         acknowledged = true;
         sendHelloAck(socket, run);
         sendBacklog();
@@ -160,53 +147,10 @@ function sendHelloAck(ws: RuntimeSessionTransport, run: { operation: string; ope
     },
     operation: {
       id: run.operation,
-      requiredHostCapabilities: run.operationDefinition?.requiredHostCapabilities ?? [],
-      requiredHostMethods: run.operationDefinition?.requiredHostMethods ?? [],
     },
   }));
 }
 
-function unsupportedSessionRequirements(message: SessionMessage, operation: RuntimeOperation | undefined): string[] {
-  const unsupported: string[] = [];
-  for (const requirement of operation?.requiredHostMethods ?? []) {
-    const hostMethod = sessionItems(message.hostMethods).find((item) => item.id === requirement.id);
-    if (!hostMethod || !supportsModes(hostMethod.modes, requirement.modes)) {
-      unsupported.push(`host method ${formatRequirement(requirement.id, requirement.modes)}`);
-    }
-  }
-  for (const requirement of operation?.requiredHostCapabilities ?? []) {
-    const capability = sessionItems(message.hostCapabilities).find((item) => item.id === requirement.id);
-    if (!capability || (requirement.schemaHash && capability.schemaHash !== requirement.schemaHash)) {
-      unsupported.push(requirement.schemaHash
-        ? `host capability ${requirement.id}@${requirement.schemaHash}`
-        : `host capability ${requirement.id}`);
-    }
-  }
-  return unsupported;
-}
-
-function sessionItems(value: unknown): Array<{ id: string; modes?: string[]; schemaHash?: string }> {
-  if (!Array.isArray(value)) return [];
-  return value.flatMap((item) => {
-    if (!isRecord(item) || typeof item.id !== "string") return [];
-    return [{
-      id: item.id,
-      modes: Array.isArray(item.modes) ? item.modes.filter((mode): mode is string => typeof mode === "string") : undefined,
-      schemaHash: typeof item.schemaHash === "string" ? item.schemaHash : undefined,
-    }];
-  });
-}
-
-function supportsModes(hostModes: string[] | undefined, requiredModes: string[] | undefined): boolean {
-  if (!requiredModes?.length) return true;
-  const supported = new Set(hostModes ?? []);
-  return requiredModes.every((mode) => supported.has(mode));
-}
-
-function formatRequirement(id: string, modes: string[] | undefined): string {
-  return modes?.length ? `${id}:${modes.join("|")}` : id;
-}
-
 function sessionEvent(event: unknown): Record<string, unknown> {
   if (isRecord(event) && event.type === "host.request") {
     return {
@@ -220,6 +164,7 @@ function sessionEvent(event: unknown): Record<string, unknown> {
     return {
       type: "host.capability.request",
       id: typeof event.id === "string" ? event.id : event.requestId,
+      ...(typeof event.nodePath === "string" ? { nodePath: event.nodePath } : {}),
       capability: event.capability,
       params: event.params,
     };

package/src/runtime/version.ts

@@ -1 +1 @@
-export const RIGKIT_RUNTIME_VERSION = "0.2.2";
+export const RIGKIT_RUNTIME_VERSION = "0.2.4";

package/src/version.ts

@@ -1 +1 @@
-export const RIGKIT_SDK_VERSION = "0.2.2";
+export const RIGKIT_SDK_VERSION = "0.2.4";