@lucern/sdk 0.3.0-alpha.1 → 0.3.0-alpha.10

package/dist/functionSurfaceClient.js

@@ -0,0 +1,1204 @@
+// 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 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("")}`;
+}
+var randomIdempotencyKey = generatePortableRequestId;
+function isRetryableStatus(status) {
+  return status >= 500 || status === 408 || status === 429;
+}
+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 parseRetryAfterMs(value) {
+  if (!value) {
+    return null;
+  }
+  const trimmed = value.trim();
+  if (!trimmed) {
+    return null;
+  }
+  const numeric = Number(trimmed);
+  if (Number.isFinite(numeric)) {
+    return Math.max(0, Math.round(numeric * 1e3));
+  }
+  const parsedDate = Date.parse(trimmed);
+  if (Number.isFinite(parsedDate)) {
+    return Math.max(0, parsedDate - Date.now());
+  }
+  return null;
+}
+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 timeoutError(timeoutMs) {
+  const error = new Error(`Request timed out after ${timeoutMs}ms`);
+  error.name = "AbortError";
+  return error;
+}
+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;
+}
+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 createGatewayRequestClient(config = {}) {
+  const fetchImpl = config.fetchImpl ?? fetch;
+  const baseUrl = config.baseUrl?.replace(/\/+$/, "") ?? "";
+  const maxRetries = config.maxRetries ?? 2;
+  const requestIdFactory = config.requestIdFactory ?? (() => generatePortableRequestId());
+  async function resolveAuthHeaders() {
+    const base = config.getAuthHeaders ? await config.getAuthHeaders() : {};
+    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 controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+      return await fetchImpl(url, { ...init, signal: controller.signal });
+    } catch (error) {
+      if (controller.signal.aborted) {
+        throw timeoutError(timeoutMs);
+      }
+      throw error;
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+  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 = config.timeoutMsByMethod?.[method];
+    if (typeof methodTimeoutMs === "number") {
+      return methodTimeoutMs;
+    }
+    return config.timeoutMs ?? 15e3;
+  }
+  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 = 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 retryAfterMs = parseRetryAfterMs(
+          response.headers.get("Retry-After")
+        );
+        if (!response.ok || !payload?.success) {
+          const failure = payload && !payload.success ? payload : null;
+          const apiError = buildApiError({
+            requestId,
+            response,
+            failure
+          });
+          const willRetry = attempt < maxRetries && isRetryableStatus(response.status);
+          await config.onResponse?.({
+            ...hookRequestContext,
+            durationMs: Date.now() - startedAt,
+            status: response.status,
+            response: responseClone,
+            error: apiError,
+            correlationId: apiError.correlationId ?? requestId,
+            policyTraceId: apiError.policyTraceId ?? null,
+            retryAfterMs,
+            willRetry
+          });
+          if (willRetry) {
+            lastError = apiError;
+            await delay(
+              computeRetryDelayMs({
+                attempt,
+                status: response.status,
+                retryAfterMs
+              })
+            );
+            continue;
+          }
+          throw apiError;
+        }
+        const successPayload = payload;
+        await config.onResponse?.({
+          ...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
+        });
+        return successPayload;
+      } catch (fetchError) {
+        if (fetchError instanceof LucernApiError) {
+          throw fetchError;
+        }
+        const willRetry = attempt < maxRetries;
+        await config.onResponse?.({
+          ...hookRequestContext,
+          durationMs: Date.now() - startedAt,
+          error: fetchError,
+          correlationId: requestId,
+          policyTraceId: null,
+          willRetry
+        });
+        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",
+  "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",
+  "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",
+  "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.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_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" },
+  "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" },
+  "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" },
+  "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_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" },
+  "heartbeat_session": { method: "POST", path: "/coordination/heartbeat-session", kind: "mutation", idempotent: true, surfaceIntent: "system" },
+  "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_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" },
+  "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" },
+  "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_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);
+    },
+    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);
+    },
+    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);
+    },
+    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);
+    },
+    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);
+    },
+    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);
+    },
+    heartbeatSession(input = {}, idempotencyKey) {
+      return execute("heartbeat_session", 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);
+    },
+    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);
+    },
+    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);
+    },
+    runGraphIntelligenceQuery(input = {}, idempotencyKey) {
+      return execute("run_graph_intelligence_query", input, idempotencyKey);
+    },
+    searchBeliefs(input = {}, idempotencyKey) {
+      return execute("search_beliefs", 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=functionSurfaceClient.js.map
+//# sourceMappingURL=functionSurfaceClient.js.map