cognitive-modules-cli 2.2.10 → 2.2.12

package/dist/modules/json-extract.d.ts

@@ -0,0 +1,7 @@
+export type JsonExtractStrategy = 'as_is' | 'code_fence' | 'balanced_first' | 'balanced_last';
+export interface JsonExtractResult {
+    json: string;
+    strategy: JsonExtractStrategy;
+}
+export declare function extractJsonCandidates(text: string): JsonExtractResult[];
+export declare function extractJsonCandidate(text: string): JsonExtractResult | null;

package/dist/modules/json-extract.js

@@ -0,0 +1,132 @@
+export function extractJsonCandidates(text) {
+    const raw = String(text ?? '');
+    if (!raw.trim())
+        return [];
+    const out = [];
+    const trimmed = raw.trim();
+    const trimmedLooksJson = looksLikeJson(trimmed);
+    // Candidate 1: treat the entire output as JSON only if it already looks like JSON.
+    if (trimmedLooksJson)
+        out.push({ json: trimmed, strategy: 'as_is' });
+    // Candidate 2: markdown code fences
+    const fence = extractFromCodeFence(raw);
+    if (fence)
+        out.push(fence);
+    // Candidate 3/4: balanced JSON values from the text
+    const first = extractBalancedJson(raw, 'first');
+    if (first)
+        out.push({ json: first, strategy: 'balanced_first' });
+    const last = extractBalancedJson(raw, 'last');
+    if (last)
+        out.push({ json: last, strategy: 'balanced_last' });
+    // Candidate last: as-is, even if it doesn't look like JSON.
+    // This is useful for providers that return a single JSON value with leading/trailing whitespace.
+    if (!trimmedLooksJson)
+        out.push({ json: trimmed, strategy: 'as_is' });
+    // Deduplicate by json string to keep parse attempts small.
+    const seen = new Set();
+    return out.filter((c) => {
+        if (!c.json)
+            return false;
+        if (seen.has(c.json))
+            return false;
+        seen.add(c.json);
+        return true;
+    });
+}
+export function extractJsonCandidate(text) {
+    const raw = String(text ?? '');
+    if (!raw.trim())
+        return null;
+    // 1) If it's already JSON, prefer that.
+    const trimmed = raw.trim();
+    if (looksLikeJson(trimmed))
+        return { json: trimmed, strategy: 'as_is' };
+    // 2) Markdown code fence ```json ... ```
+    const fence = extractFromCodeFence(raw);
+    if (fence)
+        return fence;
+    // 3) Best-effort: find a balanced JSON value in the text.
+    const first = extractBalancedJson(raw, 'first');
+    if (first)
+        return { json: first, strategy: 'balanced_first' };
+    const last = extractBalancedJson(raw, 'last');
+    if (last)
+        return { json: last, strategy: 'balanced_last' };
+    return null;
+}
+function looksLikeJson(s) {
+    const t = s.trim();
+    return (t.startsWith('{') && t.endsWith('}')) || (t.startsWith('[') && t.endsWith(']'));
+}
+function extractFromCodeFence(raw) {
+    // Non-greedy capture; allow "```json" or plain "```".
+    const m = raw.match(/```(?:json)?\s*([\s\S]*?)\s*```/i);
+    if (!m)
+        return null;
+    const json = (m[1] ?? '').trim();
+    if (!json)
+        return null;
+    return { json, strategy: 'code_fence' };
+}
+function extractBalancedJson(raw, mode) {
+    // Cap scanning to avoid pathological memory usage on giant outputs.
+    const maxScan = 256_000;
+    const s = raw.length > maxScan ? raw.slice(0, maxScan) : raw;
+    const starts = [];
+    for (let i = 0; i < s.length; i++) {
+        const ch = s[i];
+        if (ch === '{' || ch === '[')
+            starts.push(i);
+    }
+    if (!starts.length)
+        return null;
+    const order = mode === 'first' ? starts : [...starts].reverse();
+    for (const start of order) {
+        const end = findBalancedEnd(s, start);
+        if (end === -1)
+            continue;
+        const candidate = s.slice(start, end + 1).trim();
+        if (candidate)
+            return candidate;
+    }
+    return null;
+}
+function findBalancedEnd(s, start) {
+    const open = s[start];
+    const close = open === '{' ? '}' : open === '[' ? ']' : '';
+    if (!close)
+        return -1;
+    let depth = 0;
+    let inString = false;
+    let escape = false;
+    for (let i = start; i < s.length; i++) {
+        const ch = s[i];
+        if (inString) {
+            if (escape) {
+                escape = false;
+                continue;
+            }
+            if (ch === '\\\\') {
+                escape = true;
+                continue;
+            }
+            if (ch === '"') {
+                inString = false;
+            }
+            continue;
+        }
+        if (ch === '"') {
+            inString = true;
+            continue;
+        }
+        if (ch === open)
+            depth++;
+        if (ch === close) {
+            depth--;
+            if (depth === 0)
+                return i;
+        }
+    }
+    return -1;
+}

package/dist/modules/runner.d.ts

@@ -3,7 +3,7 @@
  * v2.2: Envelope format with meta/data separation, risk_rule, repair pass
  * v2.2.1: Version field, enhanced error taxonomy, observability hooks, streaming
  */
-import type { Provider, CognitiveModule, ModuleResult, ModuleInput, EnvelopeResponseV22, EnvelopeMeta, RiskLevel, ExecutionPolicy } from '../types.js';
+import type { Provider, StructuredOutputPreference, CognitiveModule, ModuleResult, ModuleInput, EnvelopeResponseV22, EnvelopeMeta, RiskLevel, ExecutionPolicy } from '../types.js';
 /**
  * Validate data against JSON schema. Returns list of errors.
  */
@@ -367,6 +367,11 @@ export interface RunOptions {
     traceId?: string;
     model?: string;
     policy?: ExecutionPolicy;
+    /**
+     * Structured output preference override (CLI/tests).
+     * If omitted, uses policy.structured (or auto).
+     */
+    structured?: StructuredOutputPreference;
 }
 export declare function runModule(module: CognitiveModule, provider: Provider, options?: RunOptions): Promise<ModuleResult>;
 /** Event types emitted during streaming execution */
@@ -396,6 +401,11 @@ export interface StreamOptions {
     traceId?: string;
     model?: string;
     policy?: ExecutionPolicy;
+    /**
+     * Structured output preference override (CLI/tests).
+     * If omitted, uses policy.structured (or auto).
+     */
+    structured?: StructuredOutputPreference;
 }
 /**
  * Run a cognitive module with streaming output.