@llm-dev-ops/agentics-cli 1.4.26 → 1.4.27

package/dist/bundled-agents/policy-engine-agents/dist/functions/core/engine/policy-engine.js

@@ -0,0 +1,278 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PolicyEngine = void 0;
+/**
+ * Policy Engine - Main evaluation engine
+ */
+var policy_1 = require("../../types/policy");
+var condition_evaluator_1 = require("../evaluator/condition-evaluator");
+var primitives_1 = require("../primitives");
+var errors_1 = require("../../utils/errors");
+var logger_1 = __importDefault(require("../../utils/logger"));
+var uuid_1 = require("uuid");
+var PolicyEngine = /** @class */ (function () {
+    function PolicyEngine(policies) {
+        if (policies === void 0) { policies = []; }
+        this.conditionEvaluator = new condition_evaluator_1.ConditionEvaluator();
+        this.tokenCounter = new primitives_1.TokenCounter();
+        this.piiDetector = new primitives_1.PIIDetector();
+        this.costCalculator = new primitives_1.CostCalculator();
+        this.policies = new Map();
+        // Load initial policies
+        for (var _i = 0, policies_1 = policies; _i < policies_1.length; _i++) {
+            var policy = policies_1[_i];
+            this.addPolicy(policy);
+        }
+    }
+    /**
+     * Add a policy to the engine
+     */
+    PolicyEngine.prototype.addPolicy = function (policy) {
+        if (policy.status === 'active') {
+            this.policies.set(policy.metadata.id, policy);
+            logger_1.default.info({ policyId: policy.metadata.id }, 'Policy added to engine');
+        }
+    };
+    /**
+     * Remove a policy from the engine
+     */
+    PolicyEngine.prototype.removePolicy = function (policyId) {
+        this.policies.delete(policyId);
+        logger_1.default.info({ policyId: policyId }, 'Policy removed from engine');
+    };
+    /**
+     * Update a policy in the engine
+     */
+    PolicyEngine.prototype.updatePolicy = function (policy) {
+        this.policies.set(policy.metadata.id, policy);
+        logger_1.default.info({ policyId: policy.metadata.id }, 'Policy updated in engine');
+    };
+    /**
+     * Get all active policies (sorted by priority, highest first)
+     */
+    PolicyEngine.prototype.getPolicies = function () {
+        return Array.from(this.policies.values()).sort(function (a, b) { return (b.metadata.priority || 0) - (a.metadata.priority || 0); });
+    };
+    /**
+     * Evaluate a request against all policies
+     */
+    PolicyEngine.prototype.evaluate = function (request) {
+        return __awaiter(this, void 0, void 0, function () {
+            var startTime, _a, requestId, context, policyIds, _b, dryRun, _c, trace, enrichedContext, policiesToEvaluate, decision, evaluationTimeMs, error_1;
+            var _this = this;
+            return __generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0:
+                        startTime = performance.now();
+                        _a = request.requestId, requestId = _a === void 0 ? (0, uuid_1.v4)() : _a, context = request.context, policyIds = request.policies, _b = request.dryRun, dryRun = _b === void 0 ? false : _b, _c = request.trace, trace = _c === void 0 ? false : _c;
+                        logger_1.default.info({ requestId: requestId, dryRun: dryRun, trace: trace }, 'Starting policy evaluation');
+                        _d.label = 1;
+                    case 1:
+                        _d.trys.push([1, 4, , 5]);
+                        return [4 /*yield*/, this.enrichContext(context)];
+                    case 2:
+                        enrichedContext = _d.sent();
+                        policiesToEvaluate = policyIds
+                            ? policyIds.map(function (id) { return _this.policies.get(id); }).filter(function (p) { return p !== undefined; })
+                            : Array.from(this.policies.values());
+                        // Sort policies by priority (higher priority first)
+                        policiesToEvaluate.sort(function (a, b) { return (b.metadata.priority || 0) - (a.metadata.priority || 0); });
+                        return [4 /*yield*/, this.evaluatePolicies(policiesToEvaluate, enrichedContext, trace)];
+                    case 3:
+                        decision = _d.sent();
+                        evaluationTimeMs = performance.now() - startTime;
+                        logger_1.default.info({
+                            requestId: requestId,
+                            decision: decision.decision,
+                            evaluationTimeMs: evaluationTimeMs,
+                            matchedPolicies: decision.matchedPolicies.length,
+                        }, 'Policy evaluation completed');
+                        return [2 /*return*/, {
+                                requestId: requestId,
+                                decision: __assign(__assign({}, decision), { evaluationTimeMs: evaluationTimeMs }),
+                                timestamp: Date.now(),
+                                cached: false,
+                            }];
+                    case 4:
+                        error_1 = _d.sent();
+                        logger_1.default.error({ requestId: requestId, error: error_1 }, 'Policy evaluation failed');
+                        throw new errors_1.PolicyEvaluationError("Evaluation failed: ".concat(error_1 instanceof Error ? error_1.message : String(error_1)), { requestId: requestId });
+                    case 5: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Enrich context with calculated fields
+     */
+    PolicyEngine.prototype.enrichContext = function (context) {
+        return __awaiter(this, void 0, void 0, function () {
+            var enriched, tokens, piiMatches, costEstimate;
+            var _a, _b, _c, _d, _e;
+            return __generator(this, function (_f) {
+                enriched = __assign({}, context);
+                // Add token count if prompt is provided
+                if ((_a = context.llm) === null || _a === void 0 ? void 0 : _a.prompt) {
+                    tokens = this.tokenCounter.estimateTokens(context.llm.prompt, context.llm.model).tokens;
+                    enriched.llm = __assign(__assign({}, context.llm), { estimatedTokens: tokens });
+                }
+                // Add PII detection
+                if ((_b = context.llm) === null || _b === void 0 ? void 0 : _b.prompt) {
+                    piiMatches = this.piiDetector.detectPII(context.llm.prompt);
+                    enriched.llm = __assign(__assign({}, enriched.llm), { containsPII: piiMatches.length > 0, piiTypes: __spreadArray([], new Set(piiMatches.map(function (m) { return m.type; })), true) });
+                }
+                // Add cost estimate
+                if (((_c = context.llm) === null || _c === void 0 ? void 0 : _c.provider) && ((_d = context.llm) === null || _d === void 0 ? void 0 : _d.model) && ((_e = context.llm) === null || _e === void 0 ? void 0 : _e.prompt)) {
+                    costEstimate = this.costCalculator.estimateCostFromText(context.llm.provider, context.llm.model, context.llm.prompt, context.llm.maxTokens || 500);
+                    enriched.llm = __assign(__assign({}, enriched.llm), { estimatedCost: costEstimate.totalCost });
+                }
+                return [2 /*return*/, enriched];
+            });
+        });
+    };
+    /**
+     * Evaluate multiple policies and aggregate decisions
+     */
+    PolicyEngine.prototype.evaluatePolicies = function (policies, context, trace) {
+        return __awaiter(this, void 0, void 0, function () {
+            var matchedPolicies, matchedRules, traces, modifications, finalDecision, finalReason, _i, policies_2, policy, _a, _b, rule, conditionResult, conditionEval;
+            return __generator(this, function (_c) {
+                matchedPolicies = [];
+                matchedRules = [];
+                traces = [];
+                modifications = {};
+                finalDecision = policy_1.DecisionType.ALLOW;
+                // Evaluate each policy
+                for (_i = 0, policies_2 = policies; _i < policies_2.length; _i++) {
+                    policy = policies_2[_i];
+                    for (_a = 0, _b = policy.rules; _a < _b.length; _a++) {
+                        rule = _b[_a];
+                        if (!rule.enabled)
+                            continue;
+                        conditionResult = this.conditionEvaluator.evaluate(rule.condition, context);
+                        if (trace) {
+                            conditionEval = {
+                                condition: rule.condition,
+                                result: conditionResult.result,
+                                evaluationTimeMs: conditionResult.evaluationTimeMs,
+                                details: conditionResult.details,
+                            };
+                            traces.push({
+                                policyId: policy.metadata.id,
+                                ruleId: rule.id,
+                                conditionEvaluations: [conditionEval],
+                                finalDecision: rule.action.decision,
+                                timestamp: Date.now(),
+                            });
+                        }
+                        // If condition matches, record it
+                        if (conditionResult.result) {
+                            matchedPolicies.push(policy.metadata.id);
+                            matchedRules.push(rule.id);
+                            // Priority: DENY > MODIFY > WARN > ALLOW
+                            if (rule.action.decision === policy_1.DecisionType.DENY) {
+                                finalDecision = policy_1.DecisionType.DENY;
+                                finalReason = rule.action.reason;
+                                break; // DENY is highest priority, stop evaluation
+                            }
+                            else if (rule.action.decision === policy_1.DecisionType.MODIFY) {
+                                finalDecision = policy_1.DecisionType.MODIFY;
+                                finalReason = rule.action.reason;
+                                Object.assign(modifications, rule.action.modifications || {});
+                            }
+                            else if (rule.action.decision === policy_1.DecisionType.WARN) {
+                                finalDecision = policy_1.DecisionType.WARN;
+                                finalReason = rule.action.reason;
+                            }
+                        }
+                    }
+                    // Break early if DENY decision made
+                    if (finalDecision === policy_1.DecisionType.DENY) {
+                        break;
+                    }
+                }
+                return [2 /*return*/, {
+                        decision: finalDecision,
+                        allowed: finalDecision !== policy_1.DecisionType.DENY,
+                        reason: finalReason,
+                        matchedPolicies: __spreadArray([], new Set(matchedPolicies), true),
+                        matchedRules: __spreadArray([], new Set(matchedRules), true),
+                        evaluationTimeMs: 0, // Will be set by caller
+                        modifications: Object.keys(modifications).length > 0 ? modifications : undefined,
+                        trace: trace && traces.length > 0 ? traces[0] : undefined,
+                    }];
+            });
+        });
+    };
+    /**
+     * Simulate policy evaluation (dry run)
+     */
+    PolicyEngine.prototype.simulate = function (request) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.evaluate(__assign(__assign({}, request), { dryRun: true, trace: true }))];
+            });
+        });
+    };
+    return PolicyEngine;
+}());
+exports.PolicyEngine = PolicyEngine;

package/dist/bundled-agents/policy-engine-agents/dist/functions/core/evaluator/condition-evaluator.js

@@ -0,0 +1,196 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConditionEvaluator = void 0;
+/**
+ * Condition Evaluator - Evaluates policy conditions against context
+ */
+var policy_1 = require("../../types/policy");
+var errors_1 = require("../../utils/errors");
+var logger_1 = __importDefault(require("../../utils/logger"));
+var lodash_1 = require("lodash");
+var ConditionEvaluator = /** @class */ (function () {
+    function ConditionEvaluator() {
+    }
+    /**
+     * Evaluate a condition against an evaluation context
+     */
+    ConditionEvaluator.prototype.evaluate = function (condition, context) {
+        var startTime = Date.now();
+        try {
+            var result = this.evaluateCondition(condition, context);
+            var evaluationTimeMs = Date.now() - startTime;
+            logger_1.default.debug({
+                condition: condition,
+                result: result,
+                evaluationTimeMs: evaluationTimeMs,
+            }, 'Condition evaluated');
+            return {
+                result: result,
+                evaluationTimeMs: evaluationTimeMs,
+                details: "Evaluated ".concat(condition.operator, " condition"),
+            };
+        }
+        catch (error) {
+            var evaluationTimeMs = Date.now() - startTime;
+            logger_1.default.error({ condition: condition, error: error }, 'Condition evaluation failed');
+            throw new errors_1.PolicyEvaluationError("Condition evaluation failed: ".concat(error instanceof Error ? error.message : String(error)), { condition: condition, evaluationTimeMs: evaluationTimeMs });
+        }
+    };
+    /**
+     * Internal recursive condition evaluation
+     */
+    ConditionEvaluator.prototype.evaluateCondition = function (condition, context) {
+        var operator = condition.operator;
+        // Logical operators
+        if (operator === policy_1.ConditionOperator.AND) {
+            return this.evaluateAnd(condition.conditions || [], context);
+        }
+        if (operator === policy_1.ConditionOperator.OR) {
+            return this.evaluateOr(condition.conditions || [], context);
+        }
+        if (operator === policy_1.ConditionOperator.NOT) {
+            return !this.evaluateCondition(condition.conditions[0], context);
+        }
+        // Comparison operators
+        var fieldValue = this.getFieldValue(condition.field, context);
+        var compareValue = condition.value;
+        switch (operator) {
+            case policy_1.ConditionOperator.EQUALS:
+                return this.equals(fieldValue, compareValue);
+            case policy_1.ConditionOperator.NOT_EQUALS:
+                return !this.equals(fieldValue, compareValue);
+            case policy_1.ConditionOperator.GREATER_THAN:
+                return this.greaterThan(fieldValue, compareValue);
+            case policy_1.ConditionOperator.GREATER_THAN_OR_EQUAL:
+                return this.greaterThanOrEqual(fieldValue, compareValue);
+            case policy_1.ConditionOperator.LESS_THAN:
+                return this.lessThan(fieldValue, compareValue);
+            case policy_1.ConditionOperator.LESS_THAN_OR_EQUAL:
+                return this.lessThanOrEqual(fieldValue, compareValue);
+            case policy_1.ConditionOperator.IN:
+                return this.in(fieldValue, compareValue);
+            case policy_1.ConditionOperator.NOT_IN:
+                return !this.in(fieldValue, compareValue);
+            case policy_1.ConditionOperator.CONTAINS:
+                return this.contains(fieldValue, compareValue);
+            case policy_1.ConditionOperator.NOT_CONTAINS:
+                return !this.contains(fieldValue, compareValue);
+            case policy_1.ConditionOperator.MATCHES:
+                return this.matches(fieldValue, compareValue);
+            default:
+                throw new errors_1.PolicyEvaluationError("Unknown operator: ".concat(operator));
+        }
+    };
+    /**
+     * AND operator - all conditions must be true
+     */
+    ConditionEvaluator.prototype.evaluateAnd = function (conditions, context) {
+        var _this = this;
+        return conditions.every(function (cond) { return _this.evaluateCondition(cond, context); });
+    };
+    /**
+     * OR operator - at least one condition must be true
+     */
+    ConditionEvaluator.prototype.evaluateOr = function (conditions, context) {
+        var _this = this;
+        return conditions.some(function (cond) { return _this.evaluateCondition(cond, context); });
+    };
+    /**
+     * Get field value from context using dot notation
+     */
+    ConditionEvaluator.prototype.getFieldValue = function (field, context) {
+        return (0, lodash_1.get)(context, field);
+    };
+    /**
+     * Equality comparison
+     */
+    ConditionEvaluator.prototype.equals = function (a, b) {
+        if (a === b)
+            return true;
+        if (a == null || b == null)
+            return a === b;
+        // Deep equality for objects and arrays
+        if (typeof a === 'object' && typeof b === 'object') {
+            return JSON.stringify(a) === JSON.stringify(b);
+        }
+        return String(a) === String(b);
+    };
+    /**
+     * Greater than comparison
+     */
+    ConditionEvaluator.prototype.greaterThan = function (a, b) {
+        var numA = Number(a);
+        var numB = Number(b);
+        if (isNaN(numA) || isNaN(numB)) {
+            return String(a) > String(b);
+        }
+        return numA > numB;
+    };
+    /**
+     * Greater than or equal comparison
+     */
+    ConditionEvaluator.prototype.greaterThanOrEqual = function (a, b) {
+        return this.greaterThan(a, b) || this.equals(a, b);
+    };
+    /**
+     * Less than comparison
+     */
+    ConditionEvaluator.prototype.lessThan = function (a, b) {
+        var numA = Number(a);
+        var numB = Number(b);
+        if (isNaN(numA) || isNaN(numB)) {
+            return String(a) < String(b);
+        }
+        return numA < numB;
+    };
+    /**
+     * Less than or equal comparison
+     */
+    ConditionEvaluator.prototype.lessThanOrEqual = function (a, b) {
+        return this.lessThan(a, b) || this.equals(a, b);
+    };
+    /**
+     * IN operator - value is in array
+     */
+    ConditionEvaluator.prototype.in = function (value, array) {
+        var _this = this;
+        if (!Array.isArray(array)) {
+            return false;
+        }
+        return array.some(function (item) { return _this.equals(value, item); });
+    };
+    /**
+     * CONTAINS operator - array/string contains value
+     */
+    ConditionEvaluator.prototype.contains = function (haystack, needle) {
+        var _this = this;
+        if (typeof haystack === 'string') {
+            return haystack.includes(String(needle));
+        }
+        if (Array.isArray(haystack)) {
+            return haystack.some(function (item) { return _this.equals(item, needle); });
+        }
+        if (typeof haystack === 'object' && haystack !== null) {
+            return Object.values(haystack).some(function (value) { return _this.equals(value, needle); });
+        }
+        return false;
+    };
+    /**
+     * MATCHES operator - regex match
+     */
+    ConditionEvaluator.prototype.matches = function (value, pattern) {
+        try {
+            var regex = new RegExp(pattern);
+            return regex.test(String(value));
+        }
+        catch (error) {
+            logger_1.default.warn({ pattern: pattern, error: error }, 'Invalid regex pattern');
+            return false;
+        }
+    };
+    return ConditionEvaluator;
+}());
+exports.ConditionEvaluator = ConditionEvaluator;

package/dist/bundled-agents/policy-engine-agents/dist/functions/core/primitives/cost-calculator.js

@@ -0,0 +1,176 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CostCalculator = void 0;
+/**
+ * Cost Calculator for LLM requests
+ */
+var token_counter_1 = require("./token-counter");
+var CostCalculator = /** @class */ (function () {
+    function CostCalculator() {
+        // Pricing data (as of 2025 - update regularly)
+        this.pricing = {
+            openai: {
+                'gpt-4-turbo': {
+                    promptCostPer1kTokens: 0.01,
+                    completionCostPer1kTokens: 0.03,
+                    currency: 'USD',
+                },
+                'gpt-4': {
+                    promptCostPer1kTokens: 0.03,
+                    completionCostPer1kTokens: 0.06,
+                    currency: 'USD',
+                },
+                'gpt-4-32k': {
+                    promptCostPer1kTokens: 0.06,
+                    completionCostPer1kTokens: 0.12,
+                    currency: 'USD',
+                },
+                'gpt-3.5-turbo': {
+                    promptCostPer1kTokens: 0.0005,
+                    completionCostPer1kTokens: 0.0015,
+                    currency: 'USD',
+                },
+                'gpt-3.5-turbo-16k': {
+                    promptCostPer1kTokens: 0.003,
+                    completionCostPer1kTokens: 0.004,
+                    currency: 'USD',
+                },
+            },
+            anthropic: {
+                'claude-3-opus': {
+                    promptCostPer1kTokens: 0.015,
+                    completionCostPer1kTokens: 0.075,
+                    currency: 'USD',
+                },
+                'claude-3-sonnet': {
+                    promptCostPer1kTokens: 0.003,
+                    completionCostPer1kTokens: 0.015,
+                    currency: 'USD',
+                },
+                'claude-3-haiku': {
+                    promptCostPer1kTokens: 0.00025,
+                    completionCostPer1kTokens: 0.00125,
+                    currency: 'USD',
+                },
+                'claude-2.1': {
+                    promptCostPer1kTokens: 0.008,
+                    completionCostPer1kTokens: 0.024,
+                    currency: 'USD',
+                },
+                'claude-2': {
+                    promptCostPer1kTokens: 0.008,
+                    completionCostPer1kTokens: 0.024,
+                    currency: 'USD',
+                },
+                'claude-instant': {
+                    promptCostPer1kTokens: 0.0008,
+                    completionCostPer1kTokens: 0.0024,
+                    currency: 'USD',
+                },
+            },
+            google: {
+                'gemini-pro': {
+                    promptCostPer1kTokens: 0.00025,
+                    completionCostPer1kTokens: 0.0005,
+                    currency: 'USD',
+                },
+                'gemini-ultra': {
+                    promptCostPer1kTokens: 0.001,
+                    completionCostPer1kTokens: 0.002,
+                    currency: 'USD',
+                },
+                'palm-2': {
+                    promptCostPer1kTokens: 0.0005,
+                    completionCostPer1kTokens: 0.0005,
+                    currency: 'USD',
+                },
+            },
+        };
+        this.tokenCounter = new token_counter_1.TokenCounter();
+    }
+    /**
+     * Calculate cost for a request
+     */
+    CostCalculator.prototype.calculateCost = function (provider, model, promptTokens, completionTokens) {
+        var pricing = this.getPricing(provider, model);
+        var promptCost = (promptTokens / 1000) * pricing.promptCostPer1kTokens;
+        var completionCost = (completionTokens / 1000) * pricing.completionCostPer1kTokens;
+        var totalCost = promptCost + completionCost;
+        return {
+            provider: provider,
+            model: model,
+            promptTokens: promptTokens,
+            completionTokens: completionTokens,
+            totalTokens: promptTokens + completionTokens,
+            promptCost: promptCost,
+            completionCost: completionCost,
+            totalCost: totalCost,
+            currency: pricing.currency,
+        };
+    };
+    /**
+     * Estimate cost from text
+     */
+    CostCalculator.prototype.estimateCostFromText = function (provider, model, promptText, estimatedCompletionTokens) {
+        if (estimatedCompletionTokens === void 0) { estimatedCompletionTokens = 500; }
+        var promptTokens = this.tokenCounter.estimateTokens(promptText, model).tokens;
+        return this.calculateCost(provider, model, promptTokens, estimatedCompletionTokens);
+    };
+    /**
+     * Get pricing for a provider/model
+     */
+    CostCalculator.prototype.getPricing = function (provider, model) {
+        var _a;
+        var providerLower = provider.toLowerCase();
+        var modelLower = model.toLowerCase();
+        // Try exact match first
+        if ((_a = this.pricing[providerLower]) === null || _a === void 0 ? void 0 : _a[modelLower]) {
+            return this.pricing[providerLower][modelLower];
+        }
+        // Try partial match (e.g., "gpt-4-turbo-preview" matches "gpt-4-turbo")
+        // Sort keys by length descending to match most specific model first
+        var providerPricing = this.pricing[providerLower];
+        if (providerPricing) {
+            var matchingModel = Object.keys(providerPricing)
+                .sort(function (a, b) { return b.length - a.length; })
+                .find(function (key) { return modelLower.includes(key.toLowerCase()); });
+            if (matchingModel) {
+                return providerPricing[matchingModel];
+            }
+        }
+        // Default pricing if not found
+        return {
+            promptCostPer1kTokens: 0.01,
+            completionCostPer1kTokens: 0.03,
+            currency: 'USD',
+        };
+    };
+    /**
+     * Compare costs across providers/models
+     */
+    CostCalculator.prototype.compareCosts = function (promptTokens, completionTokens, models) {
+        var _this = this;
+        return models.map(function (_a) {
+            var provider = _a.provider, model = _a.model;
+            return _this.calculateCost(provider, model, promptTokens, completionTokens);
+        });
+    };
+    /**
+     * Find cheapest option
+     */
+    CostCalculator.prototype.findCheapest = function (promptTokens, completionTokens, models) {
+        var costs = this.compareCosts(promptTokens, completionTokens, models);
+        return costs.reduce(function (cheapest, current) {
+            return current.totalCost < cheapest.totalCost ? current : cheapest;
+        });
+    };
+    /**
+     * Calculate monthly cost based on usage
+     */
+    CostCalculator.prototype.calculateMonthlyCost = function (provider, model, dailyRequests, avgPromptTokens, avgCompletionTokens) {
+        var singleRequestCost = this.calculateCost(provider, model, avgPromptTokens, avgCompletionTokens).totalCost;
+        return singleRequestCost * dailyRequests * 30;
+    };
+    return CostCalculator;
+}());
+exports.CostCalculator = CostCalculator;

package/dist/bundled-agents/policy-engine-agents/dist/functions/core/primitives/index.js

@@ -0,0 +1,22 @@
+"use strict";
+/**
+ * LLM Primitives - Export all primitive functions
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./token-counter"), exports);
+__exportStar(require("./pii-detector"), exports);
+__exportStar(require("./cost-calculator"), exports);