@aduek/ne-sy 0.1.0-alpha.0

package/dist/metering.d.ts

@@ -0,0 +1,53 @@
+export type BillableCategory = "blocked_high_risk_action" | "review_routed_action" | "governed_execution" | "governed_action";
+export type ExclusionReason = "malformed_audit_event" | "invalid_hash_evidence" | "duplicate_event_identity" | "missing_customer_or_workspace" | "verification_error" | "dry_run_or_demo_event" | "excluded_metadata_flag" | "action_type_not_included";
+export type HashValidationMode = "off" | "validate_when_present" | "require_hashes";
+export interface OutcomeMeteringConfig {
+    customerId: string;
+    workspaceId: string;
+    includedActionTypes: string[];
+    excludedMetadataFlags: string[];
+    includeDemoEvents: boolean;
+    hashValidationMode: HashValidationMode;
+}
+export interface UsageRecord {
+    customerId: string;
+    workspaceId: string;
+    eventId: string | null;
+    actionId: string | null;
+    actionType: string | null;
+    decision: string | null;
+    executionOutcome: string | null;
+    policyPackId: string | null;
+    policyVersion: string | null;
+    policyHash: string | null;
+    actionHash: string | null;
+    envelopeHash: string | null;
+    evidenceHash: string | null;
+    verifierVersion: string | null;
+    billableCategory: BillableCategory | null;
+    billable: boolean;
+    exclusionReason: ExclusionReason | null;
+    timestamp: string | null;
+}
+export interface MeteringSummary {
+    totalRecords: number;
+    billableRecords: number;
+    excludedRecords: number;
+    byCustomerWorkspace: Record<string, number>;
+    byPolicyPack: Record<string, number>;
+    byActionType: Record<string, number>;
+    byDecision: Record<string, number>;
+    byExecutionOutcome: Record<string, number>;
+    byBillableCategory: Record<string, number>;
+    byExclusionReason: Record<string, number>;
+}
+export interface MeteringResult {
+    records: UsageRecord[];
+    summary: MeteringSummary;
+}
+export declare function loadOutcomeConfig(path: string): OutcomeMeteringConfig;
+export declare function meterAuditJsonl(path: string, config: OutcomeMeteringConfig | unknown): MeteringResult;
+export declare function meterAuditEventsJsonl(jsonl: string, config: OutcomeMeteringConfig | unknown): MeteringResult;
+export declare function meterAuditEvents(events: Iterable<unknown>, config: OutcomeMeteringConfig | unknown): MeteringResult;
+export declare function summarizeUsageRecords(records: Iterable<UsageRecord>): MeteringSummary;
+//# sourceMappingURL=metering.d.ts.map

package/dist/metering.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"metering.d.ts","sourceRoot":"","sources":["../src/metering.ts"],"names":[],"mappings":"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"}

package/dist/metering.js

@@ -0,0 +1,224 @@
+import { readFileSync } from "node:fs";
+import { validateAuditEvent } from "./audit.js";
+import { hashAction, hashAuditEvidence, hashEnvelope } from "./evidence.js";
+import { isRecord } from "./utils.js";
+const HEX_64 = /^[0-9a-f]{64}$/;
+export function loadOutcomeConfig(path) {
+    return normalizeConfig(JSON.parse(readFileSync(path, "utf8")));
+}
+export function meterAuditJsonl(path, config) {
+    return meterAuditEventsJsonl(readFileSync(path, "utf8"), config);
+}
+export function meterAuditEventsJsonl(jsonl, config) {
+    const events = [];
+    for (const line of jsonl.split(/\r?\n/)) {
+        const trimmed = line.trim();
+        if (!trimmed)
+            continue;
+        try {
+            events.push(JSON.parse(trimmed));
+        }
+        catch {
+            events.push({ _malformedJsonLine: trimmed });
+        }
+    }
+    return meterAuditEvents(events, config);
+}
+export function meterAuditEvents(events, config) {
+    const outcomeConfig = normalizeConfig(config);
+    const seen = new Set();
+    const records = Array.from(events, (event) => meterEvent(event, outcomeConfig, seen));
+    return { records, summary: summarizeUsageRecords(records) };
+}
+export function summarizeUsageRecords(records) {
+    const recordList = Array.from(records);
+    return {
+        totalRecords: recordList.length,
+        billableRecords: recordList.filter((record) => record.billable).length,
+        excludedRecords: recordList.filter((record) => record.exclusionReason !== null).length,
+        byCustomerWorkspace: count(recordList, (record) => `${record.customerId}/${record.workspaceId}`),
+        byPolicyPack: count(recordList, (record) => `${record.policyPackId ?? "<none>"}/${record.policyVersion ?? "<none>"}`),
+        byActionType: count(recordList, (record) => record.actionType),
+        byDecision: count(recordList, (record) => record.decision),
+        byExecutionOutcome: count(recordList, (record) => record.executionOutcome),
+        byBillableCategory: count(recordList, (record) => record.billableCategory),
+        byExclusionReason: count(recordList, (record) => record.exclusionReason),
+    };
+}
+function meterEvent(event, config, seen) {
+    let exclusionReason = exclusionFor(event, config);
+    const dedupeKey = isRecord(event) ? dedupeKeyFor(event) : null;
+    if (exclusionReason === null && dedupeKey !== null) {
+        if (seen.has(dedupeKey)) {
+            exclusionReason = "duplicate_event_identity";
+        }
+        else {
+            seen.add(dedupeKey);
+        }
+    }
+    const billableCategory = exclusionReason === null ? billableCategoryFor(event) : null;
+    return {
+        ...baseFields(event, config),
+        billableCategory,
+        billable: billableCategory !== null && exclusionReason === null,
+        exclusionReason,
+    };
+}
+function baseFields(event, config) {
+    const action = isRecord(event) && isRecord(event.action) ? event.action : undefined;
+    const decision = isRecord(event) && isRecord(event.decision) ? event.decision : undefined;
+    const runtime = isRecord(event) && isRecord(event.runtime) ? event.runtime : undefined;
+    return {
+        customerId: config.customerId,
+        workspaceId: config.workspaceId,
+        eventId: stringOrNull(isRecord(event) ? event.id : undefined),
+        actionId: stringOrNull(action?.id),
+        actionType: stringOrNull(action?.type),
+        decision: stringOrNull(decision?.decision),
+        executionOutcome: stringOrNull(runtime?.executionOutcome),
+        policyPackId: stringOrNull(isRecord(event) ? event.policyPackId : undefined),
+        policyVersion: stringOrNull(isRecord(event) ? event.policyVersion : undefined),
+        policyHash: stringOrNull(isRecord(event) ? event.policyHash : undefined),
+        actionHash: stringOrNull(isRecord(event) ? event.actionHash : undefined),
+        envelopeHash: stringOrNull(isRecord(event) ? event.envelopeHash : undefined),
+        evidenceHash: stringOrNull(isRecord(event) ? event.evidenceHash : undefined),
+        verifierVersion: stringOrNull(isRecord(event) ? event.verifierVersion : undefined),
+        timestamp: stringOrNull(isRecord(event) ? event.timestamp : undefined),
+    };
+}
+function exclusionFor(event, config) {
+    if (!config.customerId || !config.workspaceId)
+        return "missing_customer_or_workspace";
+    if (!isRecord(event) || validateAuditEvent(event).length > 0)
+        return "malformed_audit_event";
+    if (!hashesValid(event, config.hashValidationMode))
+        return "invalid_hash_evidence";
+    if (isVerificationError(event))
+        return "verification_error";
+    if (!config.includeDemoEvents && isDemoOrFixtureEvent(event))
+        return "dry_run_or_demo_event";
+    if (hasExcludedFlag(event, config.excludedMetadataFlags))
+        return "excluded_metadata_flag";
+    const actionType = isRecord(event.action) ? event.action.type : undefined;
+    if (config.includedActionTypes.length > 0 && !config.includedActionTypes.includes(String(actionType))) {
+        return "action_type_not_included";
+    }
+    return null;
+}
+function hashesValid(event, mode) {
+    if (mode === "off")
+        return true;
+    const required = mode === "require_hashes";
+    const expected = [
+        ["actionHash", hashAction(event.action)],
+        ["envelopeHash", hashEnvelope({
+                agent: event.runtime?.agent,
+                action: event.action,
+                context: event.runtime?.context,
+                policyPackId: event.policyPackId,
+                policyVersion: event.policyVersion,
+                policyHash: event.policyHash,
+            })],
+        ["evidenceHash", hashAuditEvidence(event)],
+    ];
+    for (const [field, value] of expected) {
+        const actual = event[field];
+        if (actual === undefined) {
+            if (required)
+                return false;
+            continue;
+        }
+        if (actual !== value)
+            return false;
+    }
+    if (event.policyHash === undefined) {
+        if (required)
+            return false;
+    }
+    else if (!HEX_64.test(event.policyHash)) {
+        return false;
+    }
+    if (event.verifierVersion === undefined)
+        return !required;
+    return typeof event.verifierVersion === "string" && event.verifierVersion.length > 0;
+}
+function billableCategoryFor(event) {
+    const decision = isRecord(event) && isRecord(event.decision) ? event.decision.decision : undefined;
+    const outcome = isRecord(event) && isRecord(event.runtime) ? event.runtime.executionOutcome : undefined;
+    if (decision === "deny" && outcome === "blocked")
+        return "blocked_high_risk_action";
+    if (decision === "review" && outcome === "pending_review")
+        return "review_routed_action";
+    if ((decision === "allow" || decision === "log") && outcome === "executed")
+        return "governed_execution";
+    return "governed_action";
+}
+function dedupeKeyFor(event) {
+    if (typeof event.evidenceHash === "string")
+        return `evidenceHash:${event.evidenceHash}`;
+    if (typeof event.actionHash === "string" &&
+        typeof event.policyHash === "string" &&
+        isRecord(event.runtime) &&
+        typeof event.runtime.executionOutcome === "string") {
+        return `actionPolicyOutcome:${event.actionHash}:${event.policyHash}:${event.runtime.executionOutcome}`;
+    }
+    if (typeof event.id === "string")
+        return `id:${event.id}`;
+    return null;
+}
+function isVerificationError(event) {
+    const metadata = isRecord(event.decision) && isRecord(event.decision.metadata)
+        ? event.decision.metadata
+        : undefined;
+    return Boolean(metadata?.errorCategory || metadata?.errorCode || metadata?.failClosed);
+}
+function isDemoOrFixtureEvent(event) {
+    const actionMetadata = isRecord(event.action) && isRecord(event.action.metadata)
+        ? event.action.metadata
+        : undefined;
+    if (actionMetadata?.fixture || actionMetadata?.demo || actionMetadata?.dryRun)
+        return true;
+    const context = isRecord(event.runtime) && isRecord(event.runtime.context)
+        ? event.runtime.context
+        : undefined;
+    return context?.environment === "test" || context?.environment === "demo" || context?.fixture === true;
+}
+function hasExcludedFlag(event, flags) {
+    const actionMetadata = isRecord(event.action) && isRecord(event.action.metadata)
+        ? event.action.metadata
+        : undefined;
+    const decisionMetadata = isRecord(event.decision) && isRecord(event.decision.metadata)
+        ? event.decision.metadata
+        : undefined;
+    return [actionMetadata, decisionMetadata].some((metadata) => isRecord(metadata) && flags.some((flag) => metadata[flag] === true));
+}
+function normalizeConfig(value) {
+    const record = isRecord(value) ? value : {};
+    return {
+        customerId: typeof record.customerId === "string" ? record.customerId : "",
+        workspaceId: typeof record.workspaceId === "string" ? record.workspaceId : "",
+        includedActionTypes: stringArray(record.includedActionTypes),
+        excludedMetadataFlags: stringArray(record.excludedMetadataFlags),
+        includeDemoEvents: record.includeDemoEvents === true,
+        hashValidationMode: hashValidationMode(record.hashValidationMode),
+    };
+}
+function count(records, keyFn) {
+    const counts = {};
+    for (const record of records) {
+        const key = keyFn(record) ?? "<none>";
+        counts[key] = (counts[key] ?? 0) + 1;
+    }
+    return Object.fromEntries(Object.entries(counts).sort(([left], [right]) => left.localeCompare(right)));
+}
+function stringArray(value) {
+    return Array.isArray(value) && value.every((item) => typeof item === "string") ? value : [];
+}
+function hashValidationMode(value) {
+    return value === "off" || value === "validate_when_present" || value === "require_hashes"
+        ? value
+        : "validate_when_present";
+}
+function stringOrNull(value) {
+    return typeof value === "string" ? value : null;
+}

package/dist/openaiAgents.d.ts

@@ -0,0 +1,29 @@
+import type { AuditEvent, Decision, PolicyInput } from "./types.js";
+export type OpenAiGuardrailBehavior = "allow" | "rejectContent";
+export interface OpenAiToolActionInput {
+    agent: unknown;
+    toolName: string;
+    toolArguments?: Record<string, unknown> | string | null;
+    actionType?: string;
+    target?: unknown;
+    metadata?: Record<string, unknown>;
+    actionId?: string;
+    timestamp?: string;
+}
+export interface OpenAiToolInputGuardrailInput extends OpenAiToolActionInput {
+    policies?: PolicyInput;
+    context?: unknown;
+    auditPath?: string;
+    failClosed?: boolean;
+}
+export interface OpenAiToolInputGuardrailResult {
+    allowed: boolean;
+    decision: Decision;
+    auditEvent: AuditEvent;
+    action: Record<string, unknown>;
+    guardrailBehavior: OpenAiGuardrailBehavior;
+    message: string;
+}
+export declare function createOpenAiToolAction(input: OpenAiToolActionInput): Record<string, unknown>;
+export declare function runOpenAiToolInputGuardrail(input: OpenAiToolInputGuardrailInput): Promise<OpenAiToolInputGuardrailResult>;
+//# sourceMappingURL=openaiAgents.d.ts.map

package/dist/openaiAgents.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"openaiAgents.d.ts","sourceRoot":"","sources":["../src/openaiAgents.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,UAAU,EAAE,QAAQ,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAKpE,MAAM,MAAM,uBAAuB,GAAG,OAAO,GAAG,eAAe,CAAC;AAEhE,MAAM,WAAW,qBAAqB;IACpC,KAAK,EAAE,OAAO,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,aAAa,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,GAAG,IAAI,CAAC;IACxD,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACnC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,6BAA8B,SAAQ,qBAAqB;IAC1E,QAAQ,CAAC,EAAE,WAAW,CAAC;IACvB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,UAAU,CAAC,EAAE,OAAO,CAAC;CACtB;AAED,MAAM,WAAW,8BAA8B;IAC7C,OAAO,EAAE,OAAO,CAAC;IACjB,QAAQ,EAAE,QAAQ,CAAC;IACnB,UAAU,EAAE,UAAU,CAAC;IACvB,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAChC,iBAAiB,EAAE,uBAAuB,CAAC;IAC3C,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,qBAAqB,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAyB5F;AAED,wBAAsB,2BAA2B,CAC/C,KAAK,EAAE,6BAA6B,GACnC,OAAO,CAAC,8BAA8B,CAAC,CAsBzC"}

package/dist/openaiAgents.js

@@ -0,0 +1,81 @@
+import { randomUUID } from "node:crypto";
+import { PolicyEvaluationError } from "./types.js";
+import { agentRef, isRecord } from "./utils.js";
+import { verifyActionWithEvent } from "./verifier.js";
+export function createOpenAiToolAction(input) {
+    const kwargs = parseToolArguments(input.toolArguments);
+    const metadata = {
+        ...(input.metadata ?? {}),
+        framework: "openai-agents",
+        guardrail: "tool_input",
+        toolName: input.toolName,
+    };
+    return {
+        id: input.actionId ?? randomUUID(),
+        type: input.actionType ?? "tool.call",
+        actor: agentRef(input.agent),
+        target: input.target ?? {
+            id: input.toolName,
+            kind: "function",
+            trustBoundary: "internal",
+        },
+        input: {
+            args: [],
+            kwargs,
+        },
+        metadata,
+        timestamp: input.timestamp ?? new Date().toISOString(),
+    };
+}
+export async function runOpenAiToolInputGuardrail(input) {
+    const action = createOpenAiToolAction(input);
+    const verification = await verifyActionWithEvent({
+        agent: input.agent,
+        action,
+        context: input.context ?? {},
+        policies: input.policies,
+        auditPath: input.auditPath,
+        failClosed: input.failClosed,
+    });
+    const guardrailBehavior = verification.decision.allowed
+        ? "allow"
+        : "rejectContent";
+    return {
+        allowed: verification.decision.allowed,
+        decision: verification.decision,
+        auditEvent: verification.auditEvent,
+        action,
+        guardrailBehavior,
+        message: verification.decision.reason,
+    };
+}
+function parseToolArguments(toolArguments) {
+    if (toolArguments === undefined || toolArguments === null)
+        return {};
+    if (typeof toolArguments === "string") {
+        let parsed;
+        try {
+            parsed = JSON.parse(toolArguments);
+        }
+        catch (error) {
+            throw new PolicyEvaluationError("toolArguments must be a JSON object string", {
+                category: "adapter_input_error",
+                code: "adapter_invalid_json_arguments",
+            });
+        }
+        if (!isRecord(parsed)) {
+            throw new PolicyEvaluationError("toolArguments must be a JSON object string", {
+                category: "adapter_input_error",
+                code: "adapter_arguments_not_object",
+            });
+        }
+        return parsed;
+    }
+    if (!isRecord(toolArguments)) {
+        throw new PolicyEvaluationError("toolArguments must be an object, JSON object string, or null", {
+            category: "adapter_input_error",
+            code: "adapter_invalid_arguments",
+        });
+    }
+    return { ...toolArguments };
+}

package/dist/policy.d.ts

@@ -0,0 +1,12 @@
+import type { Decision, PolicyAnalysis, PolicyInput } from "./types.js";
+export declare const POLICY_HASH_ALGORITHM = "sha256";
+export declare function analyzePolicies(policyInput?: PolicyInput): PolicyAnalysis;
+export declare function validatePolicyPack(policyInput?: PolicyInput): string[];
+export declare function assertValidPolicyPack(policyInput?: PolicyInput): void;
+export declare function evaluatePolicies(agent: unknown, action: unknown, context: unknown, policyInput?: PolicyInput): Decision;
+export declare function policyVersion(policyInput?: PolicyInput): string | undefined;
+export declare function policyPackId(policyInput?: PolicyInput): string | undefined;
+export declare function policyHash(policyInput?: PolicyInput): string | undefined;
+export declare function canonicalPolicyJson(policyInput: PolicyInput): string;
+export declare function hashPolicyPack(policyInput: PolicyInput): string;
+//# sourceMappingURL=policy.d.ts.map

package/dist/policy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"policy.d.ts","sourceRoot":"","sources":["../src/policy.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EAEV,QAAQ,EAER,cAAc,EAEd,WAAW,EAEZ,MAAM,YAAY,CAAC;AAiBpB,eAAO,MAAM,qBAAqB,WAAW,CAAC;AAY9C,wBAAgB,eAAe,CAAC,WAAW,CAAC,EAAE,WAAW,GAAG,cAAc,CAyFzE;AAED,wBAAgB,kBAAkB,CAAC,WAAW,CAAC,EAAE,WAAW,GAAG,MAAM,EAAE,CAMtE;AAED,wBAAgB,qBAAqB,CAAC,WAAW,CAAC,EAAE,WAAW,GAAG,IAAI,CAMrE;AAED,wBAAgB,gBAAgB,CAC9B,KAAK,EAAE,OAAO,EACd,MAAM,EAAE,OAAO,EACf,OAAO,EAAE,OAAO,EAChB,WAAW,CAAC,EAAE,WAAW,GACxB,QAAQ,CAqCV;AAED,wBAAgB,aAAa,CAAC,WAAW,CAAC,EAAE,WAAW,GAAG,MAAM,GAAG,SAAS,CAK3E;AAED,wBAAgB,YAAY,CAAC,WAAW,CAAC,EAAE,WAAW,GAAG,MAAM,GAAG,SAAS,CAK1E;AAED,wBAAgB,UAAU,CAAC,WAAW,CAAC,EAAE,WAAW,GAAG,MAAM,GAAG,SAAS,CAGxE;AAED,wBAAgB,mBAAmB,CAAC,WAAW,EAAE,WAAW,GAAG,MAAM,CAEpE;AAED,wBAAgB,cAAc,CAAC,WAAW,EAAE,WAAW,GAAG,MAAM,CAI/D"}