@opengeni/runtime 3.2.2 → 3.4.0

package/dist/sandbox/selfhosted/session.d.ts

@@ -1,6 +1,7 @@
 import { ControlResponse, type BrowserControlEnsureRequest, type BrowserControlEnsureResponse, type BrowserFramesOpenRequest, type ComputerFramesOpenRequest, type StreamChannel } from "@opengeni/agent-proto";
 import { Manifest } from "@openai/agents/sandbox";
 import type { ExposedPortEndpoint } from "../stream-port.js";
+import { type BrowserControlHttpCall, type BrowserControlHttpOutcome } from "../browser-control-http.js";
 import { type ControlRpc } from "./control-rpc.js";
 import { type SelfhostedRetryClock } from "./retry-policy.js";
 import type { SelfhostedOpObserver } from "./op-observer.js";
@@ -95,11 +96,16 @@ export interface SelfhostedBackgroundCommandAdoption {
     connectionInstanceId: string;
     opId: string;
     command: string;
+    /** The exec already failed because the machine stopped answering. Record it
+     * with a stop request instead of as a running background command. */
+    abandoned?: boolean;
 }
 /** Exact command-admission snapshot. A worker resolves this immediately before
  * every exec/Git admission; retries and already-started operations retain it. */
 export interface SelfhostedOperationAdmission {
     transactionalFsWriteSupported?: boolean;
+    /** The live runner serves in-process browser/computer controller requests. */
+    browserControlHttpSupported?: boolean;
     /** Workspace segment of the physical agent/relay route. Personal machines may
      * originate in a different same-organization workspace than the session. */
     workspaceId?: string;
@@ -123,6 +129,9 @@ export interface SelfhostedOperationAdmission {
 export interface SelfhostedSessionDeps {
     /** Exact live daemon capability; absent preserves legacy small-file writes. */
     transactionalFsWriteSupported?: boolean;
+    /** Exact live daemon capability; absent keeps controller requests on the
+     * command transport. */
+    browserControlHttpSupported?: boolean;
     /** Authorization/session workspace. */
     workspaceId: string;
     /** Physical control-plane workspace. Defaults to workspaceId for legacy and
@@ -303,6 +312,7 @@ export declare class SelfhostedSession {
     private readonly resourcePolicySupported;
     private readonly operationCpuQuotaSupported;
     private readonly transactionalFsWriteSupported;
+    private readonly browserControlHttpSupported;
     private readonly defaultOpStream;
     private readonly connectionInstanceId;
     private readonly resolveOperationAdmission;
@@ -524,6 +534,14 @@ export declare class SelfhostedSession {
     /** Ensure the loopback browser controller sidecar owned by this connected
      * machine. The authority scope is supplied by the caller and remains local. */
     ensureBrowserControl(request: BrowserControlEnsureRequest): Promise<BrowserControlEnsureResponse>;
+    /** Send one request to the agent-owned controller of an exact authority
+     * scope, served inside the runner over loopback without starting a process.
+     * `unsupported` means this connection's runner does not serve it and nothing
+     * was sent. `controller_absent` means no controller for that scope and
+     * generation accepted the request, so it was not delivered and the caller may
+     * ensure the controller and send again. A body too large for one reply is
+     * drained from the runner's spool; the request is never repeated. */
+    browserControlHttp(request: BrowserControlHttpCall): Promise<BrowserControlHttpOutcome>;
     /** Open one browser-native frame producer and return its canonical relay
      * endpoint. This does not route through `resolveExposedPort`: that legacy
      * method allocates PTY/desktop resources based on fixed ports, while this op
@@ -597,6 +615,7 @@ export declare class SelfhostedSandboxClient {
     private readonly operationResourcePolicySupported;
     private readonly operationCpuQuotaSupported;
     private readonly transactionalFsWriteSupported;
+    private readonly browserControlHttpSupported;
     private readonly resolveOperationAdmission;
     private readonly adoptBackgroundCommand;
     private readonly settleBackgroundCommand;
@@ -631,6 +650,7 @@ export declare class SelfhostedSandboxClient {
         operationResourcePolicySupported?: boolean;
         operationCpuQuotaSupported?: boolean;
         transactionalFsWriteSupported?: boolean;
+        browserControlHttpSupported?: boolean;
         resolveOperationAdmission?: () => Promise<SelfhostedOperationAdmission | null>;
         adoptBackgroundCommand?: SelfhostedSessionDeps["adoptBackgroundCommand"];
         settleBackgroundCommand?: SelfhostedSessionDeps["settleBackgroundCommand"];
@@ -711,6 +731,8 @@ export interface SelfhostedSessionBuild {
     /** Exact live CPU enforcement capability paired with the initial snapshot. */
     operationCpuQuotaSupported?: boolean;
     transactionalFsWriteSupported?: boolean;
+    /** Exact live runner capability for in-process controller requests. */
+    browserControlHttpSupported?: boolean;
     /** Live last-boundary operation admission resolver; see SelfhostedSessionDeps. */
     resolveOperationAdmission?: () => Promise<SelfhostedOperationAdmission | null>;
     adoptBackgroundCommand?: SelfhostedSessionDeps["adoptBackgroundCommand"];

package/dist/slack-rest-mcp.js

@@ -8,15 +8,15 @@ import {
   SlackRestMcpServer,
   isOfficialSlackMcpConfig,
   slackRestToolIsMutation
-} from "./chunk-RSHQSLEJ.js";
-import "./chunk-Z5U6WE22.js";
-import "./chunk-5WJOPANS.js";
+} from "./chunk-KIL4FGX5.js";
+import "./chunk-PRZPGRIK.js";
+import "./chunk-Y5THZH5N.js";
 import "./chunk-4A4XTKKX.js";
-import "./chunk-YG26XE7B.js";
-import "./chunk-NWS4HPB7.js";
-import "./chunk-HJSIPTFA.js";
-import "./chunk-KCPW4K7L.js";
-import "./chunk-7LJ7KDPI.js";
+import "./chunk-JYDG2A7H.js";
+import "./chunk-MIAL5I4O.js";
+import "./chunk-4XDJ4TJA.js";
+import "./chunk-PZQUUBEB.js";
+import "./chunk-ERD4ICVB.js";
 import "./chunk-LJNCGUMB.js";
 import "./chunk-PLDDJCW6.js";
 export {

package/dist/workspace-tool-gateway.js

@@ -3,21 +3,21 @@ import {
   prepareAgentTools,
   secretArgumentMode,
   sessionMcpApprovalConnectionId
-} from "./chunk-2AUDDDO2.js";
-import "./chunk-462CH77G.js";
+} from "./chunk-3DFH3ZHU.js";
+import "./chunk-ETTCGPBT.js";
 import "./chunk-4KFT2G3W.js";
-import "./chunk-7OUG7WBV.js";
+import "./chunk-GWRBALGQ.js";
 import "./chunk-5ULGMFKR.js";
-import "./chunk-XQ23VCZ4.js";
-import "./chunk-RSHQSLEJ.js";
-import "./chunk-Z5U6WE22.js";
-import "./chunk-5WJOPANS.js";
+import "./chunk-6FQ6KEII.js";
+import "./chunk-KIL4FGX5.js";
+import "./chunk-PRZPGRIK.js";
+import "./chunk-Y5THZH5N.js";
 import "./chunk-4A4XTKKX.js";
-import "./chunk-YG26XE7B.js";
-import "./chunk-NWS4HPB7.js";
-import "./chunk-HJSIPTFA.js";
-import "./chunk-KCPW4K7L.js";
-import "./chunk-7LJ7KDPI.js";
+import "./chunk-JYDG2A7H.js";
+import "./chunk-MIAL5I4O.js";
+import "./chunk-4XDJ4TJA.js";
+import "./chunk-PZQUUBEB.js";
+import "./chunk-ERD4ICVB.js";
 import "./chunk-LJNCGUMB.js";
 import "./chunk-PLDDJCW6.js";
 export {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opengeni/runtime",
-  "version": "3.2.2",
+  "version": "3.4.0",
   "license": "Apache-2.0",
   "repository": {
     "type": "git",
@@ -75,19 +75,19 @@
     "@openai/agents": "0.14.3",
     "@openai/agents-core": "0.14.3",
     "@openai/agents-extensions": "0.14.3",
-    "@opengeni/agent-proto": "3.2.2",
-    "@opengeni/capabilities": "3.2.2",
-    "@opengeni/codemode": "3.2.2",
-    "@opengeni/codex": "3.2.2",
-    "@opengeni/config": "3.2.2",
-    "@opengeni/contracts": "3.2.2",
-    "@opengeni/interaction": "3.2.2",
-    "@opengeni/network": "3.2.2",
-    "@opengeni/observability": "3.2.2",
-    "@opengeni/sdk": "3.2.2",
-    "@opengeni/tool-gateway": "3.2.2",
-    "@opengeni/vaults": "3.2.2",
-    "@opengeni/xai-subscription": "3.2.2",
+    "@opengeni/agent-proto": "3.4.0",
+    "@opengeni/capabilities": "3.4.0",
+    "@opengeni/codemode": "3.4.0",
+    "@opengeni/codex": "3.4.0",
+    "@opengeni/config": "3.4.0",
+    "@opengeni/contracts": "3.4.0",
+    "@opengeni/interaction": "3.4.0",
+    "@opengeni/network": "3.4.0",
+    "@opengeni/observability": "3.4.0",
+    "@opengeni/sdk": "3.4.0",
+    "@opengeni/tool-gateway": "3.4.0",
+    "@opengeni/vaults": "3.4.0",
+    "@opengeni/xai-subscription": "3.4.0",
     "debug": "4.4.3",
     "modal": "0.9.0",
     "openai": "6.47.0",

package/src/browser-current-tab.ts

@@ -0,0 +1,139 @@
+// The browser tab an agent is working in.
+//
+// Browser tools may omit browserSessionId and targetId to keep working in the
+// tab the agent used last, the way a person keeps using the tab in front of
+// them. A step then costs a few output tokens instead of two identifiers, and
+// output tokens dominate a browser step's model latency. The remembered tab
+// lives for one turn attempt; a call that omits identifiers before any browser
+// call in that attempt resolves this session's most recently used live
+// browser and its selected tab.
+
+export class BrowserTargetResolutionError extends Error {
+  constructor(
+    readonly code: "browser_session_required" | "browser_target_required",
+    message: string,
+  ) {
+    super(message);
+    this.name = "BrowserTargetResolutionError";
+  }
+}
+
+export type CurrentBrowserTabDeps = {
+  /** This agent session's live BrowserSessions. */
+  listLiveSessions: () => Promise<ReadonlyArray<{ id: string; lastUsedAt: string }>>;
+  /** The tabs of one BrowserSession. */
+  listTargets: (
+    browserSessionId: string,
+  ) => Promise<ReadonlyArray<{ id: string; kind: string; selected: boolean }>>;
+};
+
+export type ResolvedBrowserSession = {
+  browserSessionId: string;
+  /** True when the identifier came from memory or lookup, not the caller. */
+  implicit: boolean;
+};
+
+export type ResolvedBrowserTarget = ResolvedBrowserSession & {
+  targetId: string;
+  implicitTarget: boolean;
+};
+
+export class CurrentBrowserTab {
+  private current: { browserSessionId: string; targetId: string | null } | null = null;
+
+  constructor(private readonly deps: CurrentBrowserTabDeps) {}
+
+  /** Record the session and, when known, the tab a successful call used. */
+  use(browserSessionId: string, targetId?: string | null): void {
+    if (targetId === undefined) {
+      if (this.current?.browserSessionId !== browserSessionId) {
+        this.current = { browserSessionId, targetId: null };
+      }
+      return;
+    }
+    this.current = { browserSessionId, targetId };
+  }
+
+  forgetTarget(browserSessionId: string, targetId: string): void {
+    if (this.current?.browserSessionId === browserSessionId && this.current.targetId === targetId) {
+      this.current = { browserSessionId, targetId: null };
+    }
+  }
+
+  forgetSession(browserSessionId: string): void {
+    if (this.current?.browserSessionId === browserSessionId) this.current = null;
+  }
+
+  /** A call that relied on remembered identifiers failed: resolve afresh next time. */
+  failed(resolved: ResolvedBrowserSession & { implicitTarget?: boolean }): void {
+    if (resolved.implicit) this.forgetSession(resolved.browserSessionId);
+    else if (
+      resolved.implicitTarget &&
+      this.current?.browserSessionId === resolved.browserSessionId
+    ) {
+      this.current = { browserSessionId: resolved.browserSessionId, targetId: null };
+    }
+  }
+
+  async session(browserSessionId: string | undefined): Promise<ResolvedBrowserSession> {
+    if (browserSessionId !== undefined) return { browserSessionId, implicit: false };
+    if (this.current) return { browserSessionId: this.current.browserSessionId, implicit: true };
+    const sessions = [...(await this.deps.listLiveSessions())].sort((left, right) =>
+      right.lastUsedAt.localeCompare(left.lastUsedAt),
+    );
+    const latest = sessions[0];
+    if (!latest) {
+      throw new BrowserTargetResolutionError(
+        "browser_session_required",
+        "This session has no open browser. Call browser_open first, or pass browserSessionId.",
+      );
+    }
+    return { browserSessionId: latest.id, implicit: true };
+  }
+
+  async target(value: {
+    browserSessionId?: string | undefined;
+    targetId?: string | undefined;
+  }): Promise<ResolvedBrowserTarget> {
+    const session = await this.session(value.browserSessionId);
+    if (value.targetId !== undefined) {
+      return { ...session, targetId: value.targetId, implicitTarget: false };
+    }
+    if (this.current?.browserSessionId === session.browserSessionId && this.current.targetId) {
+      return { ...session, targetId: this.current.targetId, implicitTarget: true };
+    }
+    const pages = (await this.deps.listTargets(session.browserSessionId)).filter(
+      (target) => target.kind === "page" || target.kind === "popup",
+    );
+    const chosen =
+      pages.find((target) => target.selected) ?? (pages.length === 1 ? pages[0] : null);
+    if (!chosen) {
+      throw new BrowserTargetResolutionError(
+        "browser_target_required",
+        pages.length === 0
+          ? "This browser has no open tab. Open one with browser_tabs operation=open."
+          : `This browser has ${pages.length} tabs and none is selected. Pass targetId from browser_tabs operation=list.`,
+      );
+    }
+    return { ...session, targetId: chosen.id, implicitTarget: true };
+  }
+}
+
+/** An element ref passed where a locator is expected, as a bare string. */
+export function expandRefShorthand(action: unknown): unknown {
+  if (!action || typeof action !== "object" || Array.isArray(action)) return action;
+  const record = action as Record<string, unknown>;
+  let expanded: Record<string, unknown> | null = null;
+  for (const field of ["locator", "from", "to"] as const) {
+    const value = record[field];
+    if (typeof value === "string") {
+      expanded ??= { ...record };
+      expanded[field] = { kind: "ref", ref: value };
+    }
+  }
+  if (Array.isArray(record.actions)) {
+    expanded ??= { ...record };
+    expanded.actions = record.actions.map(expandRefShorthand);
+  }
+  return expanded ?? action;
+}