@kortexya/reasoninglayer 0.7.0 → 0.9.0

package/dist/index.cjs

@@ -1,7 +1,7 @@
 'use strict';
 
 // src/config.ts
-var SDK_VERSION = "0.7.0";
+var SDK_VERSION = "0.9.0";
 function resolveConfig(config) {
   if (!config.baseUrl) {
     throw new Error("ClientConfig.baseUrl is required");
@@ -530,6 +530,28 @@ var HttpClient = class {
 };
 
 // src/serialization.ts
+var USER_DATA_FIELDS = /* @__PURE__ */ new Set([
+  // features — term/query feature maps (Record<string, ValueDto>)
+  "features",
+  // bindings — variable binding maps
+  "bindings",
+  // evidence — causal evidence maps
+  "evidence",
+  // exogenous values — causal intervention values
+  "exogenous_values",
+  "exogenousValues",
+  // modified/suggested params — action review params
+  "modified_params",
+  "modifiedParams",
+  "suggested_params",
+  "suggestedParams",
+  // match key — row matching keys
+  "match_key",
+  "matchKey",
+  // concept values — RAG concept values
+  "concept_values",
+  "conceptValues"
+]);
 function camelToSnake(str) {
   return str.replace(/[A-Z]/g, (letter) => `_${letter.toLowerCase()}`);
 }
@@ -541,6 +563,19 @@ function isPlainObject(value) {
   const proto = Object.getPrototypeOf(value);
   return proto === Object.prototype || proto === null;
 }
+function transformUserDataRecord(input, transformFn) {
+  if (Array.isArray(input)) {
+    return input.map((item) => transformFn(item));
+  }
+  if (!isPlainObject(input)) {
+    return input;
+  }
+  const result = {};
+  for (const key of Object.keys(input)) {
+    result[key] = transformFn(input[key]);
+  }
+  return result;
+}
 function toSnakeCase(input) {
   if (Array.isArray(input)) {
     return input.map((item) => toSnakeCase(item));
@@ -550,7 +585,12 @@ function toSnakeCase(input) {
   }
   const result = {};
   for (const key of Object.keys(input)) {
-    result[camelToSnake(key)] = toSnakeCase(input[key]);
+    const snakeKey = camelToSnake(key);
+    if (USER_DATA_FIELDS.has(key)) {
+      result[snakeKey] = transformUserDataRecord(input[key], toSnakeCase);
+    } else {
+      result[snakeKey] = toSnakeCase(input[key]);
+    }
   }
   return result;
 }
@@ -563,7 +603,12 @@ function toCamelCase(input) {
   }
   const result = {};
   for (const key of Object.keys(input)) {
-    result[snakeToCamel(key)] = toCamelCase(input[key]);
+    const camelKey = snakeToCamel(key);
+    if (USER_DATA_FIELDS.has(key)) {
+      result[camelKey] = transformUserDataRecord(input[key], toCamelCase);
+    } else {
+      result[camelKey] = toCamelCase(input[key]);
+    }
   }
   return result;
 }
@@ -13747,6 +13792,410 @@ var ConversationClient = class {
   }
 };
 
+// src/resources/research.ts
+var ResearchClient = class {
+  /** @internal */
+  http;
+  /** @internal */
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * Create a new research session for a given research question.
+   *
+   * @param request - The research session creation request.
+   * @returns The created session with its ID, status, and creation timestamp.
+   * @throws {ApiError} If the request fails.
+   *
+   * @remarks
+   * Initializes a new research pipeline session. The session starts in
+   * "Created" status and must be advanced by calling {@link runCycle} or
+   * {@link runToCompletion}.
+   *
+   * @example
+   * ```typescript
+   * const session = await client.research.createSession({
+   *   question: 'What are the mechanisms of antibiotic resistance in E. coli?',
+   *   maxCycles: 5,
+   *   maxPapers: 50,
+   *   paperSources: ['PubMed', 'SemanticScholar'],
+   * });
+   * console.log(session.sessionId); // UUID
+   * console.log(session.status);    // "Created"
+   * ```
+   */
+  async createSession(request) {
+    const response = await this.http.request({
+      path: "/api/v1/research/sessions",
+      method: "POST",
+      body: request,
+      secure: true,
+      type: "application/json" /* Json */,
+      format: "json"
+    });
+    return response.data;
+  }
+  /**
+   * Get the current state of a research session.
+   *
+   * @param sessionId - The session ID (UUID).
+   * @returns Full session state including cycles, totals, and timestamps.
+   * @throws {ApiError} If the session does not exist or the request fails.
+   *
+   * @remarks
+   * Returns the complete session state including all completed cycle results,
+   * aggregate counts (papers ingested, findings, contradictions, gaps), and
+   * the current session status.
+   *
+   * @example
+   * ```typescript
+   * const session = await client.research.getSession('session-uuid');
+   * console.log(session.status);              // "Completed"
+   * console.log(session.totalPapersIngested);  // 42
+   * console.log(session.totalFindings);        // 17
+   * console.log(session.cycles.length);        // 3
+   * ```
+   */
+  async getSession(sessionId) {
+    const response = await this.http.request({
+      path: `/api/v1/research/sessions/${encodeURIComponent(sessionId)}`,
+      method: "GET",
+      secure: true,
+      format: "json"
+    });
+    return response.data;
+  }
+  /**
+   * Run a single research cycle within a session.
+   *
+   * @param sessionId - The session ID (UUID).
+   * @param request - Optional parameters for the cycle (additional queries, paper limit).
+   * @returns Cycle results and whether the session has converged.
+   * @throws {ApiError} If the session does not exist or the request fails.
+   *
+   * @remarks
+   * Executes one iteration of the research pipeline: detect knowledge gaps,
+   * generate search queries, retrieve papers, ingest into OSFKB, verify
+   * claims, and detect contradictions. The `converged` field indicates
+   * whether further cycles are needed.
+   *
+   * @example
+   * ```typescript
+   * const result = await client.research.runCycle('session-uuid', {
+   *   additionalQueries: ['beta-lactamase gene transfer'],
+   *   maxPapersThisCycle: 10,
+   * });
+   * console.log(result.cycle.papersIngested);       // 8
+   * console.log(result.cycle.contradictionsDetected); // 1
+   * console.log(result.converged);                    // false
+   * ```
+   */
+  async runCycle(sessionId, request) {
+    const response = await this.http.request({
+      path: `/api/v1/research/sessions/${encodeURIComponent(sessionId)}/run`,
+      method: "POST",
+      body: request,
+      secure: true,
+      type: "application/json" /* Json */,
+      format: "json"
+    });
+    return response.data;
+  }
+  /**
+   * Run the research session to completion (all remaining cycles).
+   *
+   * @param sessionId - The session ID (UUID).
+   * @returns Final session state after all cycles have completed.
+   * @throws {ApiError} If the session does not exist or the request fails.
+   *
+   * @remarks
+   * Runs cycles until convergence (no new knowledge gaps) or the maximum
+   * cycle count is reached. This may take significant time depending on
+   * the research question complexity and paper availability.
+   *
+   * @example
+   * ```typescript
+   * const session = await client.research.runToCompletion('session-uuid');
+   * console.log(session.status);              // "Completed"
+   * console.log(session.totalPapersIngested);  // 47
+   * console.log(session.cycles.length);        // 4
+   * ```
+   */
+  async runToCompletion(sessionId) {
+    const response = await this.http.request({
+      path: `/api/v1/research/sessions/${encodeURIComponent(sessionId)}/complete`,
+      method: "POST",
+      secure: true,
+      format: "json"
+    });
+    return response.data;
+  }
+  /**
+   * Delete a research session and all associated data.
+   *
+   * @param sessionId - The session ID (UUID) to delete.
+   * @throws {ApiError} If the session does not exist or the request fails.
+   *
+   * @remarks
+   * Permanently removes the session, its cycles, findings, gaps, and
+   * contradictions. This operation cannot be undone.
+   *
+   * @example
+   * ```typescript
+   * await client.research.deleteSession('session-uuid');
+   * ```
+   */
+  async deleteSession(sessionId) {
+    await this.http.request({
+      path: `/api/v1/research/sessions/${encodeURIComponent(sessionId)}`,
+      method: "DELETE",
+      secure: true
+    });
+  }
+  /**
+   * Get verified findings for a research session.
+   *
+   * @param sessionId - The session ID (UUID).
+   * @returns Findings with evidence assessments, provenance chains, and residuation status.
+   * @throws {ApiError} If the session does not exist or the request fails.
+   *
+   * @remarks
+   * Returns all claims that have been verified through evidence assessment.
+   * Each finding includes supporting and contradicting evidence items,
+   * a truthfulness score, and the full provenance chain from paper to claim.
+   *
+   * @example
+   * ```typescript
+   * const { findings, total } = await client.research.getFindings('session-uuid');
+   * for (const finding of findings) {
+   *   console.log(`${finding.statement}: ${finding.label} (${finding.truthfulness})`);
+   *   console.log(`  Supporting: ${finding.supportingEvidence.length}`);
+   *   console.log(`  Contradicting: ${finding.contradictingEvidence.length}`);
+   * }
+   * ```
+   */
+  async getFindings(sessionId) {
+    const response = await this.http.request({
+      path: `/api/v1/research/sessions/${encodeURIComponent(sessionId)}/findings`,
+      method: "GET",
+      secure: true,
+      format: "json"
+    });
+    return response.data;
+  }
+  /**
+   * Get knowledge gaps for a research session.
+   *
+   * @param sessionId - The session ID (UUID).
+   * @returns Knowledge gaps with information gain scores and suggested queries.
+   * @throws {ApiError} If the session does not exist or the request fails.
+   *
+   * @remarks
+   * Returns sorts that are needed by rule heads but have no matching facts,
+   * identified via goal residuation. Each gap includes the information gain
+   * score, the rules that need it, and a suggested search query to resolve it.
+   *
+   * @example
+   * ```typescript
+   * const { gaps, total } = await client.research.getGaps('session-uuid');
+   * for (const gap of gaps) {
+   *   console.log(`Missing: ${gap.sortName} (info gain: ${gap.infoGain})`);
+   *   console.log(`  Needed by: ${gap.neededBy.join(', ')}`);
+   *   if (gap.suggestedSearchQuery) {
+   *     console.log(`  Suggested query: ${gap.suggestedSearchQuery}`);
+   *   }
+   * }
+   * ```
+   */
+  async getGaps(sessionId) {
+    const response = await this.http.request({
+      path: `/api/v1/research/sessions/${encodeURIComponent(sessionId)}/gaps`,
+      method: "GET",
+      secure: true,
+      format: "json"
+    });
+    return response.data;
+  }
+  /**
+   * Get detected contradictions for a research session.
+   *
+   * @param sessionId - The session ID (UUID).
+   * @returns Contradictions with claim pairs, confidence scores, and explanations.
+   * @throws {ApiError} If the session does not exist or the request fails.
+   *
+   * @remarks
+   * Returns pairs of claims where disentailment has been detected. Each
+   * contradiction includes both claim statements, a confidence score, and
+   * an explanation of the logical conflict.
+   *
+   * @example
+   * ```typescript
+   * const { contradictions, total } = await client.research.getContradictions('session-uuid');
+   * for (const c of contradictions) {
+   *   console.log(`Contradiction (confidence: ${c.confidence}):`);
+   *   console.log(`  A: ${c.statementA}`);
+   *   console.log(`  B: ${c.statementB}`);
+   *   console.log(`  Explanation: ${c.explanation}`);
+   * }
+   * ```
+   */
+  async getContradictions(sessionId) {
+    const response = await this.http.request({
+      path: `/api/v1/research/sessions/${encodeURIComponent(sessionId)}/contradictions`,
+      method: "GET",
+      secure: true,
+      format: "json"
+    });
+    return response.data;
+  }
+  /**
+   * Get the full research report for a session.
+   *
+   * @param sessionId - The session ID (UUID).
+   * @returns Complete report with findings, gaps, contradictions, statistics, and verification.
+   * @throws {ApiError} If the session does not exist or the request fails.
+   *
+   * @remarks
+   * Generates and returns a comprehensive research report including the
+   * executive summary, all verified findings, unresolved knowledge gaps,
+   * detected contradictions, research statistics, and an optional
+   * FormalJudge verification result.
+   *
+   * @example
+   * ```typescript
+   * const report = await client.research.getReport('session-uuid');
+   * console.log(report.summary);
+   * console.log(`Findings: ${report.findings.length}`);
+   * console.log(`Gaps: ${report.knowledgeGaps.length}`);
+   * console.log(`Contradictions: ${report.contradictions.length}`);
+   * if (report.verification) {
+   *   console.log(`Verdict: ${report.verification.verdict} (${report.verification.score})`);
+   * }
+   * ```
+   */
+  async getReport(sessionId) {
+    const response = await this.http.request({
+      path: `/api/v1/research/sessions/${encodeURIComponent(sessionId)}/report`,
+      method: "GET",
+      secure: true,
+      format: "json"
+    });
+    return response.data;
+  }
+  /**
+   * Search for papers across external scientific databases.
+   *
+   * @param request - Search parameters including query, max results, and source filters.
+   * @returns Search results with paper metadata and relevance scores.
+   * @throws {ApiError} If the request fails.
+   *
+   * @remarks
+   * Queries external paper databases (PubMed, Semantic Scholar, CrossRef, arXiv)
+   * and returns unified results with relevance scores. Results are not
+   * automatically ingested — use {@link ingestPaper} to add specific papers
+   * to the knowledge base.
+   *
+   * @example
+   * ```typescript
+   * const { results, totalFound } = await client.research.searchPapers({
+   *   query: 'CRISPR gene editing efficiency',
+   *   maxResults: 20,
+   *   sources: ['PubMed', 'SemanticScholar'],
+   * });
+   * console.log(`Found ${totalFound} papers, returning ${results.length}`);
+   * for (const r of results) {
+   *   console.log(`${r.metadata.title} (${r.metadata.year}) — score: ${r.relevanceScore}`);
+   * }
+   * ```
+   */
+  async searchPapers(request) {
+    const response = await this.http.request({
+      path: "/api/v1/research/papers/search",
+      method: "POST",
+      body: request,
+      secure: true,
+      type: "application/json" /* Json */,
+      format: "json"
+    });
+    return response.data;
+  }
+  /**
+   * Ingest a specific paper into the knowledge base.
+   *
+   * @param request - Paper identifier and type, with optional session association.
+   * @returns Ingestion result with metadata and extraction counts.
+   * @throws {ApiError} If the request fails.
+   *
+   * @remarks
+   * Retrieves the paper by its identifier (DOI, PMID, arXiv ID, or URL),
+   * extracts entities and claims, and ingests them into the OSFKB. If a
+   * session ID is provided, the ingested data is associated with that
+   * research session.
+   *
+   * @example
+   * ```typescript
+   * const result = await client.research.ingestPaper({
+   *   identifier: '10.1038/s41586-023-06004-9',
+   *   identifierType: 'doi',
+   *   sessionId: 'session-uuid',
+   * });
+   * if (result.success) {
+   *   console.log(`Extracted ${result.entitiesExtracted} entities`);
+   *   console.log(`Extracted ${result.claimsExtracted} claims`);
+   * }
+   * ```
+   */
+  async ingestPaper(request) {
+    const response = await this.http.request({
+      path: "/api/v1/research/papers/ingest",
+      method: "POST",
+      body: request,
+      secure: true,
+      type: "application/json" /* Json */,
+      format: "json"
+    });
+    return response.data;
+  }
+  /**
+   * Verify a specific claim against evidence in the knowledge base.
+   *
+   * @param request - Claim term ID and evidence sort ID.
+   * @returns Verification result with truthfulness score and evidence counts.
+   * @throws {ApiError} If the request fails.
+   *
+   * @remarks
+   * Runs evidence assessment on a single claim by collecting all evidence
+   * of the specified sort and computing a truthfulness score. The result
+   * includes the assessment label, counts of supporting/contradicting
+   * evidence, and residuation status if insufficient evidence exists.
+   *
+   * @example
+   * ```typescript
+   * const result = await client.research.verifyClaim({
+   *   claimTermId: 'claim-term-uuid',
+   *   evidenceSortId: 'evidence-sort-uuid',
+   * });
+   * console.log(`Truthfulness: ${result.truthfulness}`);
+   * console.log(`Label: ${result.label}`);
+   * console.log(`Supporting: ${result.supportingCount}, Contradicting: ${result.contradictingCount}`);
+   * if (result.residuated) {
+   *   console.log(`Residuated: ${result.residuationReason}`);
+   * }
+   * ```
+   */
+  async verifyClaim(request) {
+    const response = await this.http.request({
+      path: "/api/v1/research/claims/verify",
+      method: "POST",
+      body: request,
+      secure: true,
+      type: "application/json" /* Json */,
+      format: "json"
+    });
+    return response.data;
+  }
+};
+
 // src/client.ts
 var ReasoningLayerClient = class {
   /** Sort (type hierarchy) operations. */
@@ -13839,6 +14288,8 @@ var ReasoningLayerClient = class {
   osfql;
   /** Conversational AI operations (NL → OSFQL with self-correction). */
   conversation;
+  /** Verified scientific research pipeline operations. */
+  research;
   // ─── Group Caches ─────────────────────────────────────────────────
   _core;
   _ai;
@@ -14060,6 +14511,7 @@ var ReasoningLayerClient = class {
     this.optimize = new OptimizeClient(generatedInference, generatedSorts, generatedQuery, generatedTerms, resolved.tenantId);
     this.osfql = new OsfqlClient(generatedOsfql);
     this.conversation = new ConversationClient(generatedHttp);
+    this.research = new ResearchClient(generatedHttp);
   }
 };
 
@@ -14207,6 +14659,9 @@ var osfql_exports = {};
 // src/types/conversation.ts
 var conversation_exports = {};
 
+// src/types/research.ts
+var research_exports = {};
+
 // src/builders/value.ts
 var Value = {
   /**
@@ -14369,6 +14824,277 @@ var FuzzyShape = {
    */
   cyclicGaussian(mean, stdDev, period) {
     return { kind: "CyclicGaussian", mean, stdDev, period };
+  },
+  /**
+   * Create a sigmoid (logistic) fuzzy membership function.
+   *
+   * Monotonic S-curve transition: `μ(x) = 1 / (1 + exp(-steepness * (x - midpoint)))`.
+   * Positive steepness = increasing, negative = decreasing.
+   *
+   * @param midpoint - The x-value where membership = 0.5 (inflection point).
+   * @param steepness - Controls transition sharpness. Positive = left-to-right rise.
+   * @returns A `SigmoidShape`.
+   *
+   * @remarks
+   * Serialization format: Tagged by `"kind"` (FuzzyShapeDto).
+   *
+   * @example
+   * ```typescript
+   * // DNA match confidence: sharp transition around 95%
+   * FuzzyShape.sigmoid(0.95, 20)
+   * // {"kind": "Sigmoid", "midpoint": 0.95, "steepness": 20}
+   * ```
+   */
+  sigmoid(midpoint, steepness) {
+    return { kind: "Sigmoid", midpoint, steepness };
+  },
+  /**
+   * Create a generalized bell fuzzy membership function.
+   *
+   * Tunable flat-top bell: `μ(x) = 1 / (1 + |((x - center) / width)|^(2*slope))`.
+   * Unlike Gaussian, the slope controls how sharply the curve drops off.
+   *
+   * @param center - Center of the bell (membership = 1).
+   * @param width - Half-width of the bell at the crossover point.
+   * @param slope - Controls steepness of the sides. Higher = sharper edges.
+   * @returns A `BellShape`.
+   *
+   * @remarks
+   * Serialization format: Tagged by `"kind"` (FuzzyShapeDto).
+   *
+   * @example
+   * ```typescript
+   * FuzzyShape.bell(100, 15, 3)
+   * // {"kind": "Bell", "center": 100, "width": 15, "slope": 3}
+   * ```
+   */
+  bell(center, width, slope) {
+    return { kind: "Bell", center, width, slope };
+  },
+  /**
+   * Create a sigmoid difference fuzzy membership function.
+   *
+   * Difference of two sigmoids: creates a smooth bounded region (like a smooth trapezoidal).
+   * `μ(x) = sigmoid(x, midpoint1, steepness1) - sigmoid(x, midpoint2, steepness2)`.
+   *
+   * @param midpoint1 - Left transition inflection point.
+   * @param steepness1 - Left transition sharpness (positive = rising).
+   * @param midpoint2 - Right transition inflection point.
+   * @param steepness2 - Right transition sharpness (positive = falling).
+   * @returns A `SigmoidDifferenceShape`.
+   *
+   * @remarks
+   * Serialization format: Tagged by `"kind"` (FuzzyShapeDto).
+   *
+   * @example
+   * ```typescript
+   * // Smooth region between pH 6.5 and 7.5
+   * FuzzyShape.sigmoidDifference(6.5, 10, 7.5, 10)
+   * // {"kind": "SigmoidDifference", "midpoint1": 6.5, "steepness1": 10, "midpoint2": 7.5, "steepness2": 10}
+   * ```
+   */
+  sigmoidDifference(midpoint1, steepness1, midpoint2, steepness2) {
+    return { kind: "SigmoidDifference", midpoint1, steepness1, midpoint2, steepness2 };
+  },
+  /**
+   * Create a Gaussian product (gauss2mf) fuzzy membership function.
+   *
+   * Asymmetric flat-top bell: left Gaussian up to mean1, flat 1.0 in [mean1, mean2],
+   * right Gaussian after mean2.
+   *
+   * @param mean1 - Left Gaussian center.
+   * @param stdDev1 - Left Gaussian standard deviation.
+   * @param mean2 - Right Gaussian center.
+   * @param stdDev2 - Right Gaussian standard deviation.
+   * @returns A `GaussianProductShape`.
+   *
+   * @remarks
+   * Serialization format: Tagged by `"kind"` (FuzzyShapeDto).
+   *
+   * @example
+   * ```typescript
+   * FuzzyShape.gaussianProduct(36.5, 0.3, 37.5, 0.2)
+   * // {"kind": "GaussianProduct", "mean1": 36.5, "stdDev1": 0.3, "mean2": 37.5, "stdDev2": 0.2}
+   * ```
+   */
+  gaussianProduct(mean1, stdDev1, mean2, stdDev2) {
+    return { kind: "GaussianProduct", mean1, stdDev1, mean2, stdDev2 };
+  },
+  /**
+   * Create a sigmoid product fuzzy membership function.
+   *
+   * Product of two sigmoids: `μ(x) = sigmoid(x, midpoint1, steepness1) * sigmoid(x, midpoint2, steepness2)`.
+   * Always non-negative (unlike {@link sigmoidDifference}).
+   *
+   * @param midpoint1 - First sigmoid inflection point.
+   * @param steepness1 - First sigmoid sharpness.
+   * @param midpoint2 - Second sigmoid inflection point.
+   * @param steepness2 - Second sigmoid sharpness.
+   * @returns A `SigmoidProductShape`.
+   *
+   * @remarks
+   * Serialization format: Tagged by `"kind"` (FuzzyShapeDto).
+   *
+   * @example
+   * ```typescript
+   * FuzzyShape.sigmoidProduct(6.5, 10, 7.5, -10)
+   * // {"kind": "SigmoidProduct", "midpoint1": 6.5, "steepness1": 10, "midpoint2": 7.5, "steepness2": -10}
+   * ```
+   */
+  sigmoidProduct(midpoint1, steepness1, midpoint2, steepness2) {
+    return { kind: "SigmoidProduct", midpoint1, steepness1, midpoint2, steepness2 };
+  },
+  /**
+   * Create a cosine fuzzy membership function with compact support.
+   *
+   * `μ(x) = 0.5 * (1 + cos(2π/width * (x - center)))` for `|x - center| <= width/2`,
+   * `μ(x) = 0` otherwise.
+   *
+   * @param center - Center of the cosine curve (membership = 1).
+   * @param width - Full width of the support region.
+   * @returns A `CosineShape`.
+   *
+   * @remarks
+   * Serialization format: Tagged by `"kind"` (FuzzyShapeDto).
+   *
+   * @example
+   * ```typescript
+   * FuzzyShape.cosine(50, 10)
+   * // {"kind": "Cosine", "center": 50, "width": 10}
+   * ```
+   */
+  cosine(center, width) {
+    return { kind: "Cosine", center, width };
+  },
+  /**
+   * Create a spike (Laplacian/double-exponential) fuzzy membership function.
+   *
+   * `μ(x) = exp(-|x - center| / width)`. Sharp cusp at center with exponential tails.
+   *
+   * @param center - Peak of the spike (membership = 1).
+   * @param width - Controls the rate of exponential decay.
+   * @returns A `SpikeShape`.
+   *
+   * @remarks
+   * Serialization format: Tagged by `"kind"` (FuzzyShapeDto).
+   *
+   * @example
+   * ```typescript
+   * FuzzyShape.spike(100, 5)
+   * // {"kind": "Spike", "center": 100, "width": 5}
+   * ```
+   */
+  spike(center, width) {
+    return { kind: "Spike", center, width };
+  },
+  /**
+   * Create a Cauchy (Lorentzian) fuzzy membership function.
+   *
+   * `μ(x) = 1 / (1 + ((x - center) / gamma)^2)`. Heavy-tailed bell whose tails never reach zero.
+   *
+   * @param center - Center of the Cauchy curve (membership = 1).
+   * @param gamma - Half-width at half-maximum, controlling the spread.
+   * @returns A `CauchyShape`.
+   *
+   * @remarks
+   * Serialization format: Tagged by `"kind"` (FuzzyShapeDto).
+   *
+   * @example
+   * ```typescript
+   * FuzzyShape.cauchy(0, 1)
+   * // {"kind": "Cauchy", "center": 0, "gamma": 1}
+   * ```
+   */
+  cauchy(center, gamma) {
+    return { kind: "Cauchy", center, gamma };
+  },
+  /**
+   * Create an S-shaped (smf) fuzzy membership function.
+   *
+   * Smooth monotonic spline from 0 to 1 using piecewise quadratic.
+   * Reaches exact 0 and 1 (unlike {@link sigmoid}).
+   *
+   * @param a - Foot: x-value where membership starts rising from 0.
+   * @param b - Shoulder: x-value where membership reaches 1.
+   * @returns An `SShapeShape`.
+   *
+   * @remarks
+   * Serialization format: Tagged by `"kind"` (FuzzyShapeDto).
+   *
+   * @example
+   * ```typescript
+   * FuzzyShape.sShape(20, 80)
+   * // {"kind": "SShape", "a": 20, "b": 80}
+   * ```
+   */
+  sShape(a, b) {
+    return { kind: "SShape", a, b };
+  },
+  /**
+   * Create a Z-shaped (zmf) fuzzy membership function.
+   *
+   * Mirror of {@link sShape}. Smooth monotonic spline from 1 to 0
+   * using piecewise quadratic.
+   *
+   * @param a - Shoulder: x-value where membership starts falling from 1.
+   * @param b - Foot: x-value where membership reaches 0.
+   * @returns A `ZShapeShape`.
+   *
+   * @remarks
+   * Serialization format: Tagged by `"kind"` (FuzzyShapeDto).
+   *
+   * @example
+   * ```typescript
+   * FuzzyShape.zShape(20, 80)
+   * // {"kind": "ZShape", "a": 20, "b": 80}
+   * ```
+   */
+  zShape(a, b) {
+    return { kind: "ZShape", a, b };
+  },
+  /**
+   * Create a Pi-shaped (pimf) fuzzy membership function.
+   *
+   * Smooth flat-top bump: `μ(x) = SShape(x, a, b) * ZShape(x, c, d)`.
+   * Like a smooth trapezoidal.
+   *
+   * @param a - Left foot (SShape start).
+   * @param b - Left shoulder (SShape end).
+   * @param c - Right shoulder (ZShape start).
+   * @param d - Right foot (ZShape end).
+   * @returns A `PiShapeShape`.
+   *
+   * @remarks
+   * Serialization format: Tagged by `"kind"` (FuzzyShapeDto).
+   *
+   * @example
+   * ```typescript
+   * FuzzyShape.piShape(10, 20, 60, 80)
+   * // {"kind": "PiShape", "a": 10, "b": 20, "c": 60, "d": 80}
+   * ```
+   */
+  piShape(a, b, c, d) {
+    return { kind: "PiShape", a, b, c, d };
+  },
+  /**
+   * Create a piecewise linear fuzzy membership function.
+   *
+   * Membership is linearly interpolated between the provided (x, mu) data points.
+   *
+   * @param points - Array of `[x, mu]` tuples defining the membership function.
+   * @returns A `PiecewiseLinearShape`.
+   *
+   * @remarks
+   * Serialization format: Tagged by `"kind"` (FuzzyShapeDto).
+   *
+   * @example
+   * ```typescript
+   * FuzzyShape.piecewiseLinear([[0, 0], [0.5, 1], [1, 0]])
+   * // {"kind": "PiecewiseLinear", "points": [[0, 0], [0.5, 1], [1, 0]]}
+   * ```
+   */
+  piecewiseLinear(points) {
+    return { kind: "PiecewiseLinear", points };
   }
 };
 
@@ -14648,6 +15374,7 @@ exports.RateLimitError = RateLimitError;
 exports.Reasoning = reasoning_exports;
 exports.ReasoningLayerClient = ReasoningLayerClient;
 exports.ReasoningLayerError = ReasoningLayerError;
+exports.Research = research_exports;
 exports.Reviews = reviews_exports;
 exports.Row = row_exports;
 exports.SDK_VERSION = SDK_VERSION;