@opengeni/runtime 0.14.1 → 0.14.3

package/dist/index.js

@@ -176,7 +176,7 @@ import {
   withToolspaceTokenEnvironment,
   withToolspaceTokenSession,
   wrapCapabilityToolsForTurnCancellation
-} from "./chunk-HHWIZHQM.js";
+} from "./chunk-GQIFSLAC.js";
 import {
   getSkillLibraryEntry,
   isSkillLibraryEntryId,

package/dist/sandbox/index.js

@@ -170,7 +170,7 @@ import {
   withToolspaceTokenClient,
   withToolspaceTokenEnvironment,
   withToolspaceTokenSession
-} from "../chunk-HHWIZHQM.js";
+} from "../chunk-GQIFSLAC.js";
 import "../chunk-4YJ5Z52Z.js";
 import "../chunk-K4V4QYCL.js";
 import "../chunk-PZ5AY32C.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opengeni/runtime",
-  "version": "0.14.1",
+  "version": "0.14.3",
   "license": "Apache-2.0",
   "repository": {
     "type": "git",
@@ -50,8 +50,8 @@
     "@openai/agents-extensions": "0.13.3",
     "@opengeni/agent-proto": "^0.3.0",
     "@opengeni/codex": "^0.2.7",
-    "@opengeni/config": "^0.7.11",
-    "@opengeni/contracts": "^0.22.0",
+    "@opengeni/config": "^0.7.13",
+    "@opengeni/contracts": "^0.23.0",
     "@opengeni/network": "^0.1.1",
     "debug": "4.4.3",
     "modal": "0.7.6",

package/src/sandbox/providers/docker.ts

@@ -1,5 +1,7 @@
 import { DockerSandboxClient } from "@openai/agents/sandbox/local";
+import { isAbsolute } from "node:path";
 import { CAPABILITY_DESCRIPTORS } from "../capabilities";
+import { SandboxConfigError } from "../errors";
 import type { ProviderRegistration } from "./types";
 
 export const dockerProvider: ProviderRegistration = {
@@ -7,11 +9,21 @@ export const dockerProvider: ProviderRegistration = {
   descriptor: CAPABILITY_DESCRIPTORS.docker,
   // Local dev container — no credentials. (The dockerNetwork decoration is
   // applied by the factory, not here: it wraps the constructed client.)
-  validateCredentials() {},
+  validateCredentials(settings) {
+    const workspaceBaseDir = settings.dockerWorkspaceBaseDir?.trim();
+    if (workspaceBaseDir && !isAbsolute(workspaceBaseDir)) {
+      throw new SandboxConfigError(
+        "docker",
+        "OPENGENI_DOCKER_WORKSPACE_BASE_DIR must be an absolute path",
+      );
+    }
+  },
   build({ settings, exposedPorts }) {
+    const workspaceBaseDir = settings.dockerWorkspaceBaseDir?.trim();
     return new DockerSandboxClient({
       image: settings.dockerImage,
       exposedPorts,
+      ...(workspaceBaseDir ? { workspaceBaseDir } : {}),
     });
   },
 };

package/src/sandbox/routing/routing-session.ts

@@ -1228,7 +1228,22 @@ export class RoutingSandboxSession implements RoutableBackendSession {
       if (!s.materializeEntry) {
         throw new RoutingUnsupportedError("materializeEntry", this.cached?.kind ?? "unknown");
       }
-      return s.materializeEntry(args);
+      await s.materializeEntry(args);
+
+      // The local Docker SDK materializes through a host path and then bind-mounts
+      // that path into the sandbox. A containerized worker using the host Docker
+      // socket can otherwise write into its own container layer while the sandbox
+      // sees a different, empty host directory. `pathExists()` and `readFile()` on
+      // that SDK session inspect the worker-side path, so only a command executed
+      // inside the actual sandbox proves the materialized path is usable by the
+      // agent. Never let lazy `load_skill` report success on a split workspace.
+      const path =
+        args && typeof args === "object" && typeof (args as { path?: unknown }).path === "string"
+          ? (args as { path: string }).path
+          : null;
+      if (path) {
+        await assertProviderCanSeeMaterializedPath(s, path);
+      }
     });
   }
 
@@ -1304,3 +1319,51 @@ export class RoutingSandboxSession implements RoutableBackendSession {
     return this.resolve();
   }
 }
+
+const MATERIALIZED_PATH_MARKER = "__OPENGENI_MATERIALIZED_PATH_VISIBLE__";
+
+async function assertProviderCanSeeMaterializedPath(
+  session: RoutableBackendSession,
+  path: string,
+): Promise<void> {
+  const command = `test -e ${shellSingleQuote(path)} && printf %s ${shellSingleQuote(
+    MATERIALIZED_PATH_MARKER,
+  )}`;
+  const args = {
+    cmd: command,
+    workdir: providerManifestRoot(session) ?? "/workspace",
+    shell: "sh",
+    login: false,
+    tty: false,
+  };
+  let output: string;
+  if (session.execCommand) {
+    output = await session.execCommand(args);
+  } else if (session.exec) {
+    output = formatExecResult(await session.exec(args));
+  } else {
+    throw new RoutingUnsupportedError("materializeEntry.verify", "unknown");
+  }
+  if (!output.includes(MATERIALIZED_PATH_MARKER)) {
+    throw new Error(
+      `Sandbox materialization completed but the provider cannot read the destination path: ${path}`,
+    );
+  }
+}
+
+function providerManifestRoot(session: RoutableBackendSession): string | null {
+  const root = (
+    session.state as
+      | {
+          manifest?: {
+            root?: unknown;
+          };
+        }
+      | undefined
+  )?.manifest?.root;
+  return typeof root === "string" && root.length > 0 ? root : null;
+}
+
+function shellSingleQuote(value: string): string {
+  return `'${value.replaceAll("'", `'"'"'`)}'`;
+}