@opengeni/codemode 0.4.25-canary.0 → 0.4.27-canary.1

package/dist/index.js

@@ -1,23 +1,29 @@
 // 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 { randomUUID as randomUUID2 } from "crypto";
 import {
   ATTEMPT_TOOL_CATALOG_VERSION,
   ATTEMPT_TOOL_CATALOG_MAX_BYTES,
   AttemptToolCall,
   AttemptToolCatalog,
-  AttemptToolCatalogEntry,
   AttemptToolResult,
   CodemodeCallSubmission,
   CodemodeOperation,
   CodemodeDispatchAck,
   CodemodeDispatchRequest,
-  OPENGENI_API_CONTRACT_HEADER,
-  OPENGENI_API_CONTRACT_REVISION,
-  isToolResultSpilledReceipt
+  AttemptToolCaller
 } from "@opengeni/contracts";
+import {
+  ToolGatewayApprovalRequiredError as AttemptToolApprovalRequiredError,
+  ToolGatewayCatalogIntegrityError as AttemptToolCatalogIntegrityError,
+  ToolGatewayCatalogStaleError as AttemptToolCatalogStaleError,
+  ToolGatewayCatalogTooLargeError as AttemptToolCatalogTooLargeError,
+  ToolGatewayInputValidationError as AttemptToolInputValidationError,
+  ToolGatewayOutputValidationError as AttemptToolOutputValidationError,
+  ToolGatewayPathCollisionError as AttemptToolPathCollisionError,
+  ToolGatewayToolNotFoundError as AttemptToolNotFoundError,
+  digestCanonicalJson,
+  prepareToolGatewayDefinitions
+} from "@opengeni/tool-gateway";
 
 // src/environment.ts
 import { readFile } from "fs/promises";
@@ -1067,314 +1073,160 @@ function createOpenGeniCodemode(client = () => environmentCodemodeClient()) {
 var openGeni = createOpenGeniCodemode();
 
 // src/declarations.ts
+import { generateToolDeclarations, jsonSchemaToTypeScript } from "@opengeni/tool-gateway";
 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;
+  return generateToolDeclarations(
+    { digest: verified.digest, entries: verified.entries },
+    {
+      moduleSpecifier: options.moduleSpecifier ?? "@opengeni/codemode",
+      interfaceName: "CodemodeGeneratedTools",
+      callOptionsType: "CodemodeCallOptions",
+      fallbackResultType: "CodemodeToolResult",
+      generatedBy: "@opengeni/codemode via @opengeni/tool-gateway",
+      catalogDigestLabel: "Attempt catalog digest"
     }
-    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
-      )}>>`;
+
+// src/site.ts
+import { randomUUID } from "crypto";
+import { generateToolDeclarations as generateToolDeclarations2 } from "@opengeni/tool-gateway";
+var CODEMODE_SITE_LOCAL_PATH = "/__opengeni/site-tools";
+function createCodemodeSiteRequestHandler(client = () => environmentCodemodeClient()) {
+  const provide = typeof client === "function" ? client : () => client;
+  return async (request) => {
+    try {
+      const active = await provide();
+      const pathname = new URL(request.url).pathname;
+      if (pathname.startsWith(`${CODEMODE_SITE_LOCAL_PATH}/sdk/`)) {
+        const path = pathname.slice(`${CODEMODE_SITE_LOCAL_PATH}/sdk`.length) + new URL(request.url).search;
+        const response = await active.sessionRequest(path, {
+          method: request.method,
+          signal: request.signal,
+          headers: {
+            "content-type": request.headers.get("content-type") ?? "application/json",
+            accept: request.headers.get("accept") ?? "application/json",
+            ...request.headers.has("last-event-id") ? { "last-event-id": request.headers.get("last-event-id") } : {}
+          },
+          ...request.body ? { body: await request.text() } : {}
+        });
+        const headers = new Headers(response.headers);
+        headers.delete("content-encoding");
+        headers.delete("content-length");
+        headers.delete("transfer-encoding");
+        return new Response(response.body, {
+          status: response.status,
+          statusText: response.statusText,
+          headers
+        });
+      }
+      if (request.method === "GET" && pathname === `${CODEMODE_SITE_LOCAL_PATH}/catalog`) {
+        const catalog = await active.catalog({ signal: request.signal });
+        return Response.json(projectSiteCatalog(catalog));
+      }
+      if (request.method === "GET" && pathname === `${CODEMODE_SITE_LOCAL_PATH}/declarations`) {
+        const catalog = await active.catalog({ signal: request.signal });
+        return Response.json({
+          catalogDigest: catalog.digest,
+          moduleSpecifier: "@opengeni/sdk",
+          source: generateToolDeclarations2(
+            { digest: catalog.digest, entries: catalog.entries },
+            {
+              moduleSpecifier: "@opengeni/sdk",
+              interfaceName: "OpenGeniGeneratedTools",
+              callOptionsType: "OpenGeniToolCallOptions",
+              fallbackResultType: "ToolGatewayResult",
+              generatedBy: "@opengeni/codemode local Site preview",
+              catalogDigestLabel: "Attempt catalog digest"
+            }
+          )
+        });
+      }
+      if (request.method === "POST" && pathname === `${CODEMODE_SITE_LOCAL_PATH}/calls`) {
+        const body = await request.json();
+        if (!isSiteCall(body)) return siteError(400, "invalid_request", "Invalid Site tool call");
+        const catalog = await active.catalog({ signal: request.signal });
+        if (body.catalogDigest !== catalog.digest) {
+          return siteError(409, "catalog_stale", "The local Site tool catalog changed", true);
+        }
+        const operationId = body.operationId ?? randomUUID();
+        const result = await active.call(body.identity, body.arguments, {
+          operationId,
+          signal: request.signal
+        });
+        return Response.json({
+          operationId,
+          catalogDigest: catalog.digest,
+          result
+        });
+      }
+      return siteError(404, "not_found", "Local Site tool endpoint not found");
+    } catch (error) {
+      if (error instanceof CodemodeTransportError) {
+        return siteError(
+          error.status && error.status >= 400 && error.status <= 599 ? error.status : 502,
+          error.remoteCode ?? error.code,
+          error.message,
+          error.retryable === true,
+          error.outcomeUnknown === true
+        );
+      }
+      return siteError(
+        500,
+        "local_codemode_error",
+        error instanceof Error ? error.message : "Local Site tool request failed"
+      );
     }
-    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 projectSiteCatalog(catalog) {
+  return {
+    version: catalog.version,
+    generation: catalog.generation,
+    digest: catalog.digest,
+    createdAt: catalog.createdAt,
+    entries: catalog.entries
+  };
 }
-function renderDoc(value, indent) {
-  return [`${spaces(indent)}/** ${value} */`];
+function isSiteCall(value) {
+  if (!isRecord(value) || typeof value.catalogDigest !== "string") return false;
+  if (value.operationId !== void 0 && typeof value.operationId !== "string") return false;
+  return isRecord(value.identity) && typeof value.identity.serverId === "string" && typeof value.identity.toolName === "string" && isRecord(value.arguments);
 }
-function spaces(count) {
-  return " ".repeat(count);
+function siteError(status, code, message, retryable = false, outcomeUnknown = false) {
+  return Response.json(
+    {
+      error: {
+        code,
+        message,
+        retryable,
+        ...outcomeUnknown ? { outcomeUnknown: true } : {}
+      }
+    },
+    { status }
+  );
 }
-function isSchemaObject(value) {
-  return value !== null && typeof value === "object" && !Array.isArray(value);
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !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) {
+  constructor(message, status = null, options = {}) {
     super(message);
     this.status = status;
     this.name = "CodemodeTransportError";
+    this.remoteCode = options.code ?? null;
+    this.retryable = options.retryable ?? null;
+    this.outcomeUnknown = options.outcomeUnknown ?? null;
+    this.details = options.details ?? null;
   }
   code = "codemode_transport_error";
+  remoteCode;
+  retryable;
+  outcomeUnknown;
+  details;
 };
 var CodemodeOperationError = class extends Error {
   constructor(operation, code) {
@@ -1433,15 +1285,22 @@ var CodemodeClient = class {
     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();
+    return (await this.callResolved(
+      (catalog) => catalog.entries.find(
+        (entry) => entry.identity.serverId === identity.serverId && entry.identity.toolName === identity.toolName
+      ) ?? null,
+      argumentsValue,
+      options
+    )).result;
+  }
+  async callResolved(resolveEntry, argumentsValue, options) {
+    let catalog = await this.catalog(options.signal ? { signal: options.signal } : {});
+    let entry = resolveEntry(catalog);
+    if (!entry) throw new AttemptToolNotFoundError();
+    const operationId = options.operationId ?? randomUUID2();
     const deadline = Date.now() + boundedPositiveInteger(options.timeoutMs ?? this.timeoutMs, 1e3, 60 * 6e4);
     let submitted = false;
+    let staleRefreshAttempted = false;
     let operation = null;
     let nextNotifyAt = 0;
     while (true) {
@@ -1451,7 +1310,7 @@ var CodemodeClient = class {
           `Codemode operation ${operationId} did not settle before the client deadline`
         );
       }
-      const shouldNotify = !submitted || operation?.state === "queued" && Date.now() >= nextNotifyAt;
+      const shouldNotify = !submitted || (operation?.state === "queued" || operation?.state === "running") && Date.now() >= nextNotifyAt;
       if (shouldNotify) {
         submitted = true;
         nextNotifyAt = Date.now() + 2e3;
@@ -1459,21 +1318,55 @@ var CodemodeClient = class {
           operation = await this.submit(
             operationId,
             catalog.digest,
-            identity,
+            entry.identity,
             argumentsValue,
             options.signal
           );
         } catch (error) {
+          if (operation === null && !staleRefreshAttempted && error instanceof CodemodeTransportError && error.remoteCode === "codemode_catalog_stale") {
+            staleRefreshAttempted = true;
+            catalog = await this.catalog({
+              refresh: true,
+              ...options.signal ? { signal: options.signal } : {}
+            });
+            entry = resolveEntry(catalog);
+            if (!entry) throw new AttemptToolNotFoundError();
+            submitted = false;
+            nextNotifyAt = 0;
+            continue;
+          }
+          if (options.signal?.aborted) throw error;
+          if (operation === null && !canReconcileCodemodeSubmission(error)) throw error;
+          let recovered;
           try {
-            operation = await this.read(operationId, options.signal);
-          } catch {
-            throw error;
+            recovered = await this.read(operationId, options.signal);
+          } catch (recoveryError) {
+            if (options.signal?.aborted) throw recoveryError;
+            throw new CodemodeTransportError(
+              `Codemode operation ${operationId} could not be reconciled after its submission response failed`,
+              null,
+              {
+                code: "codemode_operation_recovery_unavailable",
+                retryable: true,
+                outcomeUnknown: true,
+                details: { operationId }
+              }
+            );
           }
+          assertRecoveredCodemodeOperation(recovered, {
+            operationId,
+            catalog,
+            identity: entry.identity,
+            arguments: argumentsValue
+          });
+          operation = recovered;
         }
       } else {
         operation = await this.read(operationId, options.signal);
       }
-      if (operation.state === "completed") return AttemptToolResult.parse(operation.result);
+      if (operation.state === "completed") {
+        return { result: AttemptToolResult.parse(operation.result), entry };
+      }
       if (["failed", "outcome_unknown", "cancelled"].includes(operation.state)) {
         throw new CodemodeOperationError(
           operation,
@@ -1488,25 +1381,22 @@ var CodemodeClient = class {
     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 (await this.callResolved(
+      (catalog) => catalogEntryForPath(catalog, path),
+      argumentsValue,
+      options
+    )).result;
   }
   /** 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])
+    const { result, entry } = await this.callResolved(
+      (catalog) => catalogEntryForPath(catalog, path),
+      argumentsValue,
+      options
     );
-    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) {
@@ -1537,28 +1427,59 @@ var CodemodeClient = class {
     });
     return CodemodeOperation.parse(await response.json());
   }
-  async request(path, init) {
+  /** Server-side Site preview forwarding. The attempt bearer never enters the page. */
+  async sessionRequest(path, init) {
+    if (!path.startsWith("/v1/")) {
+      throw new Error("Unsupported Site session API path");
+    }
+    return this.request(`/sdk${path}`, init, false);
+  }
+  async request(path, init, throwOnError = true) {
     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()),
-        [OPENGENI_API_CONTRACT_HEADER]: OPENGENI_API_CONTRACT_REVISION,
         authorization: `Bearer ${token}`
       }
     });
-    if (!response.ok) {
+    if (!response.ok && throwOnError) {
       let message = `Codemode request failed with HTTP ${response.status}`;
+      let errorOptions = {};
       try {
-        const payload = await response.json();
-        if (typeof payload.error?.message === "string") message = payload.error.message;
+        const error = parseCodemodeApiError(await response.json());
+        if (error?.message) message = error.message;
+        if (error) {
+          errorOptions = {
+            ...error.code ? { code: error.code } : {},
+            ...error.retryable === void 0 ? {} : { retryable: error.retryable },
+            ...error.outcomeUnknown === void 0 ? {} : { outcomeUnknown: error.outcomeUnknown },
+            ...error.details ? { details: error.details } : {}
+          };
+        }
       } catch {
       }
-      throw new CodemodeTransportError(message, response.status);
+      throw new CodemodeTransportError(message, response.status, errorOptions);
     }
     return response;
   }
 };
+function canReconcileCodemodeSubmission(error) {
+  return !(error instanceof CodemodeTransportError) || error.outcomeUnknown === true;
+}
+function assertRecoveredCodemodeOperation(operation, expected) {
+  const matches = operation.operationId === expected.operationId && operation.accountId === expected.catalog.accountId && operation.workspaceId === expected.catalog.workspaceId && operation.sessionId === expected.catalog.sessionId && operation.turnId === expected.catalog.turnId && operation.attemptId === expected.catalog.attemptId && operation.executionGeneration === expected.catalog.executionGeneration && operation.catalogDigest === expected.catalog.digest && operation.identity.serverId === expected.identity.serverId && operation.identity.toolName === expected.identity.toolName && digestCanonicalJson(operation.arguments) === digestCanonicalJson(expected.arguments);
+  if (matches) return;
+  throw new CodemodeTransportError(
+    "Codemode operation id is already bound to a different request",
+    409,
+    {
+      code: "codemode_operation_conflict",
+      retryable: false,
+      outcomeUnknown: false
+    }
+  );
+}
 function compileCodemodeTools(catalog, client) {
   const verified = parseVerifiedAttemptToolCatalog(catalog);
   const root = /* @__PURE__ */ Object.create(null);
@@ -1581,97 +1502,65 @@ function compileCodemodeTools(catalog, client) {
   return root;
 }
 var AttemptToolEnvironment = class {
-  constructor(catalog, definitions, authorize) {
-    this.authorize = authorize;
+  constructor(catalog, gateway) {
     this.catalog = catalog;
-    for (const definition of definitions) {
-      this.byIdentity.set(identityKey(definition.entry.identity), definition);
-      this.byModelName.set(definition.entry.modelName, definition);
-    }
+    this.gateway = gateway;
   }
-  catalog;
-  byIdentity = /* @__PURE__ */ new Map();
-  byModelName = /* @__PURE__ */ new Map();
   async call(input, context = {}) {
+    return await (await this.prepareCall(input, context)).execute();
+  }
+  async prepareCall(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) {
-      const outputMatchesSchema = result.structuredContent !== void 0 && definition.validateOutput(result.structuredContent);
-      if (!outputMatchesSchema && !isToolResultSpilledReceipt(result.structuredContent)) {
-        throw new AttemptToolOutputValidationError();
-      }
-    }
-    return result;
+    return await this.gateway.prepareCall(call, context);
   }
   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 }
-    });
+    return await this.gateway.callModel(input);
   }
 };
 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 prepared = prepareToolGatewayDefinitions(
+    input.definitions.map(
+      (definition) => ({
+        ...definition,
+        execute: async (argumentsValue, context) => await definition.execute(argumentsValue, {
+          ...context,
+          caller: AttemptToolCaller.parse(context.caller)
+        })
+      })
+    )
+  );
   const unsigned = {
     version: ATTEMPT_TOOL_CATALOG_VERSION,
     ...input.scope,
     generation: input.generation,
     createdAt,
-    entries: compiled.map(({ entry }) => entry)
+    entries: [...prepared.entries]
   };
   const catalog = AttemptToolCatalog.parse({
     ...unsigned,
     digest: digestAttemptToolCatalog(unsigned)
   });
   assertCatalogSize(catalog);
-  return new AttemptToolEnvironment(catalog, compiled, input.authorize);
+  return new AttemptToolEnvironment(
+    catalog,
+    prepared.create({
+      catalogDigest: catalog.digest,
+      requireApproval: (entry, caller) => caller.kind === "codemode" && entry.approval === "human",
+      ...input.confirmModelApproval ? {
+        confirmModelApproval: ({ entry, subjectId }) => input.confirmModelApproval({
+          modelName: entry.modelName,
+          subjectId
+        })
+      } : {},
+      ...input.authorize ? {
+        authorize: async ({ call, entry }) => await input.authorize({
+          call: AttemptToolCall.parse(call),
+          entry
+        })
+      } : {}
+    })
+  );
 }
 function digestAttemptToolCatalog(catalog) {
   const { createdAt: _createdAt, ...authoritative } = catalog;
@@ -1712,84 +1601,6 @@ function assertCatalogSize(catalog) {
     throw new AttemptToolCatalogTooLargeError();
   }
 }
-var COMPILED_CATALOG_SCHEMA_CACHE_MAX_ENTRIES = 512;
-var compiledCatalogSchemaCache = /* @__PURE__ */ new Map();
-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 : "";
-  const family = dialect.includes("2020-12") ? "2020-12" : dialect.includes("2019-09") ? "2019-09" : "draft7";
-  const cacheKey = `${family}:${digestCanonicalJson(schema)}`;
-  const cached = compiledCatalogSchemaCache.get(cacheKey);
-  if (cached) {
-    compiledCatalogSchemaCache.delete(cacheKey);
-    compiledCatalogSchemaCache.set(cacheKey, cached);
-    return cached;
-  }
-  const compiled = family === "2020-12" ? validators.draft2020.compile(schema) : family === "2019-09" ? validators.draft2019.compile(schema) : validators.draft7.compile(schema);
-  while (compiledCatalogSchemaCache.size >= COMPILED_CATALOG_SCHEMA_CACHE_MAX_ENTRIES) {
-    const oldest = compiledCatalogSchemaCache.keys().next().value;
-    if (oldest === void 0) break;
-    compiledCatalogSchemaCache.delete(oldest);
-  }
-  compiledCatalogSchemaCache.set(cacheKey, compiled);
-  return compiled;
-}
-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;
@@ -1807,6 +1618,30 @@ function structuredToolError(result) {
     retryable: error?.retryable === true
   };
 }
+function catalogEntryForPath(catalog, path) {
+  const matches = catalog.entries.filter(
+    (entry) => entry.codemodePath.length === path.length && entry.codemodePath.every((segment, index) => segment === path[index])
+  );
+  return matches.length === 1 ? matches[0] : null;
+}
+function parseCodemodeApiError(input) {
+  if (!input || typeof input !== "object" || Array.isArray(input)) return null;
+  const root = input;
+  const nested = root.error && typeof root.error === "object" && !Array.isArray(root.error) ? root.error : root;
+  const details = nested.details && typeof nested.details === "object" && !Array.isArray(nested.details) ? nested.details : void 0;
+  const detailCode = details?.code;
+  const code = typeof detailCode === "string" && /^[a-z0-9_]{1,128}$/u.test(detailCode) ? detailCode : void 0;
+  const message = typeof nested.message === "string" ? nested.message : void 0;
+  const retryable = typeof nested.retryable === "boolean" ? nested.retryable : void 0;
+  const outcomeUnknown = typeof nested.outcomeUnknown === "boolean" ? nested.outcomeUnknown : void 0;
+  return message || code || retryable !== void 0 || outcomeUnknown !== void 0 || details ? {
+    ...message ? { message } : {},
+    ...code ? { code } : {},
+    ...retryable === void 0 ? {} : { retryable },
+    ...outcomeUnknown === void 0 ? {} : { outcomeUnknown },
+    ...details ? { details } : {}
+  } : null;
+}
 async function abortableDelay(delayMs, signal) {
   if (!signal) {
     await new Promise((resolve) => setTimeout(resolve, delayMs));
@@ -1834,7 +1669,9 @@ export {
   AttemptToolInputValidationError,
   AttemptToolNotFoundError,
   AttemptToolOutputValidationError,
+  AttemptToolPathCollisionError,
   CODEMODE_ENVIRONMENT,
+  CODEMODE_SITE_LOCAL_PATH,
   CodemodeArtifact,
   CodemodeArtifactCollection,
   CodemodeArtifactExport,
@@ -1867,6 +1704,7 @@ export {
   codemodeDispatchSubject,
   compileCodemodeTools,
   createAttemptToolEnvironment,
+  createCodemodeSiteRequestHandler,
   createCodemodeTools,
   createOpenGeniCodemode,
   decodeCodemodeDispatchAck,