@opengeni/codemode 0.2.2

package/dist/index.js

@@ -0,0 +1,1543 @@
+// src/index.ts
+import { createHash, randomUUID } from "crypto";
+import Ajv from "ajv";
+import Ajv2019 from "ajv/dist/2019.js";
+import Ajv2020 from "ajv/dist/2020.js";
+import {
+  ATTEMPT_TOOL_CATALOG_VERSION,
+  ATTEMPT_TOOL_CATALOG_MAX_BYTES,
+  AttemptToolCall,
+  AttemptToolCatalog,
+  AttemptToolCatalogEntry,
+  AttemptToolResult,
+  CodemodeCallSubmission,
+  CodemodeOperation,
+  CodemodeDispatchAck,
+  CodemodeDispatchRequest
+} from "@opengeni/contracts";
+
+// src/environment.ts
+import { readFile } from "fs/promises";
+var CODEMODE_ENVIRONMENT = {
+  url: "OPENGENI_CODEMODE_URL",
+  tokenFile: "OPENGENI_CODEMODE_TOKEN_FILE"
+};
+var cachedEnvironmentClient = null;
+function environmentCodemodeClient(environment = process.env) {
+  const baseUrl = requiredEnvironment(environment, CODEMODE_ENVIRONMENT.url);
+  const tokenFile = requiredEnvironment(environment, CODEMODE_ENVIRONMENT.tokenFile);
+  const key = `${baseUrl}\0${tokenFile}`;
+  if (environment === process.env && cachedEnvironmentClient?.key === key) {
+    return cachedEnvironmentClient.client;
+  }
+  const client = new CodemodeClient({
+    baseUrl,
+    token: async () => await readBearerFile(tokenFile)
+  });
+  if (environment === process.env) cachedEnvironmentClient = { key, client };
+  return client;
+}
+function createCodemodeTools(client = () => environmentCodemodeClient()) {
+  const node = (path) => new Proxy(
+    async (args = {}, options = {}) => await (await client()).callPathValue(path, args, options),
+    {
+      get(_target, property) {
+        if (property === "then") return void 0;
+        if (property === Symbol.toStringTag) return "CodemodeTool";
+        if (typeof property !== "string") return void 0;
+        return node([...path, property]);
+      },
+      set() {
+        return false;
+      }
+    }
+  );
+  return new Proxy(/* @__PURE__ */ Object.create(null), {
+    get(_target, property) {
+      if (property === "then") return void 0;
+      if (property === Symbol.toStringTag) return "CodemodeTools";
+      if (typeof property !== "string") return void 0;
+      return node([property]);
+    },
+    set() {
+      return false;
+    }
+  });
+}
+var tools = createCodemodeTools();
+async function readBearerFile(path) {
+  let token;
+  try {
+    token = (await readFile(path, "utf8")).trim();
+  } catch {
+    throw new Error(`${CODEMODE_ENVIRONMENT.tokenFile} is not readable`);
+  }
+  if (!token) throw new Error(`${CODEMODE_ENVIRONMENT.tokenFile} is empty`);
+  return token;
+}
+function requiredEnvironment(environment, name) {
+  const value = environment[name]?.trim();
+  if (!value) throw new Error(`${name} is required`);
+  return value;
+}
+
+// src/artifacts.ts
+import { randomBytes } from "crypto";
+
+// src/structured.ts
+var CodemodeToolExecutionError = class extends Error {
+  constructor(result) {
+    const error = toolError(result);
+    super(error.message);
+    this.result = result;
+    this.name = "CodemodeToolExecutionError";
+    this.code = error.code;
+    this.retryable = error.retryable;
+  }
+  code;
+  retryable;
+};
+function codemodeClientProvider(client = () => environmentCodemodeClient()) {
+  return typeof client === "function" ? client : () => client;
+}
+async function callStructured(client, path, args, options) {
+  const result = await (await client()).callPath(path, args, options);
+  if (result.isError) throw new CodemodeToolExecutionError(result);
+  if (!result.structuredContent) {
+    throw new Error(`Codemode tool ${path.join(".")} returned no structured content`);
+  }
+  return result.structuredContent;
+}
+function toolError(result) {
+  const structured = result.structuredContent;
+  const error = structured?.error;
+  return {
+    code: typeof error?.code === "string" ? error.code : "tool_error",
+    message: typeof error?.message === "string" ? error.message : "Codemode tool failed",
+    retryable: error?.retryable === true
+  };
+}
+
+// src/artifacts.ts
+var PATH = {
+  list: ["artifacts", "list"],
+  create: ["artifacts", "create"],
+  import: ["artifacts", "import"],
+  get: ["artifacts", "get"],
+  inspect: ["artifacts", "inspect"],
+  apply: ["artifacts", "apply"],
+  export: ["artifacts", "export"],
+  exportStatus: ["artifacts", "exportStatus"]
+};
+var codemodeArtifactIds = Object.freeze({
+  stable: createStableArtifactId,
+  document: createDocumentArtifactId
+});
+var CodemodeArtifactCollection = class {
+  constructor(client) {
+    this.client = client;
+  }
+  ids = codemodeArtifactIds;
+  async list(options = {}, callOptions = {}) {
+    return (await callStructured(
+      this.client,
+      PATH.list,
+      options,
+      callOptions
+    )).artifacts;
+  }
+  async create(modality, title, callOptions = {}) {
+    const metadata = await callStructured(
+      this.client,
+      PATH.create,
+      { modality, title },
+      callOptions
+    );
+    return new CodemodeArtifact(this.client, metadata.id, metadata);
+  }
+  async import(fileId, modality, title, callOptions = {}) {
+    const metadata = await callStructured(
+      this.client,
+      PATH.import,
+      { fileId, modality, title },
+      callOptions
+    );
+    return new CodemodeArtifact(this.client, metadata.id, metadata);
+  }
+  use(artifact) {
+    return typeof artifact === "string" ? new CodemodeArtifact(this.client, artifact) : new CodemodeArtifact(this.client, artifact.id, artifact);
+  }
+};
+var DOCUMENT_ID_PREFIX = Object.freeze({
+  paragraph: "p",
+  table: "dt",
+  "page-break": "pb",
+  section: "sec",
+  header: "hdr",
+  footer: "ftr",
+  comment: "dc",
+  "tracked-change": "chg"
+});
+var MAX_U64 = 0xffffffffffffffffn;
+var MAX_DOCUMENT_COUNTER = BigInt(Number.MAX_SAFE_INTEGER) - 1n;
+function createStableArtifactId() {
+  const bytes = randomBytes(16);
+  if (bytes.subarray(0, 8).every((byte) => byte === 0)) bytes[0] = 1;
+  if (bytes.subarray(8, 16).every((byte) => byte === 0)) bytes[8] = 1;
+  return bytes.toString("hex");
+}
+function createDocumentArtifactId(kind, namespaceInput) {
+  const namespace = parseDocumentNamespace(namespaceInput);
+  const bytes = randomBytes(7);
+  bytes[0] = (bytes[0] ?? 0) & 31;
+  let counter = 0n;
+  for (const byte of bytes) counter = counter << 8n | BigInt(byte);
+  if (counter === 0n) counter = 1n;
+  if (counter > MAX_DOCUMENT_COUNTER) {
+    throw new Error("Generated document id counter exceeds the canonical limit");
+  }
+  return `${DOCUMENT_ID_PREFIX[kind]}/${namespace.toString(16).padStart(16, "0")}${counter.toString(16).padStart(16, "0")}`;
+}
+function parseDocumentNamespace(input) {
+  if (typeof input === "number" && (!Number.isSafeInteger(input) || input < 0) || typeof input === "string" && !/^(?:0|[1-9][0-9]*)$/u.test(input)) {
+    throw new TypeError("Document id namespace must be an unsigned decimal integer");
+  }
+  const namespace = BigInt(input);
+  if (namespace < 0n || namespace > MAX_U64) {
+    throw new RangeError("Document id namespace is outside the uint64 range");
+  }
+  return namespace;
+}
+var CodemodeArtifact = class {
+  constructor(client, id, metadata = null) {
+    this.client = client;
+    this.id = id;
+    this.metadata = metadata;
+  }
+  metadata;
+  async get(callOptions = {}) {
+    const metadata = await callStructured(
+      this.client,
+      PATH.get,
+      { artifactId: this.id },
+      callOptions
+    );
+    this.metadata = metadata;
+    return metadata;
+  }
+  async inspect(query, callOptions = {}) {
+    const modality = (await this.currentMetadata(callOptions)).modality;
+    const result = await callStructured(this.client, PATH.inspect, { artifactId: this.id, modality, request: query }, callOptions);
+    this.metadata = result.artifact;
+    return result;
+  }
+  async apply(commands, callOptions = {}) {
+    const metadata = await this.currentMetadata(callOptions);
+    const result = await callStructured(
+      this.client,
+      PATH.apply,
+      {
+        artifactId: this.id,
+        modality: metadata.modality,
+        expectedHeadSequence: metadata.headSequence,
+        expectedStateHash: metadata.stateHash,
+        commands
+      },
+      callOptions
+    );
+    this.metadata = result.artifact;
+    return result;
+  }
+  async export(format, options = {}, callOptions = {}) {
+    const started = await callStructured(this.client, PATH.export, { artifactId: this.id, format, options }, callOptions);
+    this.metadata = started.artifact;
+    return new CodemodeArtifactExport(
+      this.client,
+      started.artifact.id,
+      started.versionId,
+      started.jobId,
+      started.sourceHeadSequence,
+      started.sourceStateHash
+    );
+  }
+  async currentMetadata(callOptions) {
+    return this.metadata ?? await this.get(callOptions);
+  }
+};
+var CodemodeArtifactExport = class {
+  constructor(client, artifactId, versionId, jobId, sourceHeadSequence, sourceStateHash) {
+    this.client = client;
+    this.artifactId = artifactId;
+    this.versionId = versionId;
+    this.jobId = jobId;
+    this.sourceHeadSequence = sourceHeadSequence;
+    this.sourceStateHash = sourceStateHash;
+  }
+  async status(callOptions = {}) {
+    return await callStructured(
+      this.client,
+      PATH.exportStatus,
+      {
+        artifactId: this.artifactId,
+        versionId: this.versionId,
+        jobId: this.jobId
+      },
+      callOptions
+    );
+  }
+};
+
+// src/interaction.ts
+var PATH2 = {
+  discover: ["interaction", "discover"],
+  browserOpen: ["interaction", "browser", "open"],
+  browserTabs: ["interaction", "browser", "tabs"],
+  browserObserve: ["interaction", "browser", "observe"],
+  browserAct: ["interaction", "browser", "act"],
+  browserDebug: ["interaction", "browser", "debug"],
+  browserIdentity: ["interaction", "browser", "identity"],
+  browserPublish: ["interaction", "browser", "publish"],
+  browserLifecycle: ["interaction", "browser", "lifecycle"],
+  computerOpen: ["interaction", "computer", "open"],
+  computerTargets: ["interaction", "computer", "targets"],
+  computerObserve: ["interaction", "computer", "observe"],
+  computerAct: ["interaction", "computer", "act"],
+  computerLifecycle: ["interaction", "computer", "lifecycle"]
+};
+var OpenGeniCodemode = class {
+  browsers;
+  computers;
+  artifacts;
+  constructor(client = () => environmentCodemodeClient()) {
+    const provider = codemodeClientProvider(client);
+    this.browsers = new CodemodeBrowserCollection(provider);
+    this.computers = new CodemodeComputerCollection(provider);
+    this.artifacts = new CodemodeArtifactCollection(provider);
+  }
+  async discover(options = {}, callOptions = {}) {
+    return await callStructured(this.browsers.client, PATH2.discover, options, callOptions);
+  }
+};
+var CodemodeBrowserCollection = class {
+  constructor(client) {
+    this.client = client;
+    this.identities = new CodemodeBrowserIdentityCollection(client);
+  }
+  identities;
+  async list(options = {}, callOptions = {}) {
+    return (await callStructured(this.client, PATH2.discover, options, callOptions)).browsers;
+  }
+  async open(options = {}, callOptions = {}) {
+    const opened = await callStructured(
+      this.client,
+      PATH2.browserOpen,
+      options,
+      callOptions
+    );
+    return new CodemodeBrowser(this.client, opened.session.id);
+  }
+  use(browserSessionId) {
+    return new CodemodeBrowser(this.client, browserSessionId);
+  }
+};
+var CodemodeBrowserIdentityCollection = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async list(options = {}, callOptions = {}) {
+    const response = await callStructured(this.client, PATH2.browserIdentity, { operation: "list", ...options }, callOptions);
+    return response.result;
+  }
+  async get(identityId, callOptions = {}) {
+    const response = await callStructured(
+      this.client,
+      PATH2.browserIdentity,
+      { operation: "get", identityId },
+      callOptions
+    );
+    return response.result;
+  }
+  async create(name, callOptions = {}) {
+    const response = await callStructured(this.client, PATH2.browserIdentity, { operation: "create", name }, callOptions);
+    return response.result;
+  }
+  async revisions(identityId, callOptions = {}) {
+    const response = await callStructured(this.client, PATH2.browserIdentity, { operation: "revisions", identityId }, callOptions);
+    return response.result;
+  }
+};
+var CodemodeBrowser = class {
+  constructor(client, id) {
+    this.client = client;
+    this.id = id;
+    this.tabs = new CodemodeBrowserTabCollection(client, id);
+  }
+  tabs;
+  async refresh(callOptions = {}) {
+    const result = await callStructured(
+      this.client,
+      PATH2.browserOpen,
+      { browserSessionId: this.id },
+      callOptions
+    );
+    return result.session;
+  }
+  async observe(targetId, callOptions = {}) {
+    return await this.tabs.use(await this.tabs.resolveId(targetId, callOptions)).observe(callOptions);
+  }
+  async act(action, options = {}, callOptions = {}) {
+    const targetId = await this.tabs.resolveId(options.targetId, callOptions);
+    return await this.tabs.use(targetId).act(action, options, callOptions);
+  }
+  async diagnostics(targetId, options = {}, callOptions = {}) {
+    return await callStructured(
+      this.client,
+      PATH2.browserDebug,
+      {
+        browserSessionId: this.id,
+        targetId: await this.tabs.resolveId(targetId, callOptions),
+        ...options
+      },
+      callOptions
+    );
+  }
+  async publish(input, callOptions = {}) {
+    return await callStructured(
+      this.client,
+      PATH2.browserPublish,
+      { browserSessionId: this.id, ...input },
+      callOptions
+    );
+  }
+  async suspend(callOptions = {}) {
+    return await this.lifecycle("suspend", callOptions);
+  }
+  async resume(callOptions = {}) {
+    return await this.lifecycle("resume", callOptions);
+  }
+  async end(callOptions = {}) {
+    return await this.lifecycle("end", callOptions);
+  }
+  async lifecycle(action, callOptions) {
+    return await callStructured(
+      this.client,
+      PATH2.browserLifecycle,
+      { browserSessionId: this.id, action },
+      callOptions
+    );
+  }
+};
+var CodemodeBrowserTabCollection = class {
+  constructor(client, browserSessionId) {
+    this.client = client;
+    this.browserSessionId = browserSessionId;
+  }
+  async list(callOptions = {}) {
+    return await callStructured(
+      this.client,
+      PATH2.browserTabs,
+      { operation: "list", browserSessionId: this.browserSessionId },
+      callOptions
+    );
+  }
+  async selected(callOptions = {}) {
+    return this.use(await this.resolveId(void 0, callOptions));
+  }
+  use(targetId) {
+    return new CodemodeBrowserTab(this.client, this.browserSessionId, targetId);
+  }
+  async open(url, callOptions = {}) {
+    const before = await this.list(callOptions);
+    const after = await callStructured(
+      this.client,
+      PATH2.browserTabs,
+      {
+        operation: "open",
+        browserSessionId: this.browserSessionId,
+        ...url ? { url } : {}
+      },
+      callOptions
+    );
+    const beforeIds = new Set(before.targets.map((target) => target.id));
+    const opened = after.targets.find((target) => !beforeIds.has(target.id)) ?? after.targets.find((target) => target.selected);
+    if (!opened) throw new Error("Browser opened no discoverable tab");
+    return this.use(opened.id);
+  }
+  async select(targetId, callOptions = {}) {
+    const after = await callStructured(
+      this.client,
+      PATH2.browserTabs,
+      { operation: "select", browserSessionId: this.browserSessionId, targetId },
+      callOptions
+    );
+    if (!after.targets.some((target) => target.id === targetId && target.selected)) {
+      throw new Error("Browser did not select the requested tab");
+    }
+    return this.use(targetId);
+  }
+  async close(targetId, callOptions = {}) {
+    return await callStructured(
+      this.client,
+      PATH2.browserTabs,
+      { operation: "close", browserSessionId: this.browserSessionId, targetId },
+      callOptions
+    );
+  }
+  async resolveId(targetId, callOptions) {
+    const listed = await this.list(callOptions);
+    if (targetId) {
+      if (!listed.targets.some((target) => target.id === targetId)) {
+        throw new Error(`Browser tab is unavailable: ${targetId}`);
+      }
+      return targetId;
+    }
+    const selected = listed.targets.filter((target) => target.selected);
+    if (selected.length === 1) return selected[0].id;
+    if (listed.targets.length === 1) return listed.targets[0].id;
+    if (listed.targets.length === 0) throw new Error("Browser has no tabs");
+    throw new Error("Browser target is ambiguous; select an exact tab");
+  }
+};
+var CodemodeBrowserTab = class {
+  constructor(client, browserSessionId, id) {
+    this.client = client;
+    this.browserSessionId = browserSessionId;
+    this.id = id;
+  }
+  async observe(callOptions = {}) {
+    return await callStructured(
+      this.client,
+      PATH2.browserObserve,
+      { browserSessionId: this.browserSessionId, targetId: this.id },
+      callOptions
+    );
+  }
+  async act(action, fences = {}, callOptions = {}) {
+    return await callStructured(
+      this.client,
+      PATH2.browserAct,
+      { browserSessionId: this.browserSessionId, targetId: this.id, action, ...fences },
+      callOptions
+    );
+  }
+  async navigate(url, callOptions = {}) {
+    return await this.act({ type: "navigate", url }, {}, callOptions);
+  }
+  getByRole(role, options = {}) {
+    return new CodemodeBrowserLocator(this, { kind: "role", role, ...options });
+  }
+  getByText(text) {
+    return new CodemodeBrowserLocator(this, { kind: "text", text });
+  }
+  getByLabel(text) {
+    return new CodemodeBrowserLocator(this, { kind: "label", text });
+  }
+  getByPlaceholder(text) {
+    return new CodemodeBrowserLocator(this, { kind: "placeholder", text });
+  }
+  getByTestId(value) {
+    return new CodemodeBrowserLocator(this, { kind: "test_id", value });
+  }
+  locator(selector) {
+    return new CodemodeBrowserLocator(this, { kind: "css", selector });
+  }
+  ref(ref) {
+    return new CodemodeBrowserLocator(this, { kind: "ref", ref });
+  }
+};
+var CodemodeBrowserLocator = class {
+  constructor(tab, locator) {
+    this.tab = tab;
+    this.locator = locator;
+  }
+  async click(options = {}, callOptions = {}) {
+    return await this.tab.act(
+      { type: "click", locator: this.locator, ...options },
+      {},
+      callOptions
+    );
+  }
+  async doubleClick(callOptions = {}) {
+    return await this.tab.act({ type: "double_click", locator: this.locator }, {}, callOptions);
+  }
+  async hover(callOptions = {}) {
+    return await this.tab.act({ type: "hover", locator: this.locator }, {}, callOptions);
+  }
+  async fill(value, callOptions = {}) {
+    return await this.tab.act({ type: "fill", locator: this.locator, value }, {}, callOptions);
+  }
+  async type(text, callOptions = {}) {
+    return await this.tab.act({ type: "type", locator: this.locator, text }, {}, callOptions);
+  }
+  async press(key, callOptions = {}) {
+    return await this.tab.act({ type: "press", locator: this.locator, key }, {}, callOptions);
+  }
+  async select(values, callOptions = {}) {
+    return await this.tab.act({ type: "select", locator: this.locator, values }, {}, callOptions);
+  }
+  async check(checked = true, callOptions = {}) {
+    return await this.tab.act({ type: "check", locator: this.locator, checked }, {}, callOptions);
+  }
+};
+var CodemodeComputerCollection = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async list(options = {}, callOptions = {}) {
+    return (await callStructured(this.client, PATH2.discover, options, callOptions)).computers;
+  }
+  async open(options = {}, callOptions = {}) {
+    const opened = await callStructured(
+      this.client,
+      PATH2.computerOpen,
+      options,
+      callOptions
+    );
+    return new CodemodeComputer(this.client, opened.session.id);
+  }
+  use(computerSessionId) {
+    return new CodemodeComputer(this.client, computerSessionId);
+  }
+};
+var CodemodeComputer = class {
+  constructor(client, id) {
+    this.client = client;
+    this.id = id;
+    this.targets = new CodemodeComputerTargetCollection(client, id);
+    this.apps = this.targets;
+  }
+  targets;
+  apps;
+  async refresh(callOptions = {}) {
+    const result = await callStructured(
+      this.client,
+      PATH2.computerOpen,
+      { computerSessionId: this.id },
+      callOptions
+    );
+    return result.session;
+  }
+  async observe(targetId, callOptions = {}) {
+    return await this.targets.use(await this.targets.resolveId(targetId, callOptions)).observe(callOptions);
+  }
+  async act(action, options = {}, callOptions = {}) {
+    return await this.targets.use(await this.targets.resolveId(options.targetId, callOptions)).act(action, options, callOptions);
+  }
+  async launch(applicationId, callOptions = {}) {
+    const targetId = await this.targets.resolveId(void 0, callOptions);
+    await this.targets.use(targetId).act({ type: "launch", applicationId }, {}, callOptions);
+    return await this.targets.list(callOptions);
+  }
+  async end(callOptions = {}) {
+    return await callStructured(
+      this.client,
+      PATH2.computerLifecycle,
+      { computerSessionId: this.id, action: "end" },
+      callOptions
+    );
+  }
+};
+var CodemodeComputerTargetCollection = class {
+  constructor(client, computerSessionId) {
+    this.client = client;
+    this.computerSessionId = computerSessionId;
+  }
+  async list(callOptions = {}) {
+    return await callStructured(
+      this.client,
+      PATH2.computerTargets,
+      { computerSessionId: this.computerSessionId },
+      callOptions
+    );
+  }
+  use(targetId) {
+    return new CodemodeComputerTarget(this.client, this.computerSessionId, targetId);
+  }
+  async focused(callOptions = {}) {
+    return this.use(await this.resolveId(void 0, callOptions));
+  }
+  async resolveId(targetId, callOptions) {
+    const listed = await this.list(callOptions);
+    if (targetId) {
+      if (!listed.targets.some((target) => target.id === targetId)) {
+        throw new Error(`Computer target is unavailable: ${targetId}`);
+      }
+      return targetId;
+    }
+    const focused = listed.targets.filter((target) => target.focused);
+    if (focused.length === 1) return focused[0].id;
+    if (listed.targets.length === 1) return listed.targets[0].id;
+    if (listed.targets.length === 0)
+      throw new Error("Computer has no app, window, or screen targets");
+    throw new Error("Computer target is ambiguous; select an exact app or window");
+  }
+};
+var CodemodeComputerTarget = class {
+  constructor(client, computerSessionId, id) {
+    this.client = client;
+    this.computerSessionId = computerSessionId;
+    this.id = id;
+  }
+  async observe(callOptions = {}) {
+    return await callStructured(
+      this.client,
+      PATH2.computerObserve,
+      { computerSessionId: this.computerSessionId, targetId: this.id },
+      callOptions
+    );
+  }
+  async act(action, fences = {}, callOptions = {}) {
+    return await callStructured(
+      this.client,
+      PATH2.computerAct,
+      { computerSessionId: this.computerSessionId, targetId: this.id, action, ...fences },
+      callOptions
+    );
+  }
+  getByRole(role, options = {}) {
+    return new CodemodeComputerLocator(this, { kind: "role", role, ...options });
+  }
+  getByText(text, exact) {
+    return new CodemodeComputerLocator(this, { kind: "text", text, ...exact ? { exact } : {} });
+  }
+  getByLabel(text, exact) {
+    return new CodemodeComputerLocator(this, { kind: "label", text, ...exact ? { exact } : {} });
+  }
+  getByIdentifier(value) {
+    return new CodemodeComputerLocator(this, { kind: "identifier", value });
+  }
+  ref(ref) {
+    return new CodemodeComputerLocator(this, { kind: "ref", ref });
+  }
+};
+var CodemodeComputerLocator = class {
+  constructor(target, locator) {
+    this.target = target;
+    this.locator = locator;
+  }
+  async invoke(callOptions = {}) {
+    return await this.semantic("invoke", void 0, callOptions);
+  }
+  async focus(callOptions = {}) {
+    return await this.semantic("focus", void 0, callOptions);
+  }
+  async setValue(value, callOptions = {}) {
+    return await this.semantic("set_value", value, callOptions);
+  }
+  async select(callOptions = {}) {
+    return await this.semantic("select", void 0, callOptions);
+  }
+  async expand(callOptions = {}) {
+    return await this.semantic("expand", void 0, callOptions);
+  }
+  async collapse(callOptions = {}) {
+    return await this.semantic("collapse", void 0, callOptions);
+  }
+  async semantic(action, value, callOptions) {
+    return await this.target.act(
+      {
+        type: "semantic",
+        locator: this.locator,
+        action,
+        ...value === void 0 ? {} : { value }
+      },
+      {},
+      callOptions
+    );
+  }
+};
+function createOpenGeniCodemode(client = () => environmentCodemodeClient()) {
+  return new OpenGeniCodemode(client);
+}
+var openGeni = createOpenGeniCodemode();
+
+// src/declarations.ts
+function generateCodemodeDeclarations(catalog, options = {}) {
+  const verified = parseVerifiedAttemptToolCatalog(catalog);
+  const moduleSpecifier = options.moduleSpecifier ?? "@opengeni/codemode";
+  const root = namespaceNode();
+  for (const entry of verified.entries) insertEntry(root, entry);
+  return [
+    "// Generated by @opengeni/codemode. Do not edit.",
+    `// Attempt catalog digest: ${verified.digest}`,
+    `import type { CodemodeCallOptions, CodemodeToolResult } from ${JSON.stringify(moduleSpecifier)};`,
+    "",
+    `declare module ${JSON.stringify(moduleSpecifier)} {`,
+    "  interface CodemodeGeneratedTools {",
+    ...renderChildren(root, 4),
+    "  }",
+    "}",
+    "",
+    "export {};",
+    ""
+  ].join("\n");
+}
+function jsonSchemaToTypeScript(schema) {
+  return schemaType(schema, schema, /* @__PURE__ */ new Set(), 0);
+}
+function namespaceNode() {
+  return { children: /* @__PURE__ */ new Map(), entry: null };
+}
+function insertEntry(root, entry) {
+  let node = root;
+  for (const [index, segment] of entry.codemodePath.entries()) {
+    if (node.entry) {
+      throw new Error(
+        `Codemode declaration path ${entry.codemodePath.join(".")} extends a tool leaf`
+      );
+    }
+    let child = node.children.get(segment);
+    if (!child) {
+      child = namespaceNode();
+      node.children.set(segment, child);
+    }
+    node = child;
+    if (index === entry.codemodePath.length - 1) {
+      if (node.entry || node.children.size > 0) {
+        throw new Error(`Codemode declaration path ${entry.codemodePath.join(".")} collides`);
+      }
+      node.entry = entry;
+    }
+  }
+}
+function renderChildren(node, indent) {
+  const lines = [];
+  for (const [name, child] of [...node.children].sort(
+    ([left], [right]) => left.localeCompare(right)
+  )) {
+    if (child.entry) {
+      lines.push(...renderTool(name, child.entry, indent));
+      continue;
+    }
+    lines.push(`${spaces(indent)}readonly ${name}: {`);
+    lines.push(...renderChildren(child, indent + 2));
+    lines.push(`${spaces(indent)}};`);
+  }
+  return lines;
+}
+function renderTool(name, entry, indent) {
+  const input = schemaType(entry.inputSchema, entry.inputSchema, /* @__PURE__ */ new Set(), 0);
+  const output = entry.outputSchema ? schemaType(entry.outputSchema, entry.outputSchema, /* @__PURE__ */ new Set(), 0) : "CodemodeToolResult";
+  const optionalArguments = rootObjectArgumentsAreOptional(entry.inputSchema);
+  const description = boundedDoc(entry.description ?? entry.title);
+  return [
+    ...description ? renderDoc(description, indent) : [],
+    `${spaces(indent)}readonly ${name}: (`,
+    `${spaces(indent + 2)}argumentsValue${optionalArguments ? "?" : ""}: ${input},`,
+    `${spaces(indent + 2)}options?: CodemodeCallOptions,`,
+    `${spaces(indent)}) => Promise<${output}>;`
+  ];
+}
+function rootObjectArgumentsAreOptional(schema) {
+  if (!isSchemaObject(schema)) return false;
+  const required = Array.isArray(schema.required) ? schema.required.filter((value) => typeof value === "string") : [];
+  return required.length === 0 && (schema.type === "object" || isSchemaObject(schema.properties));
+}
+function schemaType(schema, rootSchema, resolvingRefs, depth) {
+  if (depth > 48 || schema === true) return "unknown";
+  if (schema === false) return "never";
+  if (!isSchemaObject(schema)) return "unknown";
+  if (typeof schema.$ref === "string") {
+    const reference = schema.$ref;
+    if (!reference.startsWith("#/") || resolvingRefs.has(reference)) return "unknown";
+    const resolved = resolveLocalReference(rootSchema, reference);
+    if (resolved === void 0) return "unknown";
+    const next = new Set(resolvingRefs);
+    next.add(reference);
+    return schemaType(resolved, rootSchema, next, depth + 1);
+  }
+  if (Object.hasOwn(schema, "const")) return literalType(schema.const);
+  if (Array.isArray(schema.enum)) {
+    return union(schema.enum.map(literalType));
+  }
+  const composites = [];
+  if (Array.isArray(schema.oneOf)) {
+    composites.push(
+      union(schema.oneOf.map((part) => schemaType(part, rootSchema, resolvingRefs, depth + 1)))
+    );
+  }
+  if (Array.isArray(schema.anyOf)) {
+    composites.push(
+      union(schema.anyOf.map((part) => schemaType(part, rootSchema, resolvingRefs, depth + 1)))
+    );
+  }
+  if (Array.isArray(schema.allOf)) {
+    composites.push(
+      intersection(
+        schema.allOf.map((part) => schemaType(part, rootSchema, resolvingRefs, depth + 1))
+      )
+    );
+  }
+  if (composites.length > 0) {
+    const composed = intersection(composites);
+    return schema.nullable === true ? union([composed, "null"]) : composed;
+  }
+  const declaredTypes = Array.isArray(schema.type) ? schema.type.filter((value) => typeof value === "string") : typeof schema.type === "string" ? [schema.type] : inferredSchemaTypes(schema);
+  const rendered = declaredTypes.map(
+    (type) => typeType(type, schema, rootSchema, resolvingRefs, depth + 1)
+  );
+  if (schema.nullable === true) rendered.push("null");
+  return union(rendered.length > 0 ? rendered : ["unknown"]);
+}
+function inferredSchemaTypes(schema) {
+  if (isSchemaObject(schema.properties) || Object.hasOwn(schema, "additionalProperties")) {
+    return ["object"];
+  }
+  if (Object.hasOwn(schema, "items") || Array.isArray(schema.prefixItems)) return ["array"];
+  return [];
+}
+function typeType(type, schema, rootSchema, resolvingRefs, depth) {
+  switch (type) {
+    case "null":
+      return "null";
+    case "boolean":
+      return "boolean";
+    case "integer":
+    case "number":
+      return "number";
+    case "string":
+      return "string";
+    case "array":
+      return arrayType(schema, rootSchema, resolvingRefs, depth);
+    case "object":
+      return objectType(schema, rootSchema, resolvingRefs, depth);
+    default:
+      return "unknown";
+  }
+}
+function arrayType(schema, rootSchema, resolvingRefs, depth) {
+  if (Array.isArray(schema.prefixItems)) {
+    const tuple = schema.prefixItems.map(
+      (item2) => schemaType(item2, rootSchema, resolvingRefs, depth + 1)
+    );
+    if (schema.items === false) return `readonly [${tuple.join(", ")}]`;
+    const rest = schema.items === void 0 || schema.items === true ? "unknown" : schemaType(schema.items, rootSchema, resolvingRefs, depth + 1);
+    return `readonly [${tuple.join(", ")}${tuple.length > 0 ? ", " : ""}...${rest}[]]`;
+  }
+  const item = schema.items === void 0 || schema.items === true ? "unknown" : schemaType(schema.items, rootSchema, resolvingRefs, depth + 1);
+  return `readonly (${item})[]`;
+}
+function objectType(schema, rootSchema, resolvingRefs, depth) {
+  const properties = isSchemaObject(schema.properties) ? schema.properties : {};
+  const required = new Set(
+    Array.isArray(schema.required) ? schema.required.filter((value) => typeof value === "string") : []
+  );
+  const entries = Object.entries(properties).sort(([left], [right]) => left.localeCompare(right));
+  const fields = entries.map(([name, propertySchema]) => {
+    const key = identifierOrQuoted(name);
+    const optional = required.has(name) ? "" : "?";
+    return `readonly ${key}${optional}: ${schemaType(
+      propertySchema,
+      rootSchema,
+      resolvingRefs,
+      depth + 1
+    )}`;
+  });
+  for (const missing of [...required].filter((name) => !Object.hasOwn(properties, name)).sort()) {
+    fields.push(`readonly ${identifierOrQuoted(missing)}: unknown`);
+  }
+  const additional = schema.additionalProperties;
+  if (additional !== false) {
+    if (entries.length === 0 && additional !== void 0 && additional !== true) {
+      return `Readonly<Record<string, ${schemaType(
+        additional,
+        rootSchema,
+        resolvingRefs,
+        depth + 1
+      )}>>`;
+    }
+    fields.push("readonly [key: string]: unknown");
+  }
+  return fields.length === 0 ? "Record<string, never>" : `{ ${fields.join("; ")} }`;
+}
+function resolveLocalReference(rootSchema, reference) {
+  let current = rootSchema;
+  for (const encoded of reference.slice(2).split("/")) {
+    if (!isSchemaObject(current)) return void 0;
+    const segment = encoded.replace(/~1/gu, "/").replace(/~0/gu, "~");
+    if (!Object.hasOwn(current, segment)) return void 0;
+    current = current[segment];
+  }
+  return current;
+}
+function literalType(value) {
+  if (value === null || typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+    return JSON.stringify(value);
+  }
+  if (Array.isArray(value)) return `readonly [${value.map(literalType).join(", ")}]`;
+  if (isSchemaObject(value)) {
+    return `{ ${Object.entries(value).sort(([left], [right]) => left.localeCompare(right)).map(([key, child]) => `readonly ${identifierOrQuoted(key)}: ${literalType(child)}`).join("; ")} }`;
+  }
+  return "unknown";
+}
+function union(types) {
+  const unique = [...new Set(types)];
+  if (unique.includes("unknown")) return "unknown";
+  if (unique.length === 0) return "never";
+  return unique.length === 1 ? unique[0] : unique.map(parenthesizeComposite).join(" | ");
+}
+function intersection(types) {
+  const unique = [...new Set(types.filter((type) => type !== "unknown"))];
+  if (unique.length === 0) return "unknown";
+  return unique.length === 1 ? unique[0] : unique.map(parenthesizeComposite).join(" & ");
+}
+function parenthesizeComposite(type) {
+  return /[|&]/u.test(type) ? `(${type})` : type;
+}
+function identifierOrQuoted(value) {
+  return /^[A-Za-z_$][A-Za-z0-9_$]*$/u.test(value) ? value : JSON.stringify(value);
+}
+function boundedDoc(value) {
+  if (!value) return null;
+  const normalized = value.replace(/\s+/gu, " ").trim().replace(/\*\//gu, "*\\/");
+  if (!normalized) return null;
+  return normalized.length <= 512 ? normalized : `${normalized.slice(0, 509)}...`;
+}
+function renderDoc(value, indent) {
+  return [`${spaces(indent)}/** ${value} */`];
+}
+function spaces(count) {
+  return " ".repeat(count);
+}
+function isSchemaObject(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+
+// src/index.ts
+var AttemptToolCatalogStaleError = class extends Error {
+  code = "catalog_stale";
+  constructor() {
+    super("Codemode catalog is stale for the active execution attempt");
+    this.name = "AttemptToolCatalogStaleError";
+  }
+};
+var AttemptToolNotFoundError = class extends Error {
+  code = "tool_not_found";
+  constructor() {
+    super("Tool is not present in the active execution attempt catalog");
+    this.name = "AttemptToolNotFoundError";
+  }
+};
+var AttemptToolApprovalRequiredError = class extends Error {
+  code = "approval_required";
+  constructor() {
+    super("Tool requires human approval and must be invoked through the agent");
+    this.name = "AttemptToolApprovalRequiredError";
+  }
+};
+var AttemptToolCatalogIntegrityError = class extends Error {
+  code = "catalog_integrity_failed";
+  constructor() {
+    super("Attempt tool catalog digest does not match its authoritative content");
+    this.name = "AttemptToolCatalogIntegrityError";
+  }
+};
+var AttemptToolCatalogTooLargeError = class extends Error {
+  code = "catalog_too_large";
+  constructor() {
+    super("Attempt tool catalog exceeds the maximum serialized size");
+    this.name = "AttemptToolCatalogTooLargeError";
+  }
+};
+var AttemptToolInputValidationError = class extends Error {
+  code = "invalid_tool_arguments";
+  constructor() {
+    super("Tool arguments do not match the attempt catalog input schema");
+    this.name = "AttemptToolInputValidationError";
+  }
+};
+var AttemptToolOutputValidationError = class extends Error {
+  code = "invalid_tool_result";
+  constructor() {
+    super("Tool result does not match the attempt catalog output schema");
+    this.name = "AttemptToolOutputValidationError";
+  }
+};
+var CodemodeTransportError = class extends Error {
+  constructor(message, status = null) {
+    super(message);
+    this.status = status;
+    this.name = "CodemodeTransportError";
+  }
+  code = "codemode_transport_error";
+};
+var CodemodeOperationError = class extends Error {
+  constructor(operation, code) {
+    super(operation.errorMessage ?? `Codemode operation ${operation.state}`);
+    this.operation = operation;
+    this.code = code;
+    this.name = "CodemodeOperationError";
+  }
+};
+var CodemodeToolCallError = class extends Error {
+  constructor(result) {
+    const error = structuredToolError(result);
+    super(error.message);
+    this.result = result;
+    this.name = "CodemodeToolCallError";
+    this.code = error.code;
+    this.retryable = error.retryable;
+  }
+  code;
+  retryable;
+};
+var CodemodeToolContractError = class extends Error {
+  code = "invalid_tool_result";
+  constructor(message) {
+    super(message);
+    this.name = "CodemodeToolContractError";
+  }
+};
+var CodemodeClient = class {
+  constructor(options) {
+    this.options = options;
+    this.baseUrl = options.baseUrl.replace(/\/+$/u, "");
+    if (!/^https?:\/\//u.test(this.baseUrl)) {
+      throw new Error("Codemode baseUrl must be an absolute HTTP(S) URL");
+    }
+    this.fetchImpl = options.fetch ?? globalThis.fetch.bind(globalThis);
+    this.pollIntervalMs = boundedPositiveInteger(options.pollIntervalMs ?? 500, 50, 3e4);
+    this.timeoutMs = boundedPositiveInteger(options.timeoutMs ?? 10 * 6e4, 1e3, 60 * 6e4);
+  }
+  baseUrl;
+  fetchImpl;
+  pollIntervalMs;
+  timeoutMs;
+  catalogSnapshot = null;
+  async catalog(options = {}) {
+    if (this.catalogSnapshot && !options.refresh) return this.catalogSnapshot;
+    const response = await this.request("/catalog", {
+      method: "GET",
+      ...options.signal ? { signal: options.signal } : {}
+    });
+    const catalog = parseVerifiedAttemptToolCatalog(await response.json());
+    this.catalogSnapshot = catalog;
+    return catalog;
+  }
+  async tools(options = {}) {
+    return compileCodemodeTools(await this.catalog(options), this);
+  }
+  async call(identity, argumentsValue = {}, options = {}) {
+    const catalog = await this.catalog(options.signal ? { signal: options.signal } : {});
+    if (!catalog.entries.some(
+      (entry) => entry.identity.serverId === identity.serverId && entry.identity.toolName === identity.toolName
+    )) {
+      throw new AttemptToolNotFoundError();
+    }
+    const operationId = options.operationId ?? randomUUID();
+    const deadline = Date.now() + boundedPositiveInteger(options.timeoutMs ?? this.timeoutMs, 1e3, 60 * 6e4);
+    let submitted = false;
+    let operation = null;
+    let nextNotifyAt = 0;
+    while (true) {
+      throwIfAborted(options.signal);
+      if (Date.now() >= deadline) {
+        throw new CodemodeTransportError(
+          `Codemode operation ${operationId} did not settle before the client deadline`
+        );
+      }
+      const shouldNotify = !submitted || operation?.state === "queued" && Date.now() >= nextNotifyAt;
+      if (shouldNotify) {
+        submitted = true;
+        nextNotifyAt = Date.now() + 2e3;
+        try {
+          operation = await this.submit(
+            operationId,
+            catalog.digest,
+            identity,
+            argumentsValue,
+            options.signal
+          );
+        } catch (error) {
+          try {
+            operation = await this.read(operationId, options.signal);
+          } catch {
+            throw error;
+          }
+        }
+      } else {
+        operation = await this.read(operationId, options.signal);
+      }
+      if (operation.state === "completed") return AttemptToolResult.parse(operation.result);
+      if (["failed", "outcome_unknown", "cancelled"].includes(operation.state)) {
+        throw new CodemodeOperationError(
+          operation,
+          operation.errorCode ?? `codemode_${operation.state}`
+        );
+      }
+      await abortableDelay(this.pollIntervalMs, options.signal);
+    }
+  }
+  /** Resolve and call one exact generated namespace path without parsing a wire name. */
+  async callPath(path, argumentsValue = {}, options = {}) {
+    if (path.length < 2 || path.some((segment) => segment.length === 0)) {
+      throw new AttemptToolNotFoundError();
+    }
+    const catalog = await this.catalog(options.signal ? { signal: options.signal } : {});
+    const matches = catalog.entries.filter(
+      (entry) => entry.codemodePath.length === path.length && entry.codemodePath.every((segment, index) => segment === path[index])
+    );
+    if (matches.length !== 1) throw new AttemptToolNotFoundError();
+    return await this.call(matches[0].identity, argumentsValue, options);
+  }
+  /** Return structured content when the catalog declares it; otherwise retain the full MCP result. */
+  async callPathValue(path, argumentsValue = {}, options = {}) {
+    if (path.length < 2 || path.some((segment) => segment.length === 0)) {
+      throw new AttemptToolNotFoundError();
+    }
+    const catalog = await this.catalog(options.signal ? { signal: options.signal } : {});
+    const matches = catalog.entries.filter(
+      (entry2) => entry2.codemodePath.length === path.length && entry2.codemodePath.every((segment, index) => segment === path[index])
+    );
+    if (matches.length !== 1) throw new AttemptToolNotFoundError();
+    const entry = matches[0];
+    const result = await this.call(entry.identity, argumentsValue, options);
+    if (!entry.outputSchema) return result;
+    if (result.isError) throw new CodemodeToolCallError(result);
+    if (!result.structuredContent) {
+      throw new CodemodeToolContractError(
+        `Codemode tool ${path.join(".")} declared outputSchema but returned no structured content`
+      );
+    }
+    return result.structuredContent;
+  }
+  async submit(operationId, catalogDigest, identity, argumentsValue, signal) {
+    const response = await this.request("/calls", {
+      method: "POST",
+      ...signal ? { signal } : {},
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({ operationId, catalogDigest, identity, arguments: argumentsValue })
+    });
+    return CodemodeCallSubmission.parse(await response.json()).operation;
+  }
+  async read(operationId, signal) {
+    const response = await this.request(`/calls/${operationId}`, {
+      method: "GET",
+      ...signal ? { signal } : {}
+    });
+    return CodemodeOperation.parse(await response.json());
+  }
+  async request(path, init) {
+    const token = typeof this.options.token === "function" ? await this.options.token() : this.options.token;
+    const response = await this.fetchImpl(`${this.baseUrl}${path}`, {
+      ...init,
+      headers: {
+        ...Object.fromEntries(new Headers(init.headers).entries()),
+        authorization: `Bearer ${token}`
+      }
+    });
+    if (!response.ok) {
+      let message = `Codemode request failed with HTTP ${response.status}`;
+      try {
+        const payload = await response.json();
+        if (typeof payload.error?.message === "string") message = payload.error.message;
+      } catch {
+      }
+      throw new CodemodeTransportError(message, response.status);
+    }
+    return response;
+  }
+};
+function compileCodemodeTools(catalog, client) {
+  const verified = parseVerifiedAttemptToolCatalog(catalog);
+  const root = /* @__PURE__ */ Object.create(null);
+  for (const entry of verified.entries) {
+    let cursor = root;
+    for (const segment of entry.codemodePath.slice(0, -1)) {
+      let existing = cursor[segment];
+      if (typeof existing === "function") throw new Error("Codemode path collides with a tool");
+      if (!existing) {
+        existing = /* @__PURE__ */ Object.create(null);
+        cursor[segment] = existing;
+      }
+      cursor = existing;
+    }
+    const leaf = entry.codemodePath.at(-1);
+    const invoke = async (args = {}, options = {}) => await client.callPathValue(entry.codemodePath, args, options);
+    Object.defineProperty(invoke, "entry", { value: entry, enumerable: false });
+    cursor[leaf] = invoke;
+  }
+  return root;
+}
+var AttemptToolEnvironment = class {
+  constructor(catalog, definitions, authorize) {
+    this.authorize = authorize;
+    this.catalog = catalog;
+    for (const definition of definitions) {
+      this.byIdentity.set(identityKey(definition.entry.identity), definition);
+      this.byModelName.set(definition.entry.modelName, definition);
+    }
+  }
+  catalog;
+  byIdentity = /* @__PURE__ */ new Map();
+  byModelName = /* @__PURE__ */ new Map();
+  async call(input, context = {}) {
+    const call = AttemptToolCall.parse(input);
+    if (call.catalogDigest !== this.catalog.digest) {
+      throw new AttemptToolCatalogStaleError();
+    }
+    const definition = this.byIdentity.get(identityKey(call.identity));
+    if (!definition) {
+      throw new AttemptToolNotFoundError();
+    }
+    if (call.caller.kind === "codemode" && definition.entry.approval === "human") {
+      throw new AttemptToolApprovalRequiredError();
+    }
+    if (!definition.validateInput(call.arguments)) {
+      throw new AttemptToolInputValidationError();
+    }
+    await this.authorize?.({ call, entry: definition.entry });
+    const result = AttemptToolResult.parse(
+      await definition.execute(call.arguments, {
+        operationId: call.operationId,
+        caller: call.caller,
+        ...context.transportMeta === void 0 ? {} : { transportMeta: context.transportMeta },
+        ...context.signal === void 0 ? {} : { signal: context.signal }
+      })
+    );
+    if (!result.isError && definition.validateOutput) {
+      if (result.structuredContent === void 0 || !definition.validateOutput(result.structuredContent)) {
+        throw new AttemptToolOutputValidationError();
+      }
+    }
+    return result;
+  }
+  async callModel(input) {
+    const definition = this.byModelName.get(input.modelName);
+    if (!definition) {
+      throw new AttemptToolNotFoundError();
+    }
+    const call = AttemptToolCall.parse({
+      operationId: input.operationId ?? randomUUID(),
+      catalogDigest: this.catalog.digest,
+      identity: definition.entry.identity,
+      arguments: input.arguments,
+      caller: { kind: "model", subjectId: input.subjectId }
+    });
+    return await this.call(call, {
+      ...input.transportMeta === void 0 ? {} : { transportMeta: input.transportMeta },
+      ...input.signal === void 0 ? {} : { signal: input.signal }
+    });
+  }
+};
+function createAttemptToolEnvironment(input) {
+  const createdAt = (input.createdAt ?? /* @__PURE__ */ new Date()).toISOString();
+  const paths = allocateCodemodePaths(input.definitions);
+  const schemaValidators = createSchemaValidators();
+  const compiled = input.definitions.map((definition, index) => {
+    const { execute, codemodePath: _path, ...entryInput } = definition;
+    const entry = AttemptToolCatalogEntry.parse({
+      ...entryInput,
+      codemodePath: paths[index]
+    });
+    return {
+      entry,
+      execute,
+      validateInput: compileCatalogSchema(schemaValidators, entry.inputSchema),
+      validateOutput: entry.outputSchema ? compileCatalogSchema(schemaValidators, entry.outputSchema) : null
+    };
+  });
+  const unsigned = {
+    version: ATTEMPT_TOOL_CATALOG_VERSION,
+    ...input.scope,
+    generation: input.generation,
+    createdAt,
+    entries: compiled.map(({ entry }) => entry)
+  };
+  const catalog = AttemptToolCatalog.parse({
+    ...unsigned,
+    digest: digestAttemptToolCatalog(unsigned)
+  });
+  assertCatalogSize(catalog);
+  return new AttemptToolEnvironment(catalog, compiled, input.authorize);
+}
+function digestAttemptToolCatalog(catalog) {
+  const { createdAt: _createdAt, ...authoritative } = catalog;
+  return digestCanonicalJson(authoritative);
+}
+function digestCodemodeOperationRequest(input) {
+  return digestCanonicalJson(input);
+}
+function codemodeDispatchSubject(workspaceId, attemptId) {
+  if (!UUID_PATTERN.test(workspaceId) || !UUID_PATTERN.test(attemptId)) {
+    throw new Error("Codemode dispatch subject requires UUID workspace and attempt ids");
+  }
+  return `codemode.${workspaceId}.${attemptId}.dispatch`;
+}
+function encodeCodemodeDispatchRequest(input) {
+  return new TextEncoder().encode(JSON.stringify(CodemodeDispatchRequest.parse(input)));
+}
+function decodeCodemodeDispatchRequest(input) {
+  return CodemodeDispatchRequest.parse(JSON.parse(new TextDecoder().decode(input)));
+}
+function encodeCodemodeDispatchAck(input) {
+  return new TextEncoder().encode(JSON.stringify(CodemodeDispatchAck.parse(input)));
+}
+function decodeCodemodeDispatchAck(input) {
+  return CodemodeDispatchAck.parse(JSON.parse(new TextDecoder().decode(input)));
+}
+function parseVerifiedAttemptToolCatalog(input) {
+  const catalog = AttemptToolCatalog.parse(input);
+  assertCatalogSize(catalog);
+  const { digest, ...unsigned } = catalog;
+  if (digestAttemptToolCatalog(unsigned) !== digest) {
+    throw new AttemptToolCatalogIntegrityError();
+  }
+  return catalog;
+}
+function assertCatalogSize(catalog) {
+  if (new TextEncoder().encode(JSON.stringify(catalog)).byteLength > ATTEMPT_TOOL_CATALOG_MAX_BYTES) {
+    throw new AttemptToolCatalogTooLargeError();
+  }
+}
+function createSchemaValidators() {
+  const options = {
+    allErrors: false,
+    coerceTypes: false,
+    strict: false,
+    useDefaults: false,
+    validateFormats: false
+  };
+  return {
+    draft7: new Ajv(options),
+    draft2019: new Ajv2019(options),
+    draft2020: new Ajv2020(options)
+  };
+}
+function compileCatalogSchema(validators, schema) {
+  const dialect = typeof schema.$schema === "string" ? schema.$schema : "";
+  if (dialect.includes("2020-12")) return validators.draft2020.compile(schema);
+  if (dialect.includes("2019-09")) return validators.draft2019.compile(schema);
+  return validators.draft7.compile(schema);
+}
+function allocateCodemodePaths(definitions) {
+  const bases = definitions.map(
+    (definition) => (definition.codemodePath?.length ? definition.codemodePath : [definition.identity.serverId, definition.identity.toolName]).map(safeNamespaceSegment)
+  );
+  const counts = /* @__PURE__ */ new Map();
+  for (const path of bases) {
+    const key = path.join("\0");
+    counts.set(key, (counts.get(key) ?? 0) + 1);
+  }
+  return bases.map((base, index) => {
+    const key = base.join("\0");
+    if (counts.get(key) === 1) return base;
+    const suffix = `_${shortIdentityDigest(definitions[index].identity)}`;
+    const last = base.at(-1);
+    return [...base.slice(0, -1), `${last.slice(0, 128 - suffix.length)}${suffix}`];
+  });
+}
+function safeNamespaceSegment(value) {
+  let normalized = value.replace(/[^A-Za-z0-9_$]/gu, "_");
+  if (!/^[A-Za-z_$]/u.test(normalized)) normalized = `_${normalized}`;
+  if (["__proto__", "prototype", "constructor"].includes(normalized)) {
+    normalized = `_${normalized}`;
+  }
+  return normalized.slice(0, 128) || "_";
+}
+function shortIdentityDigest(identity) {
+  return createHash("sha256").update(identityKey(identity), "utf8").digest("hex").slice(0, 10);
+}
+function identityKey(identity) {
+  return `${identity.serverId}\0${identity.toolName}`;
+}
+function digestCanonicalJson(value) {
+  return createHash("sha256").update(JSON.stringify(canonicalJsonValue(value)), "utf8").digest("hex");
+}
+function canonicalJsonValue(value) {
+  if (Array.isArray(value)) return value.map(canonicalJsonValue);
+  if (value !== null && typeof value === "object") {
+    return Object.fromEntries(
+      Object.entries(value).sort(([left], [right]) => left.localeCompare(right)).map(([key, entry]) => [key, canonicalJsonValue(entry)])
+    );
+  }
+  return value;
+}
+var UUID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/iu;
+function boundedPositiveInteger(value, minimum, maximum) {
+  if (!Number.isFinite(value)) return minimum;
+  return Math.max(minimum, Math.min(maximum, Math.floor(value)));
+}
+function throwIfAborted(signal) {
+  if (signal?.aborted) throw signal.reason ?? new DOMException("Aborted", "AbortError");
+}
+function structuredToolError(result) {
+  const structured = result.structuredContent;
+  const error = structured?.error;
+  return {
+    code: typeof error?.code === "string" ? error.code : "tool_error",
+    message: typeof error?.message === "string" ? error.message : "Codemode tool failed",
+    retryable: error?.retryable === true
+  };
+}
+async function abortableDelay(delayMs, signal) {
+  if (!signal) {
+    await new Promise((resolve) => setTimeout(resolve, delayMs));
+    return;
+  }
+  throwIfAborted(signal);
+  await new Promise((resolve, reject) => {
+    const timer = setTimeout(() => {
+      signal.removeEventListener("abort", onAbort);
+      resolve();
+    }, delayMs);
+    const onAbort = () => {
+      clearTimeout(timer);
+      reject(signal.reason ?? new DOMException("Aborted", "AbortError"));
+    };
+    signal.addEventListener("abort", onAbort, { once: true });
+  });
+}
+export {
+  AttemptToolApprovalRequiredError,
+  AttemptToolCatalogIntegrityError,
+  AttemptToolCatalogStaleError,
+  AttemptToolCatalogTooLargeError,
+  AttemptToolEnvironment,
+  AttemptToolInputValidationError,
+  AttemptToolNotFoundError,
+  AttemptToolOutputValidationError,
+  CODEMODE_ENVIRONMENT,
+  CodemodeArtifact,
+  CodemodeArtifactCollection,
+  CodemodeArtifactExport,
+  CodemodeBrowser,
+  CodemodeBrowserCollection,
+  CodemodeBrowserIdentityCollection,
+  CodemodeBrowserLocator,
+  CodemodeBrowserTab,
+  CodemodeBrowserTabCollection,
+  CodemodeClient,
+  CodemodeComputer,
+  CodemodeComputerCollection,
+  CodemodeComputerLocator,
+  CodemodeComputerTarget,
+  CodemodeComputerTargetCollection,
+  CodemodeOperationError,
+  CodemodeToolCallError,
+  CodemodeToolContractError,
+  CodemodeToolExecutionError,
+  CodemodeTransportError,
+  OpenGeniCodemode,
+  callStructured,
+  codemodeArtifactIds,
+  codemodeClientProvider,
+  codemodeDispatchSubject,
+  compileCodemodeTools,
+  createAttemptToolEnvironment,
+  createCodemodeTools,
+  createOpenGeniCodemode,
+  decodeCodemodeDispatchAck,
+  decodeCodemodeDispatchRequest,
+  digestAttemptToolCatalog,
+  digestCodemodeOperationRequest,
+  encodeCodemodeDispatchAck,
+  encodeCodemodeDispatchRequest,
+  environmentCodemodeClient,
+  generateCodemodeDeclarations,
+  jsonSchemaToTypeScript,
+  openGeni,
+  parseVerifiedAttemptToolCatalog,
+  tools
+};
+//# sourceMappingURL=index.js.map