@opengeni/runtime 3.2.2 → 3.4.0

package/dist/{chunk-2AUDDDO2.js → chunk-3DFH3ZHU.js}

@@ -21,7 +21,7 @@ import {
   withCommandNotStartedCallProof,
   withRunCredentialsClient,
   withRunCredentialsSession
-} from "./chunk-462CH77G.js";
+} from "./chunk-ETTCGPBT.js";
 import {
   SKILL_MAX_FILES,
   SKILL_READ_MAX_OUTPUT_BYTES,
@@ -58,6 +58,7 @@ import {
   estimateCompleteModelInputTokens,
   estimateSerializedValueTokens,
   estimateTextTokens,
+  expandInteractionFamilyDisclosures,
   extractOpenSuffixMembers,
   extractRemoteCompactionV2OutputItem,
   hasModelGeneratedItem,
@@ -101,19 +102,19 @@ import {
   withModelRequestCapture,
   withModelTransportStartedObserver,
   withPreparedCompactionRequest
-} from "./chunk-7OUG7WBV.js";
+} from "./chunk-GWRBALGQ.js";
 import {
   GMAIL_REST_MCP_BRIDGE_ADAPTER,
   gmailRestResultOutcome,
   isOfficialGmailMcpConfig
-} from "./chunk-XQ23VCZ4.js";
+} from "./chunk-6FQ6KEII.js";
 import {
   SLACK_REST_MCP_BRIDGE_ADAPTER
-} from "./chunk-RSHQSLEJ.js";
+} from "./chunk-KIL4FGX5.js";
 import {
   ConnectorAttachmentTransferError,
   projectConnectorAttachmentTransfers
-} from "./chunk-Z5U6WE22.js";
+} from "./chunk-PRZPGRIK.js";
 import {
   SelfhostedControlError,
   SynchronousCommandOutcomeUnknownError,
@@ -127,15 +128,15 @@ import {
   runWithToolCallCorrelation,
   withRoutingMutationOutputRejectionFence,
   wrapCapabilityToolsForTurnCancellation
-} from "./chunk-5WJOPANS.js";
+} from "./chunk-Y5THZH5N.js";
 import {
   SandboxAgent,
   filesystem,
   shell
-} from "./chunk-HJSIPTFA.js";
+} from "./chunk-4XDJ4TJA.js";
 import {
   connectMcpServers
-} from "./chunk-KCPW4K7L.js";
+} from "./chunk-PZQUUBEB.js";
 import {
   Agent,
   AgentsError,
@@ -151,6 +152,7 @@ import {
   Usage,
   applyDiff,
   azureBlobMount,
+  defineToolInputGuardrail,
   dir,
   external_exports,
   file,
@@ -162,7 +164,7 @@ import {
   setDefaultModelProvider,
   setTracingDisabled,
   tool
-} from "./chunk-7LJ7KDPI.js";
+} from "./chunk-ERD4ICVB.js";
 import {
   MCP_MAX_CONCURRENT_SERVER_OPERATIONS,
   MCP_MAX_RESPONSE_BYTES,
@@ -384,13 +386,520 @@ import {
   interactionControlFailureFromError
 } from "@opengeni/sdk";
 
-// src/browser-action-json-schema.ts
-function browserActionInputJsonSchema(schema) {
-  return external_exports.toJSONSchema(schema, {
-    target: "draft-2020-12",
-    reused: "ref"
+// src/browser-current-tab.ts
+var BrowserTargetResolutionError = class extends Error {
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = "BrowserTargetResolutionError";
+  }
+};
+var CurrentBrowserTab = class {
+  constructor(deps) {
+    this.deps = deps;
+  }
+  current = null;
+  /** Record the session and, when known, the tab a successful call used. */
+  use(browserSessionId, targetId) {
+    if (targetId === void 0) {
+      if (this.current?.browserSessionId !== browserSessionId) {
+        this.current = { browserSessionId, targetId: null };
+      }
+      return;
+    }
+    this.current = { browserSessionId, targetId };
+  }
+  forgetTarget(browserSessionId, targetId) {
+    if (this.current?.browserSessionId === browserSessionId && this.current.targetId === targetId) {
+      this.current = { browserSessionId, targetId: null };
+    }
+  }
+  forgetSession(browserSessionId) {
+    if (this.current?.browserSessionId === browserSessionId) this.current = null;
+  }
+  /** A call that relied on remembered identifiers failed: resolve afresh next time. */
+  failed(resolved) {
+    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) {
+    if (browserSessionId !== void 0) 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) {
+    const session = await this.session(value.browserSessionId);
+    if (value.targetId !== void 0) {
+      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 };
+  }
+};
+function expandRefShorthand(action) {
+  if (!action || typeof action !== "object" || Array.isArray(action)) return action;
+  const record = action;
+  let expanded = null;
+  for (const field of ["locator", "from", "to"]) {
+    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;
+}
+
+// src/interaction-tool-json-schema.ts
+var VALIDATION_ONLY_KEYWORDS = /* @__PURE__ */ new Set(["$schema", "$id", "minLength", "maxLength"]);
+var MEANINGFUL_NUMERIC_BOUND = 1e5;
+var MEANINGFUL_MAX_ITEMS = 64;
+var MEANINGFUL_PATTERN_LENGTH = 32;
+function interactionToolInputJsonSchema(schema) {
+  const generated = external_exports.toJSONSchema(schema, { target: "draft-2020-12" });
+  return modelFacingSchema(generated);
+}
+var flattenedVariants = /* @__PURE__ */ new WeakMap();
+var LOCATOR_FIELDS = /* @__PURE__ */ new Set(["locator", "from", "to"]);
+function withRefShorthandLocators(schema) {
+  return refShorthand(schema);
+}
+function refShorthand(node) {
+  if (Array.isArray(node)) return node.map(refShorthand);
+  if (!isNode(node)) return node;
+  const out = {};
+  for (const [key, value] of Object.entries(node)) {
+    if (key !== "properties" || !isNode(value)) {
+      out[key] = refShorthand(value);
+      continue;
+    }
+    const properties = {};
+    for (const [field, schema] of Object.entries(value)) {
+      properties[field] = LOCATOR_FIELDS.has(field) && isRefLocator(schema) ? { anyOf: [{ type: "string", description: "An element ref." }, refShorthand(schema)] } : refShorthand(schema);
+    }
+    out[key] = properties;
+  }
+  return out;
+}
+function isRefLocator(schema) {
+  if (!isNode(schema)) return false;
+  if (Array.isArray(schema.anyOf)) return schema.anyOf.some(isRefLocator);
+  return isNode(schema.properties) && (tagValues(schema.properties.kind) ?? []).includes("ref");
+}
+function modelFacingSchema(node) {
+  if (Array.isArray(node)) return node.map(modelFacingSchema);
+  if (!isNode(node)) return node;
+  const out = {};
+  for (const [key, value] of Object.entries(node)) {
+    if (VALIDATION_ONLY_KEYWORDS.has(key)) continue;
+    if (key === "additionalProperties" && value === false) continue;
+    if ((key === "minimum" || key === "maximum") && typeof value === "number" && Math.abs(value) >= MEANINGFUL_NUMERIC_BOUND) {
+      continue;
+    }
+    if (key === "minItems" && typeof value === "number" && value <= 1) continue;
+    if (key === "maxItems" && typeof value === "number" && value > MEANINGFUL_MAX_ITEMS) continue;
+    if (key === "pattern" && typeof value === "string" && value.length > MEANINGFUL_PATTERN_LENGTH) {
+      continue;
+    }
+    out[key] = modelFacingSchema(value);
+  }
+  for (const unionKey of ["oneOf", "anyOf"]) {
+    const members = out[unionKey];
+    if (!Array.isArray(members)) continue;
+    const flattened = flattenTaggedUnion(members);
+    if (!flattened) continue;
+    delete out[unionKey];
+    const { description, ...rest } = flattened;
+    Object.assign(out, rest);
+    const own = typeof out.description === "string" ? out.description : "";
+    out.description = own ? `${own} ${String(description)}` : description;
+    flattenedVariants.set(out, flattenedVariants.get(flattened) ?? []);
+  }
+  return out;
+}
+function flattenTaggedUnion(members) {
+  if (members.length < 2 || !members.every(isObjectSchema)) return null;
+  const objects = members;
+  const tag = ["type", "kind", "operation"].find(
+    (candidate) => objects.every((member) => tagValues(member.properties[candidate]) !== null)
+  );
+  if (!tag) return null;
+  const variants = [];
+  const tagValuesInOrder = [];
+  const properties = /* @__PURE__ */ new Map();
+  for (const member of objects) {
+    const nested = flattenedVariants.get(member);
+    const required = new Set(Array.isArray(member.required) ? member.required : []);
+    if (nested) {
+      variants.push(...nested);
+    } else {
+      const fields = Object.keys(member.properties).filter((field) => field !== tag).map((field) => required.has(field) ? field : `${field}?`);
+      for (const value of tagValues(member.properties[tag])) variants.push([value, fields]);
+    }
+    for (const value of tagValues(member.properties[tag])) {
+      if (!tagValuesInOrder.includes(value)) tagValuesInOrder.push(value);
+    }
+    for (const [field, schema] of Object.entries(member.properties)) {
+      if (field === tag) continue;
+      const seen = properties.get(field) ?? [];
+      if (!seen.some((existing) => sameSchema(existing, schema))) seen.push(schema);
+      properties.set(field, seen);
+    }
+  }
+  const merged = {
+    [tag]: { type: "string", enum: tagValuesInOrder }
+  };
+  for (const [field, schemas] of properties) {
+    merged[field] = schemas.length === 1 ? schemas[0] : mergeAlternatives(schemas);
+  }
+  const summary = mergeSameTagVariants(variants).map(([value, fields]) => fields.length > 0 ? `${value}: ${fields.join(", ")}` : value).join("; ");
+  const flattened = {
+    type: "object",
+    properties: merged,
+    required: [tag],
+    description: `Fields by ${tag} (? = optional): ${summary}.`
+  };
+  flattenedVariants.set(flattened, variants);
+  return flattened;
+}
+function mergeSameTagVariants(variants) {
+  const byValue = /* @__PURE__ */ new Map();
+  for (const [value, fields] of variants) {
+    const seen = byValue.get(value) ?? [];
+    seen.push(fields);
+    byValue.set(value, seen);
+  }
+  return [...byValue].map(([value, members]) => {
+    if (members.length === 1) return [value, members[0]];
+    const names = [];
+    for (const fields of members) {
+      for (const field of fields) {
+        const name = field.endsWith("?") ? field.slice(0, -1) : field;
+        if (!names.includes(name)) names.push(name);
+      }
+    }
+    return [
+      value,
+      names.map((name) => members.every((fields) => fields.includes(name)) ? name : `${name}?`)
+    ];
   });
 }
+function mergeAlternatives(schemas) {
+  if (schemas.every((schema) => tagValues(schema) !== null)) {
+    return { type: "string", enum: [...new Set(schemas.flatMap((schema) => tagValues(schema)))] };
+  }
+  return { anyOf: schemas };
+}
+function tagValues(schema) {
+  if (!isNode(schema)) return null;
+  if (typeof schema.const === "string") return [schema.const];
+  if (Array.isArray(schema.enum) && schema.enum.length > 0 && schema.enum.every((value) => typeof value === "string")) {
+    return schema.enum;
+  }
+  return null;
+}
+function isObjectSchema(schema) {
+  return isNode(schema) && schema.type === "object" && isNode(schema.properties);
+}
+function sameSchema(left, right) {
+  return JSON.stringify(left) === JSON.stringify(right);
+}
+function isNode(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+var MAX_REPORTED_ISSUES = 4;
+var MAX_ISSUE_MESSAGE_CHARS = 240;
+function describeInvalidToolArguments(error) {
+  const issues = leafIssues(error.issues, []).slice(0, MAX_REPORTED_ISSUES);
+  const described = issues.map(({ path, message }) => {
+    const text = message.replace(/^Invalid input: /u, "").slice(0, MAX_ISSUE_MESSAGE_CHARS);
+    return path.length > 0 ? `${path.join(".")}: ${text}` : text;
+  });
+  return `Interaction tool arguments are invalid: ${described.join("; ")}.`;
+}
+function leafIssues(issues, base) {
+  const leaves = [];
+  for (const issue of issues) {
+    const path = [...base, ...issue.path];
+    if (issue.code === "invalid_union" && issue.errors.length > 0) {
+      leaves.push(...leafIssues(chosenUnionBranch(issue.errors), path));
+      continue;
+    }
+    if (issue.code === "unrecognized_keys") {
+      leaves.push({ path, message: `unexpected field ${issue.keys.join(", ")}` });
+      continue;
+    }
+    leaves.push({ path, message: issue.message });
+  }
+  return leaves;
+}
+function chosenUnionBranch(branches) {
+  const tagMismatch = (issue) => issue.code === "invalid_union" && issue.errors.length === 0 || issue.code === "invalid_value" && ["type", "kind", "operation"].includes(String(issue.path.at(-1)));
+  const matching = branches.filter((branch) => !branch.some(tagMismatch));
+  if (matching.length > 0) {
+    return matching.reduce((best, branch) => branch.length < best.length ? branch : best);
+  }
+  const unknownTag = branches.find(
+    (branch) => branch.some((issue) => issue.code === "invalid_union" && issue.errors.length === 0)
+  );
+  return unknownTag?.filter((issue) => issue.code === "invalid_union") ?? branches.reduce((best, branch) => branch.length < best.length ? branch : best);
+}
+
+// src/browser-model-text.ts
+var REFLESS_ROLES = /* @__PURE__ */ new Set([
+  "article",
+  "banner",
+  "blockquote",
+  "caption",
+  "cell",
+  "code",
+  "columnheader",
+  "complementary",
+  "contentinfo",
+  "definition",
+  "deletion",
+  "document",
+  "emphasis",
+  "figure",
+  "form",
+  "generic",
+  "group",
+  "heading",
+  "insertion",
+  "LabelText",
+  "LineBreak",
+  "list",
+  "listitem",
+  "log",
+  "main",
+  "mark",
+  "navigation",
+  "none",
+  "note",
+  "paragraph",
+  "presentation",
+  "region",
+  "row",
+  "rowgroup",
+  "rowheader",
+  "Section",
+  "separator",
+  "status",
+  "strong",
+  "subscript",
+  "superscript",
+  "table",
+  "term",
+  "text",
+  "time"
+]);
+function shownState(role, state) {
+  if (state === "focusable" || state === "settable" || state === "editable") return false;
+  if (state.startsWith("editable=") || state.startsWith("url=")) return false;
+  if (state.endsWith("=")) return false;
+  if (role === "document" && state === "focused") return false;
+  return true;
+}
+function quoted(value) {
+  return JSON.stringify(value);
+}
+function browserNodeLine(node, allRefs, baseDepth = 0) {
+  const parts = [`${"  ".repeat(Math.max(0, node.depth - baseDepth))}- ${node.role}`];
+  if (node.name) parts.push(quoted(node.name));
+  if (allRefs || (node.actions?.length ?? 0) > 0 || !REFLESS_ROLES.has(node.role)) {
+    parts.push(`[${node.ref}]`);
+  }
+  if (node.value !== void 0 && node.value !== "") {
+    parts.push(typeof node.value === "string" ? `value=${quoted(node.value)}` : "value=<redacted>");
+  }
+  if (node.description) parts.push(`description=${quoted(node.description)}`);
+  for (const state of node.states ?? []) if (shownState(node.role, state)) parts.push(state);
+  return parts.join(" ");
+}
+function browserTargetLine(target) {
+  const kind = target.kind === "page" ? "" : ` (${target.kind})`;
+  const selected = target.selected ? " selected" : "";
+  return `Tab ${target.id}${kind}${selected}: ${quoted(target.title)} ${target.url}`;
+}
+function shallowestDepth(nodes) {
+  let base = Number.POSITIVE_INFINITY;
+  for (const node of nodes) base = Math.min(base, node.depth);
+  return Number.isFinite(base) ? base : 0;
+}
+function plural(count, noun) {
+  if (count === 1) return `${count} ${noun}`;
+  return `${count} ${noun}${/(?:s|x|ch|sh)$/.test(noun) ? "es" : "s"}`;
+}
+function browserObservationText(observation, options = {}) {
+  const allRefs = options.allRefs === true;
+  const lines = [browserTargetLine({ ...observation.target, selected: false })];
+  const viewport = observation.viewport;
+  if (viewport) {
+    const extras = [
+      viewport.deviceScaleFactor && viewport.deviceScaleFactor !== 1 ? `scale ${viewport.deviceScaleFactor}` : null,
+      viewport.maxTouchPoints ? `${viewport.maxTouchPoints} touch points` : null
+    ].filter((entry) => entry !== null);
+    lines.push(
+      `Viewport ${viewport.width}x${viewport.height}${extras.length ? ` (${extras.join(", ")})` : ""}`
+    );
+  }
+  const dialog = observation.dialog;
+  if (dialog) {
+    const prompt = dialog.type === "prompt" && dialog.defaultPrompt ? ` default ${quoted(dialog.defaultPrompt)}` : "";
+    lines.push(`Open ${dialog.type} dialog: ${quoted(dialog.message)}${prompt}`);
+  }
+  const diagnostics = observation.diagnostics;
+  if (diagnostics) {
+    const reported = [
+      diagnostics.consoleErrorCount ? plural(diagnostics.consoleErrorCount, "console error") : null,
+      diagnostics.pageErrorCount ? plural(diagnostics.pageErrorCount, "page error") : null,
+      diagnostics.failedRequestCount ? plural(diagnostics.failedRequestCount, "failed request") : null,
+      diagnostics.downloadCount ? plural(diagnostics.downloadCount, "download") : null
+    ].filter((entry) => entry !== null);
+    if (reported.length) lines.push(`Page reported ${reported.join(", ")}`);
+  }
+  if (observation.changedRegions && observation.changedRegions.length > 0) {
+    lines.push(`Changed regions: ${JSON.stringify(observation.changedRegions)}`);
+  }
+  if (observation.screenshot) lines.push(`Screenshot: ${JSON.stringify(observation.screenshot)}`);
+  const view = observation.agentView;
+  const nodes = view.nodes;
+  if (observation.focusedRef && !nodes.some(
+    (node) => node.ref === observation.focusedRef && (node.states ?? []).includes("focused")
+  )) {
+    lines.push(`Focused element: ${observation.focusedRef}`);
+  }
+  if (view.sourceKind === "none") {
+    lines.push("No accessibility view is available for this tab.");
+  } else {
+    if (view.sourceKind === "diff") lines.push("Changed elements:");
+    const base = shallowestDepth(nodes);
+    for (const node of nodes) lines.push(browserNodeLine(node, allRefs, base));
+  }
+  const notes = [
+    view.omittedNodeCount ? `${plural(view.omittedNodeCount, "element")} not shown` : null,
+    view.removedRefCount ? `${plural(view.removedRefCount, "earlier element")} removed` : null,
+    view.clippedFieldCount ? `${plural(view.clippedFieldCount, "long field")} clipped` : null
+  ].filter((entry) => entry !== null);
+  if (notes.length) lines.push(`(${notes.join("; ")})`);
+  return lines.join("\n");
+}
+function resolvedTargetText(target) {
+  const parts = [`#${target.actionIndex} ${target.role}`];
+  if (target.name) parts.push(quoted(target.name));
+  if (target.ref) parts.push(`[${target.ref}]`);
+  if (target.container) {
+    parts.push(
+      `in ${target.container.role}${target.container.name ? ` ${quoted(target.container.name)}` : ""}`
+    );
+  }
+  return parts.join(" ");
+}
+function browserActionText(receipt) {
+  const lines = [`Action ${receipt.state} on tab ${receipt.targetId}.`];
+  if (receipt.error) {
+    const { code, message, retryable, ...details } = receipt.error;
+    lines.push(
+      `Error ${code}${retryable ? " (retryable)" : ""}: ${message}${Object.keys(details).length ? ` ${JSON.stringify(details)}` : ""}`
+    );
+  }
+  if (receipt.targets && receipt.targets.length > 0) {
+    lines.push(`Acted on: ${receipt.targets.map(resolvedTargetText).join("; ")}`);
+  }
+  if (receipt.observation) {
+    lines.push(browserObservationText(receipt.observation, { allRefs: receipt.allRefs === true }));
+  }
+  return lines.join("\n");
+}
+var PLACEMENT_LABELS = {
+  sandbox_group: "the managed sandbox",
+  connected_machine: "a Connected Machine",
+  external_provider: "a remote browser provider",
+  attached_device: "the user's own Chrome"
+};
+function browserSessionLine(session) {
+  const engine = session.engine ?? "browser";
+  const mode = session.placement.kind === "attached_device" ? "" : session.headless ? " headless" : " headed";
+  const placement = PLACEMENT_LABELS[session.placement.kind] ?? session.placement.kind;
+  const extras = [
+    session.identityId ? `identity ${session.identityId}` : null,
+    session.failureCode ? `failure ${session.failureCode}` : null
+  ].filter((entry) => entry !== null);
+  return `BrowserSession ${session.id} (${session.lifecycle}): ${engine}${mode} on ${placement}${extras.length ? `, ${extras.join(", ")}` : ""}`;
+}
+function attachedProfileText(profile) {
+  return `${quoted(profile.name)}${profile.profileLabel ? ` (${profile.profileLabel})` : ""} deviceId ${profile.id}`;
+}
+function browserOpenText(output) {
+  const lines = [browserSessionLine(output.session)];
+  if (output.attachedProfile) {
+    lines.push(`Attached Chrome profile: ${attachedProfileText(output.attachedProfile)}`);
+  }
+  if (output.otherAttachedProfiles && output.otherAttachedProfiles.length > 0) {
+    lines.push(
+      `Other attached profiles: ${output.otherAttachedProfiles.map(attachedProfileText).join("; ")}`
+    );
+  }
+  const observedId = output.observation?.target.id;
+  for (const target of output.targets) {
+    if (target.id !== observedId) lines.push(browserTargetLine(target));
+  }
+  if (output.otherTabCount) {
+    lines.push(`${plural(output.otherTabCount, "other tab")} (browser_tabs list shows them)`);
+  }
+  if (output.observation) lines.push(browserObservationText(output.observation));
+  else if (output.targets.length === 0) lines.push("No tabs are open.");
+  return lines.join("\n");
+}
+function browserTabsText(output) {
+  const lines = [
+    `BrowserSession ${output.browserSessionId} has ${plural(output.targets.length, "tab")}:`
+  ];
+  for (const target of output.targets) lines.push(browserTargetLine(target));
+  if (output.mutationObservation) lines.push(browserObservationText(output.mutationObservation));
+  return lines.join("\n");
+}
+function browserReadText(output) {
+  const lines = [
+    `Tab ${output.targetId}: ${plural(output.totalMatches, "match")} (${output.mode})${output.scopeFound ? "" : "; the scope element was not found"}`
+  ];
+  const base = shallowestDepth(output.nodes);
+  for (const node of output.nodes) lines.push(browserNodeLine(node, true, base));
+  const notes = [
+    output.omittedMatches ? `${plural(output.omittedMatches, "match")} not shown` : null,
+    output.clippedFieldCount ? `${plural(output.clippedFieldCount, "long field")} clipped` : null
+  ].filter((entry) => entry !== null);
+  if (notes.length) lines.push(`(${notes.join("; ")})`);
+  return lines.join("\n");
+}
 
 // src/interaction-tools.ts
 var INTERACTION_ATTEMPT_TOOL_NAMES = FIRST_PARTY_IN_PROCESS_TOOL_NAMES;
@@ -462,9 +971,11 @@ var CompactBrowserActionReceipt = external_exports.object({
   observation: CompactBrowserObservation.optional()
 }).strict();
 var BrowserAgentActionReceipt = external_exports.union([BrowserActionReceipt, CompactBrowserActionReceipt]);
+var CurrentBrowserSessionId = external_exports.string().uuid().optional().describe("Omit to use the browser you used last.");
+var CurrentBrowserTargetId = external_exports.string().min(1).max(512).optional().describe("Omit to use the tab you used last.");
 var BrowserScreenshotInput = external_exports.object({
-  browserSessionId: external_exports.string().uuid(),
-  targetId: external_exports.string().min(1).max(512),
+  browserSessionId: CurrentBrowserSessionId,
+  targetId: CurrentBrowserTargetId,
   fullPage: external_exports.boolean().optional(),
   quality: external_exports.number().int().min(1).max(100).optional()
 }).strict();
@@ -485,8 +996,8 @@ var BrowserScreenshotOutput = external_exports.object({
   fullPage: external_exports.boolean()
 }).strict();
 var BrowserReadInput = external_exports.object({
-  browserSessionId: external_exports.string().uuid(),
-  targetId: external_exports.string().min(1).max(512),
+  browserSessionId: CurrentBrowserSessionId,
+  targetId: CurrentBrowserTargetId,
   mode: external_exports.enum(["matches", "count", "subtree", "dom"]).optional(),
   dom: external_exports.discriminatedUnion("kind", [
     external_exports.object({
@@ -681,20 +1192,20 @@ var BrowserOpenOutput = external_exports.object({
   otherAttachedProfiles: external_exports.array(AgentAttachedProfile).optional()
 }).strict();
 var BrowserTabsInput = external_exports.discriminatedUnion("operation", [
-  external_exports.object({ operation: external_exports.literal("list"), browserSessionId: external_exports.string().uuid() }).strict(),
+  external_exports.object({ operation: external_exports.literal("list"), browserSessionId: CurrentBrowserSessionId }).strict(),
   external_exports.object({
     operation: external_exports.literal("open"),
-    browserSessionId: external_exports.string().uuid(),
+    browserSessionId: CurrentBrowserSessionId,
     url: external_exports.string().url().max(16384).optional()
   }).strict(),
   external_exports.object({
     operation: external_exports.literal("select"),
-    browserSessionId: external_exports.string().uuid(),
+    browserSessionId: CurrentBrowserSessionId,
     targetId: external_exports.string().min(1).max(512)
   }).strict(),
   external_exports.object({
     operation: external_exports.literal("close"),
-    browserSessionId: external_exports.string().uuid(),
+    browserSessionId: CurrentBrowserSessionId,
     targetId: external_exports.string().min(1).max(512)
   }).strict()
 ]);
@@ -704,24 +1215,24 @@ var BrowserTabsOutput = external_exports.object({
   mutationObservation: CompactBrowserObservation.optional()
 }).strict();
 var BrowserObserveInput = external_exports.object({
-  browserSessionId: external_exports.string().uuid(),
-  targetId: external_exports.string().min(1).max(512),
+  browserSessionId: CurrentBrowserSessionId,
+  targetId: CurrentBrowserTargetId,
   view: external_exports.enum(["compact", "full"]).optional(),
   includeScreenshot: external_exports.boolean().optional()
 }).strict();
 var BrowserActInput = external_exports.object({
-  browserSessionId: external_exports.string().uuid(),
-  targetId: external_exports.string().min(1).max(512),
+  browserSessionId: CurrentBrowserSessionId,
+  targetId: CurrentBrowserTargetId,
   expectedTargetGeneration: external_exports.string().min(1).max(256).optional(),
   expectedDocumentGeneration: external_exports.string().min(1).max(256).nullable().optional(),
   expectedFrameId: external_exports.string().min(1).max(256).nullable().optional(),
   view: external_exports.enum(["compact", "full", "none"]).optional(),
-  action: external_exports.union([BrowserAction, BrowserActionBatch])
+  action: external_exports.preprocess(expandRefShorthand, external_exports.union([BrowserAction, BrowserActionBatch]))
 }).strict();
 var BrowserClipboardInput = external_exports.object({ browserSessionId: external_exports.string().uuid() }).strict();
 var BrowserDebugInput = external_exports.object({
-  browserSessionId: external_exports.string().uuid(),
-  targetId: external_exports.string().min(1).max(512),
+  browserSessionId: CurrentBrowserSessionId,
+  targetId: CurrentBrowserTargetId,
   kinds: external_exports.array(external_exports.enum(["console", "page_error", "failed_request", "download"])).max(4).optional(),
   after: external_exports.number().int().nonnegative().optional(),
   limit: external_exports.number().int().min(1).max(1e3).optional()
@@ -872,6 +1383,40 @@ function createInteractionAttemptToolDefinitions(input) {
   const selected = new Set(input.selectedTools ?? DEFAULT_FIRST_PARTY_MCP_TOOLS);
   const permissions = input.permissions ?? DEFAULT_FIRST_PARTY_MCP_PERMISSIONS;
   const definitions = [];
+  const currentTab = new CurrentBrowserTab({
+    listLiveSessions: async () => filterDiscoveredSessions(
+      (await input.transport.listBrowserSessions(input.workspaceId, {
+        associatedSessionId: input.sessionId,
+        includeTerminal: false
+      })).sessions,
+      input.sessionId,
+      "current_session",
+      false
+    ),
+    listTargets: async (browserSessionId) => (await input.transport.listBrowserTargets(input.workspaceId, browserSessionId)).targets
+  });
+  const onTab = async (value, run2) => {
+    const tab = await currentTab.target(value);
+    try {
+      const output = await run2(tab);
+      currentTab.use(tab.browserSessionId, tab.targetId);
+      return output;
+    } catch (error) {
+      if (isGoneBrowserError(error)) currentTab.failed(tab);
+      throw error;
+    }
+  };
+  const onBrowser = async (browserSessionId, run2) => {
+    const browser = await currentTab.session(browserSessionId);
+    try {
+      const output = await run2(browser);
+      currentTab.use(browser.browserSessionId);
+      return output;
+    } catch (error) {
+      if (isGoneBrowserError(error)) currentTab.failed(browser);
+      throw error;
+    }
+  };
   const add = (options) => {
     if (!selected.has(options.name) || !hasToolPermission(permissions, TOOL_PERMISSION[options.name])) {
       return;
@@ -882,7 +1427,9 @@ function createInteractionAttemptToolDefinitions(input) {
       codemodePath: options.codemodePath,
       title: options.title,
       description: options.description,
-      inputSchema: options.name === "browser_act" ? browserActionInputJsonSchema(options.input) : jsonSchema(options.input),
+      inputSchema: (options.modelInputSchema ?? ((schema) => schema))(
+        interactionToolInputJsonSchema(options.input)
+      ),
       outputSchema: jsonSchema(options.output),
       annotations: {
         title: options.title,
@@ -899,7 +1446,8 @@ function createInteractionAttemptToolDefinitions(input) {
         raw,
         context,
         options.execute,
-        options.readOnly
+        options.readOnly,
+        options.modelText
       )
     });
   };
@@ -969,80 +1517,93 @@ function createInteractionAttemptToolDefinitions(input) {
     name: "browser_open",
     codemodePath: ["interaction", "browser", "open"],
     title: "Open or reuse browser",
-    description: `Open a managed BrowserSession on the current agent placement, reuse a relevant compatible live session by default, attach to an explicit workspace BrowserSession, or open the user's own Chrome with placement={kind:'attached_device'}. Use that directly for requests about 'my browser', 'my tabs', or current Chrome: it opens the only Chrome profile connected through the Opengeni Browser extension, or else the most recently active one (reported as attachedProfile, the rest as otherAttachedProfiles). Add deviceId (from interaction_discover scope=attached_browsers or otherAttachedProfiles) only when the user wants a different profile. Omitting placement never uses the user's Chrome. If no profile is connected, explain that the Chrome extension must be connected instead of silently creating a blank managed browser (it needs a Connected Machine, then the Opengeni Browser extension: ${OPENGENI_BROWSER_EXTENSION_URL}). BrowserSessions persist across tool calls; shell-launched browser daemons do not survive remote-command cleanup. Never switch to the user's attached Chrome as a fallback for a failed managed browser unless the user requested that profile. A new attached session opens a dedicated tab. Managed Chromium defaults to headed so OAuth and later human interaction use a supported browser; request headless=true only for agent-only work that will not require sign-in or human control. Operator-enabled disposable sandbox verification may explicitly request storageMode=ephemeral_context with headless=true: no saved identity, route, Computer, checkpoint or resume; process loss ends the session. Default private_profile storage is unchanged. Returns exact session and tab state, plus observation: a compact snapshot of the opened (or selected) tab when one is available. With initialUrl, targets holds only the opened tab and otherTabCount counts the rest (browser_tabs list shows them). Reuse its refs and generations for the first action instead of observing again.`,
+    description: `Open a managed BrowserSession on the current agent placement, reuse a relevant compatible live session by default, attach to an explicit workspace BrowserSession, or open the user's own Chrome with placement={kind:'attached_device'}. Use that directly for requests about 'my browser', 'my tabs', or current Chrome: it opens the only Chrome profile connected through the Opengeni Browser extension, or else the most recently active one (reported as attachedProfile, the rest as otherAttachedProfiles). Add deviceId (from interaction_discover scope=attached_browsers or otherAttachedProfiles) only when the user wants a different profile. Omitting placement never uses the user's Chrome. If no profile is connected, explain that the Chrome extension must be connected instead of silently creating a blank managed browser (it needs a Connected Machine, then the Opengeni Browser extension: ${OPENGENI_BROWSER_EXTENSION_URL}). BrowserSessions persist across tool calls; shell-launched browser daemons do not survive remote-command cleanup. Never switch to the user's attached Chrome as a fallback for a failed managed browser unless the user requested that profile. A new attached session opens a dedicated tab. Managed Chromium defaults to headed so OAuth and later human interaction use a supported browser; request headless=true only for agent-only work that will not require sign-in or human control. Operator-enabled disposable sandbox verification may explicitly request storageMode=ephemeral_context with headless=true: no saved identity, route, Computer, checkpoint or resume; process loss ends the session. Default private_profile storage is unchanged. Returns the session, its tabs and an outline of the opened (or selected) tab when one is available, in the browser_observe format. With initialUrl, only the opened tab is listed and the others are counted (browser_tabs list shows them). Act on the outline's elements directly instead of observing again. Call it first for any browser task; browser_observe, browser_act, browser_screenshot and browser_tabs then work on the session it returns.`,
     input: BrowserOpenInput,
     output: BrowserOpenOutput,
     readOnly: false,
     idempotent: true,
-    execute: async (value, context) => await openBrowser(input.transport, input.workspaceId, input.sessionId, value, context)
+    modelText: browserOpenText,
+    execute: async (value, context) => {
+      const opened = await openBrowser(
+        input.transport,
+        input.workspaceId,
+        input.sessionId,
+        value,
+        context
+      );
+      currentTab.use(
+        opened.session.id,
+        opened.observation?.target.id ?? opened.targets.find((target) => target.selected)?.id ?? null
+      );
+      return opened;
+    }
   });
   add({
     name: "browser_tabs",
     codemodePath: ["interaction", "browser", "tabs"],
     title: "Manage browser tabs",
-    description: "List, open, logically select, or close tabs in one exact BrowserSession. Selection changes the BrowserSession's default target, not the visible desktop tab. New attached-Chrome tabs open in the background. Use browser_act activate only when foregrounding the owned tab is explicitly intended. Closing a tab does not release the browser process; use browser_lifecycle for session cleanup. Returns the authoritative complete tab list after the operation. Open/select also return mutationObservation, the operation's compact page snapshot. Reuse its refs and generations for immediate actions; refresh after later page changes.",
+    description: "List, open, logically select, or close tabs in one exact BrowserSession. Selection changes the BrowserSession's default target, not the visible desktop tab. New attached-Chrome tabs open in the background. Use browser_act activate only when foregrounding the owned tab is explicitly intended. Closing a tab does not release the browser process; use browser_lifecycle for session cleanup. Returns the authoritative complete tab list after the operation. Open/select also return the page outline. Act on its elements directly; observe again after later page changes.",
     input: BrowserTabsInput,
     output: BrowserTabsOutput,
     readOnly: false,
     idempotent: false,
-    execute: async (value) => {
+    modelText: browserTabsText,
+    execute: async (value) => await onBrowser(value.browserSessionId, async ({ browserSessionId }) => {
       let mutationObservation;
       if (value.operation === "open") {
         mutationObservation = await input.transport.openBrowserTarget(
           input.workspaceId,
-          value.browserSessionId,
+          browserSessionId,
           { ...value.url ? { url: value.url } : {} }
         );
       } else if (value.operation === "select") {
         mutationObservation = await input.transport.selectBrowserTarget(
           input.workspaceId,
-          value.browserSessionId,
+          browserSessionId,
           value.targetId
         );
       } else if (value.operation === "close") {
-        return agentTargetList(
-          await input.transport.closeBrowserTarget(
-            input.workspaceId,
-            value.browserSessionId,
-            value.targetId
-          )
+        const closed = await input.transport.closeBrowserTarget(
+          input.workspaceId,
+          browserSessionId,
+          value.targetId
         );
+        currentTab.forgetTarget(browserSessionId, value.targetId);
+        return agentTargetList(closed);
       }
-      const tabs = await input.transport.listBrowserTargets(
-        input.workspaceId,
-        value.browserSessionId
-      );
-      return mutationObservation ? {
-        ...agentTargetList(tabs),
-        mutationObservation: projectBrowserObservation(mutationObservation, "compact")
-      } : agentTargetList(tabs);
-    }
+      const tabs = await input.transport.listBrowserTargets(input.workspaceId, browserSessionId);
+      if (mutationObservation) {
+        currentTab.use(browserSessionId, mutationObservation.target.id);
+        return {
+          ...agentTargetList(tabs),
+          mutationObservation: projectBrowserObservation(mutationObservation, "compact")
+        };
+      }
+      return agentTargetList(tabs);
+    })
   });
   add({
     name: "browser_observe",
     codemodePath: ["interaction", "browser", "observe"],
     title: "Observe browser tab",
-    description: "Read one tab's URL, title, viewport, causal generations, and a bounded accessibility view. Compact view is the default: agentView lists selected refs, and omittedNodeCount or clippedFieldCount appear only when something was left out; it is not a complete page tree. Empty and default fields are omitted. Set view=full for the complete accessibility snapshot. Set includeScreenshot=true to add a current still image as tool image content; browser_screenshot is faster when only pixels are needed.",
+    description: `Read one tab's URL, title, viewport and accessibility outline: one line per element, role "name" [ref] value and states, indented by nesting. Locate an element by role and name, or by ref ({kind:'ref',ref}); refs are listed on controls and other actionable elements, not on text and layout lines. The default view is selective and says how many elements it left out; it is not a complete page tree. Set view=full for every element with its ref. Set includeScreenshot=true to add a current still image as tool image content; browser_screenshot is faster when only pixels are needed.`,
     input: BrowserObserveInput,
     output: BrowserAgentObservation,
     readOnly: true,
     idempotent: true,
-    execute: async (value) => {
+    modelText: agentObservationText,
+    execute: async (value) => await onTab(value, async ({ browserSessionId, targetId }) => {
       const observationRequest = input.transport.observeBrowserTarget(
         input.workspaceId,
-        value.browserSessionId,
-        value.targetId
+        browserSessionId,
+        targetId
       );
       if (!value.includeScreenshot)
         return projectBrowserObservation(await observationRequest, value.view ?? "compact");
       const [observed, captured] = await Promise.allSettled([
         observationRequest,
         Promise.resolve().then(
-          () => input.transport.captureBrowserTarget(
-            input.workspaceId,
-            value.browserSessionId,
-            value.targetId
-          )
+          () => input.transport.captureBrowserTarget(input.workspaceId, browserSessionId, targetId)
         )
       ]);
       if (observed.status === "rejected") throw observed.reason;
@@ -1052,8 +1613,8 @@ function createInteractionAttemptToolDefinitions(input) {
       if (observation.target.targetGeneration !== frame.targetGeneration || observation.target.documentGeneration !== frame.documentGeneration) {
         observation = await input.transport.observeBrowserTarget(
           input.workspaceId,
-          value.browserSessionId,
-          value.targetId
+          browserSessionId,
+          targetId
         );
       }
       if (observation.target.targetGeneration !== frame.targetGeneration || observation.target.documentGeneration !== frame.documentGeneration) {
@@ -1063,7 +1624,7 @@ function createInteractionAttemptToolDefinitions(input) {
         projectBrowserObservation(observation, value.view ?? "compact"),
         [browserToolImageContent(frame.data, frame.mediaType)]
       );
-    }
+    })
   });
   add({
     name: "browser_read",
@@ -1074,12 +1635,13 @@ function createInteractionAttemptToolDefinitions(input) {
     output: BrowserReadToolOutput,
     readOnly: true,
     idempotent: true,
-    execute: async (value) => {
+    modelText: (output) => output.source === "accessibility" ? browserReadText(output) : JSON.stringify(output),
+    execute: async (value) => await onTab(value, async ({ browserSessionId, targetId }) => {
       if (value.mode === "dom") {
         const state = value.expectedTargetGeneration !== void 0 && value.expectedDocumentGeneration !== void 0 && value.expectedFrameId !== void 0 ? null : await input.transport.getBrowserTargetState(
           input.workspaceId,
-          value.browserSessionId,
-          value.targetId
+          browserSessionId,
+          targetId
         );
         const fences = {
           expectedTargetGeneration: value.expectedTargetGeneration ?? state.targetGeneration,
@@ -1110,22 +1672,18 @@ function createInteractionAttemptToolDefinitions(input) {
         return {
           ...await input.transport.readBrowserDom(
             input.workspaceId,
-            value.browserSessionId,
-            value.targetId,
+            browserSessionId,
+            targetId,
             request
           ),
           source: "dom"
         };
       }
       return readBrowserObservation(
-        await input.transport.observeBrowserTarget(
-          input.workspaceId,
-          value.browserSessionId,
-          value.targetId
-        ),
+        await input.transport.observeBrowserTarget(input.workspaceId, browserSessionId, targetId),
         value
       );
-    }
+    })
   });
   add({
     name: "browser_screenshot",
@@ -1136,13 +1694,16 @@ function createInteractionAttemptToolDefinitions(input) {
     output: BrowserScreenshotOutput,
     readOnly: true,
     idempotent: true,
-    execute: async (value) => {
+    execute: async (value) => await onTab(value, async ({ browserSessionId, targetId }) => {
       const frame = await input.transport.captureBrowserTarget(
         input.workspaceId,
-        value.browserSessionId,
-        value.targetId,
+        browserSessionId,
+        targetId,
         {},
-        { fullPage: value.fullPage ?? false, ...value.quality ? { quality: value.quality } : {} }
+        {
+          fullPage: value.fullPage ?? false,
+          ...value.quality ? { quality: value.quality } : {}
+        }
       );
       return new InteractionExecutionResult(
         {
@@ -1163,33 +1724,31 @@ function createInteractionAttemptToolDefinitions(input) {
         },
         [browserToolImageContent(frame.data, frame.mediaType)]
       );
-    }
+    })
   });
   add({
     name: "browser_act",
     codemodePath: ["interaction", "browser", "act"],
     title: "Act in browser tab",
-    description: "Perform one semantic-first browser action or bounded batch. Prefer action={type:'batch',actions:[...],fenceEachAction:true} for predictable edits in the same observed document, such as filling known form fields before one authorized submit. Pause for new page state, a dialog, or a decision instead of batching steps that depend on an unseen result. Reuse a page observation, when present, from browser_open, tab open/select or a prior action; observe only when none is present or it lacks needed content. Observe again after page changes or when needed content was omitted. If an action reports outcome_unknown, inspect the outcome and do not replay the batch. Use viewport to set page width, height, desktop/mobile layout and touch emulation, then check the measured viewport in the returned observation; emulation does not prove physical mobile-browser behavior. Use history back/forward for tab navigation; keypress shortcuts are page input and may not navigate browser history. A press key is one character or a key name (Enter, Tab, Escape, Backspace, Delete, Insert, Home, End, PageUp, PageDown, ArrowUp/Down/Left/Right, Space, F1-F24), optionally prefixed by Ctrl+, Alt+, Shift+, Meta+ or Mod+. The explicit activate action foregrounds the target in the user's desktop browser; use only when that is intended. Permission actions set a managed browser's web permission for this tab's exact current top-level origin. Omit generation fences to fetch fresh generation metadata without scanning accessibility; supplying all three fences skips that state read while preserving controller validation. The default receipt includes a compact accessibility view with explicit omissions; set view=full for the complete observation, or view=none when no post-action tree is needed. An upload action takes workspace File IDs; the artifact.artifactId returned by sandbox_file_publish is one. Text in fill, type and clipboard write may contain {{secret:\u2026}} references; the value (or the current TOTP code for /otp) is typed at dispatch and never shown to you. Use type with mode:'keys' for split one-time-code boxes or inputs that ignore pasted text.",
+    description: "Perform one semantic-first browser action or bounded batch. Prefer action={type:'batch',actions:[...],fenceEachAction:true} for predictable edits in the same observed document, such as filling known form fields before one authorized submit. Pause for new page state, a dialog, or a decision instead of batching steps that depend on an unseen result. Reuse a page observation, when present, from browser_open, tab open/select or a prior action; observe only when none is present or it lacks needed content. Observe again after page changes or when needed content was omitted. If an action reports outcome_unknown, inspect the outcome and do not replay the batch. Use viewport to set page width, height, desktop/mobile layout and touch emulation, then check the measured viewport in the returned observation; emulation does not prove physical mobile-browser behavior. Use history back/forward for tab navigation; keypress shortcuts are page input and may not navigate browser history. A press key is one character or a key name (Enter, Tab, Escape, Backspace, Delete, Insert, Home, End, PageUp, PageDown, ArrowUp/Down/Left/Right, Space, F1-F24), optionally prefixed by Ctrl+, Alt+, Shift+, Meta+ or Mod+. The explicit activate action foregrounds the target in the user's desktop browser; use only when that is intended. Permission actions set a managed browser's web permission for this tab's exact current top-level origin. The default receipt includes the page outline after the action, in the browser_observe format; set view=full for every element, or view=none when no post-action outline is needed. An upload action takes workspace File IDs; the artifact.artifactId returned by sandbox_file_publish is one. Text in fill, type and clipboard write may contain {{secret:\u2026}} references; the value (or the current TOTP code for /otp) is typed at dispatch and never shown to you. Use type with mode:'keys' for split one-time-code boxes or inputs that ignore pasted text.",
     input: BrowserActInput,
+    modelInputSchema: withRefShorthandLocators,
     output: BrowserAgentActionReceipt,
     readOnly: false,
     idempotent: true,
-    execute: async (value, context) => {
-      const receipt = await input.transport.actInBrowser(
-        input.workspaceId,
-        value.browserSessionId,
-        {
-          operationId: context.operationId,
-          targetId: value.targetId,
-          ...value.expectedTargetGeneration === void 0 ? {} : { expectedTargetGeneration: value.expectedTargetGeneration },
-          ...value.expectedDocumentGeneration === void 0 ? {} : { expectedDocumentGeneration: value.expectedDocumentGeneration },
-          ...value.expectedFrameId === void 0 ? {} : { expectedFrameId: value.expectedFrameId },
-          ...value.view === "none" ? { observationMode: "none" } : {},
-          action: value.action
-        }
-      );
+    modelText: agentActionText,
+    execute: async (value, context) => await onTab(value, async ({ browserSessionId, targetId }) => {
+      const receipt = await input.transport.actInBrowser(input.workspaceId, browserSessionId, {
+        operationId: context.operationId,
+        targetId,
+        ...value.expectedTargetGeneration === void 0 ? {} : { expectedTargetGeneration: value.expectedTargetGeneration },
+        ...value.expectedDocumentGeneration === void 0 ? {} : { expectedDocumentGeneration: value.expectedDocumentGeneration },
+        ...value.expectedFrameId === void 0 ? {} : { expectedFrameId: value.expectedFrameId },
+        ...value.view === "none" ? { observationMode: "none" } : {},
+        action: value.action
+      });
       return value.view === "full" ? receipt : compactActionReceipt(receipt);
-    }
+    })
   });
   add({
     name: "browser_clipboard",
@@ -1211,15 +1770,18 @@ function createInteractionAttemptToolDefinitions(input) {
     output: BrowserDiagnosticBatch,
     readOnly: true,
     idempotent: true,
-    execute: async (value) => await input.transport.listBrowserDiagnostics(
-      input.workspaceId,
-      value.browserSessionId,
-      value.targetId,
-      {
-        ...value.kinds ? { kinds: value.kinds } : {},
-        ...value.after !== void 0 ? { after: value.after } : {},
-        ...value.limit !== void 0 ? { limit: value.limit } : {}
-      }
+    execute: async (value) => await onTab(
+      value,
+      async ({ browserSessionId, targetId }) => await input.transport.listBrowserDiagnostics(
+        input.workspaceId,
+        browserSessionId,
+        targetId,
+        {
+          ...value.kinds ? { kinds: value.kinds } : {},
+          ...value.after !== void 0 ? { after: value.after } : {},
+          ...value.limit !== void 0 ? { limit: value.limit } : {}
+        }
+      )
     )
   });
   add({
@@ -1502,6 +2064,7 @@ function createInteractionAttemptToolDefinitions(input) {
           request
         );
       }
+      currentTab.forgetSession(value.browserSessionId);
       return await input.transport.endBrowserSession(
         input.workspaceId,
         value.browserSessionId,
@@ -1513,7 +2076,7 @@ function createInteractionAttemptToolDefinitions(input) {
     name: "computer_open",
     codemodePath: ["interaction", "computer", "open"],
     title: "Open or reuse computer",
-    description: "Open a ComputerSession on the current agent placement, reuse a relevant live session by default, or attach to an explicit workspace ComputerSession. Returns exact apps/windows/screens.",
+    description: "Open a ComputerSession on the current agent placement, reuse a relevant live session by default, or attach to an explicit workspace ComputerSession. Returns exact apps/windows/screens. Call it first for any computer task; computer_observe and computer_act then work on the session it returns.",
     input: ComputerOpenInput,
     output: ComputerOpenOutput,
     readOnly: false,
@@ -1800,6 +2363,7 @@ function createFirstPartyInteractionAttemptToolDefinitions(input) {
 async function openBrowser(transport, workspaceId, sourceSessionId, value, context) {
   let session;
   let created = false;
+  let initialView;
   let profileChoice;
   if (value.browserSessionId) {
     session = await transport.getBrowserSession(workspaceId, value.browserSessionId);
@@ -1827,7 +2391,7 @@ async function openBrowser(transport, workspaceId, sourceSessionId, value, conte
       created = true;
       if (attachedInventory) profileChoice = chooseAttachedProfile(attachedInventory);
       const placement = profileChoice ? { kind: "attached_device", deviceId: profileChoice.chosen.id } : value.placement;
-      session = (await transport.createBrowserSession(workspaceId, {
+      const createdResponse = await transport.createBrowserSession(workspaceId, {
         operationId: context.operationId,
         sessionId: sourceSessionId,
         ...value.name ? { name: value.name } : {},
@@ -1839,7 +2403,9 @@ async function openBrowser(transport, workspaceId, sourceSessionId, value, conte
         ...value.baseRevisionId ? { baseRevisionId: value.baseRevisionId } : {},
         ...value.networkRouteId ? { networkRouteId: value.networkRouteId } : {},
         ...value.linkedComputerSessionId ? { linkedComputerSessionId: value.linkedComputerSessionId } : {}
-      })).session;
+      });
+      session = createdResponse.session;
+      initialView = createdResponse.initialView;
     }
   }
   if (session.lifecycle === "suspended") {
@@ -1852,7 +2418,7 @@ async function openBrowser(transport, workspaceId, sourceSessionId, value, conte
     ...profileChoice.others.length > 0 ? { otherAttachedProfiles: profileChoice.others.map(agentAttachedProfile) } : {}
   } : {};
   if (session.lifecycle !== "active") return { session, targets: [], ...chosenProfile };
-  let targets = (await transport.listBrowserTargets(workspaceId, session.id)).targets;
+  let targets = initialView?.targets ?? (await transport.listBrowserTargets(workspaceId, session.id)).targets;
   if (value.initialUrl && !created && !targets.some((target) => sameBrowserUrl(target.url, value.initialUrl))) {
     if (!transport.openBrowserTargetWithInventory) {
       throw new Error("browser transport does not support metadata-only tab opening");
@@ -1871,7 +2437,7 @@ async function openBrowser(transport, workspaceId, sourceSessionId, value, conte
     targets = inventory.targets;
   }
   const primary = openedBrowserTarget(targets, value.initialUrl);
-  const observation = primary ? await observeOpenedBrowserTarget(transport, workspaceId, session.id, primary) : void 0;
+  const observation = !primary ? void 0 : initialView?.observation.target.id === primary.id ? projectBrowserObservation(initialView.observation, "compact") : await observeOpenedBrowserTarget(transport, workspaceId, session.id, primary);
   const opened = value.initialUrl && primary && sameBrowserUrl(primary.url, value.initialUrl) ? primary : void 0;
   const shown = opened && targets.length > 1 ? [opened] : targets;
   return {
@@ -2207,7 +2773,62 @@ function readBrowserObservation(observation, input) {
     maxNodeBytes: BROWSER_AGENT_MAX_NODE_BYTES
   };
 }
-async function safeInteractionExecution(inputSchema, outputSchema, raw, context, execute, readOnly) {
+function resultModelText(output, modelText) {
+  if (modelText) {
+    try {
+      return modelText(output);
+    } catch {
+    }
+  }
+  return JSON.stringify(output);
+}
+function fullObservationText(observation) {
+  const semantic = observation.semantic;
+  const roots = semantic?.kind === "snapshot" ? semantic.roots : semantic?.kind === "diff" ? semantic.changed : [];
+  return browserObservationText(
+    {
+      target: observation.target,
+      viewport: observation.viewport,
+      focusedRef: observation.focusedRef,
+      changedRegions: observation.changedRegions,
+      diagnostics: observation.diagnostics,
+      dialog: observation.dialog,
+      screenshot: observation.screenshot ?? void 0,
+      agentView: {
+        sourceKind: semantic?.kind ?? "none",
+        nodes: flattenBrowserNodes(roots).map(({ node, depth }) => ({
+          ref: node.ref,
+          role: node.role,
+          depth,
+          ...node.name !== void 0 ? { name: node.name } : {},
+          ...node.description !== void 0 ? { description: node.description } : {},
+          ...node.value !== void 0 ? { value: node.value } : {},
+          states: node.states,
+          actions: node.actions
+        })),
+        ...semantic?.kind === "diff" && semantic.removedRefs.length > 0 ? { removedRefCount: semantic.removedRefs.length } : {}
+      }
+    },
+    { allRefs: true }
+  );
+}
+function agentObservationText(observation) {
+  return "agentView" in observation ? browserObservationText(observation) : fullObservationText(observation);
+}
+function agentActionText(receipt) {
+  if ("protocolVersion" in receipt) {
+    const text = browserActionText({
+      targetId: receipt.targetId,
+      state: receipt.state,
+      error: receipt.error,
+      ...receipt.targets ? { targets: receipt.targets } : {}
+    });
+    return receipt.observation ? `${text}
+${fullObservationText(receipt.observation)}` : text;
+  }
+  return browserActionText(receipt);
+}
+async function safeInteractionExecution(inputSchema, outputSchema, raw, context, execute, readOnly, modelText) {
   try {
     const value = inputSchema.parse(raw);
     const executed = await execute(value, context);
@@ -2216,7 +2837,7 @@ async function safeInteractionExecution(inputSchema, outputSchema, raw, context,
     );
     const result = {
       content: [
-        { type: "text", text: JSON.stringify(structuredContent) },
+        { type: "text", text: resultModelText(structuredContent, modelText) },
         ...executed instanceof InteractionExecutionResult ? executed.additionalContent : []
       ],
       structuredContent
@@ -2224,7 +2845,10 @@ async function safeInteractionExecution(inputSchema, outputSchema, raw, context,
     return result;
   } catch (error) {
     if (error instanceof external_exports.ZodError) {
-      return interactionErrorResult("invalid_arguments", "Interaction tool arguments are invalid.");
+      return interactionErrorResult("invalid_arguments", describeInvalidToolArguments(error));
+    }
+    if (error instanceof BrowserTargetResolutionError) {
+      return interactionErrorResult(error.code, error.message);
     }
     const secretReferenceFailure = secretReferenceToolResult(error);
     if (secretReferenceFailure) return secretReferenceFailure;
@@ -2282,6 +2906,9 @@ function browserToolImageContent(data, mimeType) {
   }
   return { type: "image", data: Buffer.from(data).toString("base64"), mimeType };
 }
+function isGoneBrowserError(error) {
+  return error instanceof OpenGeniApiError && (error.status === 404 || error.status === 410);
+}
 function interactionErrorResult(code, message, retryable = false, requestId) {
   const error = { code, message, retryable, ...requestId ? { requestId } : {} };
   return {
@@ -3101,6 +3728,7 @@ function createSecretArgumentResolver(input) {
 import {
   approvalIdentifier,
   INTERACTION_REQUEST_HUMAN_MODEL_TOOL_NAME as INTERACTION_REQUEST_HUMAN_MODEL_TOOL_NAME2,
+  RequestHumanInteractionToolInput as RequestHumanInteractionToolInput2,
   CAPABILITY_DESCRIPTORS,
   DEFAULT_FIRST_PARTY_MCP_PERMISSIONS as DEFAULT_FIRST_PARTY_MCP_PERMISSIONS4,
   DEFAULT_FIRST_PARTY_MCP_TOOLS as DEFAULT_FIRST_PARTY_MCP_TOOLS2,
@@ -5111,7 +5739,7 @@ import { existsSync, readdirSync } from "fs";
 // ../sdk/package.json
 var package_default = {
   name: "@opengeni/sdk",
-  version: "3.2.2",
+  version: "3.4.0",
   description: "Framework-agnostic TypeScript SDK for the Opengeni API: typed client, session lifecycle, SSE event streaming with reconnect + replay-by-sequence, and proxy re-streaming helpers.",
   license: "Apache-2.0",
   repository: {
@@ -5333,7 +5961,7 @@ var package_default = {
 // ../react/package.json
 var package_default2 = {
   name: "@opengeni/react",
-  version: "3.2.2",
+  version: "3.4.0",
   description: "React hooks and styled components for Opengeni: live session streaming, chat composer, message timeline, session status, and fleet views \u2014 token-themed (CSS variables), dark-first, built on Tailwind v4 + Radix + Motion.",
   license: "Apache-2.0",
   repository: {
@@ -5670,7 +6298,7 @@ var package_default2 = {
 // ../codemode/package.json
 var package_default3 = {
   name: "@opengeni/codemode",
-  version: "3.2.2",
+  version: "3.4.0",
   description: "Attempt-frozen programmatic tool catalog and execution authority for Opengeni.",
   license: "Apache-2.0",
   repository: {
@@ -5720,7 +6348,7 @@ var package_default3 = {
 // ../ogtool/package.json
 var package_default4 = {
   name: "@opengeni/ogtool",
-  version: "3.2.2",
+  version: "3.4.0",
   description: "Codemode CLI and typed client entrypoint for an Opengeni execution attempt.",
   license: "Apache-2.0",
   repository: {
@@ -7287,7 +7915,7 @@ function callModelInputFilterForSettings(settings, options = {}) {
 }
 function baseModelInputFilterForSettings(settings) {
   const stripProviderIds = settings.openaiProviderItemIds === "strip";
-  return memoizedInputItemProjectionFilter(
+  const projectItems = memoizedInputItemProjectionFilter(
     (source) => {
       let item = restoreGenericDispatchHistoryItem(source);
       item = normalizeComputerCallAction(
@@ -7303,7 +7931,12 @@ function baseModelInputFilterForSettings(settings) {
     // latest model/tool step instead of walking a six-figure history again.
     { appendOnlyInput: true }
   );
+  return composeCallModelInputFilters([interactionFamilyDisclosureFilter, projectItems]);
 }
+var interactionFamilyDisclosureFilter = ({ modelData }) => {
+  const input = expandInteractionFamilyDisclosures(modelData.input);
+  return input === modelData.input ? modelData : { ...modelData, input };
+};
 
 // src/workspace-governance.ts
 import {
@@ -9367,6 +10000,18 @@ function activeModelToolInvocation(modelName) {
   const invocation = modelToolInvocation.getStore();
   return invocation?.modelName === modelName ? invocation : null;
 }
+function interactionRequestArgumentsProblem(serialized) {
+  let value;
+  try {
+    value = JSON.parse(serialized);
+  } catch {
+    return "Invalid interaction_request_human arguments: they are not valid JSON. Nothing was requested; call it again with a JSON object matching its schema.";
+  }
+  const parsed = RequestHumanInteractionToolInput2.safeParse(value);
+  if (parsed.success) return null;
+  const issues = parsed.error.issues.slice(0, 5).map((issue) => `${issue.path.join(".") || "arguments"}: ${issue.message}`);
+  return `Invalid interaction_request_human arguments: ${issues.join("; ")}. Nothing was requested; call it again with corrected arguments.`;
+}
 function installInteractionInterventionPolicy(agent, approvedToolCallId) {
   const approvalRequiredCallIds = /* @__PURE__ */ new Set();
   const listMcpTools = agent.getMcpTools.bind(agent);
@@ -9380,6 +10025,20 @@ function installInteractionInterventionPolicy(agent, approvedToolCallId) {
       const originalInvoke = tool2.invoke.bind(tool2);
       return {
         ...tool2,
+        // Runs before the approval pause, so invalid arguments come back to
+        // the model as a correctable tool result. Without it the call would
+        // pause first, the intervention could never be recorded, and the
+        // turn would fail.
+        inputGuardrails: [
+          ...tool2.inputGuardrails ?? [],
+          defineToolInputGuardrail({
+            name: "validate_interaction_request_human",
+            run: async ({ toolCall }) => {
+              const problem = interactionRequestArgumentsProblem(toolCall.arguments);
+              return problem ? ToolGuardrailFunctionOutputFactory.rejectContent(problem) : ToolGuardrailFunctionOutputFactory.allow();
+            }
+          })
+        ],
         needsApproval: async (_runContext, _parsedInput, callId) => {
           if (!callId) {
             throw new Error("Interaction intervention is missing its durable approval identity");
@@ -12309,7 +12968,10 @@ var PrefixedMcpServer = class _PrefixedMcpServer {
         return {
           ...tool2,
           name,
-          ...this.accountLabel ? {
+          // Name the account only when the turn has several accounts of this
+          // connector to tell apart. With one account the line adds nothing
+          // the model can act on, and it would repeat on every tool.
+          ...this.accountLabel?.account ? {
             description: `Account: ${this.accountLabel.model}. Use only this account; if the intended account for a write is unclear, ask before calling.
 ${tool2.description ?? ""}`.trimEnd()
           } : {}
@@ -13466,7 +14128,7 @@ async function runOwnedSandboxSetup(agent, session, setupSession, opts) {
   if (opts.recordLazyManifest) {
     const manifest = agent.defaultManifest;
     if (manifest) {
-      const { recordLazyMaterializedDirectories } = await import("./lazy-manifest-AJ6XPJ4F.js");
+      const { recordLazyMaterializedDirectories } = await import("./lazy-manifest-BLZ3UZLX.js");
       await recordLazyMaterializedDirectories(session, manifest);
     }
   }
@@ -15942,6 +16604,7 @@ export {
   hasCanonicalEditableArtifactToolSurface,
   buildOpenGeniAgent,
   sessionMcpApprovalConnectionId,
+  interactionRequestArgumentsProblem,
   withStructuredViewImageFunctionResults,
   buildAgentCapabilities,
   sandboxRunAs,
@@ -16006,4 +16669,4 @@ export {
   runAzureCliLoginHook,
   renderSessionGoalContext2 as renderSessionGoalContext
 };
-//# sourceMappingURL=chunk-2AUDDDO2.js.map
+//# sourceMappingURL=chunk-3DFH3ZHU.js.map