wauldo 0.6.0 → 0.7.1

package/dist/index.mjs

@@ -864,16 +864,6 @@ async function* parseSSEStream(body) {
 }
 
 // src/http_client.ts
-function concatUint8Arrays(arrays) {
-  const total = arrays.reduce((n, a) => n + a.length, 0);
-  const result = new Uint8Array(total);
-  let offset = 0;
-  for (const a of arrays) {
-    result.set(a, offset);
-    offset += a.length;
-  }
-  return result;
-}
 function validateResponse(data, typeName) {
   if (data === null || data === void 0) {
     throw new ServerError(`Invalid ${typeName}: response is null`, 0);
@@ -1008,51 +998,6 @@ var HttpClient = class {
     );
     return validateResponse(data, "RagUploadResponse");
   }
-  /**
-   * POST /v1/upload-file — Upload a file (PDF, DOCX, text, image) for RAG indexing.
-   *
-   * @param file - File content as Buffer/Uint8Array
-   * @param filename - The filename (determines content type detection)
-   * @param options - Optional title, tags, timeoutMs
-   * @returns Upload confirmation with quality scoring
-   */
-  async uploadFile(file, filename, options) {
-    const boundary = "----WauldoSDKBoundary";
-    const parts = [];
-    const enc = new TextEncoder();
-    parts.push(enc.encode(`--${boundary}\r
-Content-Disposition: form-data; name="file"; filename="${filename}"\r
-Content-Type: application/octet-stream\r
-\r
-`));
-    parts.push(file instanceof Uint8Array ? file : new Uint8Array(file));
-    parts.push(enc.encode("\r\n"));
-    if (options?.title) {
-      parts.push(enc.encode(`--${boundary}\r
-Content-Disposition: form-data; name="title"\r
-\r
-${options.title}\r
-`));
-    }
-    if (options?.tags) {
-      parts.push(enc.encode(`--${boundary}\r
-Content-Disposition: form-data; name="tags"\r
-\r
-${options.tags}\r
-`));
-    }
-    parts.push(enc.encode(`--${boundary}--\r
-`));
-    const body = concatUint8Arrays(parts);
-    const data = await fetchWithRetry(
-      { ...this.retryConfig, headers: { ...this.retryConfig.headers, "Content-Type": `multipart/form-data; boundary=${boundary}` } },
-      "POST",
-      "/v1/upload-file",
-      body,
-      options?.timeoutMs
-    );
-    return validateResponse(data, "UploadFileResponse");
-  }
   /** POST /v1/query — Query RAG knowledge base */
   async ragQuery(query, topK = 5, options) {
     const body = { query, top_k: topK };
@@ -1095,122 +1040,59 @@ ${options.tags}\r
     const result = await this.ragQuery(question, 3);
     return result.answer ?? JSON.stringify(result.sources);
   }
-  // ── Orchestrator endpoints ───────────────────────────────────────────
-  /** POST /v1/orchestrator/execute — Route to best specialist agent */
-  async orchestrate(prompt) {
-    const data = await fetchWithRetry(
-      this.retryConfig,
-      "POST",
-      "/v1/orchestrator/execute",
-      { prompt }
-    );
-    return validateResponse(data, "OrchestratorResponse");
-  }
-  /** POST /v1/orchestrator/parallel — Run all 4 specialists in parallel */
-  async orchestrateParallel(prompt) {
-    const data = await fetchWithRetry(
-      this.retryConfig,
-      "POST",
-      "/v1/orchestrator/parallel",
-      { prompt }
-    );
-    return validateResponse(data, "OrchestratorResponse");
-  }
-  // ── Fact-Check endpoints ──────────────────────────────────────────────
+  // ── Guard (Fact-Check) ─────────────────────────────────────────────
   /**
-   * POST /v1/fact-check — Verify claims against source context.
+   * POST /v1/fact-check — Verify text claims against source context.
+   *
+   * Guard is a hallucination firewall: checks whether LLM output is supported
+   * by source documents. Blocks wrong answers before they reach users.
    *
-   * @param request - Text and source context to verify
-   * @returns FactCheckResponse with verdict, action, and per-claim results
+   * @param text - The LLM-generated text to verify
+   * @param sourceContext - The ground-truth source document(s)
+   * @param mode - "lexical" (<1ms), "hybrid" (~50ms), or "semantic" (~500ms)
+   * @param options - Optional per-request overrides
    *
    * @example
    * ```typescript
-   * const result = await client.factCheck({
-   *   text: 'Returns accepted within 60 days.',
-   *   source_context: 'Our policy allows returns within 14 days.',
-   *   mode: 'lexical',
-   * });
-   * console.log(result.verdict); // "rejected"
+   * const result = await client.guard(
+   *   'Returns accepted within 60 days',
+   *   'Our return policy: 14 days.',
+   * );
+   * if (result.action === 'block') {
+   *   console.log('Hallucination caught:', result.claims[0]?.reason);
+   * }
    * ```
    */
-  async factCheck(request) {
+  async guard(text, sourceContext, mode = "lexical", options) {
     const data = await fetchWithRetry(
       this.retryConfig,
       "POST",
       "/v1/fact-check",
-      request
+      { text, source_context: sourceContext, mode },
+      options?.timeoutMs
     );
-    return validateResponse(data, "FactCheckResponse");
+    return validateResponse(data, "GuardResponse");
   }
-  /**
-   * POST /v1/verify — Verify citations in AI-generated text.
-   *
-   * @example
-   * ```ts
-   * const result = await client.verifyCitation({
-   *   text: 'Rust was released in 2010 [Source: rust_book].',
-   *   sources: [{ name: 'rust_book', content: 'Rust was first released in 2010.' }],
-   * });
-   * console.log(result.phantom_count); // 0
-   * ```
-   */
-  async verifyCitation(request) {
+  // ── Orchestrator endpoints ───────────────────────────────────────────
+  /** POST /v1/orchestrator/execute — Route to best specialist agent */
+  async orchestrate(prompt) {
     const data = await fetchWithRetry(
       this.retryConfig,
       "POST",
-      "/v1/verify",
-      request
-    );
-    return validateResponse(data, "VerifyCitationResponse");
-  }
-  /**
-   * Verify an LLM output against a source document.
-   * Convenience wrapper around factCheck(). Returns a simple safe/unsafe result.
-   */
-  async guard(text, source, mode = "lexical") {
-    const result = await this.factCheck({ text, source_context: source, mode });
-    const claim = result.claims?.[0];
-    return {
-      safe: claim?.verdict === "verified",
-      verdict: claim?.verdict ?? "rejected",
-      action: claim?.action ?? "block",
-      reason: claim?.reason ?? "no_claims",
-      confidence: claim?.confidence ?? 0
-    };
-  }
-  // ── Analytics & Insights endpoints ───────────────────────────────────
-  /**
-   * GET /v1/insights — ROI metrics for your API key
-   */
-  async getInsights() {
-    const data = await fetchWithRetry(
-      this.retryConfig,
-      "GET",
-      "/v1/insights"
-    );
-    return validateResponse(data, "InsightsResponse");
-  }
-  /**
-   * GET /v1/analytics — Usage analytics and cache performance
-   */
-  async getAnalytics(minutes = 60) {
-    const data = await fetchWithRetry(
-      this.retryConfig,
-      "GET",
-      `/v1/analytics?minutes=${minutes}`
+      "/v1/orchestrator/execute",
+      { prompt }
     );
-    return validateResponse(data, "AnalyticsResponse");
+    return validateResponse(data, "OrchestratorResponse");
   }
-  /**
-   * GET /v1/analytics/traffic — Per-tenant traffic monitoring
-   */
-  async getAnalyticsTraffic() {
+  /** POST /v1/orchestrator/parallel — Run all 4 specialists in parallel */
+  async orchestrateParallel(prompt) {
     const data = await fetchWithRetry(
       this.retryConfig,
-      "GET",
-      "/v1/analytics/traffic"
+      "POST",
+      "/v1/orchestrator/parallel",
+      { prompt }
     );
-    return validateResponse(data, "TrafficSummary");
+    return validateResponse(data, "OrchestratorResponse");
   }
 };
 
@@ -1315,132 +1197,6 @@ var MockHttpClient = class {
     this.record("conversation", options);
     return new Conversation(this, options);
   }
-  async uploadFile(_file, filename, options) {
-    this.record("uploadFile", filename, options);
-    return {
-      document_id: "mock-doc-file-1",
-      chunks_count: 5,
-      indexed_at: (/* @__PURE__ */ new Date()).toISOString(),
-      content_type: "application/pdf",
-      trace_id: "mock-trace-1",
-      quality: {
-        score: 0.85,
-        label: "good",
-        word_count: 1200,
-        line_density: 8.5,
-        avg_line_length: 72,
-        paragraph_count: 15
-      }
-    };
-  }
-  async factCheck(request) {
-    this.record("factCheck", request);
-    const hasConflict = request.text !== request.source_context;
-    return {
-      verdict: hasConflict ? "rejected" : "verified",
-      action: hasConflict ? "block" : "allow",
-      hallucination_rate: hasConflict ? 1 : 0,
-      mode: request.mode ?? "lexical",
-      total_claims: 1,
-      supported_claims: hasConflict ? 0 : 1,
-      confidence: hasConflict ? 0.25 : 0.92,
-      claims: [{
-        text: request.text,
-        claim_type: "factual",
-        supported: !hasConflict,
-        confidence: hasConflict ? 0.25 : 0.92,
-        confidence_label: hasConflict ? "low" : "high",
-        verdict: hasConflict ? "rejected" : "verified",
-        action: hasConflict ? "block" : "allow",
-        reason: hasConflict ? "numerical_mismatch" : null,
-        evidence: request.source_context
-      }],
-      processing_time_ms: 1
-    };
-  }
-  async guard(text, source, mode = "lexical") {
-    this.record("guard", text, source, mode);
-    return {
-      safe: true,
-      verdict: "verified",
-      action: "allow",
-      reason: null,
-      confidence: 0.95
-    };
-  }
-  async verifyCitation(request) {
-    this.record("verifyCitation", request);
-    const citations = request.text.match(/\[(?:Source:\s*[^\]]+|\d+|Ref:\s*[^\]]+)\]/g) ?? [];
-    const sentences = request.text.split(/[.!?]+/).filter((s) => s.trim().length > 0);
-    const citedSentences = sentences.filter((s) => /\[(?:Source:\s*[^\]]+|\d+|Ref:\s*[^\]]+)\]/.test(s));
-    const ratio = sentences.length > 0 ? citedSentences.length / sentences.length : 0;
-    return {
-      citation_ratio: ratio,
-      has_sufficient_citations: ratio >= (request.threshold ?? 0.5),
-      sentence_count: sentences.length,
-      citation_count: citations.length,
-      uncited_sentences: sentences.filter((s) => !/\[(?:Source:\s*[^\]]+|\d+|Ref:\s*[^\]]+)\]/.test(s)).map((s) => s.trim()),
-      citations: citations.map((c) => ({
-        citation: c,
-        source_name: c.replace(/[\[\]]/g, "").replace("Source: ", ""),
-        is_valid: (request.sources ?? []).some((src) => c.includes(src.name))
-      })),
-      phantom_count: 0,
-      processing_time_ms: 1
-    };
-  }
-  async getInsights() {
-    this.record("getInsights");
-    return {
-      tig_key: "mock-tig-key",
-      total_requests: 1250,
-      intelligence_requests: 980,
-      fallback_requests: 270,
-      tokens: {
-        baseline_total: 5e5,
-        real_total: 325e3,
-        saved_total: 175e3,
-        saved_percent_avg: 35
-      },
-      cost: {
-        estimated_usd_saved: 12.5
-      }
-    };
-  }
-  async getAnalytics(minutes = 60) {
-    this.record("getAnalytics", minutes);
-    return {
-      cache: {
-        total_requests: 450,
-        cache_hit_rate: 0.42,
-        avg_latency_ms: 180,
-        p95_latency_ms: 850
-      },
-      tokens: {
-        total_baseline: 12e4,
-        total_real: 78e3,
-        total_saved: 42e3,
-        avg_savings_percent: 35
-      },
-      uptime_secs: 86400
-    };
-  }
-  async getAnalyticsTraffic() {
-    this.record("getAnalyticsTraffic");
-    return {
-      total_requests_today: 3200,
-      total_tokens_today: 15e5,
-      top_tenants: [
-        { tenant_id: "tenant-alpha", requests_today: 1200, tokens_used: 58e4, success_rate: 0.98, avg_latency_ms: 220 },
-        { tenant_id: "tenant-beta", requests_today: 850, tokens_used: 42e4, success_rate: 0.96, avg_latency_ms: 310 },
-        { tenant_id: "tenant-gamma", requests_today: 600, tokens_used: 28e4, success_rate: 0.99, avg_latency_ms: 150 }
-      ],
-      error_rate: 0.02,
-      avg_latency_ms: 240,
-      p95_latency_ms: 890,
-      uptime_secs: 86400
-    };
-  }
   async ragAsk(question, text, source = "document") {
     this.record("ragAsk", question, text, source);
     await this.ragUpload(text, source);
@@ -1456,6 +1212,12 @@ var MockHttpClient = class {
 function chatContent(response) {
   return response.choices[0]?.message?.content ?? "";
 }
+function guardIsSafe(response) {
+  return response.verdict === "verified";
+}
+function guardIsBlocked(response) {
+  return response.action === "block";
+}
 export {
   AgentClient,
   ConnectionError,
@@ -1467,5 +1229,7 @@ export {
   ToolNotFoundError,
   ValidationError,
   WauldoError,
-  chatContent
+  chatContent,
+  guardIsBlocked,
+  guardIsSafe
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wauldo",
-  "version": "0.6.0",
+  "version": "0.7.1",
   "description": "Official TypeScript SDK for Wauldo — Verified AI answers from your documents",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",