@opengeni/runtime 0.13.12 → 0.14.0

package/dist/sandbox/index.js

@@ -170,7 +170,7 @@ import {
   withToolspaceTokenClient,
   withToolspaceTokenEnvironment,
   withToolspaceTokenSession
-} from "../chunk-FLRCDJRI.js";
+} from "../chunk-3NUSY22C.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.13.12",
+  "version": "0.14.0",
   "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.8",
-    "@opengeni/contracts": "^0.20.1",
+    "@opengeni/config": "^0.7.10",
+    "@opengeni/contracts": "^0.21.0",
     "@opengeni/network": "^0.1.1",
     "debug": "4.4.3",
     "modal": "0.7.6",

package/src/index.ts

@@ -187,6 +187,7 @@ import {
 } from "./sandbox/turn-tool-cancellation";
 import { computerUse, type ComputerToolMode } from "./sandbox-computer";
 import type { RuntimeMetricsHooks } from "./metrics";
+import { workspaceSkills, type WorkspaceSkillSearchPath } from "./workspace-skills";
 
 // The Agents SDK's debug namespaces can otherwise serialize complete model
 // inputs/outputs and tool arguments/results. These getters read process.env on
@@ -1260,7 +1261,7 @@ export type ToolspaceTokenWriterSession = SandboxSessionLike;
 export type EffectiveSkillSelection = Readonly<{
   id: string;
   name: string;
-  source: "bundled" | "library" | "pack";
+  source: "bundled" | "library" | "pack" | "session";
   version: string | null;
   contentSha256: string | null;
   reason: string;
@@ -1430,6 +1431,9 @@ export type BuildAgentOptions = {
   // skills in the sandbox skill index (mounted under .agents/) so
   // skills/<name> references resolve like any other indexed skill.
   packSkills?: PackSkill[];
+  // Inline skills fixed onto this session at creation. They use the SDK's lazy
+  // skill source and are materialized only when the model loads one.
+  sessionSkills?: PackSkill[];
   // Explicitly selected, immutable curated-library skill content. These are
   // separate from packSkills so repository-local/pack compatibility does not
   // turn a curated entry into a mutable override.
@@ -1460,7 +1464,7 @@ export type PackSkillFile = {
 
 export type PackSkill = {
   name: string;
-  description?: string | null;
+  description?: string | null | undefined;
   files: PackSkillFile[];
 };
 
@@ -1903,6 +1907,8 @@ export function buildOpenGeniAgent(
       ...(options.skillLibrarySkills?.length
         ? { skillLibrarySkills: options.skillLibrarySkills }
         : {}),
+      ...(options.sessionSkills?.length ? { sessionSkills: options.sessionSkills } : {}),
+      ...repositoryWorkspaceSkillPathsOption(resources),
       ...(options.structuredToolTransport !== undefined
         ? { structuredToolTransport: options.structuredToolTransport }
         : {}),
@@ -1925,6 +1931,7 @@ export function buildOpenGeniAgent(
         options.skillLibrarySelections ?? [],
         options.skillLibrarySkills ?? [],
         options.packSkills ?? [],
+        options.sessionSkills ?? [],
       ).map((selection) => Object.freeze(selection)),
     ),
   );
@@ -2240,6 +2247,8 @@ export function buildAgentCapabilities(
   packSkills: PackSkill[],
   options: {
     skillLibrarySkills?: PackSkill[];
+    sessionSkills?: PackSkill[];
+    workspaceSkillPaths?: readonly WorkspaceSkillSearchPath[];
     structuredToolTransport?: boolean;
     // EXPLICIT computer-use transport (see BuildAgentOptions.computerToolMode). When
     // present, computerUse() is handed the mode directly and its tools() obeys it
@@ -2276,11 +2285,29 @@ export function buildAgentCapabilities(
     filesystemCapability,
     shell({ ...(toolCancellation ? {} : { configureTools: withExecOpCorrelation }) }),
   ];
+  const sessionSkills = sessionSkillsForMaterialization(
+    packSkills,
+    options.skillLibrarySkills ?? [],
+    options.sessionSkills ?? [],
+  );
   caps.push(
     skills({
-      lazyFrom: lazySkillSourceWithPackSkills(packSkills, options.skillLibrarySkills ?? []),
+      lazyFrom: lazySkillSourceWithPackSkills(
+        [...packSkills, ...sessionSkills],
+        options.skillLibrarySkills ?? [],
+      ),
     }),
   );
+  if (options.workspaceSkillPaths?.length) {
+    caps.push(
+      workspaceSkills(options.workspaceSkillPaths, [
+        ...bundledSkillDirNames(bundledSkillsDir()),
+        ...(options.skillLibrarySkills ?? []).map((skill) => skill.name),
+        ...packSkills.map((skill) => skill.name),
+        ...sessionSkills.map((skill) => skill.name),
+      ]),
+    );
+  }
   // P4.3 computer-use: the agent drives the SAME :0 humans watch (xdotool/XTEST +
   // scrot), but only when the desktop tier is ON, computer-use is enabled, and the
   // backend is one whose image carries the X stack (descriptorgate — honest about
@@ -2373,6 +2400,9 @@ export type PrepareToolsOptions = {
   executionGeneration?: number;
   subjectId?: string;
   subjectLabel?: string;
+  // Immutable human authority used only for subject-owned connection lookup.
+  // This is intentionally separate from the worker's first-party MCP identity.
+  credentialSubjectId?: string;
   // Overrides the fixed first-party MCP permission set for this session's
   // delegated token (manager-style sessions). The caller is responsible for
   // having validated the set against the session creator's grant.
@@ -2465,6 +2495,14 @@ export async function prepareAgentTools(
     return { mcpServers: [], close: async () => {}, codexConnectorNamespaces };
   }
   const registry = new Map(settings.mcpServers.map((server) => [server.id, server]));
+  const subjectOwnedTool = tools.find(
+    (tool) => registry.get(tool.id)?.connectionRef?.subjectScope === "subject",
+  );
+  if (subjectOwnedTool && !options.credentialSubjectId) {
+    throw new Error(
+      `subject-owned connection for MCP server ${subjectOwnedTool.id} requires a human turn initiator`,
+    );
+  }
   const aggregateToolBudget = new McpAggregateToolListBudget();
   // npm Undici's dispatcher transport can hang indefinitely under Bun even
   // after an AbortSignal fires. Bun's native fetch is the supported runtime
@@ -2738,7 +2776,7 @@ async function resolveConnectionForRequest(
     destinationUrl,
     forceRefresh,
     ...(toolName ? { toolName } : {}),
-    ...(options.subjectId ? { subjectId: options.subjectId } : {}),
+    ...(options.credentialSubjectId ? { subjectId: options.credentialSubjectId } : {}),
   };
   try {
     return await options.resolveCredential(request);
@@ -5278,6 +5316,32 @@ export function buildManifest(
   });
 }
 
+export function repositoryWorkspaceSkillPathsOption(resources: readonly ResourceRef[]): {
+  workspaceSkillPaths?: readonly WorkspaceSkillSearchPath[];
+} {
+  const repositories = resources.filter(
+    (resource): resource is Extract<ResourceRef, { kind: "repository" }> =>
+      resource.kind === "repository",
+  );
+  if (repositories.length === 0) return {};
+
+  const paths = new Map<string, WorkspaceSkillSearchPath>();
+  const add = (path: string, source: string): void => {
+    if (!paths.has(path)) paths.set(path, { path, source });
+  };
+  // A Connected Machine maps /workspace to its configured working directory,
+  // which may itself be the selected repository. Managed sandboxes normally use
+  // the repository mount paths below. Checking both keeps the rule portable.
+  add(".agents/skills", "workspace .agents/skills");
+  add(".claude/skills", "workspace .claude/skills");
+  for (const repository of repositories) {
+    const mountPath = resourceMountPath(repository);
+    add(`${mountPath}/.agents/skills`, `${mountPath}/.agents/skills`);
+    add(`${mountPath}/.claude/skills`, `${mountPath}/.claude/skills`);
+  }
+  return { workspaceSkillPaths: [...paths.values()] };
+}
+
 function sandboxDownloadDirectory(download: SandboxFileDownload, mountPath: string): any {
   if (download.mountPath !== mountPath) {
     throw new Error(
@@ -7331,6 +7395,7 @@ function effectiveSkillSelections(
   librarySelections: readonly EffectiveSkillSelection[],
   librarySkills: readonly PackSkill[],
   packSkills: readonly PackSkill[],
+  sessionSkills: readonly PackSkill[],
 ): readonly EffectiveSkillSelection[] {
   const defaultSelections = bundledSkillDirNames(bundledSkillsDir()).map((name) => ({
     id: `bundled:${name}`,
@@ -7342,6 +7407,12 @@ function effectiveSkillSelections(
   }));
   const libraryNameKeys = new Set(librarySkills.map((skill) => skill.name.toLowerCase()));
   const packNameKeys = new Set(packSkills.map((skill) => skill.name.toLowerCase()));
+  const effectiveSessionSkills = sessionSkillsForMaterialization(
+    packSkills,
+    librarySkills,
+    sessionSkills,
+  );
+  const sessionNameKeys = new Set(effectiveSessionSkills.map((skill) => skill.name.toLowerCase()));
   const selected = librarySelections.filter((selection) =>
     libraryNameKeys.has(selection.name.toLowerCase()),
   );
@@ -7349,9 +7420,14 @@ function effectiveSkillSelections(
     ...defaultSelections.filter(
       (selection) =>
         !libraryNameKeys.has(selection.name.toLowerCase()) &&
-        !packNameKeys.has(selection.name.toLowerCase()),
+        !packNameKeys.has(selection.name.toLowerCase()) &&
+        !sessionNameKeys.has(selection.name.toLowerCase()),
+    ),
+    ...selected.filter(
+      (selection) =>
+        !packNameKeys.has(selection.name.toLowerCase()) &&
+        !sessionNameKeys.has(selection.name.toLowerCase()),
     ),
-    ...selected.filter((selection) => !packNameKeys.has(selection.name.toLowerCase())),
     ...packSkills.map((skill) => ({
       id: `pack:${skill.name}`,
       name: skill.name,
@@ -7360,9 +7436,56 @@ function effectiveSkillSelections(
       contentSha256: null,
       reason: "enabled capability pack",
     })),
+    ...effectiveSessionSkills.map((skill) => ({
+      id: `session:${skill.name}`,
+      name: skill.name,
+      source: "session" as const,
+      version: null,
+      contentSha256: null,
+      reason: "attached to session",
+    })),
   ];
 }
 
+function sessionSkillsForMaterialization(
+  packSkills: readonly PackSkill[],
+  librarySkills: readonly PackSkill[],
+  sessionSkills: readonly PackSkill[],
+): PackSkill[] {
+  const configured = new Map<string, PackSkill>();
+  for (const skill of [...librarySkills, ...packSkills]) {
+    configured.set(skill.name.toLowerCase(), skill);
+  }
+  const bundledNames = new Set(
+    bundledSkillDirNames(bundledSkillsDir()).map((name) => name.toLowerCase()),
+  );
+  const selected = new Map<string, PackSkill>();
+  for (const skill of sessionSkills) {
+    assertSafePackSkillName(skill.name);
+    const key = skill.name.toLowerCase();
+    if (bundledNames.has(key)) {
+      throw new Error(`Session skill "${skill.name}" conflicts with a bundled skill`);
+    }
+    const existing = selected.get(key) ?? configured.get(key);
+    if (existing) {
+      if (skillFingerprint(existing) !== skillFingerprint(skill)) {
+        throw new Error(`Conflicting skill definitions for "${skill.name}"`);
+      }
+      continue;
+    }
+    selected.set(key, skill);
+  }
+  return [...selected.values()];
+}
+
+function skillFingerprint(skill: PackSkill): string {
+  return JSON.stringify(
+    [...skill.files]
+      .sort((left, right) => left.path.localeCompare(right.path))
+      .map(({ path, content }) => ({ path, content })),
+  );
+}
+
 function removeSkillChildByNameKey(children: Record<string, Entry>, nameKey: string): void {
   for (const name of Object.keys(children)) {
     if (name.toLowerCase() === nameKey) {

package/src/sandbox/index.ts

@@ -536,14 +536,14 @@ function withDockerNetwork(client: SandboxClient, network: string | undefined):
 }
 
 async function connectDockerNetwork(network: string, containerId: string): Promise<void> {
-  const result = Bun.spawnSync(["docker", "network", "connect", network, containerId], {
-    stdout: "pipe",
-    stderr: "pipe",
+  const { spawnSync } = await import("node:child_process");
+  const result = spawnSync("docker", ["network", "connect", network, containerId], {
+    encoding: "utf8",
   });
-  if (result.exitCode === 0) {
+  if (result.status === 0) {
     return;
   }
-  const stderr = new TextDecoder().decode(result.stderr);
+  const stderr = result.stderr ?? result.error?.message ?? "";
   if (stderr.includes("already exists")) {
     return;
   }

package/src/workspace-skills.ts

@@ -0,0 +1,235 @@
+import { createHash } from "node:crypto";
+
+import { Capability, type SandboxSessionLike } from "@openai/agents/sandbox";
+
+const SKILL_FILE = "SKILL.md";
+const MAX_DISCOVERED_SKILLS = 256;
+const MAX_SKILL_ENTRIES = 1_024;
+const MAX_SKILL_BYTES = 32 * 1024 * 1024;
+const SAFE_SKILL_NAME = /^[A-Za-z0-9][A-Za-z0-9._-]*$/;
+
+export type WorkspaceSkillSearchPath = Readonly<{
+  path: string;
+  source: string;
+}>;
+
+type WorkspaceSkill = Readonly<{
+  name: string;
+  description: string;
+  path: string;
+  fingerprint: string;
+  source: string;
+}>;
+
+/**
+ * Index skills that already exist in the live workspace.
+ *
+ * Unlike the SDK's `skills({ from })` and `skills({ lazyFrom })` sources, this
+ * capability deliberately contributes no manifest entries and materializes
+ * nothing. Repository resources and Connected Machines already own these
+ * files; the bound sandbox session is the one portable way to inspect them.
+ */
+export class WorkspaceSkillsCapability extends Capability {
+  readonly type = "workspace-skills";
+  private discovery?: Promise<readonly WorkspaceSkill[]>;
+
+  constructor(
+    private readonly searchPaths: readonly WorkspaceSkillSearchPath[],
+    private readonly reservedNames: ReadonlySet<string> = new Set(),
+  ) {
+    super();
+  }
+
+  override async instructions(): Promise<string | null> {
+    const session = requireWorkspaceSkillSession(this._session);
+    this.discovery ??= discoverWorkspaceSkills(
+      session,
+      this.searchPaths,
+      this.reservedNames,
+      this._runAs,
+    );
+    const skills = await this.discovery;
+    if (skills.length === 0) return null;
+
+    const available = skills
+      .map((skill) => `- ${skill.name}: ${skill.description} (file: ${skill.path})`)
+      .join("\n");
+    return `## Repository skills
+
+Repository skills are instructions already present in the live workspace. They do not need to be loaded or copied.
+
+### Available repository skills
+${available}
+
+### How to use repository skills
+- If the user names a skill, or the task clearly matches a skill description, read its complete SKILL.md before acting.
+- Resolve referenced scripts, references, assets, and templates relative to that skill directory.
+- Use only the minimum relevant skills for the turn, and say briefly which ones you are using.
+- Do not assume a skill remains applicable on later turns; evaluate the current request again.`;
+  }
+}
+
+export function workspaceSkills(
+  searchPaths: readonly WorkspaceSkillSearchPath[],
+  reservedNames: Iterable<string> = [],
+): WorkspaceSkillsCapability {
+  return new WorkspaceSkillsCapability(
+    searchPaths,
+    new Set([...reservedNames].map((name) => name.toLowerCase())),
+  );
+}
+
+export async function discoverWorkspaceSkills(
+  session: SandboxSessionLike,
+  searchPaths: readonly WorkspaceSkillSearchPath[],
+  reservedNames: ReadonlySet<string> = new Set(),
+  runAs?: string,
+): Promise<readonly WorkspaceSkill[]> {
+  if (!session.listDir || !session.readFile) {
+    throw new Error("Workspace skill discovery requires sandbox listDir() and readFile() support");
+  }
+  const discovered = new Map<string, WorkspaceSkill>();
+  let candidates = 0;
+  for (const searchPath of searchPaths) {
+    let entries;
+    try {
+      entries = await session.listDir({ path: searchPath.path, ...(runAs ? { runAs } : {}) });
+    } catch {
+      continue;
+    }
+    for (const entry of [...entries].sort((left, right) => left.name.localeCompare(right.name))) {
+      if (entry.type !== "dir") continue;
+      candidates += 1;
+      if (candidates > MAX_DISCOVERED_SKILLS) {
+        throw new Error(`Repository skill discovery exceeds ${MAX_DISCOVERED_SKILLS} directories`);
+      }
+      const skillMarkdownPath = joinWorkspacePath(entry.path, SKILL_FILE);
+      let markdown: string;
+      try {
+        const content = await session.readFile({
+          path: skillMarkdownPath,
+          ...(runAs ? { runAs } : {}),
+        });
+        markdown = typeof content === "string" ? content : new TextDecoder().decode(content);
+      } catch {
+        continue;
+      }
+      const frontmatter = parseSkillFrontmatter(markdown);
+      const name = frontmatter.name?.trim() || entry.name;
+      if (name.length > 64 || !SAFE_SKILL_NAME.test(name)) {
+        throw new Error(`Repository skill has an invalid name: ${name.slice(0, 64)}`);
+      }
+      const description = frontmatter.description?.trim() || "No description provided.";
+      if (description.length > 2_048 || /[\r\n]/.test(description)) {
+        throw new Error(`Repository skill "${name}" has an invalid description`);
+      }
+      const key = name.toLowerCase();
+      if (reservedNames.has(key)) {
+        throw new Error(`Workspace skill "${name}" conflicts with a configured OpenGeni skill`);
+      }
+      const candidate: WorkspaceSkill = {
+        name,
+        description,
+        path: skillMarkdownPath,
+        fingerprint: await fingerprintWorkspaceDirectory(session, entry.path, runAs),
+        source: searchPath.source,
+      };
+      const existing = discovered.get(key);
+      if (!existing) {
+        discovered.set(key, candidate);
+        continue;
+      }
+      if (existing.fingerprint !== candidate.fingerprint) {
+        throw new Error(
+          `Workspace skill "${name}" has conflicting definitions in ${existing.source} and ${candidate.source}`,
+        );
+      }
+    }
+  }
+  return [...discovered.values()].sort((left, right) => left.name.localeCompare(right.name));
+}
+
+async function fingerprintWorkspaceDirectory(
+  session: SandboxSessionLike,
+  root: string,
+  runAs?: string,
+): Promise<string> {
+  const hash = createHash("sha256");
+  let entryCount = 0;
+  let byteCount = 0;
+
+  async function visit(path: string, relativePath: string): Promise<void> {
+    const entries = await session.listDir!({ path, ...(runAs ? { runAs } : {}) });
+    for (const entry of [...entries].sort((left, right) => left.name.localeCompare(right.name))) {
+      entryCount += 1;
+      if (entryCount > MAX_SKILL_ENTRIES) {
+        throw new Error(`Workspace skill exceeds ${MAX_SKILL_ENTRIES} filesystem entries`);
+      }
+      const childRelativePath = relativePath ? `${relativePath}/${entry.name}` : entry.name;
+      hash.update(entry.type);
+      hash.update("\0");
+      hash.update(childRelativePath);
+      hash.update("\0");
+      if (entry.type === "dir") {
+        await visit(entry.path, childRelativePath);
+        continue;
+      }
+      if (entry.type !== "file") continue;
+      const content = await session.readFile!({
+        path: entry.path,
+        ...(runAs ? { runAs } : {}),
+      });
+      const bytes = typeof content === "string" ? new TextEncoder().encode(content) : content;
+      byteCount += bytes.byteLength;
+      if (byteCount > MAX_SKILL_BYTES) {
+        throw new Error(`Workspace skill exceeds ${MAX_SKILL_BYTES} bytes`);
+      }
+      hash.update(bytes);
+      hash.update("\0");
+    }
+  }
+
+  await visit(root, "");
+  return hash.digest("hex");
+}
+
+function parseSkillFrontmatter(markdown: string): {
+  name?: string;
+  description?: string;
+} {
+  const lines = markdown.split(/\r?\n/);
+  if (lines[0]?.trim() !== "---") return {};
+  const end = lines.findIndex((line, index) => index > 0 && line.trim() === "---");
+  if (end === -1) return {};
+  const values: Record<string, string> = {};
+  for (const line of lines.slice(1, end)) {
+    const separator = line.indexOf(":");
+    if (separator === -1) continue;
+    const key = line.slice(0, separator).trim();
+    if (key !== "name" && key !== "description") continue;
+    values[key] = unquote(line.slice(separator + 1).trim());
+  }
+  return values;
+}
+
+function unquote(value: string): string {
+  if (
+    value.length >= 2 &&
+    value[0] === value[value.length - 1] &&
+    (value[0] === '"' || value[0] === "'")
+  ) {
+    return value.slice(1, -1);
+  }
+  return value;
+}
+
+function joinWorkspacePath(parent: string, child: string): string {
+  return `${parent.replace(/\/+$/, "")}/${child}`;
+}
+
+function requireWorkspaceSkillSession(session: SandboxSessionLike | undefined): SandboxSessionLike {
+  if (!session) {
+    throw new Error('capability "workspace-skills" used before bind(session)');
+  }
+  return session;
+}