@haikeilabs/agentware 0.1.0

package/dist/middleware/guardrails/response_validator.js

@@ -0,0 +1,145 @@
+import { retryNudge, unknownToolNudge } from "./nudge";
+export class ResponseValidator {
+    toolNames;
+    rescueEnabled;
+    retryNudgeFn;
+    thinkPattern;
+    pythonTagPattern;
+    codeFencePattern;
+    rehearsalPattern;
+    qwenFunctionPattern;
+    constructor(toolNames, rescueEnabled = true, retryNudgeFn) {
+        this.toolNames = new Set(toolNames);
+        this.rescueEnabled = rescueEnabled;
+        this.retryNudgeFn = retryNudgeFn ?? retryNudge;
+        this.thinkPattern = new RegExp("\\[THINK\\].*?\\[/THINK\\]|<think>.*?</think>", "gi");
+        this.pythonTagPattern = new RegExp("\\<\\|python_tag\\|\\>", "gi");
+        this.codeFencePattern = new RegExp("```(?:json)?\\s*\\n?", "g");
+        this.rehearsalPattern = new RegExp("(\\w+)\\[ARGS\\](\\{.*?\\})", "g");
+        this.qwenFunctionPattern = new RegExp("<function=([^>\\s]+)>(.*?)<\\/function>", "g");
+    }
+    validateTextResponse(response) {
+        if (this.rescueEnabled) {
+            const rescued = this.rescueToolCall(response);
+            if (rescued.length > 0) {
+                return { toolCalls: rescued, nudge: null, needsRetry: false };
+            }
+        }
+        const nudge = this.retryNudgeFn(response, Array.from(this.toolNames));
+        return { toolCalls: [], nudge, needsRetry: true };
+    }
+    validateToolCalls(toolCalls) {
+        const unknown = [];
+        const validCalls = [];
+        for (const tc of toolCalls) {
+            if (!this.toolNames.has(tc.tool)) {
+                unknown.push(tc.tool);
+            }
+            else {
+                validCalls.push(tc);
+            }
+        }
+        if (unknown.length > 0) {
+            const nudge = unknownToolNudge(unknown[0], Array.from(this.toolNames));
+            return { toolCalls: [], nudge, needsRetry: true };
+        }
+        return { toolCalls: validCalls, nudge: null, needsRetry: false };
+    }
+    rescueToolCall(response) {
+        let cleaned = response.replace(this.thinkPattern, "");
+        cleaned = cleaned.replace(this.pythonTagPattern, "");
+        cleaned = cleaned.trim();
+        if (!cleaned) {
+            return [];
+        }
+        let calls = this.extractJsonToolCalls(cleaned);
+        if (calls.length > 0) {
+            return calls;
+        }
+        calls = this.extractRehearsalToolCalls(cleaned);
+        if (calls.length > 0) {
+            return calls;
+        }
+        return this.extractQwenXmlToolCalls(cleaned);
+    }
+    extractJsonToolCalls(text) {
+        const cleaned = text.replace(this.codeFencePattern, "").trim();
+        const calls = [];
+        let i = 0;
+        while (i < cleaned.length) {
+            if (cleaned[i] === "{") {
+                let depth = 0;
+                let j = i;
+                while (j < cleaned.length) {
+                    if (cleaned[j] === "{") {
+                        depth++;
+                    }
+                    else if (cleaned[j] === "}") {
+                        depth--;
+                        if (depth === 0) {
+                            const candidate = cleaned.slice(i, j + 1);
+                            const call = this.tryParseToolCall(candidate);
+                            if (call) {
+                                calls.push(call);
+                            }
+                            i = j + 1;
+                            break;
+                        }
+                    }
+                    j++;
+                }
+                if (depth !== 0) {
+                    i++;
+                }
+            }
+            else {
+                i++;
+            }
+        }
+        return calls;
+    }
+    tryParseToolCall(jsonStr) {
+        let data;
+        try {
+            data = JSON.parse(jsonStr);
+        }
+        catch {
+            return null;
+        }
+        const toolName = data.tool || data.name;
+        if (!toolName) {
+            return null;
+        }
+        if (!this.toolNames.has(toolName)) {
+            return null;
+        }
+        const args = data.args ||
+            data.arguments || {};
+        return { tool: toolName, args };
+    }
+    extractRehearsalToolCalls(text) {
+        const calls = [];
+        const regex = /(\w+)\[ARGS\](\{.*?\})/g;
+        let match;
+        while ((match = regex.exec(text)) !== null) {
+            const toolName = match[1];
+            const argsStr = match[2];
+            if (!this.toolNames.has(toolName)) {
+                continue;
+            }
+            try {
+                const args = JSON.parse(argsStr);
+                if (typeof args === "object" && args !== null) {
+                    calls.push({ tool: toolName, args: args });
+                }
+            }
+            catch {
+                continue;
+            }
+        }
+        return calls;
+    }
+    extractQwenXmlToolCalls(_text) {
+        return [];
+    }
+}

package/dist/middleware/guardrails/step_enforcer.d.ts

@@ -0,0 +1,20 @@
+export declare class StepNotAllowedError extends Error {
+    tool: string;
+    missingSteps: string[];
+    constructor(tool: string, missingSteps: string[]);
+}
+export declare class StepEnforcer {
+    private stepDefinitions;
+    private completedSteps;
+    private allowedTerminals;
+    constructor();
+    addStep(tool: string, prerequisites?: string[]): void;
+    addTerminal(tool: string, allowed?: Map<string, boolean>): void;
+    markStepComplete(sessionId: string, step: string): void;
+    resetSession(sessionId: string): void;
+    canExecute(sessionId: string, tool: string): [boolean, string[]];
+    validateExecution(sessionId: string, tool: string): void;
+    isTerminalAllowed(sessionId: string, terminalTool: string): boolean;
+    getAllowedTerminals(sessionId: string): string[];
+}
+//# sourceMappingURL=step_enforcer.d.ts.map

package/dist/middleware/guardrails/step_enforcer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"step_enforcer.d.ts","sourceRoot":"","sources":["../../../src/middleware/guardrails/step_enforcer.ts"],"names":[],"mappings":"AAAA,qBAAa,mBAAoB,SAAQ,KAAK;IAC5C,IAAI,EAAE,MAAM,CAAC;IACb,YAAY,EAAE,MAAM,EAAE,CAAC;gBAEX,IAAI,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,EAAE;CAMjD;AAED,qBAAa,YAAY;IACvB,OAAO,CAAC,eAAe,CAAwB;IAC/C,OAAO,CAAC,cAAc,CAAoC;IAC1D,OAAO,CAAC,gBAAgB,CAAoC;;IAQ5D,OAAO,CAAC,IAAI,EAAE,MAAM,EAAE,aAAa,CAAC,EAAE,MAAM,EAAE,GAAG,IAAI;IAIrD,WAAW,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,GAAG,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI;IAI/D,gBAAgB,CAAC,SAAS,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,IAAI;IAOvD,YAAY,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI;IAIrC,UAAU,CAAC,SAAS,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,CAAC,OAAO,EAAE,MAAM,EAAE,CAAC;IAYhE,iBAAiB,CAAC,SAAS,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,IAAI;IAQxD,iBAAiB,CAAC,SAAS,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,GAAG,OAAO;IAKnE,mBAAmB,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,EAAE;CAUjD"}

package/dist/middleware/guardrails/step_enforcer.js

@@ -0,0 +1,65 @@
+export class StepNotAllowedError extends Error {
+    tool;
+    missingSteps;
+    constructor(tool, missingSteps) {
+        super(`step not allowed: missing ${missingSteps.join(", ")}`);
+        this.name = "StepNotAllowedError";
+        this.tool = tool;
+        this.missingSteps = missingSteps;
+    }
+}
+export class StepEnforcer {
+    stepDefinitions;
+    completedSteps;
+    allowedTerminals;
+    constructor() {
+        this.stepDefinitions = new Map();
+        this.completedSteps = new Map();
+        this.allowedTerminals = new Map();
+    }
+    addStep(tool, prerequisites) {
+        this.stepDefinitions.set(tool, prerequisites || []);
+    }
+    addTerminal(tool, allowed) {
+        this.allowedTerminals.set(tool, allowed || new Map());
+    }
+    markStepComplete(sessionId, step) {
+        if (!this.completedSteps.has(sessionId)) {
+            this.completedSteps.set(sessionId, new Map());
+        }
+        this.completedSteps.get(sessionId).set(step, true);
+    }
+    resetSession(sessionId) {
+        this.completedSteps.delete(sessionId);
+    }
+    canExecute(sessionId, tool) {
+        const prereqs = this.stepDefinitions.get(tool);
+        if (prereqs === undefined) {
+            return [true, []];
+        }
+        const completed = this.completedSteps.get(sessionId) || new Map();
+        const missing = prereqs.filter((p) => completed.get(p) !== true);
+        return [missing.length === 0, missing];
+    }
+    validateExecution(sessionId, tool) {
+        const [allowed, missing] = this.canExecute(sessionId, tool);
+        if (allowed) {
+            return;
+        }
+        throw new StepNotAllowedError(tool, missing);
+    }
+    isTerminalAllowed(sessionId, terminalTool) {
+        const [allowed] = this.canExecute(sessionId, terminalTool);
+        return allowed;
+    }
+    getAllowedTerminals(sessionId) {
+        const result = [];
+        for (const tool of this.stepDefinitions.keys()) {
+            const [allowed] = this.canExecute(sessionId, tool);
+            if (allowed) {
+                result.push(tool);
+            }
+        }
+        return result;
+    }
+}

package/dist/middleware/index.d.ts

@@ -0,0 +1,5 @@
+export { MiddlewareImpl, Middleware, ToolExecutor } from "./middleware.js";
+export { Action, CallerContext, Decision, MessageType, MessageMeta } from "./types.js";
+export { PolicyEvaluator, Policy, Rule, Condition, Operator, SimplePolicyEvaluator } from "./policy.js";
+export { Auditor, AuditRecord, InMemoryAuditor, AuditFilter } from "./audit.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/middleware/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/middleware/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,UAAU,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAC3E,OAAO,EAAE,MAAM,EAAE,aAAa,EAAE,QAAQ,EAAE,WAAW,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AACvF,OAAO,EAAE,eAAe,EAAE,MAAM,EAAE,IAAI,EAAE,SAAS,EAAE,QAAQ,EAAE,qBAAqB,EAAE,MAAM,aAAa,CAAC;AACxG,OAAO,EAAE,OAAO,EAAE,WAAW,EAAE,eAAe,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC"}

package/dist/middleware/index.js

@@ -0,0 +1,4 @@
+export { MiddlewareImpl } from "./middleware.js";
+export { Action, MessageType } from "./types.js";
+export { Operator, SimplePolicyEvaluator } from "./policy.js";
+export { InMemoryAuditor } from "./audit.js";

package/dist/middleware/inference.d.ts

@@ -0,0 +1,28 @@
+import type { Message, ToolDefinition } from "../llm/request.js";
+import type { Response } from "../llm/response.js";
+import type { Backend } from "../llm/backend.js";
+import type { ContextWindowManager } from "../llmcontext/context_window.js";
+import type { ResponseValidator } from "./guardrails/response_validator.js";
+import { ErrorTracker } from "./guardrails/error_tracker.js";
+import { StepEnforcer } from "./guardrails/step_enforcer.js";
+export declare class RetriesExhaustedError extends Error {
+    constructor(message: string);
+}
+export interface InferenceResult {
+    response: Response;
+    newMessages: Message[];
+    toolCallCounter: number;
+    attempts: number;
+}
+export interface InferenceConfig {
+    client: Backend;
+    contextManager?: ContextWindowManager;
+    validator?: ResponseValidator;
+    errorTracker?: ErrorTracker;
+    stepEnforcer?: StepEnforcer;
+    toolSpecs: ToolDefinition[];
+    maxAttempts: number;
+    stepIndex?: number;
+}
+export declare function runInference(messages: Message[], cfg: InferenceConfig, sessionId?: string): Promise<InferenceResult | null>;
+//# sourceMappingURL=inference.d.ts.map

package/dist/middleware/inference.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inference.d.ts","sourceRoot":"","sources":["../../src/middleware/inference.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AACjE,OAAO,KAAK,EAAE,QAAQ,EAA2B,MAAM,oBAAoB,CAAC;AAC5E,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,mBAAmB,CAAC;AACjD,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,iCAAiC,CAAC;AAG5E,OAAO,KAAK,EAAE,iBAAiB,EAA8B,MAAM,oCAAoC,CAAC;AACxG,OAAO,EAAE,YAAY,EAAiB,MAAM,+BAA+B,CAAC;AAC5E,OAAO,EAAE,YAAY,EAAE,MAAM,+BAA+B,CAAC;AAG7D,qBAAa,qBAAsB,SAAQ,KAAK;gBAClC,OAAO,EAAE,MAAM;CAI5B;AAED,MAAM,WAAW,eAAe;IAC9B,QAAQ,EAAE,QAAQ,CAAC;IACnB,WAAW,EAAE,OAAO,EAAE,CAAC;IACvB,eAAe,EAAE,MAAM,CAAC;IACxB,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,eAAe;IAC9B,MAAM,EAAE,OAAO,CAAC;IAChB,cAAc,CAAC,EAAE,oBAAoB,CAAC;IACtC,SAAS,CAAC,EAAE,iBAAiB,CAAC;IAC9B,YAAY,CAAC,EAAE,YAAY,CAAC;IAC5B,YAAY,CAAC,EAAE,YAAY,CAAC;IAC5B,SAAS,EAAE,cAAc,EAAE,CAAC;IAC5B,WAAW,EAAE,MAAM,CAAC;IACpB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED,wBAAsB,YAAY,CAChC,QAAQ,EAAE,OAAO,EAAE,EACnB,GAAG,EAAE,eAAe,EACpB,SAAS,GAAE,MAAW,GACrB,OAAO,CAAC,eAAe,GAAG,IAAI,CAAC,CAwJjC"}

package/dist/middleware/inference.js

@@ -0,0 +1,141 @@
+import { Role } from "../llm/request.js";
+import { MessageType } from "./types.js";
+import { ErrorCategory } from "./guardrails/error_tracker.js";
+import { stepNudge } from "./guardrails/nudge.js";
+export class RetriesExhaustedError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "RetriesExhaustedError";
+    }
+}
+export async function runInference(messages, cfg, sessionId = "") {
+    let maxAttempts = cfg.maxAttempts;
+    if (maxAttempts <= 0) {
+        maxAttempts = 3;
+    }
+    const currentMessages = [...messages];
+    let lastResponse = null;
+    let toolCallCounter = 0;
+    let attempts = 0;
+    while (attempts < maxAttempts) {
+        attempts++;
+        if (cfg.contextManager) {
+            if (cfg.contextManager.shouldCompact(currentMessages)) {
+                const compacted = cfg.contextManager.compact(currentMessages);
+                currentMessages.length = 0;
+                currentMessages.push(...compacted);
+            }
+            const warning = cfg.contextManager.checkThresholds(currentMessages);
+            if (warning) {
+                const warningMsg = {
+                    role: Role.USER,
+                    content: warning,
+                    meta: { type: MessageType.CONTEXT_WARNING },
+                };
+                currentMessages.push(warningMsg);
+            }
+        }
+        let resp;
+        try {
+            resp = cfg.client.complete(currentMessages);
+        }
+        catch (e) {
+            if (cfg.errorTracker && e instanceof Error) {
+                cfg.errorTracker.recordError(sessionId, "", {}, e, ErrorCategory.UNKNOWN);
+            }
+            throw e;
+        }
+        if (cfg.contextManager && resp.usage_tokens.total_tokens > 0) {
+            cfg.contextManager.updateTokenCount(resp.usage_tokens.total_tokens);
+        }
+        let validationResult = null;
+        if (resp.tool_calls && resp.tool_calls.length > 0) {
+            const guardrailsToolCalls = resp.tool_calls.map((tc) => ({
+                tool: tc.name,
+                args: tc.arguments,
+            }));
+            if (cfg.validator) {
+                validationResult = cfg.validator.validateToolCalls(guardrailsToolCalls);
+            }
+            else {
+                validationResult = {
+                    toolCalls: guardrailsToolCalls,
+                    nudge: null,
+                    needsRetry: false,
+                };
+            }
+        }
+        else if (resp.content) {
+            if (cfg.validator) {
+                validationResult = cfg.validator.validateTextResponse(resp.content);
+            }
+            else {
+                validationResult = { toolCalls: [], nudge: null, needsRetry: false };
+            }
+            if (!validationResult.needsRetry && validationResult.toolCalls.length > 0) {
+                resp.tool_calls = validationResult.toolCalls.map((tc) => ({
+                    id: "",
+                    name: tc.tool,
+                    arguments: tc.args,
+                }));
+            }
+        }
+        else {
+            if (cfg.validator) {
+                validationResult = cfg.validator.validateTextResponse("");
+            }
+            else {
+                validationResult = { toolCalls: [], nudge: null, needsRetry: true };
+            }
+        }
+        lastResponse = resp;
+        if (validationResult && !validationResult.needsRetry) {
+            if (cfg.errorTracker) {
+                cfg.errorTracker.resetSession(sessionId);
+            }
+            if (cfg.stepEnforcer && resp.tool_calls && resp.tool_calls.length > 0) {
+                for (const tc of resp.tool_calls) {
+                    const [allowed, missing] = cfg.stepEnforcer.canExecute(sessionId, tc.name);
+                    if (!allowed) {
+                        const nudge = stepNudge(tc.name, missing, 1);
+                        const nudgeMsg = {
+                            role: Role.USER,
+                            content: nudge.content,
+                            meta: { type: MessageType.STEP_NUDGE },
+                        };
+                        currentMessages.push(nudgeMsg);
+                        continue;
+                    }
+                }
+            }
+            toolCallCounter += resp.tool_calls ? resp.tool_calls.length : 0;
+            return {
+                response: lastResponse,
+                newMessages: currentMessages,
+                toolCallCounter,
+                attempts,
+            };
+        }
+        if (cfg.errorTracker) {
+            cfg.errorTracker.recordError(sessionId, "", {}, new Error("validation failed"), ErrorCategory.UNKNOWN);
+        }
+        if (attempts >= maxAttempts) {
+            throw new RetriesExhaustedError(`retries exhausted after ${attempts} attempts`);
+        }
+        if (validationResult && validationResult.nudge) {
+            const nudgeMsg = {
+                role: Role.USER,
+                content: validationResult.nudge.content,
+                meta: { type: MessageType.RETRY_NUDGE },
+            };
+            currentMessages.push(nudgeMsg);
+        }
+        const failedMsg = {
+            role: Role.ASSISTANT,
+            content: resp.content,
+            meta: { type: MessageType.TEXT_RESPONSE },
+        };
+        currentMessages.push(failedMsg);
+    }
+    throw new RetriesExhaustedError(`retries exhausted after ${attempts} attempts`);
+}

package/dist/middleware/middleware.d.ts

@@ -0,0 +1,22 @@
+import type { CallerContext } from "./types.js";
+import type { PolicyEvaluator } from "./policy.js";
+import type { Auditor } from "./audit.js";
+export interface ToolExecutor {
+    execute(toolName: string, args: Record<string, unknown>): [unknown, boolean, string];
+}
+export interface Middleware {
+    execute(toolName: string, args: Record<string, unknown>, caller: CallerContext): [unknown, boolean, string];
+    withPolicy(evaluator: PolicyEvaluator): MiddlewareImpl;
+    withAuditor(auditor: Auditor): MiddlewareImpl;
+}
+export declare class MiddlewareImpl implements Middleware {
+    private executor;
+    private evaluator;
+    private auditor;
+    constructor(executor: ToolExecutor);
+    execute(toolName: string, args: Record<string, unknown>, caller: CallerContext): [unknown, boolean, string];
+    withPolicy(evaluator: PolicyEvaluator): MiddlewareImpl;
+    withAuditor(auditor: Auditor): MiddlewareImpl;
+}
+export declare function newMiddleware(executor: ToolExecutor): MiddlewareImpl;
+//# sourceMappingURL=middleware.d.ts.map

package/dist/middleware/middleware.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"middleware.d.ts","sourceRoot":"","sources":["../../src/middleware/middleware.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAChD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AACnD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC;AAG1C,MAAM,WAAW,YAAY;IAC3B,OAAO,CAAC,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,CAAC,OAAO,EAAE,OAAO,EAAE,MAAM,CAAC,CAAC;CACtF;AAED,MAAM,WAAW,UAAU;IACzB,OAAO,CACL,QAAQ,EAAE,MAAM,EAChB,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC7B,MAAM,EAAE,aAAa,GACpB,CAAC,OAAO,EAAE,OAAO,EAAE,MAAM,CAAC,CAAC;IAC9B,UAAU,CAAC,SAAS,EAAE,eAAe,GAAG,cAAc,CAAC;IACvD,WAAW,CAAC,OAAO,EAAE,OAAO,GAAG,cAAc,CAAC;CAC/C;AAED,qBAAa,cAAe,YAAW,UAAU;IAC/C,OAAO,CAAC,QAAQ,CAAe;IAC/B,OAAO,CAAC,SAAS,CAAgC;IACjD,OAAO,CAAC,OAAO,CAAwB;gBAE3B,QAAQ,EAAE,YAAY;IAIlC,OAAO,CACL,QAAQ,EAAE,MAAM,EAChB,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC7B,MAAM,EAAE,aAAa,GACpB,CAAC,OAAO,EAAE,OAAO,EAAE,MAAM,CAAC;IAoC7B,UAAU,CAAC,SAAS,EAAE,eAAe,GAAG,cAAc;IAKtD,WAAW,CAAC,OAAO,EAAE,OAAO,GAAG,cAAc;CAI9C;AAED,wBAAgB,aAAa,CAAC,QAAQ,EAAE,YAAY,GAAG,cAAc,CAEpE"}

package/dist/middleware/middleware.js

@@ -0,0 +1,51 @@
+import { Action } from "./types.js";
+export class MiddlewareImpl {
+    executor;
+    evaluator = null;
+    auditor = null;
+    constructor(executor) {
+        this.executor = executor;
+    }
+    execute(toolName, args, caller) {
+        const decision = this.evaluator
+            ? this.evaluator.evaluate(toolName, args, caller)
+            : { action: Action.ALLOW, rule: "default", reason: "no policy configured", timestamp: new Date() };
+        if (this.auditor) {
+            this.auditor.record({
+                session_id: caller.session_id || "",
+                tool_name: toolName,
+                args,
+                decision,
+                timestamp: new Date(),
+            });
+        }
+        if (decision.action === Action.DENY) {
+            return [null, false, `denied by policy: ${decision.reason}`];
+        }
+        if (decision.action === Action.FILTER) {
+            const redactFields = typeof decision.redacted_args === 'object' && decision.redacted_args !== null
+                ? Object.keys(decision.redacted_args)
+                : [];
+            if (redactFields.length > 0) {
+                args = { ...args };
+                for (const field of redactFields) {
+                    if (field in args) {
+                        args[field] = "[REDACTED]";
+                    }
+                }
+            }
+        }
+        return this.executor.execute(toolName, args);
+    }
+    withPolicy(evaluator) {
+        this.evaluator = evaluator;
+        return this;
+    }
+    withAuditor(auditor) {
+        this.auditor = auditor;
+        return this;
+    }
+}
+export function newMiddleware(executor) {
+    return new MiddlewareImpl(executor);
+}

package/dist/middleware/policy.d.ts

@@ -0,0 +1,46 @@
+import type { CallerContext, Decision } from "./types.js";
+import { Action } from "./types.js";
+export declare enum Operator {
+    EQ = "eq",
+    NOT_EQ = "not_eq",
+    CONTAINS = "contains",
+    NOT_CONTAINS = "not_contains",
+    MATCHES = "matches",
+    NOT_MATCHES = "not_matches",
+    EXISTS = "exists",
+    NOT_EXISTS = "not_exists"
+}
+export interface PolicyEvaluator {
+    evaluate(toolName: string, args: Record<string, unknown>, caller: CallerContext): Decision;
+}
+export interface Condition {
+    field: string;
+    operator: Operator;
+    value?: string;
+}
+export interface Rule {
+    name: string;
+    tools?: string[];
+    action: Action;
+    conditions?: Condition[];
+    max_rate?: {
+        count: number;
+        window_ms: number;
+    };
+    redact_fields?: string[];
+}
+export interface Policy {
+    rules: Rule[];
+    default_deny: boolean;
+}
+export declare class SimplePolicyEvaluator implements PolicyEvaluator {
+    private policy;
+    constructor(policy: Policy);
+    evaluate(toolName: string, args: Record<string, unknown>, caller: CallerContext): Decision;
+    private ruleMatchesTool;
+    private evaluateConditions;
+    private evaluateCondition;
+    private getValue;
+    private compare;
+}
+//# sourceMappingURL=policy.d.ts.map

package/dist/middleware/policy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"policy.d.ts","sourceRoot":"","sources":["../../src/middleware/policy.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAC1D,OAAO,EAAE,MAAM,EAAE,MAAM,YAAY,CAAC;AAEpC,oBAAY,QAAQ;IAClB,EAAE,OAAO;IACT,MAAM,WAAW;IACjB,QAAQ,aAAa;IACrB,YAAY,iBAAiB;IAC7B,OAAO,YAAY;IACnB,WAAW,gBAAgB;IAC3B,MAAM,WAAW;IACjB,UAAU,eAAe;CAC1B;AAED,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,EAAE,aAAa,GAAG,QAAQ,CAAC;CAC5F;AAED,MAAM,WAAW,SAAS;IACxB,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,QAAQ,CAAC;IACnB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,IAAI;IACnB,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,CAAC,EAAE,MAAM,EAAE,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,CAAC,EAAE,SAAS,EAAE,CAAC;IACzB,QAAQ,CAAC,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAA;KAAE,CAAC;IAChD,aAAa,CAAC,EAAE,MAAM,EAAE,CAAC;CAC1B;AAED,MAAM,WAAW,MAAM;IACrB,KAAK,EAAE,IAAI,EAAE,CAAC;IACd,YAAY,EAAE,OAAO,CAAC;CACvB;AAED,qBAAa,qBAAsB,YAAW,eAAe;IAC3D,OAAO,CAAC,MAAM,CAAS;gBAEX,MAAM,EAAE,MAAM;IAI1B,QAAQ,CAAC,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,EAAE,aAAa,GAAG,QAAQ;IAwC1F,OAAO,CAAC,eAAe;IAKvB,OAAO,CAAC,kBAAkB;IAS1B,OAAO,CAAC,iBAAiB;IASzB,OAAO,CAAC,QAAQ;IAoBhB,OAAO,CAAC,OAAO;CA8BhB"}

package/dist/middleware/policy.js

@@ -0,0 +1,122 @@
+import { Action } from "./types.js";
+export var Operator;
+(function (Operator) {
+    Operator["EQ"] = "eq";
+    Operator["NOT_EQ"] = "not_eq";
+    Operator["CONTAINS"] = "contains";
+    Operator["NOT_CONTAINS"] = "not_contains";
+    Operator["MATCHES"] = "matches";
+    Operator["NOT_MATCHES"] = "not_matches";
+    Operator["EXISTS"] = "exists";
+    Operator["NOT_EXISTS"] = "not_exists";
+})(Operator || (Operator = {}));
+export class SimplePolicyEvaluator {
+    policy;
+    constructor(policy) {
+        this.policy = policy;
+    }
+    evaluate(toolName, args, caller) {
+        for (const rule of this.policy.rules) {
+            if (!this.ruleMatchesTool(rule, toolName))
+                continue;
+            if (!this.evaluateConditions(rule.conditions || [], args, caller))
+                continue;
+            const redacted_args = {};
+            if (rule.redact_fields) {
+                for (const field of rule.redact_fields) {
+                    if (field in args) {
+                        redacted_args[field] = true;
+                    }
+                }
+            }
+            return {
+                action: rule.action,
+                rule: rule.name,
+                reason: `matched rule ${rule.name}`,
+                timestamp: new Date(),
+                redacted_args: Object.keys(redacted_args).length > 0 ? redacted_args : undefined,
+            };
+        }
+        if (this.policy.default_deny) {
+            return {
+                action: Action.DENY,
+                rule: "default",
+                reason: "no matching rules and default deny is enabled",
+                timestamp: new Date(),
+            };
+        }
+        return {
+            action: Action.ALLOW,
+            rule: "default",
+            reason: "no matching rules and default allow is enabled",
+            timestamp: new Date(),
+        };
+    }
+    ruleMatchesTool(rule, toolName) {
+        if (!rule.tools || rule.tools.length === 0)
+            return true;
+        return rule.tools.includes("*") || rule.tools.includes(toolName);
+    }
+    evaluateConditions(conditions, args, caller) {
+        if (conditions.length === 0)
+            return true;
+        return conditions.every((c) => this.evaluateCondition(c, args, caller));
+    }
+    evaluateCondition(condition, args, caller) {
+        const value = this.getValue(condition.field, args, caller);
+        return this.compare(value, condition.operator, condition.value || "");
+    }
+    getValue(field, args, caller) {
+        if (field.startsWith("caller.")) {
+            const key = field.slice(7);
+            if (key === "role")
+                return caller.role || "";
+            if (key === "source")
+                return caller.source || "";
+            if (key === "trusted")
+                return caller.trusted ? "true" : "false";
+            if (key === "user_id")
+                return caller.user_id || "";
+            if (key === "session_id")
+                return caller.session_id || "";
+        }
+        else if (field.startsWith("args.")) {
+            const key = field.slice(5);
+            const val = args[key];
+            return val !== undefined ? String(val) : "";
+        }
+        return "";
+    }
+    compare(value, operator, target) {
+        switch (operator) {
+            case Operator.EQ:
+                return value === target;
+            case Operator.NOT_EQ:
+                return value !== target;
+            case Operator.CONTAINS:
+                return value.includes(target);
+            case Operator.NOT_CONTAINS:
+                return !value.includes(target);
+            case Operator.MATCHES:
+                try {
+                    return new RegExp(target).test(value);
+                }
+                catch {
+                    return false;
+                }
+            case Operator.NOT_MATCHES:
+                try {
+                    return !new RegExp(target).test(value);
+                }
+                catch {
+                    return true;
+                }
+            case Operator.EXISTS:
+                return value !== "";
+            case Operator.NOT_EXISTS:
+                return value === "";
+            default:
+                return false;
+        }
+    }
+}