nexus-ai-pro 2.3.0 → 2.4.0

package/dist/protocols/ag-ui.js

@@ -0,0 +1,180 @@
+import { answerOf, asText, messageOf, protocolId, textOf, toolCallOf, } from './shared.js';
+export function agUiMessages(messages) {
+    const converted = [];
+    for (const message of messages) {
+        if (!['user', 'assistant', 'system', 'developer', 'tool'].includes(message.role))
+            continue;
+        const content = textOf(message.content);
+        converted.push(messageOf(message.role, content, {
+            ...(message.toolCalls?.length ? { toolCalls: message.toolCalls } : {}),
+            ...(message.role === 'tool' && message.toolCallId ? { toolCallId: message.toolCallId } : {}),
+        }));
+    }
+    return converted;
+}
+export async function* agUiEvents(graph, run, options = {}) {
+    const queue = [];
+    let wake;
+    let done = false;
+    const push = (event) => {
+        queue.push({ ...event, timestamp: Date.now() });
+        wake?.();
+    };
+    const translate = translator(push);
+    push({
+        type: 'RUN_STARTED',
+        threadId: run.threadId,
+        runId: run.runId,
+        ...(run.parentRunId ? { parentRunId: run.parentRunId } : {}),
+    });
+    const runOptions = {
+        threadId: run.threadId,
+        onEvent: translate.event,
+        ...(options.signal ? { signal: options.signal } : {}),
+        ...(options.principal ? { principal: options.principal } : {}),
+    };
+    const finished = (async () => {
+        try {
+            let result;
+            if (run.resume?.length) {
+                const answer = options.answer ??
+                    ((entry) => (entry.status === 'cancelled' ? false : (entry.payload ?? true)));
+                result = await graph.resumeInterruptsWith(run.threadId, Object.fromEntries(run.resume.map((entry) => [entry.interruptId, answer(entry)])), runOptions);
+            }
+            else {
+                const messages = agUiMessages(run.messages);
+                result = await graph.invoke(options.input ? options.input(run, messages) : { messages }, runOptions);
+            }
+            translate.close();
+            if (options.stateSnapshot !== false)
+                push({ type: 'STATE_SNAPSHOT', snapshot: result.state });
+            push(finishedEvent(run, result));
+        }
+        catch (error) {
+            translate.close();
+            push({
+                type: 'RUN_ERROR',
+                message: error instanceof Error ? error.message : String(error),
+                ...(error?.code ? { code: String(error.code) } : {}),
+            });
+        }
+        finally {
+            done = true;
+            wake?.();
+        }
+    })();
+    while (true) {
+        if (queue.length > 0) {
+            yield queue.shift();
+            continue;
+        }
+        if (done)
+            break;
+        await new Promise((resolve) => {
+            wake = resolve;
+        });
+        wake = undefined;
+    }
+    await finished;
+}
+export function agUiHandler(graph, options = {}) {
+    return async (request) => {
+        if (request.method !== 'POST')
+            return new Response('AG-UI runs are POSTed', { status: 405, headers: { allow: 'POST' } });
+        let run;
+        try {
+            run = (await request.json());
+        }
+        catch {
+            return new Response('The body is not a RunAgentInput', { status: 400 });
+        }
+        if (typeof run?.threadId !== 'string' || (!Array.isArray(run.messages) && !run.resume)) {
+            return new Response('A RunAgentInput needs a threadId and messages', { status: 400 });
+        }
+        run = { ...run, runId: run.runId || protocolId('run'), messages: run.messages ?? [] };
+        const caller = await options.principal?.(request);
+        const encoder = new TextEncoder();
+        const body = new ReadableStream({
+            async start(controller) {
+                const { principal: _resolve, ...rest } = options;
+                for await (const event of agUiEvents(graph, run, {
+                    ...rest,
+                    signal: request.signal,
+                    ...(caller ? { principal: caller } : {}),
+                })) {
+                    controller.enqueue(encoder.encode(encodeAgUiEvent(event)));
+                }
+                controller.close();
+            },
+        });
+        return new Response(body, {
+            headers: { 'content-type': 'text/event-stream', 'cache-control': 'no-cache', connection: 'keep-alive' },
+        });
+    };
+}
+export function encodeAgUiEvent(event) {
+    return `data: ${JSON.stringify(event)}\n\n`;
+}
+function translator(push) {
+    let open;
+    const closeMessage = () => {
+        if (open)
+            push({ type: 'TEXT_MESSAGE_END', messageId: open });
+        open = undefined;
+    };
+    return {
+        event(event) {
+            if (event.type === 'task_start' && !event.namespace)
+                push({ type: 'STEP_STARTED', stepName: event.node });
+            else if (event.type === 'task_end' && !event.namespace) {
+                closeMessage();
+                push({ type: 'STEP_FINISHED', stepName: event.node });
+            }
+            else if (event.type === 'message' && event.chunk.kind !== 'reasoning' && event.chunk.content) {
+                const messageId = event.chunk.messageId ?? `${event.taskId}:${event.step}`;
+                if (open !== messageId) {
+                    closeMessage();
+                    open = messageId;
+                    push({ type: 'TEXT_MESSAGE_START', messageId, role: 'assistant' });
+                }
+                push({ type: 'TEXT_MESSAGE_CONTENT', messageId, delta: event.chunk.content });
+            }
+            else if (event.type === 'tool') {
+                closeMessage();
+                const tool = event.tool;
+                if (tool.phase === 'start') {
+                    push({ type: 'TOOL_CALL_START', toolCallId: tool.id, toolCallName: tool.name });
+                    push({ type: 'TOOL_CALL_ARGS', toolCallId: tool.id, delta: asText(tool.args ?? {}) });
+                    push({ type: 'TOOL_CALL_END', toolCallId: tool.id });
+                }
+                else if (tool.phase === 'result' || tool.phase === 'error') {
+                    push({
+                        type: 'TOOL_CALL_RESULT',
+                        messageId: `${tool.id}:result`,
+                        toolCallId: tool.id,
+                        role: 'tool',
+                        content: tool.phase === 'result' ? asText(tool.result) : (tool.error ?? 'The tool failed'),
+                    });
+                }
+            }
+        },
+        close: closeMessage,
+    };
+}
+function finishedEvent(run, result) {
+    const base = { type: 'RUN_FINISHED', threadId: run.threadId, runId: run.runId };
+    if (result.status === 'awaiting_input' && result.interrupts?.length) {
+        return { ...base, outcome: { type: 'interrupt', interrupts: result.interrupts.map(agUiInterrupt) } };
+    }
+    return { ...base, outcome: { type: 'success' }, result: answerOf(result.state) };
+}
+function agUiInterrupt(interrupt) {
+    const call = toolCallOf(interrupt);
+    return {
+        id: interrupt.id,
+        reason: call ? 'tool_call' : 'input_required',
+        ...(interrupt.reason ? { message: interrupt.reason } : {}),
+        ...(call ? { toolCallId: call.id } : {}),
+        ...(interrupt.payload === undefined ? {} : { metadata: { payload: interrupt.payload } }),
+    };
+}

package/dist/protocols/shared.d.ts

@@ -0,0 +1,80 @@
+/**
+ * What the protocol adapters share: the part of a compiled graph they drive, and the conversions
+ * between a protocol's messages and the graph's. Structural, so a protocol entry point never imports
+ * the graph runtime: an agent or any compiled graph already satisfies it.
+ */
+import type { GraphEvent } from '../types/graph.js';
+import type { Message } from '../types/messages.js';
+import type { Principal } from '../types/principal.js';
+/** Run options a protocol passes to a graph. */
+export interface ProtocolRunOptions {
+    /** The thread: a protocol's conversation, context, or session id. */
+    threadId?: string;
+    /** Stops the run, as a protocol's cancel does. */
+    signal?: AbortSignal;
+    /** Receives the run's fine-grained events, which the protocol translates as they happen. */
+    onEvent?: (event: GraphEvent) => void;
+    /** Who the run is for, when the protocol's transport authenticated the caller. */
+    principal?: Principal;
+}
+/** A question a paused run is waiting on. */
+export interface ProtocolInterrupt {
+    /** Its id, which an answer names. */
+    id: string;
+    /** The question. */
+    reason?: string;
+    /** What it is about, such as the tool call awaiting approval. */
+    payload?: unknown;
+}
+/** What a run ended with. */
+export interface ProtocolResult {
+    /** The thread it ran on. */
+    threadId: string;
+    /** `completed`, `awaiting_input`, or another graph status. */
+    status: string;
+    /** The state it ended with. */
+    state: unknown;
+    /** Every question a paused run asked. */
+    interrupts?: ProtocolInterrupt[];
+}
+/** The part of a compiled graph the protocols drive. An agent from `createAgent()` satisfies it. */
+export interface ProtocolGraph {
+    /** Runs an input. */
+    invoke(input: unknown, options?: ProtocolRunOptions): Promise<ProtocolResult>;
+    /** Answers a paused run's questions, by interrupt id, and continues it. */
+    resumeInterruptsWith(threadId: string, answers: Record<string, unknown>, options?: ProtocolRunOptions): Promise<ProtocolResult>;
+}
+/** A role a protocol message may carry. */
+export type ProtocolRole = 'user' | 'assistant' | 'system' | 'developer' | 'tool' | 'agent';
+/** The final answer a run produced: an agent's `answer`, or its state as JSON. */
+export declare function answerOf(state: unknown): string;
+/**
+ * The conversation a finished run leaves, to send whole with the next turn: an agent's transcript,
+ * tool calls and results included, or the fallback for a graph that keeps none.
+ */
+export declare function transcriptOf(state: unknown, fallback: Message[]): Message[];
+/** The text of a protocol message's content, for content as a string or a list of text parts. */
+export declare function textOf(content: unknown): string;
+/** A Nexus message from a protocol role and text. A developer message is a system message. */
+export declare function messageOf(role: ProtocolRole, content: string, extra?: Partial<Message>): Message;
+/** A short random id, for runs and messages the protocol creates. */
+export declare function protocolId(prefix: string): string;
+/** Whether an interrupt asks to approve a tool call, as an agent's approvals do. */
+export declare function toolCallOf(interrupt: ProtocolInterrupt): {
+    id: string;
+    name: string;
+    args: unknown;
+} | undefined;
+/**
+ * Words answering an approval, as an approval: yes, ok, allow, approve, or confirm allows, and
+ * anything else refuses, with the words as the reason. A protocol that carries only text needs this
+ * so that "no" never reads as consent.
+ */
+export declare function approvalOf(text: string): {
+    approved: true;
+} | {
+    approved: false;
+    reason?: string;
+};
+/** A value as the text a protocol's text field carries. */
+export declare function asText(value: unknown): string;

package/dist/protocols/shared.js

@@ -0,0 +1,49 @@
+export function answerOf(state) {
+    const answer = state?.answer;
+    if (typeof answer === 'string')
+        return answer;
+    return state === undefined ? '' : JSON.stringify(state);
+}
+export function transcriptOf(state, fallback) {
+    const messages = state?.messages;
+    return Array.isArray(messages) && messages.every((item) => typeof item?.role === 'string')
+        ? messages
+        : fallback;
+}
+export function textOf(content) {
+    if (typeof content === 'string')
+        return content;
+    if (Array.isArray(content)) {
+        return content
+            .map((part) => {
+            const value = part;
+            return typeof value.text === 'string' ? value.text : '';
+        })
+            .filter(Boolean)
+            .join('\n');
+    }
+    return '';
+}
+export function messageOf(role, content, extra = {}) {
+    const mapped = role === 'developer' ? 'system' : role === 'agent' ? 'assistant' : role;
+    return { role: mapped, content, ...extra };
+}
+export function protocolId(prefix) {
+    return `${prefix}-${globalThis.crypto.randomUUID()}`;
+}
+export function toolCallOf(interrupt) {
+    const payload = interrupt.payload;
+    return typeof payload?.id === 'string' && typeof payload.name === 'string'
+        ? { id: payload.id, name: payload.name, args: payload.args }
+        : undefined;
+}
+export function approvalOf(text) {
+    const words = text.trim();
+    if (/^(y|yes|ok|okay|allow|allowed|approve|approved|confirm|confirmed|go ahead)\b/i.test(words)) {
+        return { approved: true };
+    }
+    return { approved: false, ...(words ? { reason: words } : {}) };
+}
+export function asText(value) {
+    return typeof value === 'string' ? value : JSON.stringify(value ?? null);
+}

package/dist/providers/anthropic.js

@@ -163,6 +163,7 @@ export class AnthropicProvider extends BaseProvider {
             this.client = new Anthropic({
                 apiKey: this.config.apiKey,
                 baseURL: this.config.baseUrl,
+                ...(this.config.fetch ? { fetch: this.config.fetch } : {}),
             });
         }
         return this.client;

package/dist/providers/cohere.js

@@ -14,7 +14,7 @@ export class CohereProvider extends BaseProvider {
         try {
             this.throwIfAborted(request);
             const startTime = Date.now();
-            const response = await fetch(`${this.baseUrl()}/v2/chat`, {
+            const response = await (this.config.fetch ?? fetch)(`${this.baseUrl()}/v2/chat`, {
                 method: 'POST',
                 headers: {
                     Authorization: `Bearer ${this.config.apiKey}`,
@@ -78,7 +78,7 @@ export class CohereProvider extends BaseProvider {
         }, request.signal);
     }
     async healthCheck() {
-        const response = await fetch(`${this.baseUrl()}/v2/models`, {
+        const response = await (this.config.fetch ?? fetch)(`${this.baseUrl()}/v2/models`, {
             headers: { Authorization: `Bearer ${this.config.apiKey}` },
         });
         return response.ok;

package/dist/providers/google.js

@@ -1,3 +1,4 @@
+import { decodeBase64 } from '../utils/base64.js';
 import { BaseProvider } from './base.js';
 import { buildMeta } from '../core/usage.js';
 import { generateRequestId } from '../utils/ids.js';
@@ -119,7 +120,7 @@ export class GoogleProvider extends BaseProvider {
         const endpoint = stream ? 'streamGenerateContent' : 'generateContent';
         const url = `${this.baseUrl()}/models/${encodeURIComponent(model)}:${endpoint}?key=${encodeURIComponent(this.config.apiKey)}${stream ? '&alt=sse' : ''}`;
         const body = JSON.stringify(this.createBody(request));
-        const response = await fetch(url, {
+        const response = await (this.config.fetch ?? fetch)(url, {
             method: 'POST',
             headers: { 'content-type': 'application/json' },
             body,
@@ -310,13 +311,3 @@ export class GoogleProvider extends BaseProvider {
         return Object.fromEntries(Object.entries(value).filter(([, entry]) => entry !== undefined));
     }
 }
-function decodeBase64(data) {
-    const buffer = globalThis.Buffer;
-    if (buffer)
-        return new Uint8Array(buffer.from(data, 'base64'));
-    const binary = atob(data);
-    const bytes = new Uint8Array(binary.length);
-    for (let index = 0; index < binary.length; index += 1)
-        bytes[index] = binary.charCodeAt(index);
-    return bytes;
-}

package/dist/providers/openai.js

@@ -25,6 +25,7 @@ export class OpenAIProvider extends BaseProvider {
                 organization: this.config.organization,
                 defaultHeaders: this.config.defaultHeaders,
                 defaultQuery: this.config.defaultQuery,
+                ...(this.config.fetch ? { fetch: this.config.fetch } : {}),
             });
         }
         return this.client;

package/dist/rag/file-ingestion.js

@@ -1,4 +1,4 @@
-import { scanUploads } from '../security/upload-scanner.js';
+import { isTextual, scanUploads, textOf, } from '../security/upload-scanner.js';
 import { ingestDocuments } from './ingestion.js';
 export async function ingestFilesAfterScan(files, options = {}) {
     const scan = scanUploads(files, options.scan);
@@ -10,19 +10,30 @@ export async function ingestFilesAfterScan(files, options = {}) {
     for (const file of files) {
         const extractor = options.extractors?.find((item) => item.supports(file));
         if (extractor) {
+            const text = await extractor.extract(file);
+            if (options.scan?.scanTextContent !== false) {
+                const extracted = scanUploads([{ name: file.name, mimeType: 'text/plain', content: text }], {
+                    ...(options.scan?.forbiddenPatterns ? { forbiddenPatterns: options.scan.forbiddenPatterns } : {}),
+                    blockedExtensions: [],
+                });
+                if (!extracted.ok) {
+                    throw new Error(`Upload scan failed on extracted text: ${extracted.findings.map((finding) => `${finding.fileName}: ${finding.message}`).join('; ')}`);
+                }
+            }
             documents.push({
                 id: file.name,
                 source: file.name,
-                text: await extractor.extract(file),
+                text,
                 metadata: { mimeType: file.mimeType, sizeBytes: file.sizeBytes },
             });
             continue;
         }
-        if (typeof file.content === 'string' && isTextMime(file.mimeType)) {
+        const text = isTextual(file.mimeType) ? textOf(file.content, file.mimeType) : undefined;
+        if (text !== undefined) {
             documents.push({
                 id: file.name,
                 source: file.name,
-                text: file.content,
+                text,
                 metadata: { mimeType: file.mimeType, sizeBytes: file.sizeBytes },
             });
             continue;
@@ -48,8 +59,3 @@ export function createOcrExtractor(ocrImage, mimeTypes = ['image/png', 'image/jp
         extract: ocrImage,
     };
 }
-function isTextMime(mimeType) {
-    if (!mimeType)
-        return true;
-    return (mimeType.startsWith('text/') || ['application/json', 'application/xml', 'application/markdown'].includes(mimeType));
-}

package/dist/runtime/detect.d.ts

@@ -0,0 +1,17 @@
+/** A JavaScript runtime this package recognizes. */
+export type RuntimeName = 'node' | 'deno' | 'bun' | 'workerd' | 'edge-light' | 'browser' | 'unknown';
+/** Which runtime the code is running on. */
+export interface RuntimeInfo {
+    /**
+     * `node`, `deno`, `bun`, `workerd` for Cloudflare Workers, `edge-light` for Vercel's edge
+     * runtime, `browser` for a page or a web worker, or `unknown`.
+     */
+    name: RuntimeName;
+    /** The runtime's version, where it reports one. */
+    version?: string;
+}
+/**
+ * Which runtime the code is running on, from what each one reliably exposes. Deno and Bun are
+ * checked before Node.js, since both also present Node's `process`.
+ */
+export declare function runtimeInfo(): RuntimeInfo;

package/dist/runtime/detect.js

@@ -0,0 +1,16 @@
+export function runtimeInfo() {
+    const host = globalThis;
+    if (host.Deno?.version?.deno)
+        return { name: 'deno', version: host.Deno.version.deno };
+    if (host.Bun?.version)
+        return { name: 'bun', version: host.Bun.version };
+    if (typeof host.EdgeRuntime === 'string')
+        return { name: 'edge-light' };
+    if (host.navigator?.userAgent === 'Cloudflare-Workers')
+        return { name: 'workerd' };
+    if (host.process?.versions?.node)
+        return { name: 'node', version: host.process.versions.node };
+    if (host.document !== undefined || typeof host.importScripts === 'function')
+        return { name: 'browser' };
+    return { name: 'unknown' };
+}

package/dist/runtime/index.d.ts

@@ -0,0 +1,19 @@
+/**
+ * The portable kernel: the contracts every model call and tool call is built on, for any JavaScript
+ * runtime. That means Node.js, Deno, Bun, edge runtimes such as Cloudflare Workers and Vercel's,
+ * and browsers.
+ *
+ * Nothing here, nor anything it imports, uses `fs`, `net`, `child_process`, Node's `crypto`, or
+ * Node's globals, and CI runs its tests on each runtime. The provider adapters, graphs, agents, and
+ * protocols are portable too, on their own entry points.
+ */
+export type { AssetContent, AudioContent, BinaryBuffer, CacheHint, CompletionRequest, ContentPart, ImageContent, Message, MessageRole, PromptCacheConfig, ReasoningConfig, TextContent, ToolCallResult, ToolChoice, ToolContext, ToolDefinition, ToolOutput, VideoContent, } from '../types/messages.js';
+export type { CacheOutcome, NexusResponse, NexusStream, ResponseCost, ResponseMeta, StreamChunk, TokenUsage, ToolCall, } from '../types/response.js';
+export type { ProviderCallContext } from '../types/lifecycle.js';
+export { BaseProvider, type ProviderInfo } from '../providers/base.js';
+export { categorizeProviderError, createProviderHttpError, isAbortError, isRetryableProviderError, NexusProviderError, type NexusProviderErrorCategory, type NexusProviderErrorOptions, toNexusProviderError, } from '../providers/errors.js';
+export { isToolOutput, ToolExecutor, tool, toolMessageContent, toolOutput } from '../agent/tool.js';
+export { capabilitiesOf, isSensitiveCapability, type ParsedCapability, parseCapability, } from '../agent/capabilities.js';
+export { type NegotiateOptions, type NegotiationResult, NexusCapabilityError, negotiateCompletionRequest, } from '../capabilities/negotiate.js';
+export { collectStream, createTextStream, mapStream } from '../core/streaming.js';
+export { type RuntimeInfo, type RuntimeName, runtimeInfo } from './detect.js';

package/dist/runtime/index.js

@@ -0,0 +1,7 @@
+export { BaseProvider } from '../providers/base.js';
+export { categorizeProviderError, createProviderHttpError, isAbortError, isRetryableProviderError, NexusProviderError, toNexusProviderError, } from '../providers/errors.js';
+export { isToolOutput, ToolExecutor, tool, toolMessageContent, toolOutput } from '../agent/tool.js';
+export { capabilitiesOf, isSensitiveCapability, parseCapability, } from '../agent/capabilities.js';
+export { NexusCapabilityError, negotiateCompletionRequest, } from '../capabilities/negotiate.js';
+export { collectStream, createTextStream, mapStream } from '../core/streaming.js';
+export { runtimeInfo } from './detect.js';

package/dist/security/injection-detector.d.ts

@@ -7,5 +7,7 @@ export declare class InjectionDetector {
     /** Returns the request with injection markers defused. */
     neutralize(request: CompletionRequest): CompletionRequest;
     private extractText;
+    /** Defuses what `detect()` finds. Text with nothing to defuse is returned exactly as it was. */
     private escapeInstructionLikeText;
+    private escapeNormalized;
 }

package/dist/security/injection-detector.js

@@ -1,3 +1,4 @@
+import { normalizeForDetection } from '../utils/checksums.js';
 const DEFAULT_PATTERNS = [
     {
         pattern: /ignore\s+(all\s+)?previous\s+instructions/i,
@@ -38,7 +39,7 @@ export class InjectionDetector {
         ];
         const findings = [];
         request.messages.forEach((message, index) => {
-            for (const text of this.extractText(message)) {
+            for (const text of this.extractText(message).map(normalizeForDetection)) {
                 patterns.forEach(({ pattern, severity, label }) => {
                     const match = text.match(pattern);
                     if (!match)
@@ -72,6 +73,11 @@ export class InjectionDetector {
         return message.content.filter((part) => part.type === 'text').map((part) => part.text);
     }
     escapeInstructionLikeText(text) {
+        const normalized = normalizeForDetection(text);
+        const escaped = this.escapeNormalized(normalized);
+        return escaped === normalized ? text : escaped;
+    }
+    escapeNormalized(text) {
         return text
             .replace(/ignore\s+(all\s+)?previous\s+instructions/gi, '[neutralized instruction override]')
             .replace(/disregard\s+(all\s+)?(prior|previous)\s+instructions/gi, '[neutralized instruction override]')

package/dist/security/input-guard.js

@@ -18,7 +18,7 @@ const SECRET_PATTERNS = [
 ];
 const SUSPICIOUS_URL_PATTERNS = [
     {
-        pattern: /https?:\/\/(?:localhost|127\.0\.0\.1|0\.0\.0\.0|169\.254\.169\.254)(?:[:/]|$)/gi,
+        pattern: /https?:\/\/(?:localhost|127(?:\.\d{1,3}){3}|0\.0\.0\.0|\[::1?\]|169\.254\.169\.254|metadata\.google\.internal|100\.100\.100\.200)(?:[:/]|$)/gi,
         label: 'local or metadata URL',
     },
     { pattern: /https?:\/\/[^\s]*\.(?:onion)(?:[:/]|$)/gi, label: 'onion URL' },
@@ -97,7 +97,7 @@ export class InputGuard {
             let output = text;
             patterns.forEach(({ pattern, label, severity }) => {
                 output = output.replace(pattern, (value) => {
-                    findings.push({ type, severity, message: `Detected ${label}`, path, value });
+                    findings.push({ type, severity, message: `Detected ${label}`, path, value: previewSecret(value) });
                     return action === 'mask' ? '[REDACTED]' : value;
                 });
             });
@@ -126,3 +126,6 @@ export class InputGuard {
         return message.content.filter((part) => part.type === 'text').map((part) => part.text);
     }
 }
+function previewSecret(value) {
+    return `${value.slice(0, 4)}… (${value.length} characters)`;
+}

package/dist/security/output-guard.js

@@ -1,3 +1,4 @@
+import { luhn, phoneNumber } from '../utils/checksums.js';
 const OUTPUT_SECRET_PATTERNS = [
     {
         pattern: /-----BEGIN [A-Z ]*PRIVATE KEY-----[\s\S]*?-----END [A-Z ]*PRIVATE KEY-----/g,
@@ -12,17 +13,18 @@ const OUTPUT_SECRET_PATTERNS = [
     { pattern: /\bAIza[0-9A-Za-z_-]{35}\b/g, label: 'google api key', severity: 'critical' },
     { pattern: /\beyJ[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\b/g, label: 'jwt token', severity: 'high' },
     { pattern: /\b[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,}\b/gi, label: 'email address', severity: 'high' },
+    { pattern: /\b(?:\d[ -]*?){13,19}\b/g, label: 'possible credit card', severity: 'high', valid: luhn },
     {
         pattern: /(?:\+?\d{1,3}[\s.-]?)?(?:\(?\d{2,4}\)?[\s.-]?)?\d{3,4}[\s.-]?\d{4}\b/g,
         label: 'phone number',
         severity: 'high',
+        valid: phoneNumber,
     },
     {
         pattern: /\b(?:(?:25[0-5]|2[0-4]\d|1?\d?\d)\.){3}(?:25[0-5]|2[0-4]\d|1?\d?\d)\b/g,
         label: 'ip address',
         severity: 'high',
     },
-    { pattern: /\b(?:\d[ -]*?){13,19}\b/g, label: 'possible credit card', severity: 'high' },
     {
         pattern: /(?:api[_-]?key|access[_-]?token|refresh[_-]?token|client[_-]?secret|secret|password|token)\s*[:=]\s*(?:['"][^'"\r\n]+['"]|[^\s,;]{8,})/gi,
         label: 'secret assignment',
@@ -33,8 +35,8 @@ const OUTPUT_SECRET_PATTERNS = [
 const CONNECTION_STRING_PATTERN = /\b(?:postgres|postgresql|mysql|mongodb|redis|mssql):\/\/[^\s'"<>]+/gi;
 export function redactSensitiveText(value) {
     let redacted = value;
-    for (const { pattern } of OUTPUT_SECRET_PATTERNS) {
-        redacted = redacted.replace(pattern, '[REDACTED]');
+    for (const { pattern, valid } of OUTPUT_SECRET_PATTERNS) {
+        redacted = redacted.replace(pattern, (match) => (valid && !valid(match) ? match : '[REDACTED]'));
     }
     return redacted.replace(CONNECTION_STRING_PATTERN, '[REDACTED_CONNECTION_STRING]');
 }
@@ -64,9 +66,11 @@ export class OutputGuard {
         }
         const shouldRedact = config.output?.piiRedaction !== false;
         if (shouldRedact) {
-            for (const { pattern, label, severity } of OUTPUT_SECRET_PATTERNS) {
+            for (const { pattern, label, severity, valid } of OUTPUT_SECRET_PATTERNS) {
                 for (const target of textTargets) {
                     target.value = target.value.replace(pattern, (value) => {
+                        if (valid && !valid(value))
+                            return value;
                         findings.push({
                             type: 'pii',
                             severity,