@kortexya/reasoninglayer 1.7.1 → 1.8.1

package/dist/index.cjs

@@ -7,7 +7,7 @@ var __export = (target, all) => {
 };
 
 // src/config.ts
-var SDK_VERSION = "1.7.1";
+var SDK_VERSION = "1.8.1";
 function resolveConfig(config) {
   if (!config.baseUrl) {
     throw new Error("ClientConfig.baseUrl is required");
@@ -4356,9 +4356,10 @@ var Reviews = class {
    * @request GET:/api/v1/reviews/pending
    * @secure
    */
-  listPendingReviews = (params = {}) => this.http.request({
+  listPendingReviews = (query, params = {}) => this.http.request({
     path: `/api/v1/reviews/pending`,
     method: "GET",
+    query,
     secure: true,
     format: "json",
     ...params
@@ -5022,6 +5023,31 @@ var Extraction = class {
   });
 };
 
+// src/api-spec/generated/DocumentAnalysis.ts
+var DocumentAnalysis = class {
+  http;
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * No description
+   *
+   * @tags document-analysis
+   * @name AnalyzeDocuments
+   * @request POST:/api/v1/documents/analyze
+   * @secure
+   */
+  analyzeDocuments = (data, params = {}) => this.http.request({
+    path: `/api/v1/documents/analyze`,
+    method: "POST",
+    body: data,
+    secure: true,
+    type: "application/json" /* Json */,
+    format: "json",
+    ...params
+  });
+};
+
 // src/api-spec/generated/Oversight.ts
 var Oversight = class {
   http;
@@ -11784,6 +11810,30 @@ function MarkMessagesReadResponseFromApiToFront(dto) {
     message: dto.message
   };
 }
+function GetInboxRequestFromFrontToApi(model) {
+  return {
+    agent_id: model.agentId,
+    tenant_id: model.tenantId,
+    include_read: model.includeRead
+  };
+}
+function InboxMessageDtoFromApiToFront(dto) {
+  return {
+    messageId: dto.message_id,
+    fromAgentId: dto.from_agent_id,
+    content: dto.content,
+    priority: dto.priority,
+    timestamp: dto.timestamp,
+    read: dto.read
+  };
+}
+function GetInboxResponseFromApiToFront(dto) {
+  return {
+    messages: dto.messages.map(InboxMessageDtoFromApiToFront),
+    unreadCount: dto.unread_count,
+    totalCount: dto.total_count
+  };
+}
 function ProvideFeedbackRequestFromFrontToApi(model) {
   return {
     agent_id: model.agentId,
@@ -11946,6 +11996,25 @@ var CognitiveClient = class {
     this.ws = ws ?? null;
   }
   // --- Agent CRUD ---
+  /**
+   * List all of the tenant's cognitive agents.
+   *
+   * @returns Every agent's basic BDI state (beliefs, goals, pending status).
+   *
+   * @remarks
+   * Uses GET `/api/v1/cognitive/agents`. Lazy-hydrates from the database on the
+   * backend, so agents created by another client/process are included — not just
+   * those created in the current session. Tenant is identified by the
+   * `X-Tenant-Id` header (set automatically).
+   */
+  async listAgents() {
+    const response = await this.api.http.request({
+      path: `/api/v1/cognitive/agents`,
+      method: "GET",
+      format: "json"
+    });
+    return response.data.agents.map(AgentStateDtoFromApiToFront);
+  }
   /**
    * Create a new cognitive agent.
    *
@@ -12173,6 +12242,20 @@ var CognitiveClient = class {
     const response = await this.messaging.markMessagesRead(MarkMessagesReadRequestFromFrontToApi({ ...request, tenantId: this.tenantId }));
     return MarkMessagesReadResponseFromApiToFront(response.data);
   }
+  /**
+   * Get an agent's inbox (messages addressed to it from other agents).
+   *
+   * @param request - Recipient agent ID and whether to include read messages.
+   * @returns The agent's messages with unread/total counts.
+   *
+   * @remarks
+   * Uses POST `/api/v1/cognitive/agents/messages/inbox`. The inbox is per-agent;
+   * aggregate across a roster by calling this for each agent.
+   */
+  async getInbox(request) {
+    const response = await this.messaging.getInbox(GetInboxRequestFromFrontToApi({ ...request, tenantId: this.tenantId }));
+    return GetInboxResponseFromApiToFront(response.data);
+  }
   // --- Feedback ---
   /**
    * Provide feedback on an agent result.
@@ -15342,9 +15425,14 @@ function RejectEntityRequestFromFrontToApi(model) {
 var ReviewsClient = class {
   /** @internal */
   api;
+  /** @internal — tenant scope; forwarded as the `tenant_id` query the
+   * pending-reviews / summary endpoints require (the `X-Tenant-Id` header
+   * alone is not sufficient for these GET routes). */
+  tenantId;
   /** @internal */
-  constructor(api) {
+  constructor(api, tenantId) {
     this.api = api;
+    this.tenantId = tenantId;
   }
   /**
    * Add an entity to the pending review queue.
@@ -15417,12 +15505,16 @@ var ReviewsClient = class {
     return response.data;
   }
   /**
-   * List all pending reviews.
+   * List all pending reviews for the configured tenant.
+   *
+   * `GET /api/v1/reviews/pending` requires `tenant_id` as a query parameter
+   * (the `X-Tenant-Id` header is not honoured for this route), so we forward
+   * the client's tenant scope explicitly — omitting it yields a 400.
    *
    * @returns List of pending review entries.
    */
   async listPending() {
-    const response = await this.api.listPendingReviews();
+    const response = await this.api.listPendingReviews({ tenant_id: this.tenantId });
     return response.data;
   }
   /**
@@ -18421,6 +18513,92 @@ var ExtractClient = class {
   }
 };
 
+// src/normalizers/documents.ts
+function AnalyzeDocumentsRequestFromFrontToApi(model) {
+  return {
+    documents: model.documents.map((d) => ({
+      name: d.name,
+      content: d.content,
+      type_hint: d.typeHint ?? null
+    })),
+    rule_sort_filter: model.ruleSortFilter ?? [],
+    include_proof_traces: model.includeProofTraces ?? true,
+    include_fix_suggestions: model.includeFixSuggestions ?? true,
+    max_rules: model.maxRules ?? 0
+  };
+}
+function mapProofStep(s) {
+  return {
+    stepType: s.step_type ?? "",
+    description: s.description ?? "",
+    confidence: s.confidence ?? 0,
+    ruleUsed: s.rule_used ?? null
+  };
+}
+function mapEntity(e) {
+  return {
+    sortName: e.sort_name ?? "",
+    features: e.features ?? {},
+    confidence: e.confidence ?? 0,
+    sourceText: e.source_text ?? null
+  };
+}
+function mapRuleResult(r) {
+  return {
+    ruleId: r.rule_id ?? "",
+    ruleDescription: r.rule_description ?? "",
+    ruleSort: r.rule_sort ?? "",
+    severity: r.severity ?? "informational",
+    status: r.status ?? "inconclusive",
+    confidence: r.confidence ?? 0,
+    evidence: r.evidence ?? [],
+    proofTrace: r.proof_trace ? r.proof_trace.map(mapProofStep) : null,
+    fixSuggestion: r.fix_suggestion ?? null,
+    relevantExcerpt: r.relevant_excerpt ?? null
+  };
+}
+function mapDocument(d) {
+  return {
+    documentName: d.document_name ?? "",
+    detectedType: d.detected_type ?? null,
+    complianceScore: d.compliance_score ?? 0,
+    ruleResults: (d.rule_results ?? []).map(mapRuleResult),
+    extractedEntities: (d.extracted_entities ?? []).map(mapEntity),
+    summary: d.summary ?? ""
+  };
+}
+function DocumentAnalysisResponseFromApiToFront(dto) {
+  return {
+    documents: dto.documents.map(mapDocument),
+    overallCompliance: dto.overall_compliance,
+    totalRulesEvaluated: dto.total_rules_evaluated,
+    totalRulesPassed: dto.total_rules_passed,
+    totalRulesFailed: dto.total_rules_failed
+  };
+}
+
+// src/resources/documents.ts
+var DocumentsClient = class {
+  /** @internal */
+  api;
+  /** @internal */
+  constructor(api) {
+    this.api = api;
+  }
+  /**
+   * Analyse documents against the knowledge base's compliance rules.
+   *
+   * @param request - Documents (name + content) plus optional rule-sort focus.
+   * @returns Per-document rule results, scores, entities and proof traces.
+   */
+  async analyze(request) {
+    const response = await this.api.analyzeDocuments(
+      AnalyzeDocumentsRequestFromFrontToApi(request)
+    );
+    return DocumentAnalysisResponseFromApiToFront(response.data);
+  }
+};
+
 // src/normalizers/oversight.ts
 function TrajectoryStepDtoFromFrontToApi(model) {
   return {
@@ -22370,6 +22548,42 @@ function UICustomizationDtoFromApiToFront(dto) {
     params: dto.params
   };
 }
+function CognitiveStrategyDtoFromApiToFront(dto) {
+  return {
+    mode: dto.mode,
+    strategy: dto.strategy,
+    rlActive: dto.rl_active
+  };
+}
+function MatchedEntityDtoFromApiToFront2(dto) {
+  return {
+    name: dto.name,
+    sortName: dto.sort_name,
+    termId: dto.term_id ?? void 0,
+    confidence: dto.confidence,
+    matchReason: dto.match_reason
+  };
+}
+function ReasoningStageDtoFromApiToFront(dto) {
+  return {
+    name: dto.name,
+    order: dto.order,
+    kind: dto.kind,
+    sensorPoint: dto.sensor_point ?? void 0,
+    llmUsed: dto.llm_used,
+    confidence: dto.confidence ?? void 0,
+    matchedEntities: dto.matched_entities?.map(MatchedEntityDtoFromApiToFront2) ?? [],
+    osfql: dto.osfql ?? void 0,
+    strategy: dto.strategy ?? void 0,
+    detail: dto.detail ?? void 0
+  };
+}
+function ReasoningTraceDtoFromApiToFront(dto) {
+  return {
+    stages: dto.stages.map(ReasoningStageDtoFromApiToFront),
+    llmCalls: dto.llm_calls
+  };
+}
 function ConversationMessageResponseFromApiToFront(dto) {
   return {
     assistantMessage: dto.assistant_message,
@@ -22385,6 +22599,8 @@ function ConversationMessageResponseFromApiToFront(dto) {
     claimAnnotations: dto.claim_annotations?.map(ClaimAnnotationDtoFromApiToFront) ?? void 0,
     proofTrace: dto.proof_trace ? ProofTraceNodeDtoFromApiToFront(dto.proof_trace) : void 0,
     uiCustomizations: dto.ui_customizations?.map(UICustomizationDtoFromApiToFront) ?? void 0,
+    cognitiveStrategy: dto.cognitive_strategy ? CognitiveStrategyDtoFromApiToFront(dto.cognitive_strategy) : void 0,
+    reasoningTrace: dto.reasoning_trace ? ReasoningTraceDtoFromApiToFront(dto.reasoning_trace) : void 0,
     validityCertificateHash: dto.validity_certificate_hash ?? void 0,
     validityCertificateId: dto.validity_certificate_id ?? void 0
   };
@@ -22599,6 +22815,64 @@ var ConversationClient = class {
   }
 };
 
+// src/normalizers/verification.ts
+function CertificateDetailFromApiToFront(dto) {
+  const wire = dto;
+  const verdict = wire.verdict ?? {};
+  const verdictTag = Object.keys(verdict)[0] ?? "Unknown";
+  const residuated = verdict["Residuated"];
+  return {
+    certificateId: wire.certificate_id,
+    propertyLabel: wire.property_label,
+    method: wire.method ?? void 0,
+    contentSha256Hex: wire.content_sha256_hex,
+    verdict: verdictTag,
+    verdictPartial: typeof residuated?.partial === "number" ? residuated.partial : void 0,
+    ruleProgramHash: wire.rule_program_hash ?? void 0,
+    ruleRevision: wire.rule_revision ?? void 0
+  };
+}
+
+// src/resources/verification.ts
+var VerificationClient = class {
+  /** @internal */
+  http;
+  /** @internal */
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * Fetch a validity certificate by id.
+   *
+   * @param certificateId - The certificate id (an answer's `validityCertificateId`).
+   * @returns The certificate's verdict, content hash, proof method and rule-program pin.
+   * @throws {ApiError} If the certificate is unknown (`404`) or the request fails.
+   *
+   * @remarks
+   * A `404` is expected when the id is a prose-provenance fallback certificate
+   * (not persisted in the verification store) rather than an OSFQL-soundness one —
+   * treat it as "no per-answer certificate available".
+   *
+   * @example
+   * ```typescript
+   * const answer = await client.conversation.sendMessage({ message, generateCertificate: true });
+   * if (answer.validityCertificateId) {
+   *   const cert = await client.verification.getCertificate(answer.validityCertificateId);
+   *   console.log(cert.verdict, cert.contentSha256Hex);
+   * }
+   * ```
+   */
+  async getCertificate(certificateId) {
+    const response = await this.http.request({
+      path: `/api/v1/verification/certificates/${encodeURIComponent(certificateId)}`,
+      method: "GET",
+      secure: true,
+      format: "json"
+    });
+    return CertificateDetailFromApiToFront(response.data);
+  }
+};
+
 // src/resources/research.ts
 var ResearchClient = class {
   /** @internal */
@@ -24954,6 +25228,8 @@ var ReasoningLayerClient = class {
   discovery;
   /** Entity extraction operations. */
   extract;
+  /** Document compliance analysis (check document content against KB rules). */
+  documents;
   /** FormalJudge oversight operations (safety verification, refinement). */
   oversight;
   /** Categorical Deep Learning operations (differentiable FC, soft unification, safety). */
@@ -24994,6 +25270,8 @@ var ReasoningLayerClient = class {
   osfql;
   /** Conversational AI operations (NL → OSFQL with self-correction). */
   conversation;
+  /** Validity-certificate lookup (per-answer soundness seals). */
+  verification;
   /** Verified scientific research pipeline operations. */
   research;
   /** Knowledge graph context assembly operations (LLM prompt building). */
@@ -25175,6 +25453,7 @@ var ReasoningLayerClient = class {
     const generatedActionReviews = new ActionReviews(generatedHttp);
     const generatedDiscovery = new Discovery(generatedHttp);
     const generatedExtraction = new Extraction(generatedHttp);
+    const generatedDocumentAnalysis = new DocumentAnalysis(generatedHttp);
     const generatedOversight = new Oversight(generatedHttp);
     const generatedCdl = new Cdl(generatedHttp);
     const generatedPreferences = new Preferences(generatedHttp);
@@ -25212,7 +25491,7 @@ var ReasoningLayerClient = class {
     this.execution = new ExecutionClient(generatedExecution);
     this.causal = new CausalClient(generatedCausal);
     this.ingestion = new IngestionClient(generatedIngestion);
-    this.reviews = new ReviewsClient(generatedReviews);
+    this.reviews = new ReviewsClient(generatedReviews, resolved.tenantId);
     this.visualization = new VisualizationClient(generatedVisualization);
     this.ilp = new IlpClient(generatedIlp);
     this.reasoning = new ReasoningClient(generatedReasoning);
@@ -25227,6 +25506,7 @@ var ReasoningLayerClient = class {
     this.actionReviews = new ActionReviewsClient(generatedActionReviews, resolved.tenantId);
     this.discovery = new DiscoveryClient(generatedDiscovery);
     this.extract = new ExtractClient(generatedExtraction);
+    this.documents = new DocumentsClient(generatedDocumentAnalysis);
     this.oversight = new OversightClient(generatedOversight);
     this.cdl = new CdlClient(generatedCdl);
     this.neuroSymbolic = new NeuroSymbolicClient(generatedNeuroSymbolic);
@@ -25247,6 +25527,7 @@ var ReasoningLayerClient = class {
     this.flowNetworks = new FlowNetworksClient(new FlowNetworks(generatedHttp));
     this.osfql = new OsfqlClient(generatedOsfql);
     this.conversation = new ConversationClient(generatedHttp);
+    this.verification = new VerificationClient(generatedHttp);
     this.research = new ResearchClient(generatedHttp);
     const generatedContext = new Context(generatedHttp);
     const generatedRlTraining = new RlTraining(generatedHttp);
@@ -25350,6 +25631,9 @@ var discovery_exports = {};
 // src/types/extract.ts
 var extract_exports = {};
 
+// src/types/documents.ts
+var documents_exports = {};
+
 // src/types/oversight.ts
 var oversight_exports = {};
 
@@ -25420,6 +25704,9 @@ var osfql_exports = {};
 // src/types/conversation.ts
 var conversation_exports = {};
 
+// src/types/verification.ts
+var verification_exports = {};
+
 // src/types/compliance.ts
 var compliance_exports = {};
 
@@ -26502,6 +26789,7 @@ exports.Constraints = constraints_exports;
 exports.Control = control_exports;
 exports.Conversation = conversation_exports;
 exports.Discovery = discovery_exports;
+exports.Documents = documents_exports;
 exports.Execution = execution_exports;
 exports.Extract = extract_exports;
 exports.Feasibility = feasibility_exports;
@@ -26562,6 +26850,7 @@ exports.Utilities = utilities_exports;
 exports.ValidationError = ValidationError;
 exports.Value = Value;
 exports.Values = values_exports;
+exports.Verification = verification_exports;
 exports.Visualization = visualization_exports;
 exports.WebSocketClient = WebSocketClient;
 exports.WebSocketConnection = WebSocketConnection;