@kortexya/reasoninglayer 0.8.0 → 0.9.0

package/dist/index.js

@@ -1,5 +1,5 @@
 // src/config.ts
-var SDK_VERSION = "0.8.0";
+var SDK_VERSION = "0.9.0";
 function resolveConfig(config) {
   if (!config.baseUrl) {
     throw new Error("ClientConfig.baseUrl is required");
@@ -13790,6 +13790,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. */
@@ -13882,6 +14286,8 @@ var ReasoningLayerClient = class {
   osfql;
   /** Conversational AI operations (NL → OSFQL with self-correction). */
   conversation;
+  /** Verified scientific research pipeline operations. */
+  research;
   // ─── Group Caches ─────────────────────────────────────────────────
   _core;
   _ai;
@@ -14103,6 +14509,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);
   }
 };
 
@@ -14250,6 +14657,9 @@ var osfql_exports = {};
 // src/types/conversation.ts
 var conversation_exports = {};
 
+// src/types/research.ts
+var research_exports = {};
+
 // src/builders/value.ts
 var Value = {
   /**
@@ -14412,6 +14822,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 };
   }
 };
 
@@ -14643,6 +15324,6 @@ function discriminateFeatureValue(value) {
   );
 }
 
-export { action_reviews_exports as ActionReviews, admin_exports as Admin, analysis_exports as Analysis, ApiError, AuthenticationError, BadRequestError, cdl_exports as CDL, causal_exports as Causal, cognitive_exports as Cognitive, collections_exports as Collections, communities_exports as Communities, ConstraintViolationError, constraints_exports as Constraints, control_exports as Control, conversation_exports as Conversation, discovery_exports as Discovery, execution_exports as Execution, extract_exports as Extract, ForbiddenError, functions_exports as Functions, fuzzy_exports as Fuzzy, FuzzyShape, generation_exports as Generation, health_exports as Health, homoiconic_exports as Homoiconic, ilp_exports as ILP, image_extraction_exports as ImageExtraction, inference_exports as Inference, ingestion_exports as Ingestion, InternalServerError, LP, namespaces_exports as Namespaces, NetworkError, neuro_symbolic_exports as NeuroSymbolic, NotFoundError, ontology_exports as Ontology, optimize_exports as Optimize, osfql_exports as Osfql, oversight_exports as Oversight, plain_values_exports as PlainValues, preferences_exports as Preferences, proof_engine_exports as ProofEngine, query_exports as Query, rag_exports as RAG, RateLimitError, reasoning_exports as Reasoning, ReasoningLayerClient, ReasoningLayerError, reviews_exports as Reviews, row_exports as Row, SDK_VERSION, scenarios_exports as Scenarios, SortBuilder, sorts_exports as Sorts, sources_exports as Sources, spaces_exports as Spaces, statistical_exports as Statistical, synthetic_exports as Synthetic, terms_exports as Terms, TimeoutError, utilities_exports as Utilities, ValidationError, Value, values_exports as Values, visualization_exports as Visualization, WebSocketClient, WebSocketConnection, webhook_actions_exports as WebhookActions, allen, constrained, discriminateFeatureValue, guard, isConstrainedPlainVar, isPsiTermInput, isTaggedValueDto, isUuid, psi, toTaggedFeatures, toTaggedValue, toTermInputDto, toUntaggedFeatures, toUntaggedValue };
+export { action_reviews_exports as ActionReviews, admin_exports as Admin, analysis_exports as Analysis, ApiError, AuthenticationError, BadRequestError, cdl_exports as CDL, causal_exports as Causal, cognitive_exports as Cognitive, collections_exports as Collections, communities_exports as Communities, ConstraintViolationError, constraints_exports as Constraints, control_exports as Control, conversation_exports as Conversation, discovery_exports as Discovery, execution_exports as Execution, extract_exports as Extract, ForbiddenError, functions_exports as Functions, fuzzy_exports as Fuzzy, FuzzyShape, generation_exports as Generation, health_exports as Health, homoiconic_exports as Homoiconic, ilp_exports as ILP, image_extraction_exports as ImageExtraction, inference_exports as Inference, ingestion_exports as Ingestion, InternalServerError, LP, namespaces_exports as Namespaces, NetworkError, neuro_symbolic_exports as NeuroSymbolic, NotFoundError, ontology_exports as Ontology, optimize_exports as Optimize, osfql_exports as Osfql, oversight_exports as Oversight, plain_values_exports as PlainValues, preferences_exports as Preferences, proof_engine_exports as ProofEngine, query_exports as Query, rag_exports as RAG, RateLimitError, reasoning_exports as Reasoning, ReasoningLayerClient, ReasoningLayerError, research_exports as Research, reviews_exports as Reviews, row_exports as Row, SDK_VERSION, scenarios_exports as Scenarios, SortBuilder, sorts_exports as Sorts, sources_exports as Sources, spaces_exports as Spaces, statistical_exports as Statistical, synthetic_exports as Synthetic, terms_exports as Terms, TimeoutError, utilities_exports as Utilities, ValidationError, Value, values_exports as Values, visualization_exports as Visualization, WebSocketClient, WebSocketConnection, webhook_actions_exports as WebhookActions, allen, constrained, discriminateFeatureValue, guard, isConstrainedPlainVar, isPsiTermInput, isTaggedValueDto, isUuid, psi, toTaggedFeatures, toTaggedValue, toTermInputDto, toUntaggedFeatures, toUntaggedValue };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map