@lucern/sdk 1.0.10 → 1.0.12

package/dist/functionSurface.js

@@ -1,1461 +1,2 @@
-import { createTelemetryExporterFromEnv, emitTelemetrySignal } from '@lucern/transport-core';
-import { redactDiagnosticValue } from '@lucern/transport-core/redaction';
-import { classifyRetry } from '@lucern/transport-core/transport';
-import { Effect, Exit, Cause } from 'effect';
-
-// src/coreClient.ts
-
-// src/authContext.ts
-var LucernSdkAuthContextError = class extends Error {
-  reason;
-  constructor(reason, message) {
-    super(message);
-    this.name = "LucernSdkAuthContextError";
-    this.reason = reason;
-  }
-};
-function cleanString(value) {
-  const normalized = value?.trim();
-  return normalized ? normalized : void 0;
-}
-function cleanStringList(values) {
-  if (!values) {
-    return [];
-  }
-  return values.map((value) => value.trim()).filter(
-    (value, index, list) => value.length > 0 && list.indexOf(value) === index
-  );
-}
-function requireString(value, reason, label) {
-  const normalized = cleanString(value);
-  if (!normalized) {
-    throw new LucernSdkAuthContextError(
-      reason,
-      `Canonical Lucern SDK auth context is missing ${label}.`
-    );
-  }
-  return normalized;
-}
-function requirePrincipalType(principalType) {
-  if (!principalType) {
-    throw new LucernSdkAuthContextError(
-      "principal_missing",
-      "Canonical Lucern SDK auth context is missing principalType."
-    );
-  }
-  return principalType;
-}
-function requireAuthMode(authMode) {
-  if (!authMode) {
-    throw new LucernSdkAuthContextError(
-      "principal_missing",
-      "Canonical Lucern SDK auth context is missing authMode."
-    );
-  }
-  return authMode;
-}
-function ensurePermitMatch(args) {
-  const actual = cleanString(args.actual);
-  if (actual && actual !== args.expected) {
-    throw new LucernSdkAuthContextError(
-      "policy_denied",
-      `Canonical Lucern SDK auth context has conflicting Permit ${args.field}.`
-    );
-  }
-}
-function normalizeCanonicalLucernAuthContext(input) {
-  if (!input) {
-    throw new LucernSdkAuthContextError(
-      "principal_missing",
-      "Canonical Lucern SDK auth context is required."
-    );
-  }
-  if (input.policyDecision === "deny") {
-    throw new LucernSdkAuthContextError(
-      "policy_denied",
-      "Canonical Lucern SDK auth context carries a denied policy decision."
-    );
-  }
-  const principalId = requireString(
-    input.principalId,
-    "principal_missing",
-    "principalId"
-  );
-  const tenantId = requireString(input.tenantId, "tenant_missing", "tenantId");
-  const workspaceId = requireString(
-    input.workspaceId,
-    "workspace_missing",
-    "workspaceId"
-  );
-  const roles = cleanStringList(input.roles);
-  const scopes = cleanStringList(input.scopes);
-  const principalType = requirePrincipalType(input.principalType);
-  const authMode = requireAuthMode(input.authMode);
-  const roleBasedInteractiveAuth = authMode === "interactive_user" && roles.length > 0;
-  if (roles.length === 0 || scopes.length === 0 && !roleBasedInteractiveAuth) {
-    throw new LucernSdkAuthContextError(
-      "membership_missing",
-      "Canonical Lucern SDK auth context requires non-empty roles and scopes."
-    );
-  }
-  const subject = cleanString(input.permit?.subject) ?? principalId;
-  const tenant = cleanString(input.permit?.tenant) ?? tenantId;
-  const workspace = cleanString(input.permit?.workspace) ?? workspaceId;
-  ensurePermitMatch({
-    field: "subject",
-    expected: principalId,
-    actual: subject
-  });
-  ensurePermitMatch({ field: "tenant", expected: tenantId, actual: tenant });
-  ensurePermitMatch({
-    field: "workspace",
-    expected: workspaceId,
-    actual: workspace
-  });
-  const context = input.permit?.context ? { ...input.permit.context } : void 0;
-  return {
-    clerkId: cleanString(input.clerkId),
-    principalId,
-    tenantId,
-    workspaceId,
-    principalType,
-    authMode,
-    roles,
-    scopes,
-    delegationChain: input.delegationChain ? [...input.delegationChain] : [],
-    policyTraceId: cleanString(input.policyTraceId),
-    correlationId: cleanString(input.correlationId),
-    membershipId: cleanString(input.membershipId),
-    permit: {
-      subject,
-      tenant,
-      workspace,
-      resource: cleanString(input.permit?.resource),
-      action: cleanString(input.permit?.action),
-      relation: cleanString(input.permit?.relation),
-      context
-    }
-  };
-}
-function createCanonicalAuthHeaders(authContext) {
-  const headers = {
-    "x-lucern-principal-id": authContext.principalId,
-    "x-lucern-principal-type": authContext.principalType,
-    "x-lucern-tenant": authContext.tenantId,
-    "x-lucern-tenant-id": authContext.tenantId,
-    "x-lucern-workspace": authContext.workspaceId,
-    "x-lucern-workspace-id": authContext.workspaceId,
-    "x-lucern-auth-mode": authContext.authMode,
-    "x-lucern-roles": authContext.roles.join(","),
-    "x-lucern-scopes": authContext.scopes.join(","),
-    "x-lucern-permit-context": JSON.stringify(authContext.permit)
-  };
-  if (authContext.clerkId) {
-    headers["x-lucern-clerk-id"] = authContext.clerkId;
-    headers["x-lucern-user-id"] = authContext.clerkId;
-  }
-  if (authContext.delegationChain.length > 0) {
-    headers["x-lucern-delegation-chain"] = JSON.stringify(
-      authContext.delegationChain
-    );
-  }
-  if (authContext.policyTraceId) {
-    headers["x-lucern-policy-trace-id"] = authContext.policyTraceId;
-  }
-  if (authContext.correlationId) {
-    headers["x-correlation-id"] = authContext.correlationId;
-    headers["x-lucern-correlation-id"] = authContext.correlationId;
-  }
-  if (authContext.membershipId) {
-    headers["x-lucern-membership-id"] = authContext.membershipId;
-  }
-  return headers;
-}
-
-// src/coreClient.ts
-var DEFAULT_GATEWAY_TIMEOUT_MS = 15e3;
-var DEFAULT_GATEWAY_MAX_RETRIES = 2;
-var DEFAULT_ENV_TIMEOUT_MS = "LUCERN_REQUEST_TIMEOUT_MS";
-var DEFAULT_ENV_MAX_RETRIES = "LUCERN_GATEWAY_MAX_RETRIES";
-var ENV_TIMEOUT_BY_METHOD_PREFIX = "LUCERN_REQUEST_TIMEOUT_MS_";
-var GatewayTimeoutError = class extends Error {
-  retryable = true;
-  timeoutMs;
-  constructor(timeoutMs) {
-    super(`Request timed out after ${timeoutMs}ms`);
-    this.name = "AbortError";
-    this.timeoutMs = timeoutMs;
-  }
-};
-var GatewayTransportError = class extends Error {
-  retryable;
-  cause;
-  constructor(message, options) {
-    super(message);
-    this.name = "GatewayTransportError";
-    this.retryable = options?.retryable ?? true;
-    this.cause = options?.cause;
-  }
-};
-function isGatewayRetryableError(error) {
-  return error instanceof GatewayTimeoutError && error.retryable || error instanceof GatewayTransportError && error.retryable || false;
-}
-var LucernApiError = class extends Error {
-  code;
-  status;
-  invariant;
-  suggestion;
-  details;
-  requestId;
-  correlationId;
-  policyTraceId;
-  constructor(args) {
-    super(args.message);
-    this.name = "LucernApiError";
-    this.code = args.code;
-    this.status = args.status;
-    this.invariant = args.invariant;
-    this.suggestion = args.suggestion;
-    this.details = args.details;
-    this.requestId = args.requestId;
-    this.correlationId = args.correlationId;
-    this.policyTraceId = args.policyTraceId;
-  }
-};
-function fillRandomBytes(length) {
-  const bytes = new Uint8Array(length);
-  if (typeof globalThis.crypto?.getRandomValues === "function") {
-    globalThis.crypto.getRandomValues(bytes);
-    return bytes;
-  }
-  for (let index = 0; index < length; index += 1) {
-    bytes[index] = Math.floor(Math.random() * 256);
-  }
-  return bytes;
-}
-function generatePortableRequestId() {
-  if (typeof globalThis.crypto?.randomUUID === "function") {
-    return globalThis.crypto.randomUUID();
-  }
-  const bytes = fillRandomBytes(16);
-  bytes[6] = bytes[6] & 15 | 64;
-  bytes[8] = bytes[8] & 63 | 128;
-  const hex = Array.from(bytes, (value) => value.toString(16).padStart(2, "0"));
-  return `${hex.slice(0, 4).join("")}-${hex.slice(4, 6).join("")}-${hex.slice(
-    6,
-    8
-  ).join("")}-${hex.slice(8, 10).join("")}-${hex.slice(10).join("")}`;
-}
-function resolveEnvironment() {
-  const processEnv = typeof globalThis === "object" && globalThis !== null && "process" in globalThis ? globalThis.process : void 0;
-  const env = processEnv !== void 0 && typeof processEnv === "object" && processEnv !== null && typeof processEnv.env === "object" ? processEnv.env : void 0;
-  return {
-    get: (name) => {
-      const value = env?.[name];
-      return typeof value === "string" && value.length > 0 ? value : void 0;
-    }
-  };
-}
-function telemetryEnvironmentRecord(environment) {
-  const names = [
-    "LUCERN_TELEMETRY_ENABLED",
-    "AXIOM_TELEMETRY_ENABLED",
-    "LUCERN_AXIOM_TOKEN",
-    "AXIOM_TOKEN",
-    "LUCERN_AXIOM_EVENTS_DATASET",
-    "LUCERN_AXIOM_DATASET",
-    "AXIOM_EVENTS_DATASET",
-    "AXIOM_DATASET",
-    "LUCERN_AXIOM_API_URL",
-    "AXIOM_URL",
-    "LUCERN_ENVIRONMENT",
-    "NODE_ENV",
-    "LUCERN_RELEASE",
-    "SENTRY_RELEASE",
-    "VERCEL_GIT_COMMIT_SHA"
-  ];
-  return Object.fromEntries(
-    names.map((name) => [name, environment.get(name)])
-  );
-}
-function resolveRequestProfile(config, environment) {
-  const requestIdFactory = config.requestIdFactory ?? (() => generatePortableRequestId());
-  const parsedMaxRetries = parseIntegerFromString(
-    config.maxRetries,
-    environment.get(DEFAULT_ENV_MAX_RETRIES)
-  );
-  const parsedTimeoutMs = parseIntegerFromString(
-    config.timeoutMs,
-    environment.get(DEFAULT_ENV_TIMEOUT_MS)
-  );
-  const methodTimeouts = {
-    ...config.timeoutMsByMethod
-  };
-  for (const method of ["GET", "POST", "PUT", "PATCH", "DELETE"]) {
-    const envKey = `${ENV_TIMEOUT_BY_METHOD_PREFIX}${method}`;
-    const raw = environment.get(envKey);
-    if (!raw || methodTimeouts[method] !== void 0) {
-      continue;
-    }
-    const parsed = parseIntegerFromString(void 0, raw);
-    if (typeof parsed === "number") {
-      methodTimeouts[method] = parsed;
-    }
-  }
-  return {
-    maxRetries: parsedMaxRetries ?? DEFAULT_GATEWAY_MAX_RETRIES,
-    timeoutMs: parsedTimeoutMs ?? DEFAULT_GATEWAY_TIMEOUT_MS,
-    timeoutMsByMethod: methodTimeouts,
-    requestIdFactory
-  };
-}
-function createGatewayRuntime(config, environment) {
-  return {
-    fetch: config.fetchImpl ?? fetch,
-    now: () => Date.now(),
-    sleep: (ms) => delay(ms),
-    env: environment,
-    redaction: resolveRequestRedactionValue,
-    profile: resolveRequestProfile(config, environment)
-  };
-}
-function parseIntegerFromString(value, rawValue) {
-  if (typeof value === "number" && Number.isInteger(value) && value >= 0) {
-    return value;
-  }
-  if (typeof rawValue !== "string" || !rawValue.trim()) {
-    return void 0;
-  }
-  const parsed = Number.parseInt(rawValue, 10);
-  return Number.isInteger(parsed) && parsed >= 0 ? parsed : void 0;
-}
-function resolveRequestRedactionValue(value) {
-  return redactDiagnosticValue(value);
-}
-function resolveGatewayBaseUrl(configBaseUrl, environment) {
-  const envBaseUrl = environment.get("LUCERN_API_URL") ?? environment.get("LUCERN_BASE_URL") ?? environment.get("LUCERN_GATEWAY_BASE_URL");
-  return (configBaseUrl ?? envBaseUrl ?? "").replace(/\/+$/, "");
-}
-function normalizeGatewayEnvironment(value) {
-  return value === "sandbox" || value === "production" ? value : void 0;
-}
-var randomIdempotencyKey = generatePortableRequestId;
-function fallbackErrorCode(status) {
-  if (status === 401) {
-    return "AUTHENTICATION_REQUIRED";
-  }
-  if (status === 403) {
-    return "FORBIDDEN";
-  }
-  if (status === 404) {
-    return "NOT_FOUND";
-  }
-  if (status === 408) {
-    return "UPSTREAM_ERROR";
-  }
-  if (status === 409) {
-    return "CONFLICT";
-  }
-  if (status === 429) {
-    return "RATE_LIMIT_EXCEEDED";
-  }
-  if (status >= 500) {
-    return "UPSTREAM_ERROR";
-  }
-  return "INTERNAL_ERROR";
-}
-function delay(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-function computeRetryDelayMs(args) {
-  const baseDelay = args.status === 429 ? Math.max(
-    args.retryAfterMs ?? 0,
-    Math.min(1e3 * 2 ** args.attempt, 1e4)
-  ) : Math.min(1e3 * 2 ** args.attempt, 4e3);
-  if (args.status !== 429) {
-    return baseDelay;
-  }
-  const jitterWindow = Math.max(250, Math.round(baseDelay * 0.25));
-  return baseDelay + Math.round(Math.random() * jitterWindow);
-}
-function classifyGatewayErrorForRetry(error) {
-  return isGatewayRetryableError(error) || classifyRetry({ error }).retryable;
-}
-function isRecord(value) {
-  return value !== null && typeof value === "object" && !Array.isArray(value);
-}
-function readPolicySummaryFromDetails(details) {
-  if (!isRecord(details)) {
-    return null;
-  }
-  const directSummary = details.summary;
-  if (typeof directSummary === "string" && directSummary.trim().length > 0) {
-    return directSummary.trim();
-  }
-  const policy = details.policy;
-  if (!isRecord(policy)) {
-    return null;
-  }
-  const explanation = policy.explanation;
-  if (!isRecord(explanation)) {
-    return null;
-  }
-  const nestedSummary = explanation.summary;
-  if (typeof nestedSummary === "string" && nestedSummary.trim().length > 0) {
-    return nestedSummary.trim();
-  }
-  return null;
-}
-function redactJsonDiagnosticValue(value) {
-  return value === void 0 ? void 0 : redactDiagnosticValue(value);
-}
-async function resolveConfiguredAuthContext(authContext) {
-  if (typeof authContext === "function") {
-    return await authContext();
-  }
-  return authContext;
-}
-function mergeHeaderRecord(base, addition) {
-  const headers = new Headers(base);
-  for (const [key, value] of Object.entries(addition)) {
-    const existing = headers.get(key);
-    if (existing !== null && existing !== value) {
-      throw new LucernSdkAuthContextError(
-        "policy_denied",
-        `Canonical Lucern SDK auth context conflicts with existing ${key} header.`
-      );
-    }
-    headers.set(key, value);
-  }
-  return Object.fromEntries(headers.entries());
-}
-function cleanHeaderValue(value) {
-  const normalized = value?.trim();
-  return normalized ? normalized : void 0;
-}
-function createGatewayRequestClient(config = {}) {
-  const env = resolveEnvironment();
-  const runtime = createGatewayRuntime(config, env);
-  const baseUrl = resolveGatewayBaseUrl(config.baseUrl, env);
-  const maxRetries = runtime.profile.maxRetries;
-  const requestIdFactory = runtime.profile.requestIdFactory;
-  const requestTimeoutByMethod = runtime.profile.timeoutMsByMethod;
-  const defaultRequestTimeoutMs = runtime.profile.timeoutMs;
-  const normalizedEnvironment = normalizeGatewayEnvironment(config.environment);
-  const telemetryExporter = config.telemetryEnabled === false ? null : config.telemetryExporter ?? createTelemetryExporterFromEnv(telemetryEnvironmentRecord(env), {
-    service: "lucern-sdk",
-    environment: normalizedEnvironment
-  });
-  async function resolveAuthHeaders() {
-    const provided = config.getAuthHeaders ? await config.getAuthHeaders() : {};
-    const headers = new Headers(provided);
-    const setIfAbsent = (name, value) => {
-      const normalized = cleanHeaderValue(value);
-      if (normalized && !headers.has(name)) {
-        headers.set(name, normalized);
-      }
-    };
-    setIfAbsent("x-lucern-key", config.apiKey);
-    setIfAbsent("x-lucern-session-token", config.userToken);
-    setIfAbsent("x-lucern-environment", normalizedEnvironment);
-    setIfAbsent("x-lucern-clerk-id", config.clerkId);
-    setIfAbsent("x-lucern-user-id", config.userId ?? config.clerkId);
-    setIfAbsent("x-lucern-deployment-host", config.deploymentHost);
-    const base = Object.fromEntries(headers.entries());
-    const authContextInput = await resolveConfiguredAuthContext(
-      config.authContext
-    );
-    if (!authContextInput && !config.requireCanonicalAuthContext) {
-      return base;
-    }
-    const authContext = normalizeCanonicalLucernAuthContext(authContextInput);
-    return mergeHeaderRecord(base, createCanonicalAuthHeaders(authContext));
-  }
-  async function fetchWithTimeout(url, init, timeoutMs) {
-    const normalizeTransportError = (error, isTimeout) => {
-      if (isTimeout) {
-        return new GatewayTimeoutError(timeoutMs);
-      }
-      return error instanceof GatewayTimeoutError || error instanceof GatewayTransportError ? error : new GatewayTransportError(
-        error instanceof Error ? error.message : "Gateway transport error",
-        {
-          cause: error,
-          retryable: classifyGatewayErrorForRetry(error)
-        }
-      );
-    };
-    const controller = new AbortController();
-    const timer = setTimeout(() => controller.abort(), timeoutMs);
-    const requestEffect = Effect.tryPromise({
-      try: () => runtime.fetch(url, { ...init, signal: controller.signal }),
-      catch: (error) => normalizeTransportError(error, controller.signal.aborted)
-    });
-    try {
-      const exit = await Effect.runPromiseExit(requestEffect);
-      if (Exit.isSuccess(exit)) {
-        return exit.value;
-      }
-      const failure = Array.from(Cause.failures(exit.cause))[0];
-      if (failure !== void 0) {
-        throw failure;
-      }
-      throw Cause.squash(exit.cause);
-    } finally {
-      clearTimeout(timer);
-    }
-  }
-  async function emitSdkResponseTelemetry(context) {
-    const retry = classifyRetry({
-      status: context.status,
-      error: context.error,
-      retryAfter: context.retryAfterMs !== null && context.retryAfterMs !== void 0 ? String(context.retryAfterMs / 1e3) : void 0
-    });
-    await emitTelemetrySignal(telemetryExporter, {
-      signalType: "trace",
-      surface: "sdk-retry",
-      eventName: context.willRetry ? "sdk.retry" : context.error ? "sdk.request.error" : "sdk.request.complete",
-      severity: context.error ? context.willRetry ? "warn" : "error" : "info",
-      durationMs: context.durationMs,
-      metricName: "sdk.request.duration_ms",
-      metricValue: context.durationMs,
-      correlationId: context.correlationId ?? context.requestId,
-      policyTraceId: context.policyTraceId ?? null,
-      tenantId: context.headers.get("x-lucern-tenant-id") ?? context.headers.get("x-lucern-tenant") ?? void 0,
-      workspaceId: context.headers.get("x-lucern-workspace-id") ?? context.headers.get("x-lucern-workspace") ?? void 0,
-      attributes: {
-        service: "lucern-sdk",
-        operation: "gateway.request",
-        path: context.path,
-        httpMethod: context.method,
-        httpStatus: context.status,
-        attempt: context.attempt,
-        maxRetries: context.maxRetries,
-        retryReason: retry.reason,
-        retryAfterMs: context.retryAfterMs ?? retry.retryAfterMs,
-        willRetry: context.willRetry,
-        retryable: retry.retryable,
-        errorName: context.error instanceof Error ? context.error.name : void 0,
-        errorMessage: context.error instanceof Error ? context.error.message : void 0
-      }
-    });
-  }
-  async function parsePayload(response) {
-    const text = await response.text();
-    if (!text) {
-      return null;
-    }
-    const parsed = tryParseGatewayEnvelopeJson(text);
-    if (!parsed.ok) {
-      return null;
-    }
-    return isRecord(parsed.value) ? parsed.value : null;
-  }
-  function resolveTimeoutMs(method, requestTimeoutMs) {
-    if (typeof requestTimeoutMs === "number") {
-      return requestTimeoutMs;
-    }
-    const methodTimeoutMs = requestTimeoutByMethod?.[method];
-    if (typeof methodTimeoutMs === "number") {
-      return methodTimeoutMs;
-    }
-    return defaultRequestTimeoutMs;
-  }
-  function tryParseGatewayEnvelopeJson(text) {
-    const trimmed = text.trim();
-    if (!trimmed.startsWith("{") && !trimmed.startsWith("[")) {
-      return { ok: false, reason: "non-json" };
-    }
-    try {
-      return { ok: true, value: JSON.parse(trimmed) };
-    } catch (error) {
-      if (error instanceof SyntaxError) {
-        return { ok: false, reason: "invalid-json", error };
-      }
-      throw error;
-    }
-  }
-  function buildApiError(args) {
-    const failure = args.failure;
-    const legacyError = failure && isRecord(failure.error) ? failure.error : failure?.legacyError;
-    const correlationId = failure?.correlationId ?? args.response.headers.get("x-lucern-correlation-id")?.trim() ?? args.requestId;
-    const policyTraceId = failure?.policyTraceId ?? args.response.headers.get("x-lucern-policy-trace-id")?.trim() ?? null;
-    const details = runtime.redaction(
-      redactJsonDiagnosticValue(failure?.details ?? legacyError?.details)
-    );
-    const policySummary = readPolicySummaryFromDetails(details);
-    const failureMessage = typeof failure?.error === "string" ? failure.error : legacyError?.message;
-    return new LucernApiError({
-      code: failure?.code ?? legacyError?.code ?? fallbackErrorCode(args.response.status),
-      message: policySummary ?? failureMessage ?? (args.response.ok ? "Platform API returned an invalid success payload." : "Platform API request failed."),
-      status: args.response.status,
-      invariant: failure?.invariant,
-      suggestion: failure?.suggestion,
-      details,
-      requestId: args.requestId,
-      correlationId,
-      policyTraceId
-    });
-  }
-  async function request(args) {
-    const authHeaders = await resolveAuthHeaders();
-    const method = args.method ?? "GET";
-    const timeoutMs = resolveTimeoutMs(method, args.timeoutMs);
-    const headers = new Headers({
-      "content-type": "application/json",
-      ...authHeaders
-    });
-    if (args.idempotencyKey) {
-      headers.set("idempotency-key", args.idempotencyKey);
-    }
-    const requestId = headers.get("x-correlation-id")?.trim() || headers.get("x-request-id")?.trim() || args.requestId || requestIdFactory();
-    if (!headers.has("x-correlation-id") && !headers.has("x-request-id")) {
-      headers.set("x-correlation-id", requestId);
-    }
-    const url = `${baseUrl}${args.path}`;
-    const serializedBody = args.body ? JSON.stringify(args.body) : void 0;
-    const init = {
-      method,
-      headers,
-      body: serializedBody
-    };
-    let lastError;
-    for (let attempt = 0; attempt <= maxRetries; attempt++) {
-      const hookRequestContext = {
-        requestId,
-        attempt,
-        maxRetries,
-        method,
-        path: args.path,
-        url,
-        headers: new Headers(headers),
-        body: serializedBody,
-        timeoutMs
-      };
-      await config.onRequest?.(hookRequestContext);
-      const startedAt = Date.now();
-      try {
-        const response = await fetchWithTimeout(url, init, timeoutMs);
-        const responseClone = response.clone();
-        const payload = await parsePayload(response);
-        const retry = classifyRetry({
-          status: response.status,
-          retryAfter: response.headers.get("Retry-After")
-        });
-        const retryAfterMs = retry.retryAfterMs ?? null;
-        if (!response.ok || !payload?.success) {
-          const failure = payload && !payload.success ? payload : null;
-          const apiError = buildApiError({
-            requestId,
-            response,
-            failure
-          });
-          const willRetry = attempt < maxRetries && retry.retryable;
-          const responseContext2 = {
-            ...hookRequestContext,
-            durationMs: Date.now() - startedAt,
-            status: response.status,
-            response: responseClone,
-            error: apiError,
-            correlationId: apiError.correlationId ?? requestId,
-            policyTraceId: apiError.policyTraceId ?? null,
-            retryAfterMs,
-            willRetry
-          };
-          await config.onResponse?.(responseContext2);
-          await emitSdkResponseTelemetry(responseContext2);
-          if (willRetry) {
-            lastError = apiError;
-            await delay(
-              computeRetryDelayMs({
-                attempt,
-                status: response.status,
-                retryAfterMs
-              })
-            );
-            continue;
-          }
-          throw apiError;
-        }
-        const successPayload = payload;
-        const responseContext = {
-          ...hookRequestContext,
-          durationMs: Date.now() - startedAt,
-          status: response.status,
-          response: responseClone,
-          correlationId: successPayload.correlationId ?? response.headers.get("x-lucern-correlation-id")?.trim() ?? requestId,
-          policyTraceId: successPayload.policyTraceId ?? response.headers.get("x-lucern-policy-trace-id")?.trim() ?? null,
-          idempotentReplay: successPayload.idempotentReplay,
-          retryAfterMs,
-          willRetry: false
-        };
-        await config.onResponse?.(responseContext);
-        await emitSdkResponseTelemetry(responseContext);
-        return successPayload;
-      } catch (fetchError) {
-        if (fetchError instanceof LucernApiError) {
-          throw fetchError;
-        }
-        const willRetry = attempt < maxRetries && classifyGatewayErrorForRetry(fetchError);
-        const responseContext = {
-          ...hookRequestContext,
-          durationMs: Date.now() - startedAt,
-          error: fetchError,
-          correlationId: requestId,
-          policyTraceId: null,
-          willRetry
-        };
-        await config.onResponse?.(responseContext);
-        await emitSdkResponseTelemetry(responseContext);
-        lastError = fetchError;
-        if (willRetry) {
-          await delay(computeRetryDelayMs({ attempt }));
-        }
-      }
-    }
-    throw lastError instanceof Error ? lastError : new Error("Platform API request failed after retries.");
-  }
-  return {
-    request
-  };
-}
-
-// src/generated/functionSurface.ts
-var FUNCTION_SURFACE_METHOD_PATHS = [
-  "answers.answerQuestion",
-  "answers.createAnswer",
-  "answers.getAnswer",
-  "beliefs.archiveBelief",
-  "beliefs.bisectConfidence",
-  "beliefs.createBelief",
-  "beliefs.forkBelief",
-  "beliefs.getBelief",
-  "beliefs.getConfidenceHistory",
-  "beliefs.listBeliefs",
-  "beliefs.modulateConfidence",
-  "beliefs.refineBelief",
-  "beliefs.searchBeliefs",
-  "bootstrap.generateSessionHandoff",
-  "coding.getChangeHistory",
-  "coding.getCodeContext",
-  "coding.getFailureLog",
-  "coding.recordAttempt",
-  "context.analyzeTopicDensity",
-  "context.applyAutoBranching",
-  "context.compileContext",
-  "context.discover",
-  "context.discoverEntityConnections",
-  "context.getLatticeCoverage",
-  "context.recordScopeLearning",
-  "context.seedBeliefLattice",
-  "context.triggerBeliefReview",
-  "contracts.createEpistemicContract",
-  "contracts.evaluateContract",
-  "contracts.getContractStatus",
-  "contradictions.flagContradiction",
-  "controlPlane.identity.resolveInteractivePrincipal",
-  "coordination.broadcastMessage",
-  "coordination.claimFiles",
-  "coordination.endSession",
-  "coordination.getAgentInbox",
-  "coordination.heartbeatSession",
-  "coordination.listActiveSessions",
-  "coordination.registerSession",
-  "coordination.sendAgentMessage",
-  "edges.batchCreateEdges",
-  "edges.createEdge",
-  "edges.queryLineage",
-  "edges.removeEdge",
-  "edges.removeEdgesBetween",
-  "edges.updateEdge",
-  "embeddings.getByNodeIds",
-  "embeddings.listMissingForTopic",
-  "embeddings.markEmbeddingBackfillQueued",
-  "embeddings.vectorSearchByTopic",
-  "evidence.addEvidence",
-  "evidence.createEvidence",
-  "evidence.getEvidence",
-  "evidence.linkEvidence",
-  "evidence.linkEvidenceToBelief",
-  "evidence.linkEvidenceToQuestion",
-  "evidence.listEvidence",
-  "evidence.searchEvidence",
-  "graph.detectConfirmationBias",
-  "graph.findContradictions",
-  "graph.getGraphGaps",
-  "graph.getGraphNeighborhood",
-  "graph.getGraphStructureAnalysis",
-  "graph.getTopicCoverage",
-  "graph.traceEntityImpact",
-  "graph.traverseGraph",
-  "graphAnalysis.listGraphIntelligenceQueries",
-  "graphAnalysis.runGraphIntelligenceQuery",
-  "hybrid.analyzeGraphImpact",
-  "hybrid.detectGraphDrift",
-  "hybrid.expandGraphNeighborhood",
-  "hybrid.findRelatedNodes",
-  "hybrid.hybridDiscover",
-  "hybrid.resolveTopicSemantic",
-  "identity.checkPermission",
-  "identity.filterByPermission",
-  "identity.whoami",
-  "judgments.getAuditTrail",
-  "judgments.recordJudgment",
-  "lenses.applyLensToTopic",
-  "lenses.createLens",
-  "lenses.listLenses",
-  "lenses.removeLensFromTopic",
-  "nodes.archiveEpistemicNode",
-  "nodes.batchCreateEpistemicNodes",
-  "nodes.createEpistemicNode",
-  "nodes.getEpistemicNode",
-  "nodes.listEpistemicNodes",
-  "nodes.supersedeEpistemicNode",
-  "nodes.updateEpistemicNode",
-  "nodes.verifyEpistemicNode",
-  "observations.getObservationContext",
-  "observations.ingestObservation",
-  "ontologies.applyOntology",
-  "ontologies.archiveOntology",
-  "ontologies.createOntology",
-  "ontologies.createOntologyVersion",
-  "ontologies.deprecateOntologyVersion",
-  "ontologies.getOntology",
-  "ontologies.listOntologies",
-  "ontologies.matchEntityType",
-  "ontologies.publishOntologyVersion",
-  "ontologies.resolveEffectiveOntology",
-  "ontologies.updateOntology",
-  "policy.manageWritePolicy",
-  "questions.archiveQuestion",
-  "questions.createQuestion",
-  "questions.findMissingQuestions",
-  "questions.getFalsificationQuestions",
-  "questions.getHighPriorityQuestions",
-  "questions.getQuestion",
-  "questions.listQuestions",
-  "questions.refineQuestion",
-  "questions.updateQuestionStatus",
-  "tasks.completeTask",
-  "tasks.createTask",
-  "tasks.listTasks",
-  "tasks.updateTask",
-  "topics.createTopic",
-  "topics.getTopic",
-  "topics.getTopicGraphSpine",
-  "topics.getTopicTree",
-  "topics.listTopics",
-  "topics.materializeTopicGraph",
-  "topics.updateTopic",
-  "worktrees.activateWorktree",
-  "worktrees.addWorktree",
-  "worktrees.beginBuildSession",
-  "worktrees.getWorktree",
-  "worktrees.listAllWorktrees",
-  "worktrees.listCampaigns",
-  "worktrees.listWorktrees",
-  "worktrees.merge",
-  "worktrees.openPullRequest",
-  "worktrees.pipelineSnapshot",
-  "worktrees.push",
-  "worktrees.updateWorktreeMetadata",
-  "worktrees.updateWorktreeTargets"
-];
-var CONTRACTS = {
-  "activate_worktree": { method: "POST", path: "/worktrees/activate", kind: "mutation", idempotent: true, surfaceIntent: "mcp_workflow" },
-  "add_evidence": { method: "POST", path: "/evidence/add", kind: "mutation", idempotent: true, surfaceIntent: "compatibility" },
-  "add_worktree": { method: "POST", path: "/worktrees", kind: "mutation", idempotent: true, surfaceIntent: "mcp_workflow" },
-  "analyze_graph_impact": { method: "POST", path: "/hybrid/impact", kind: "action", idempotent: false, surfaceIntent: "mcp_analysis" },
-  "analyze_topic_density": { method: "POST", path: "/scope/topic-density", kind: "query", idempotent: false, surfaceIntent: "mcp_analysis" },
-  "answer_question": { method: "POST", path: "/questions/answer", kind: "mutation", idempotent: true, surfaceIntent: "compatibility" },
-  "apply_auto_branching": { method: "POST", path: "/scope/auto-branching", kind: "mutation", idempotent: true, surfaceIntent: "mcp_analysis" },
-  "apply_lens_to_topic": { method: "POST", path: "/lenses/apply", kind: "mutation", idempotent: true, surfaceIntent: "mcp_workflow" },
-  "apply_ontology": { method: "POST", path: "/ontologies/apply", kind: "mutation", idempotent: true, surfaceIntent: "mcp_workflow" },
-  "archive_belief": { method: "DELETE", path: "/beliefs", kind: "mutation", idempotent: true, surfaceIntent: "mcp_core" },
-  "archive_epistemic_node": { method: "POST", path: "/nodes/archive", kind: "mutation", idempotent: true, surfaceIntent: "mcp_core" },
-  "archive_ontology": { method: "DELETE", path: "/ontologies", kind: "mutation", idempotent: true, surfaceIntent: "mcp_governance" },
-  "archive_question": { method: "DELETE", path: "/questions", kind: "mutation", idempotent: true, surfaceIntent: "mcp_core" },
-  "batch_create_edges": { method: "POST", path: "/edges/batch", kind: "mutation", idempotent: true, surfaceIntent: "mcp_analysis" },
-  "batch_create_epistemic_nodes": { method: "POST", path: "/nodes/batch", kind: "mutation", idempotent: true, surfaceIntent: "mcp_core" },
-  "begin_build_session": { method: "POST", path: "/mcp/build-session/begin", kind: "mutation", idempotent: true, surfaceIntent: "system" },
-  "bisect_confidence": { method: "POST", path: "/beliefs/confidence/bisect", kind: "query", idempotent: false, surfaceIntent: "mcp_core" },
-  "broadcast_message": { method: "POST", path: "/coordination/messages/broadcast", kind: "mutation", idempotent: true, surfaceIntent: "system" },
-  "check_permission": { method: "POST", path: "/identity/check-permission", kind: "query", idempotent: false, surfaceIntent: "mcp_core" },
-  "claim_files": { method: "POST", path: "/coordination/file-claims", kind: "mutation", idempotent: true, surfaceIntent: "system" },
-  "compile_context": { method: "POST", path: "/context/compile", kind: "query", idempotent: false, surfaceIntent: "mcp_core" },
-  "complete_task": { method: "POST", path: "/tasks/complete", kind: "mutation", idempotent: true, surfaceIntent: "mcp_workflow" },
-  "create_answer": { method: "POST", path: "/answers", kind: "mutation", idempotent: true, surfaceIntent: "mcp_core" },
-  "create_belief": { method: "POST", path: "/beliefs", kind: "mutation", idempotent: true, surfaceIntent: "mcp_core" },
-  "create_edge": { method: "POST", path: "/edges", kind: "mutation", idempotent: true, surfaceIntent: "mcp_analysis" },
-  "create_epistemic_contract": { method: "POST", path: "/contracts", kind: "mutation", idempotent: true, surfaceIntent: "mcp_governance" },
-  "create_epistemic_node": { method: "POST", path: "/nodes", kind: "mutation", idempotent: true, surfaceIntent: "mcp_core" },
-  "create_evidence": { method: "POST", path: "/evidence", kind: "mutation", idempotent: true, surfaceIntent: "mcp_core" },
-  "create_lens": { method: "POST", path: "/lenses", kind: "mutation", idempotent: true, surfaceIntent: "mcp_governance" },
-  "create_ontology": { method: "POST", path: "/ontologies", kind: "mutation", idempotent: true, surfaceIntent: "mcp_governance" },
-  "create_ontology_version": { method: "POST", path: "/ontologies/versions", kind: "mutation", idempotent: true, surfaceIntent: "mcp_governance" },
-  "create_question": { method: "POST", path: "/questions", kind: "mutation", idempotent: true, surfaceIntent: "mcp_core" },
-  "create_task": { method: "POST", path: "/tasks", kind: "mutation", idempotent: true, surfaceIntent: "mcp_workflow" },
-  "create_topic": { method: "POST", path: "/topics", kind: "mutation", idempotent: true, surfaceIntent: "mcp_core" },
-  "deprecate_ontology_version": { method: "POST", path: "/ontologies/versions/deprecate", kind: "mutation", idempotent: true, surfaceIntent: "mcp_governance" },
-  "detect_confirmation_bias": { method: "POST", path: "/graph/confirmation-bias", kind: "query", idempotent: false, surfaceIntent: "mcp_analysis" },
-  "detect_graph_drift": { method: "POST", path: "/hybrid/drift", kind: "action", idempotent: false, surfaceIntent: "mcp_analysis" },
-  "discover": { method: "POST", path: "/context/discover", kind: "query", idempotent: false, surfaceIntent: "compatibility" },
-  "discover_entity_connections": { method: "POST", path: "/context/entity-connections", kind: "query", idempotent: false, surfaceIntent: "mcp_analysis" },
-  "end_session": { method: "POST", path: "/coordination/end-session", kind: "mutation", idempotent: true, surfaceIntent: "system" },
-  "evaluate_contract": { method: "POST", path: "/contracts/evaluate", kind: "mutation", idempotent: true, surfaceIntent: "mcp_governance" },
-  "expand_graph_neighborhood": { method: "POST", path: "/hybrid/neighborhood", kind: "action", idempotent: false, surfaceIntent: "mcp_analysis" },
-  "filter_by_permission": { method: "POST", path: "/identity/filter-by-permission", kind: "query", idempotent: false, surfaceIntent: "mcp_core" },
-  "find_contradictions": { method: "POST", path: "/graph/contradictions", kind: "query", idempotent: false, surfaceIntent: "mcp_analysis" },
-  "find_missing_questions": { method: "POST", path: "/questions/missing", kind: "query", idempotent: false, surfaceIntent: "mcp_core" },
-  "find_related_nodes": { method: "POST", path: "/hybrid/related-nodes", kind: "action", idempotent: false, surfaceIntent: "mcp_analysis" },
-  "flag_contradiction": { method: "POST", path: "/contradictions", kind: "mutation", idempotent: true, surfaceIntent: "mcp_analysis" },
-  "fork_belief": { method: "POST", path: "/beliefs/fork", kind: "mutation", idempotent: true, surfaceIntent: "mcp_core" },
-  "generate_session_handoff": { method: "POST", path: "/bootstrap/session-handoff", kind: "query", idempotent: false, surfaceIntent: "system" },
-  "get_agent_inbox": { method: "POST", path: "/coordination/messages/inbox", kind: "query", idempotent: false, surfaceIntent: "system" },
-  "get_answer": { method: "GET", path: "/answers/get", kind: "query", idempotent: false, surfaceIntent: "mcp_core" },
-  "get_audit_trail": { method: "POST", path: "/judgments/audit-trail", kind: "query", idempotent: false, surfaceIntent: "system" },
-  "get_belief": { method: "GET", path: "/beliefs/get", kind: "query", idempotent: false, surfaceIntent: "mcp_core" },
-  "get_change_history": { method: "POST", path: "/coding/change-history", kind: "query", idempotent: false, surfaceIntent: "system" },
-  "get_code_context": { method: "POST", path: "/coding/context", kind: "query", idempotent: false, surfaceIntent: "system" },
-  "get_confidence_history": { method: "POST", path: "/beliefs/confidence-history", kind: "query", idempotent: false, surfaceIntent: "compatibility" },
-  "get_contract_status": { method: "POST", path: "/contracts/status", kind: "query", idempotent: false, surfaceIntent: "mcp_governance" },
-  "get_embeddings_by_node_ids": { method: "POST", path: "/embeddings/by-node-ids", kind: "query", idempotent: false, surfaceIntent: "mcp_analysis" },
-  "get_epistemic_node": { method: "GET", path: "/nodes/get", kind: "query", idempotent: false, surfaceIntent: "mcp_core" },
-  "get_evidence": { method: "GET", path: "/evidence/get", kind: "query", idempotent: false, surfaceIntent: "mcp_core" },
-  "get_failure_log": { method: "POST", path: "/coding/failure-log", kind: "query", idempotent: false, surfaceIntent: "system" },
-  "get_falsification_questions": { method: "POST", path: "/questions/falsification", kind: "query", idempotent: false, surfaceIntent: "mcp_core" },
-  "get_graph_gaps": { method: "POST", path: "/graph/gaps", kind: "query", idempotent: false, surfaceIntent: "mcp_analysis" },
-  "get_graph_neighborhood": { method: "POST", path: "/graph/neighborhood", kind: "query", idempotent: false, surfaceIntent: "mcp_analysis" },
-  "get_graph_structure_analysis": { method: "POST", path: "/graph/structure-analysis", kind: "query", idempotent: false, surfaceIntent: "mcp_analysis" },
-  "get_high_priority_questions": { method: "POST", path: "/questions/high-priority", kind: "query", idempotent: false, surfaceIntent: "mcp_core" },
-  "get_lattice_coverage": { method: "POST", path: "/scope/belief-lattice/coverage", kind: "query", idempotent: false, surfaceIntent: "system" },
-  "get_observation_context": { method: "POST", path: "/observations/context", kind: "query", idempotent: false, surfaceIntent: "mcp_workflow" },
-  "get_ontology": { method: "GET", path: "/ontologies/get", kind: "query", idempotent: false, surfaceIntent: "mcp_workflow" },
-  "get_question": { method: "GET", path: "/questions/get", kind: "query", idempotent: false, surfaceIntent: "mcp_core" },
-  "get_topic": { method: "GET", path: "/topics/get", kind: "query", idempotent: false, surfaceIntent: "mcp_core" },
-  "get_topic_coverage": { method: "POST", path: "/graph/topic-coverage", kind: "query", idempotent: false, surfaceIntent: "mcp_analysis" },
-  "get_topic_graph_spine": { method: "GET", path: "/topics/graph-spine", kind: "query", idempotent: false, surfaceIntent: "mcp_core" },
-  "get_topic_tree": { method: "GET", path: "/topics/tree", kind: "query", idempotent: false, surfaceIntent: "mcp_core" },
-  "get_worktree": { method: "GET", path: "/worktrees/get", kind: "query", idempotent: false, surfaceIntent: "mcp_workflow" },
-  "heartbeat_session": { method: "POST", path: "/coordination/heartbeat-session", kind: "mutation", idempotent: true, surfaceIntent: "system" },
-  "hybrid_discover": { method: "POST", path: "/hybrid/discover", kind: "action", idempotent: false, surfaceIntent: "mcp_analysis" },
-  "identity_whoami": { method: "GET", path: "/identity/whoami", kind: "query", idempotent: false, surfaceIntent: "mcp_core" },
-  "ingest_observation": { method: "POST", path: "/observations/ingest", kind: "mutation", idempotent: true, surfaceIntent: "mcp_workflow" },
-  "link_evidence": { method: "POST", path: "/evidence/link", kind: "mutation", idempotent: true, surfaceIntent: "compatibility" },
-  "link_evidence_to_belief": { method: "POST", path: "/evidence/link-belief", kind: "mutation", idempotent: true, surfaceIntent: "mcp_core" },
-  "link_evidence_to_question": { method: "POST", path: "/evidence/link-question", kind: "mutation", idempotent: true, surfaceIntent: "mcp_core" },
-  "list_active_sessions": { method: "POST", path: "/coordination/active-sessions", kind: "query", idempotent: false, surfaceIntent: "system" },
-  "list_all_worktrees": { method: "GET", path: "/worktrees/all", kind: "query", idempotent: false, surfaceIntent: "mcp_workflow" },
-  "list_beliefs": { method: "GET", path: "/beliefs", kind: "query", idempotent: false, surfaceIntent: "mcp_core" },
-  "list_campaigns": { method: "GET", path: "/worktrees/campaigns", kind: "query", idempotent: false, surfaceIntent: "mcp_workflow" },
-  "list_epistemic_nodes": { method: "GET", path: "/nodes", kind: "query", idempotent: false, surfaceIntent: "mcp_core" },
-  "list_evidence": { method: "GET", path: "/evidence", kind: "query", idempotent: false, surfaceIntent: "mcp_core" },
-  "list_graph_intelligence_queries": { method: "POST", path: "/graph-intelligence/queries", kind: "query", idempotent: false, surfaceIntent: "mcp_analysis" },
-  "list_lenses": { method: "GET", path: "/lenses", kind: "query", idempotent: false, surfaceIntent: "mcp_workflow" },
-  "list_missing_embeddings": { method: "GET", path: "/embeddings/missing", kind: "query", idempotent: false, surfaceIntent: "mcp_analysis" },
-  "list_ontologies": { method: "GET", path: "/ontologies", kind: "query", idempotent: false, surfaceIntent: "mcp_workflow" },
-  "list_questions": { method: "GET", path: "/questions", kind: "query", idempotent: false, surfaceIntent: "mcp_core" },
-  "list_tasks": { method: "GET", path: "/tasks", kind: "query", idempotent: false, surfaceIntent: "mcp_workflow" },
-  "list_topics": { method: "GET", path: "/topics", kind: "query", idempotent: false, surfaceIntent: "mcp_core" },
-  "list_worktrees": { method: "GET", path: "/worktrees", kind: "query", idempotent: false, surfaceIntent: "mcp_workflow" },
-  "manage_write_policy": { method: "POST", path: "/policy/write-policy/manage", kind: "mutation", idempotent: true, surfaceIntent: "mcp_governance" },
-  "match_entity_type": { method: "POST", path: "/ontologies/match-entity-type", kind: "query", idempotent: false, surfaceIntent: "mcp_workflow" },
-  "materialize_topic_graph": { method: "POST", path: "/topics/materialize-graph", kind: "mutation", idempotent: true, surfaceIntent: "mcp_core" },
-  "merge": { method: "POST", path: "/worktrees/merge", kind: "mutation", idempotent: true, surfaceIntent: "mcp_workflow" },
-  "modulate_confidence": { method: "POST", path: "/beliefs/confidence", kind: "mutation", idempotent: true, surfaceIntent: "mcp_core" },
-  "open_pull_request": { method: "POST", path: "/worktrees/open-pull-request", kind: "mutation", idempotent: true, surfaceIntent: "system" },
-  "pipeline_snapshot": { method: "POST", path: "/worktrees/pipeline-snapshot", kind: "query", idempotent: false, surfaceIntent: "system" },
-  "publish_ontology_version": { method: "POST", path: "/ontologies/versions/publish", kind: "mutation", idempotent: true, surfaceIntent: "mcp_governance" },
-  "push": { method: "POST", path: "/worktrees/push", kind: "mutation", idempotent: true, surfaceIntent: "system" },
-  "query_lineage": { method: "POST", path: "/edges/lineage", kind: "query", idempotent: false, surfaceIntent: "mcp_analysis" },
-  "queue_embedding_backfill": { method: "POST", path: "/embeddings/backfill-queued", kind: "mutation", idempotent: true, surfaceIntent: "mcp_analysis" },
-  "record_attempt": { method: "POST", path: "/coding/attempts", kind: "mutation", idempotent: true, surfaceIntent: "system" },
-  "record_judgment": { method: "POST", path: "/judgments", kind: "mutation", idempotent: true, surfaceIntent: "system" },
-  "record_scope_learning": { method: "POST", path: "/scope/learnings", kind: "mutation", idempotent: true, surfaceIntent: "system" },
-  "refine_belief": { method: "PATCH", path: "/beliefs/refine", kind: "mutation", idempotent: true, surfaceIntent: "mcp_core" },
-  "refine_question": { method: "PATCH", path: "/questions/refine", kind: "mutation", idempotent: true, surfaceIntent: "mcp_core" },
-  "register_session": { method: "POST", path: "/coordination/register-session", kind: "mutation", idempotent: true, surfaceIntent: "system" },
-  "remove_edge": { method: "DELETE", path: "/edges", kind: "mutation", idempotent: true, surfaceIntent: "mcp_analysis" },
-  "remove_edges_between": { method: "DELETE", path: "/edges/between", kind: "mutation", idempotent: true, surfaceIntent: "mcp_analysis" },
-  "remove_lens_from_topic": { method: "DELETE", path: "/lenses/apply", kind: "mutation", idempotent: true, surfaceIntent: "mcp_workflow" },
-  "resolve_effective_ontology": { method: "POST", path: "/ontologies/effective", kind: "query", idempotent: false, surfaceIntent: "mcp_workflow" },
-  "resolve_interactive_principal": { method: "POST", path: "/control-plane/identity/resolve-interactive-principal", kind: "query", idempotent: false, surfaceIntent: "mcp_core" },
-  "resolve_topic_semantic": { method: "POST", path: "/hybrid/topics/resolve", kind: "action", idempotent: false, surfaceIntent: "mcp_analysis" },
-  "run_graph_intelligence_query": { method: "POST", path: "/graph-intelligence/run", kind: "query", idempotent: false, surfaceIntent: "mcp_analysis" },
-  "search_beliefs": { method: "POST", path: "/beliefs/search", kind: "query", idempotent: false, surfaceIntent: "mcp_core" },
-  "search_embeddings": { method: "POST", path: "/embeddings/vector-search", kind: "action", idempotent: false, surfaceIntent: "mcp_analysis" },
-  "search_evidence": { method: "POST", path: "/evidence/search", kind: "query", idempotent: false, surfaceIntent: "mcp_core" },
-  "seed_belief_lattice": { method: "POST", path: "/scope/belief-lattice/seed", kind: "mutation", idempotent: true, surfaceIntent: "system" },
-  "send_agent_message": { method: "POST", path: "/coordination/messages/send", kind: "mutation", idempotent: true, surfaceIntent: "system" },
-  "supersede_epistemic_node": { method: "POST", path: "/nodes/supersede", kind: "mutation", idempotent: true, surfaceIntent: "mcp_core" },
-  "trace_entity_impact": { method: "POST", path: "/graph/trace-entity-impact", kind: "query", idempotent: false, surfaceIntent: "mcp_analysis" },
-  "traverse_graph": { method: "POST", path: "/graph/traverse", kind: "query", idempotent: false, surfaceIntent: "mcp_analysis" },
-  "trigger_belief_review": { method: "POST", path: "/context/belief-review", kind: "mutation", idempotent: true, surfaceIntent: "mcp_analysis" },
-  "update_edge": { method: "PATCH", path: "/edges", kind: "mutation", idempotent: true, surfaceIntent: "mcp_analysis" },
-  "update_epistemic_node": { method: "PATCH", path: "/nodes", kind: "mutation", idempotent: true, surfaceIntent: "mcp_core" },
-  "update_ontology": { method: "PATCH", path: "/ontologies", kind: "mutation", idempotent: true, surfaceIntent: "mcp_governance" },
-  "update_question_status": { method: "PATCH", path: "/questions/status", kind: "mutation", idempotent: true, surfaceIntent: "mcp_core" },
-  "update_task": { method: "PATCH", path: "/tasks", kind: "mutation", idempotent: true, surfaceIntent: "mcp_workflow" },
-  "update_topic": { method: "PATCH", path: "/topics", kind: "mutation", idempotent: true, surfaceIntent: "mcp_core" },
-  "update_worktree_metadata": { method: "PATCH", path: "/worktrees/metadata", kind: "mutation", idempotent: true, surfaceIntent: "mcp_workflow" },
-  "update_worktree_targets": { method: "PATCH", path: "/worktrees/targets", kind: "mutation", idempotent: true, surfaceIntent: "mcp_workflow" },
-  "verify_epistemic_node": { method: "POST", path: "/nodes/verify", kind: "mutation", idempotent: true, surfaceIntent: "mcp_core" }
-};
-function createSessionId() {
-  return typeof crypto !== "undefined" && typeof crypto.randomUUID === "function" ? crypto.randomUUID() : randomIdempotencyKey();
-}
-function withSdkSessionId(input, sessionId) {
-  return {
-    ...input,
-    __sdkSessionId: typeof input.__sdkSessionId === "string" ? input.__sdkSessionId : sessionId
-  };
-}
-function toFunctionSurfaceQuery(input) {
-  const params = new URLSearchParams();
-  for (const [key, value] of Object.entries(input)) {
-    if (value === void 0) {
-      continue;
-    }
-    const serialized2 = typeof value === "string" ? value : JSON.stringify(value);
-    if (serialized2 !== void 0) {
-      params.set(key, serialized2);
-    }
-  }
-  const serialized = params.toString();
-  return serialized ? `?${serialized}` : "";
-}
-function createFunctionSurfaceClient(config = {}) {
-  const gateway = createGatewayRequestClient(config);
-  const sessionId = createSessionId();
-  function execute(name, input, idempotencyKey) {
-    const contract = CONTRACTS[name];
-    const payload = withSdkSessionId(input, sessionId);
-    const path = contract.method === "GET" ? `${contract.path}${toFunctionSurfaceQuery(payload)}` : contract.path;
-    return gateway.request({
-      path: `/api/platform/v1${path}`,
-      method: contract.method,
-      body: contract.method === "GET" ? void 0 : payload,
-      idempotencyKey: contract.kind !== "query" && Boolean(contract.idempotent) ? idempotencyKey ?? randomIdempotencyKey() : void 0
-    });
-  }
-  return {
-    sessionId,
-    activateWorktree(input = {}, idempotencyKey) {
-      return execute("activate_worktree", input, idempotencyKey);
-    },
-    addEvidence(input = {}, idempotencyKey) {
-      return execute("add_evidence", input, idempotencyKey);
-    },
-    addWorktree(input = {}, idempotencyKey) {
-      return execute("add_worktree", input, idempotencyKey);
-    },
-    analyzeGraphImpact(input = {}, idempotencyKey) {
-      return execute("analyze_graph_impact", input, idempotencyKey);
-    },
-    analyzeTopicDensity(input = {}, idempotencyKey) {
-      return execute("analyze_topic_density", input, idempotencyKey);
-    },
-    answerQuestion(input = {}, idempotencyKey) {
-      return execute("answer_question", input, idempotencyKey);
-    },
-    applyAutoBranching(input = {}, idempotencyKey) {
-      return execute("apply_auto_branching", input, idempotencyKey);
-    },
-    applyLensToTopic(input = {}, idempotencyKey) {
-      return execute("apply_lens_to_topic", input, idempotencyKey);
-    },
-    applyOntology(input = {}, idempotencyKey) {
-      return execute("apply_ontology", input, idempotencyKey);
-    },
-    archiveBelief(input = {}, idempotencyKey) {
-      return execute("archive_belief", input, idempotencyKey);
-    },
-    archiveEpistemicNode(input = {}, idempotencyKey) {
-      return execute("archive_epistemic_node", input, idempotencyKey);
-    },
-    archiveOntology(input = {}, idempotencyKey) {
-      return execute("archive_ontology", input, idempotencyKey);
-    },
-    archiveQuestion(input = {}, idempotencyKey) {
-      return execute("archive_question", input, idempotencyKey);
-    },
-    batchCreateEdges(input = {}, idempotencyKey) {
-      return execute("batch_create_edges", input, idempotencyKey);
-    },
-    batchCreateEpistemicNodes(input = {}, idempotencyKey) {
-      return execute("batch_create_epistemic_nodes", input, idempotencyKey);
-    },
-    beginBuildSession(input = {}, idempotencyKey) {
-      return execute("begin_build_session", input, idempotencyKey);
-    },
-    bisectConfidence(input = {}, idempotencyKey) {
-      return execute("bisect_confidence", input, idempotencyKey);
-    },
-    broadcastMessage(input = {}, idempotencyKey) {
-      return execute("broadcast_message", input, idempotencyKey);
-    },
-    checkPermission(input = {}, idempotencyKey) {
-      return execute("check_permission", input, idempotencyKey);
-    },
-    claimFiles(input = {}, idempotencyKey) {
-      return execute("claim_files", input, idempotencyKey);
-    },
-    compileContext(input = {}, idempotencyKey) {
-      return execute("compile_context", input, idempotencyKey);
-    },
-    completeTask(input = {}, idempotencyKey) {
-      return execute("complete_task", input, idempotencyKey);
-    },
-    createAnswer(input = {}, idempotencyKey) {
-      return execute("create_answer", input, idempotencyKey);
-    },
-    createBelief(input = {}, idempotencyKey) {
-      return execute("create_belief", input, idempotencyKey);
-    },
-    createEdge(input = {}, idempotencyKey) {
-      return execute("create_edge", input, idempotencyKey);
-    },
-    createEpistemicContract(input = {}, idempotencyKey) {
-      return execute("create_epistemic_contract", input, idempotencyKey);
-    },
-    createEpistemicNode(input = {}, idempotencyKey) {
-      return execute("create_epistemic_node", input, idempotencyKey);
-    },
-    createEvidence(input = {}, idempotencyKey) {
-      return execute("create_evidence", input, idempotencyKey);
-    },
-    createLens(input = {}, idempotencyKey) {
-      return execute("create_lens", input, idempotencyKey);
-    },
-    createOntology(input = {}, idempotencyKey) {
-      return execute("create_ontology", input, idempotencyKey);
-    },
-    createOntologyVersion(input = {}, idempotencyKey) {
-      return execute("create_ontology_version", input, idempotencyKey);
-    },
-    createQuestion(input = {}, idempotencyKey) {
-      return execute("create_question", input, idempotencyKey);
-    },
-    createTask(input = {}, idempotencyKey) {
-      return execute("create_task", input, idempotencyKey);
-    },
-    createTopic(input = {}, idempotencyKey) {
-      return execute("create_topic", input, idempotencyKey);
-    },
-    deprecateOntologyVersion(input = {}, idempotencyKey) {
-      return execute("deprecate_ontology_version", input, idempotencyKey);
-    },
-    detectConfirmationBias(input = {}, idempotencyKey) {
-      return execute("detect_confirmation_bias", input, idempotencyKey);
-    },
-    detectGraphDrift(input = {}, idempotencyKey) {
-      return execute("detect_graph_drift", input, idempotencyKey);
-    },
-    discover(input = {}, idempotencyKey) {
-      return execute("discover", input, idempotencyKey);
-    },
-    discoverEntityConnections(input = {}, idempotencyKey) {
-      return execute("discover_entity_connections", input, idempotencyKey);
-    },
-    endSession(input = {}, idempotencyKey) {
-      return execute("end_session", input, idempotencyKey);
-    },
-    evaluateContract(input = {}, idempotencyKey) {
-      return execute("evaluate_contract", input, idempotencyKey);
-    },
-    expandGraphNeighborhood(input = {}, idempotencyKey) {
-      return execute("expand_graph_neighborhood", input, idempotencyKey);
-    },
-    filterByPermission(input = {}, idempotencyKey) {
-      return execute("filter_by_permission", input, idempotencyKey);
-    },
-    findContradictions(input = {}, idempotencyKey) {
-      return execute("find_contradictions", input, idempotencyKey);
-    },
-    findMissingQuestions(input = {}, idempotencyKey) {
-      return execute("find_missing_questions", input, idempotencyKey);
-    },
-    findRelatedNodes(input = {}, idempotencyKey) {
-      return execute("find_related_nodes", input, idempotencyKey);
-    },
-    flagContradiction(input = {}, idempotencyKey) {
-      return execute("flag_contradiction", input, idempotencyKey);
-    },
-    forkBelief(input = {}, idempotencyKey) {
-      return execute("fork_belief", input, idempotencyKey);
-    },
-    generateSessionHandoff(input = {}, idempotencyKey) {
-      return execute("generate_session_handoff", input, idempotencyKey);
-    },
-    getAgentInbox(input = {}, idempotencyKey) {
-      return execute("get_agent_inbox", input, idempotencyKey);
-    },
-    getAnswer(input = {}, idempotencyKey) {
-      return execute("get_answer", input, idempotencyKey);
-    },
-    getAuditTrail(input = {}, idempotencyKey) {
-      return execute("get_audit_trail", input, idempotencyKey);
-    },
-    getBelief(input = {}, idempotencyKey) {
-      return execute("get_belief", input, idempotencyKey);
-    },
-    getChangeHistory(input = {}, idempotencyKey) {
-      return execute("get_change_history", input, idempotencyKey);
-    },
-    getCodeContext(input = {}, idempotencyKey) {
-      return execute("get_code_context", input, idempotencyKey);
-    },
-    getConfidenceHistory(input = {}, idempotencyKey) {
-      return execute("get_confidence_history", input, idempotencyKey);
-    },
-    getContractStatus(input = {}, idempotencyKey) {
-      return execute("get_contract_status", input, idempotencyKey);
-    },
-    getByNodeIds(input = {}, idempotencyKey) {
-      return execute("get_embeddings_by_node_ids", input, idempotencyKey);
-    },
-    getEpistemicNode(input = {}, idempotencyKey) {
-      return execute("get_epistemic_node", input, idempotencyKey);
-    },
-    getEvidence(input = {}, idempotencyKey) {
-      return execute("get_evidence", input, idempotencyKey);
-    },
-    getFailureLog(input = {}, idempotencyKey) {
-      return execute("get_failure_log", input, idempotencyKey);
-    },
-    getFalsificationQuestions(input = {}, idempotencyKey) {
-      return execute("get_falsification_questions", input, idempotencyKey);
-    },
-    getGraphGaps(input = {}, idempotencyKey) {
-      return execute("get_graph_gaps", input, idempotencyKey);
-    },
-    getGraphNeighborhood(input = {}, idempotencyKey) {
-      return execute("get_graph_neighborhood", input, idempotencyKey);
-    },
-    getGraphStructureAnalysis(input = {}, idempotencyKey) {
-      return execute("get_graph_structure_analysis", input, idempotencyKey);
-    },
-    getHighPriorityQuestions(input = {}, idempotencyKey) {
-      return execute("get_high_priority_questions", input, idempotencyKey);
-    },
-    getLatticeCoverage(input = {}, idempotencyKey) {
-      return execute("get_lattice_coverage", input, idempotencyKey);
-    },
-    getObservationContext(input = {}, idempotencyKey) {
-      return execute("get_observation_context", input, idempotencyKey);
-    },
-    getOntology(input = {}, idempotencyKey) {
-      return execute("get_ontology", input, idempotencyKey);
-    },
-    getQuestion(input = {}, idempotencyKey) {
-      return execute("get_question", input, idempotencyKey);
-    },
-    getTopic(input = {}, idempotencyKey) {
-      return execute("get_topic", input, idempotencyKey);
-    },
-    getTopicCoverage(input = {}, idempotencyKey) {
-      return execute("get_topic_coverage", input, idempotencyKey);
-    },
-    getTopicGraphSpine(input = {}, idempotencyKey) {
-      return execute("get_topic_graph_spine", input, idempotencyKey);
-    },
-    getTopicTree(input = {}, idempotencyKey) {
-      return execute("get_topic_tree", input, idempotencyKey);
-    },
-    getWorktree(input = {}, idempotencyKey) {
-      return execute("get_worktree", input, idempotencyKey);
-    },
-    heartbeatSession(input = {}, idempotencyKey) {
-      return execute("heartbeat_session", input, idempotencyKey);
-    },
-    hybridDiscover(input = {}, idempotencyKey) {
-      return execute("hybrid_discover", input, idempotencyKey);
-    },
-    whoami(input = {}, idempotencyKey) {
-      return execute("identity_whoami", input, idempotencyKey);
-    },
-    ingestObservation(input = {}, idempotencyKey) {
-      return execute("ingest_observation", input, idempotencyKey);
-    },
-    linkEvidence(input = {}, idempotencyKey) {
-      return execute("link_evidence", input, idempotencyKey);
-    },
-    linkEvidenceToBelief(input = {}, idempotencyKey) {
-      return execute("link_evidence_to_belief", input, idempotencyKey);
-    },
-    linkEvidenceToQuestion(input = {}, idempotencyKey) {
-      return execute("link_evidence_to_question", input, idempotencyKey);
-    },
-    listActiveSessions(input = {}, idempotencyKey) {
-      return execute("list_active_sessions", input, idempotencyKey);
-    },
-    listAllWorktrees(input = {}, idempotencyKey) {
-      return execute("list_all_worktrees", input, idempotencyKey);
-    },
-    listBeliefs(input = {}, idempotencyKey) {
-      return execute("list_beliefs", input, idempotencyKey);
-    },
-    listCampaigns(input = {}, idempotencyKey) {
-      return execute("list_campaigns", input, idempotencyKey);
-    },
-    listEpistemicNodes(input = {}, idempotencyKey) {
-      return execute("list_epistemic_nodes", input, idempotencyKey);
-    },
-    listEvidence(input = {}, idempotencyKey) {
-      return execute("list_evidence", input, idempotencyKey);
-    },
-    listGraphIntelligenceQueries(input = {}, idempotencyKey) {
-      return execute("list_graph_intelligence_queries", input, idempotencyKey);
-    },
-    listLenses(input = {}, idempotencyKey) {
-      return execute("list_lenses", input, idempotencyKey);
-    },
-    listMissingForTopic(input = {}, idempotencyKey) {
-      return execute("list_missing_embeddings", input, idempotencyKey);
-    },
-    listOntologies(input = {}, idempotencyKey) {
-      return execute("list_ontologies", input, idempotencyKey);
-    },
-    listQuestions(input = {}, idempotencyKey) {
-      return execute("list_questions", input, idempotencyKey);
-    },
-    listTasks(input = {}, idempotencyKey) {
-      return execute("list_tasks", input, idempotencyKey);
-    },
-    listTopics(input = {}, idempotencyKey) {
-      return execute("list_topics", input, idempotencyKey);
-    },
-    listWorktrees(input = {}, idempotencyKey) {
-      return execute("list_worktrees", input, idempotencyKey);
-    },
-    manageWritePolicy(input = {}, idempotencyKey) {
-      return execute("manage_write_policy", input, idempotencyKey);
-    },
-    matchEntityType(input = {}, idempotencyKey) {
-      return execute("match_entity_type", input, idempotencyKey);
-    },
-    materializeTopicGraph(input = {}, idempotencyKey) {
-      return execute("materialize_topic_graph", input, idempotencyKey);
-    },
-    merge(input = {}, idempotencyKey) {
-      return execute("merge", input, idempotencyKey);
-    },
-    modulateConfidence(input = {}, idempotencyKey) {
-      return execute("modulate_confidence", input, idempotencyKey);
-    },
-    openPullRequest(input = {}, idempotencyKey) {
-      return execute("open_pull_request", input, idempotencyKey);
-    },
-    pipelineSnapshot(input = {}, idempotencyKey) {
-      return execute("pipeline_snapshot", input, idempotencyKey);
-    },
-    publishOntologyVersion(input = {}, idempotencyKey) {
-      return execute("publish_ontology_version", input, idempotencyKey);
-    },
-    push(input = {}, idempotencyKey) {
-      return execute("push", input, idempotencyKey);
-    },
-    queryLineage(input = {}, idempotencyKey) {
-      return execute("query_lineage", input, idempotencyKey);
-    },
-    markEmbeddingBackfillQueued(input = {}, idempotencyKey) {
-      return execute("queue_embedding_backfill", input, idempotencyKey);
-    },
-    recordAttempt(input = {}, idempotencyKey) {
-      return execute("record_attempt", input, idempotencyKey);
-    },
-    recordJudgment(input = {}, idempotencyKey) {
-      return execute("record_judgment", input, idempotencyKey);
-    },
-    recordScopeLearning(input = {}, idempotencyKey) {
-      return execute("record_scope_learning", input, idempotencyKey);
-    },
-    refineBelief(input = {}, idempotencyKey) {
-      return execute("refine_belief", input, idempotencyKey);
-    },
-    refineQuestion(input = {}, idempotencyKey) {
-      return execute("refine_question", input, idempotencyKey);
-    },
-    registerSession(input = {}, idempotencyKey) {
-      return execute("register_session", input, idempotencyKey);
-    },
-    removeEdge(input = {}, idempotencyKey) {
-      return execute("remove_edge", input, idempotencyKey);
-    },
-    removeEdgesBetween(input = {}, idempotencyKey) {
-      return execute("remove_edges_between", input, idempotencyKey);
-    },
-    removeLensFromTopic(input = {}, idempotencyKey) {
-      return execute("remove_lens_from_topic", input, idempotencyKey);
-    },
-    resolveEffectiveOntology(input = {}, idempotencyKey) {
-      return execute("resolve_effective_ontology", input, idempotencyKey);
-    },
-    resolveInteractivePrincipal(input = {}, idempotencyKey) {
-      return execute("resolve_interactive_principal", input, idempotencyKey);
-    },
-    resolveTopicSemantic(input = {}, idempotencyKey) {
-      return execute("resolve_topic_semantic", input, idempotencyKey);
-    },
-    runGraphIntelligenceQuery(input = {}, idempotencyKey) {
-      return execute("run_graph_intelligence_query", input, idempotencyKey);
-    },
-    searchBeliefs(input = {}, idempotencyKey) {
-      return execute("search_beliefs", input, idempotencyKey);
-    },
-    vectorSearchByTopic(input = {}, idempotencyKey) {
-      return execute("search_embeddings", input, idempotencyKey);
-    },
-    searchEvidence(input = {}, idempotencyKey) {
-      return execute("search_evidence", input, idempotencyKey);
-    },
-    seedBeliefLattice(input = {}, idempotencyKey) {
-      return execute("seed_belief_lattice", input, idempotencyKey);
-    },
-    sendAgentMessage(input = {}, idempotencyKey) {
-      return execute("send_agent_message", input, idempotencyKey);
-    },
-    supersedeEpistemicNode(input = {}, idempotencyKey) {
-      return execute("supersede_epistemic_node", input, idempotencyKey);
-    },
-    traceEntityImpact(input = {}, idempotencyKey) {
-      return execute("trace_entity_impact", input, idempotencyKey);
-    },
-    traverseGraph(input = {}, idempotencyKey) {
-      return execute("traverse_graph", input, idempotencyKey);
-    },
-    triggerBeliefReview(input = {}, idempotencyKey) {
-      return execute("trigger_belief_review", input, idempotencyKey);
-    },
-    updateEdge(input = {}, idempotencyKey) {
-      return execute("update_edge", input, idempotencyKey);
-    },
-    updateEpistemicNode(input = {}, idempotencyKey) {
-      return execute("update_epistemic_node", input, idempotencyKey);
-    },
-    updateOntology(input = {}, idempotencyKey) {
-      return execute("update_ontology", input, idempotencyKey);
-    },
-    updateQuestionStatus(input = {}, idempotencyKey) {
-      return execute("update_question_status", input, idempotencyKey);
-    },
-    updateTask(input = {}, idempotencyKey) {
-      return execute("update_task", input, idempotencyKey);
-    },
-    updateTopic(input = {}, idempotencyKey) {
-      return execute("update_topic", input, idempotencyKey);
-    },
-    updateWorktreeMetadata(input = {}, idempotencyKey) {
-      return execute("update_worktree_metadata", input, idempotencyKey);
-    },
-    updateWorktreeTargets(input = {}, idempotencyKey) {
-      return execute("update_worktree_targets", input, idempotencyKey);
-    },
-    verifyEpistemicNode(input = {}, idempotencyKey) {
-      return execute("verify_epistemic_node", input, idempotencyKey);
-    }
-  };
-}
-
-export { FUNCTION_SURFACE_METHOD_PATHS, createFunctionSurfaceClient };
-//# sourceMappingURL=functionSurface.js.map
+export * from "./generated/functionSurface.js";
 //# sourceMappingURL=functionSurface.js.map