@mcoda/codali 0.1.87 → 0.1.89

package/dist/gateway/GatewayPlanner.js

@@ -0,0 +1,379 @@
+import { validateCodaliGatewayPlannerOutput, } from "./CodaliGatewaySchemas.js";
+import { compileCodaliGatewayPolicy, } from "./GatewayPolicyCompiler.js";
+import { CODALI_GATEWAY_SECURITY_PROMPT_HARDENING } from "./GatewaySecurityPolicy.js";
+export class CodaliGatewayPlannerError extends Error {
+    constructor(code, message, issues) {
+        super(`${code}: ${message}`);
+        this.name = "CodaliGatewayPlannerError";
+        this.code = code;
+        this.issues = issues;
+    }
+}
+export const CODALI_GATEWAY_CLASSIFIER_SCHEMA = {
+    type: "object",
+    additionalProperties: false,
+    required: [
+        "queryType",
+        "needsPrivateData",
+        "needsFreshData",
+        "needsDocdex",
+        "needsAppTools",
+        "needsImageWorker",
+    ],
+    properties: {
+        queryType: { type: "string", minLength: 1 },
+        needsPrivateData: { type: "boolean" },
+        needsFreshData: { type: "boolean" },
+        needsDocdex: { type: "boolean" },
+        needsAppTools: { type: "boolean" },
+        needsImageWorker: { type: "boolean" },
+        directAnswerCandidate: { type: "string" },
+        rationale: { type: "string" },
+        confidence: { enum: ["high", "medium", "low"] },
+        metadata: { type: "object" },
+    },
+};
+export const CODALI_GATEWAY_PLANNER_SCHEMA = {
+    type: "object",
+    additionalProperties: true,
+    required: ["queryType", "subquestions", "workerTasks"],
+    properties: {
+        runId: { type: "string" },
+        queryType: { type: "string", minLength: 1 },
+        summary: { type: "string" },
+        subquestions: {
+            type: "array",
+            items: {
+                type: "object",
+                additionalProperties: true,
+                required: ["id", "question"],
+                properties: {
+                    id: { type: "string", minLength: 1 },
+                    question: { type: "string", minLength: 1 },
+                    rationale: { type: "string" },
+                    priority: { type: "number" },
+                },
+            },
+        },
+        workerTasks: {
+            type: "array",
+            items: {
+                type: "object",
+                additionalProperties: true,
+                required: ["id", "workerRole", "objective", "toolsAllowed", "outputFormat"],
+                properties: {
+                    id: { type: "string", minLength: 1 },
+                    workerRole: { type: "string", minLength: 1 },
+                    objective: { type: "string", minLength: 1 },
+                    query: { type: "string" },
+                    toolsAllowed: { type: "array", items: { type: "string" } },
+                    outputFormat: { type: "string", minLength: 1 },
+                    expectedSources: { type: "array", items: { type: "string" } },
+                    constraints: { type: "array", items: { type: "string" } },
+                    priority: { type: "number" },
+                    metadata: { type: "object" },
+                },
+            },
+        },
+        expectedEvidenceCount: { type: "number" },
+        maxIterations: { type: "number" },
+        requiresFinalLargeModel: { type: "boolean" },
+        metadata: { type: "object" },
+    },
+};
+const CLASSIFIER_RESPONSE_FORMAT = {
+    type: "json_schema",
+    schema: CODALI_GATEWAY_CLASSIFIER_SCHEMA,
+};
+const PLANNER_RESPONSE_FORMAT = {
+    type: "json_schema",
+    schema: CODALI_GATEWAY_PLANNER_SCHEMA,
+};
+const isRecord = (value) => Boolean(value && typeof value === "object" && !Array.isArray(value));
+const readString = (record, key) => typeof record[key] === "string" && record[key].trim()
+    ? record[key].trim()
+    : undefined;
+const readBoolean = (record, key) => typeof record[key] === "boolean" ? record[key] : undefined;
+const parseJsonObject = (content) => {
+    const trimmed = content.trim();
+    const fenced = trimmed.match(/^```(?:json)?\s*([\s\S]*?)\s*```$/i)?.[1]?.trim();
+    const candidate = fenced ?? trimmed;
+    try {
+        return JSON.parse(candidate);
+    }
+    catch {
+        const start = candidate.indexOf("{");
+        const end = candidate.lastIndexOf("}");
+        if (start >= 0 && end > start) {
+            return JSON.parse(candidate.slice(start, end + 1));
+        }
+        throw new CodaliGatewayPlannerError("GATEWAY_JSON_PARSE_FAILED", "Planner stage returned non-JSON content.");
+    }
+};
+const validateClassifierOutput = (value) => {
+    const issues = [];
+    if (!isRecord(value)) {
+        return {
+            issues: [
+                {
+                    path: "$",
+                    code: "expected_object",
+                    message: "Classifier output must be an object.",
+                },
+            ],
+        };
+    }
+    const queryType = readString(value, "queryType") ?? readString(value, "query_type");
+    if (!queryType) {
+        issues.push({
+            path: "$.queryType",
+            code: "expected_non_empty_string",
+            message: "queryType is required.",
+        });
+    }
+    const requiredBooleans = [
+        "needsPrivateData",
+        "needsFreshData",
+        "needsDocdex",
+        "needsAppTools",
+        "needsImageWorker",
+    ];
+    const booleans = {};
+    for (const key of requiredBooleans) {
+        const snakeKey = key.replace(/[A-Z]/g, (char) => `_${char.toLowerCase()}`);
+        const valueForKey = readBoolean(value, key) ?? readBoolean(value, snakeKey);
+        if (valueForKey === undefined) {
+            issues.push({
+                path: `$.${key}`,
+                code: "expected_boolean",
+                message: `${key} is required and must be a boolean.`,
+            });
+        }
+        else {
+            booleans[key] = valueForKey;
+        }
+    }
+    const confidence = readString(value, "confidence");
+    if (confidence !== undefined &&
+        confidence !== "high" &&
+        confidence !== "medium" &&
+        confidence !== "low") {
+        issues.push({
+            path: "$.confidence",
+            code: "expected_enum",
+            message: "confidence must be high, medium, or low.",
+        });
+    }
+    if (issues.length > 0 || !queryType) {
+        return { issues };
+    }
+    return {
+        issues,
+        output: {
+            queryType,
+            needsPrivateData: booleans.needsPrivateData ?? false,
+            needsFreshData: booleans.needsFreshData ?? false,
+            needsDocdex: booleans.needsDocdex ?? false,
+            needsAppTools: booleans.needsAppTools ?? false,
+            needsImageWorker: booleans.needsImageWorker ?? false,
+            directAnswerCandidate: readString(value, "directAnswerCandidate") ??
+                readString(value, "direct_answer_candidate"),
+            rationale: readString(value, "rationale"),
+            confidence,
+            metadata: isRecord(value.metadata) ? value.metadata : undefined,
+        },
+    };
+};
+const describeTool = (name, descriptors) => {
+    const descriptor = descriptors?.[name];
+    if (!descriptor) {
+        return `${name}: read-only allowed tool`;
+    }
+    if (typeof descriptor === "string") {
+        return `${name}: ${descriptor}`;
+    }
+    return `${name}: ${descriptor.description ?? "read-only allowed tool"}`;
+};
+const allowedToolNames = (compilation) => [...compilation.effectiveAllowedTools].sort();
+export const buildCodaliGatewayClassifierMessages = (input) => {
+    const policy = input.policyCompilation ?? compileCodaliGatewayPolicy({ request: input.request });
+    const tools = allowedToolNames(policy);
+    const system = [
+        "You are Codali gateway classifier.",
+        "Return JSON only. Do not answer the user.",
+        "Classify the request into routing facts for a product-neutral orchestration gateway.",
+        "Small models only produce structured artifacts; final user-visible prose is handled later.",
+        CODALI_GATEWAY_SECURITY_PROMPT_HARDENING.policyImmutability,
+        CODALI_GATEWAY_SECURITY_PROMPT_HARDENING.tenantScope,
+    ].join("\n");
+    const user = [
+        `Query: ${input.request.query}`,
+        `Mode: ${input.request.mode ?? "balanced"}`,
+        `Product: ${input.request.product?.name ?? "generic"}`,
+        `Tenant scoped: ${input.request.tenant?.id || input.request.tenant?.slug ? "yes" : "unknown"}`,
+        `Image worker allowed: ${input.request.policy.allowImageWorker === true ? "yes" : "no"}`,
+        `Available tools: ${tools.length > 0 ? tools.join(", ") : "none"}`,
+        "Decide these booleans: needsPrivateData, needsFreshData, needsDocdex, needsAppTools, needsImageWorker.",
+        "If a direct answer is possible without private/runtime tools, include directAnswerCandidate.",
+    ].join("\n");
+    return [
+        { role: "system", content: system },
+        { role: "user", content: user },
+    ];
+};
+export const buildCodaliGatewayPlannerMessages = (input, classifier) => {
+    const policy = input.policyCompilation ?? compileCodaliGatewayPolicy({ request: input.request });
+    const tools = allowedToolNames(policy);
+    const toolLines = tools.length > 0
+        ? tools.map((tool) => `- ${describeTool(tool, input.toolDescriptions)}`).join("\n")
+        : "- none";
+    const workerRoles = [
+        "direct_answer",
+        "rag_worker",
+        "tool_worker",
+        "extractor",
+        "verifier",
+        input.request.policy.allowImageWorker === true ? "image_worker" : undefined,
+    ].filter(Boolean).join(", ");
+    const system = [
+        "You are Codali gateway planner.",
+        "Return JSON only. Do not answer the user.",
+        "Create bounded worker tasks that gather evidence or produce structured artifacts.",
+        "Only use tool names listed in the allowed tool section.",
+        "Do not include denied, disabled, write, shell, destructive, or outside-workspace tools.",
+        CODALI_GATEWAY_SECURITY_PROMPT_HARDENING.toolOutputBoundary,
+        CODALI_GATEWAY_SECURITY_PROMPT_HARDENING.policyImmutability,
+        CODALI_GATEWAY_SECURITY_PROMPT_HARDENING.tenantScope,
+    ].join("\n");
+    const user = [
+        `Query: ${input.request.query}`,
+        `Classifier: ${JSON.stringify(classifier)}`,
+        `Policy limits: maxIterations=${input.request.policy.maxIterations}, maxToolCalls=${policy.security.limits.maxToolCalls}, maxModelCalls=${policy.security.limits.maxModelCalls}, maxEvidenceItems=${policy.security.limits.maxEvidenceItems}, maxImageArtifacts=${policy.security.limits.maxImageArtifacts}`,
+        `Worker roles available: ${workerRoles}`,
+        "Allowed tools:",
+        toolLines,
+        "Output planner JSON with queryType, subquestions, workerTasks, expectedEvidenceCount, maxIterations, requiresFinalLargeModel, and metadata.",
+    ].join("\n");
+    return [
+        { role: "system", content: system },
+        { role: "user", content: user },
+    ];
+};
+const buildRepairMessages = (stage, originalMessages, rawContent, error) => [
+    ...originalMessages,
+    { role: "assistant", content: rawContent },
+    {
+        role: "user",
+        content: [
+            `Repair the ${stage} JSON output.`,
+            "Return JSON only and match the required schema exactly.",
+            `Validation error: ${error instanceof Error ? error.message : String(error)}`,
+        ].join("\n"),
+    },
+];
+const sanitizePlannerOutput = (planner, input) => {
+    const policy = input.policyCompilation ?? compileCodaliGatewayPolicy({ request: input.request });
+    const allowed = new Set(allowedToolNames(policy));
+    const warnings = [];
+    const workerTasks = [];
+    for (const task of planner.workerTasks) {
+        if (task.workerRole === "image_worker" && input.request.policy.allowImageWorker !== true) {
+            warnings.push(`planner_task_removed_image_worker_disabled:${task.id}`);
+            continue;
+        }
+        const filteredTools = task.toolsAllowed.filter((tool) => allowed.has(tool));
+        const removed = task.toolsAllowed.filter((tool) => !allowed.has(tool));
+        if (removed.length > 0) {
+            warnings.push(`planner_task_tools_removed:${task.id}:${removed.join(",")}`);
+        }
+        workerTasks.push({ ...task, toolsAllowed: filteredTools });
+    }
+    return {
+        warnings,
+        planner: {
+            ...planner,
+            maxIterations: planner.maxIterations === undefined
+                ? undefined
+                : Math.min(planner.maxIterations, input.request.policy.maxIterations),
+            workerTasks,
+        },
+    };
+};
+export class CodaliGatewayPlanner {
+    constructor(provider, options = {}) {
+        this.provider = provider;
+        this.options = options;
+        this.maxRepairAttempts = options.maxRepairAttempts ?? 1;
+    }
+    async classify(input) {
+        const messages = buildCodaliGatewayClassifierMessages(input);
+        const response = await this.generateValidated("classifier", messages, CLASSIFIER_RESPONSE_FORMAT, validateClassifierOutput);
+        const warnings = [];
+        const classifier = { ...response.value };
+        if (classifier.needsImageWorker && input.request.policy.allowImageWorker !== true) {
+            classifier.needsImageWorker = false;
+            warnings.push("classifier_image_worker_disabled");
+        }
+        return { ...response, classifier, warnings };
+    }
+    async plan(input) {
+        const policyCompilation = input.policyCompilation ?? compileCodaliGatewayPolicy({ request: input.request });
+        if (!policyCompilation.ok) {
+            throw new CodaliGatewayPlannerError("GATEWAY_POLICY_COMPILE_FAILED", "Cannot plan with invalid gateway policy.");
+        }
+        const classifierResult = await this.classify({ ...input, policyCompilation });
+        const plannerMessages = buildCodaliGatewayPlannerMessages({ ...input, policyCompilation }, classifierResult.classifier);
+        const plannerResult = await this.generateValidated("planner", plannerMessages, PLANNER_RESPONSE_FORMAT, (value) => {
+            const validation = validateCodaliGatewayPlannerOutput(value);
+            return validation.ok
+                ? { output: validation.value, issues: [] }
+                : { issues: validation.issues };
+        });
+        const sanitized = sanitizePlannerOutput(plannerResult.value, { ...input, policyCompilation });
+        return {
+            policyCompilation,
+            classifier: classifierResult.classifier,
+            planner: sanitized.planner,
+            warnings: [...classifierResult.warnings, ...sanitized.warnings],
+            classifierRepairAttempts: classifierResult.repairAttempts,
+            plannerRepairAttempts: plannerResult.repairAttempts,
+            classifierRawContent: classifierResult.rawContent,
+            plannerRawContent: plannerResult.rawContent,
+        };
+    }
+    async generateValidated(stage, messages, responseFormat, validator) {
+        let currentMessages = messages;
+        let repairAttempts = 0;
+        let lastError;
+        let lastRaw = "";
+        for (;;) {
+            const response = await this.provider.generate({
+                messages: currentMessages,
+                maxTokens: this.options.maxTokens,
+                temperature: this.options.temperature ?? 0,
+                responseFormat,
+            });
+            lastRaw = response.message.content;
+            try {
+                const parsed = parseJsonObject(lastRaw);
+                const validated = validator(parsed);
+                if (validated.output) {
+                    return { value: validated.output, repairAttempts, rawContent: lastRaw };
+                }
+                throw new CodaliGatewayPlannerError("GATEWAY_STAGE_SCHEMA_INVALID", `${stage} output failed schema validation.`, validated.issues);
+            }
+            catch (error) {
+                lastError = error;
+                if (repairAttempts >= this.maxRepairAttempts) {
+                    if (error instanceof CodaliGatewayPlannerError) {
+                        throw error;
+                    }
+                    throw new CodaliGatewayPlannerError("GATEWAY_STAGE_SCHEMA_INVALID", `${stage} output could not be parsed or validated.`);
+                }
+                repairAttempts += 1;
+                currentMessages = buildRepairMessages(stage, messages, lastRaw, lastError);
+            }
+        }
+    }
+}
+export const createCodaliGatewayPlanner = (provider, options) => new CodaliGatewayPlanner(provider, options);

package/dist/gateway/GatewayPolicyCompiler.d.ts

@@ -0,0 +1,30 @@
+import type { CodaliRuntimeDocdexInput, CodaliRuntimePolicy, CodaliRuntimeToolManifest } from "../runtime/CodaliRuntime.js";
+import type { CodaliJobBudgets } from "../runtime/CodaliJobRuntime.js";
+import type { CodaliGatewayMode, CodaliGatewayPolicy, CodaliGatewayRequest, CodaliGatewaySecurityReview } from "./CodaliGatewayTypes.js";
+import { type CodaliGatewayCompiledToolCapability, type CodaliGatewayCompilerIssue, type CodaliGatewaySkippedTool, type ToolCapabilityCompilation } from "./ToolCapabilityCompiler.js";
+export interface GatewayPolicyCompilerInput {
+    request?: Pick<CodaliGatewayRequest, "policy" | "docdex" | "tools" | "mode" | "tenant" | "metadata">;
+    policy?: CodaliGatewayPolicy;
+    docdex?: CodaliRuntimeDocdexInput;
+    tools?: CodaliRuntimeToolManifest;
+    mode?: CodaliGatewayMode;
+    runtimeMode?: CodaliRuntimePolicy["mode"];
+    requiredDocdexOperations?: string[];
+    maxParallelStages?: number;
+}
+export interface GatewayPolicyCompilation {
+    ok: boolean;
+    runtimePolicy: CodaliRuntimePolicy;
+    jobBudgets: CodaliJobBudgets;
+    effectiveAllowedTools: string[];
+    effectiveDeniedTools: string[];
+    skippedTools: CodaliGatewaySkippedTool[];
+    toolCapabilities: CodaliGatewayCompiledToolCapability[];
+    toolCompilation: ToolCapabilityCompilation;
+    security: CodaliGatewaySecurityReview;
+    warnings: CodaliGatewayCompilerIssue[];
+    errors: CodaliGatewayCompilerIssue[];
+}
+export declare const compileCodaliGatewayPolicy: (input: GatewayPolicyCompilerInput) => GatewayPolicyCompilation;
+export declare const compileGatewayPolicy: (input: GatewayPolicyCompilerInput) => GatewayPolicyCompilation;
+//# sourceMappingURL=GatewayPolicyCompiler.d.ts.map

package/dist/gateway/GatewayPolicyCompiler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"GatewayPolicyCompiler.d.ts","sourceRoot":"","sources":["../../src/gateway/GatewayPolicyCompiler.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,wBAAwB,EACxB,mBAAmB,EACnB,yBAAyB,EAC1B,MAAM,6BAA6B,CAAC;AACrC,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,gCAAgC,CAAC;AACvE,OAAO,KAAK,EACV,iBAAiB,EACjB,mBAAmB,EACnB,oBAAoB,EACpB,2BAA2B,EAC5B,MAAM,yBAAyB,CAAC;AAEjC,OAAO,EAEL,KAAK,mCAAmC,EACxC,KAAK,0BAA0B,EAC/B,KAAK,wBAAwB,EAC7B,KAAK,yBAAyB,EAC/B,MAAM,6BAA6B,CAAC;AAErC,MAAM,WAAW,0BAA0B;IACzC,OAAO,CAAC,EAAE,IAAI,CACZ,oBAAoB,EACpB,QAAQ,GAAG,QAAQ,GAAG,OAAO,GAAG,MAAM,GAAG,QAAQ,GAAG,UAAU,CAC/D,CAAC;IACF,MAAM,CAAC,EAAE,mBAAmB,CAAC;IAC7B,MAAM,CAAC,EAAE,wBAAwB,CAAC;IAClC,KAAK,CAAC,EAAE,yBAAyB,CAAC;IAClC,IAAI,CAAC,EAAE,iBAAiB,CAAC;IACzB,WAAW,CAAC,EAAE,mBAAmB,CAAC,MAAM,CAAC,CAAC;IAC1C,wBAAwB,CAAC,EAAE,MAAM,EAAE,CAAC;IACpC,iBAAiB,CAAC,EAAE,MAAM,CAAC;CAC5B;AAED,MAAM,WAAW,wBAAwB;IACvC,EAAE,EAAE,OAAO,CAAC;IACZ,aAAa,EAAE,mBAAmB,CAAC;IACnC,UAAU,EAAE,gBAAgB,CAAC;IAC7B,qBAAqB,EAAE,MAAM,EAAE,CAAC;IAChC,oBAAoB,EAAE,MAAM,EAAE,CAAC;IAC/B,YAAY,EAAE,wBAAwB,EAAE,CAAC;IACzC,gBAAgB,EAAE,mCAAmC,EAAE,CAAC;IACxD,eAAe,EAAE,yBAAyB,CAAC;IAC3C,QAAQ,EAAE,2BAA2B,CAAC;IACtC,QAAQ,EAAE,0BAA0B,EAAE,CAAC;IACvC,MAAM,EAAE,0BAA0B,EAAE,CAAC;CACtC;AAyDD,eAAO,MAAM,0BAA0B,GACrC,OAAO,0BAA0B,KAChC,wBA+FF,CAAC;AAEF,eAAO,MAAM,oBAAoB,UAlGxB,0BAA0B,KAChC,wBAiG2D,CAAC"}

package/dist/gateway/GatewayPolicyCompiler.js

@@ -0,0 +1,114 @@
+import { resolveCodaliGatewaySecurityPolicy } from "./GatewaySecurityPolicy.js";
+import { compileToolCapabilities, } from "./ToolCapabilityCompiler.js";
+const isUnsafePolicyEnabled = (policy) => {
+    const unsafe = [];
+    if (policy.allowWrites !== false)
+        unsafe.push("allowWrites");
+    if (policy.allowShell !== false)
+        unsafe.push("allowShell");
+    if (policy.allowDestructiveOperations !== false) {
+        unsafe.push("allowDestructiveOperations");
+    }
+    if (policy.allowOutsideWorkspace !== false)
+        unsafe.push("allowOutsideWorkspace");
+    return unsafe;
+};
+const issue = (code, message, details) => ({
+    code,
+    message,
+    severity: "error",
+    details,
+});
+const modeToRuntimeMode = (mode) => {
+    switch (mode) {
+        case "cheap":
+        case "fast":
+            return "tool_loop";
+        case "deep":
+        case "image":
+            return "smart_pipeline";
+        case "balanced":
+        default:
+            return "tool_loop";
+    }
+};
+const positiveOrDefault = (value, fallback) => Number.isFinite(value) && value > 0 ? Math.floor(value) : fallback;
+export const compileCodaliGatewayPolicy = (input) => {
+    const policy = input.policy ?? input.request?.policy;
+    if (!policy) {
+        throw new Error("GATEWAY_POLICY_REQUIRED: Gateway policy is required.");
+    }
+    const docdex = input.docdex ?? input.request?.docdex;
+    const tools = input.tools ?? input.request?.tools ?? docdex?.toolManifest;
+    const mode = input.mode ?? input.request?.mode;
+    const toolCompilation = compileToolCapabilities({
+        policy,
+        docdex,
+        tools,
+        requiredDocdexOperations: input.requiredDocdexOperations,
+    });
+    const errors = [...toolCompilation.errors];
+    const warnings = [...toolCompilation.warnings];
+    const unsafeFlags = isUnsafePolicyEnabled(policy);
+    if (unsafeFlags.length > 0) {
+        errors.push(issue("GATEWAY_READ_ONLY_POLICY_REQUIRED", "Codali gateway policies must disable shell, writes, destructive operations, and outside-workspace access.", { flags: unsafeFlags }));
+    }
+    if (policy.maxToolCalls < 0) {
+        errors.push(issue("GATEWAY_INVALID_MAX_TOOL_CALLS", "maxToolCalls must be zero or greater."));
+    }
+    const effectiveAllowedTools = toolCompilation.visibleTools;
+    const effectiveDeniedTools = toolCompilation.deniedTools;
+    const security = resolveCodaliGatewaySecurityPolicy({
+        request: input.request ? { ...input.request, policy } : {
+            policy,
+            tenant: undefined,
+            metadata: undefined,
+        },
+        effectiveAllowedTools,
+        effectiveDeniedTools,
+        toolCapabilities: toolCompilation.capabilities,
+    });
+    warnings.push(...security.warnings);
+    errors.push(...security.errors);
+    const runtimePolicy = {
+        allowWrites: false,
+        allowShell: false,
+        allowDestructiveOperations: false,
+        allowOutsideWorkspace: false,
+        allowedTools: effectiveAllowedTools,
+        deniedTools: effectiveDeniedTools,
+        appToolContracts: Object.keys(toolCompilation.appToolContracts).length > 0
+            ? toolCompilation.appToolContracts
+            : undefined,
+        appVirtualTools: toolCompilation.appVirtualTools.length > 0
+            ? toolCompilation.appVirtualTools
+            : undefined,
+        appToolGateway: toolCompilation.appToolGateway,
+        maxSteps: positiveOrDefault(policy.maxIterations, 1),
+        maxToolCalls: security.limits.maxToolCalls,
+        maxTokens: positiveOrDefault(policy.maxContextPackTokens, 1),
+        timeoutMs: security.limits.maxRuntimeMs,
+        mode: input.runtimeMode ?? modeToRuntimeMode(mode),
+    };
+    const jobBudgets = {
+        maxRuntimeMs: runtimePolicy.timeoutMs,
+        maxToolCalls: runtimePolicy.maxToolCalls,
+        maxFollowups: runtimePolicy.maxSteps,
+        maxParallelStages: input.maxParallelStages ??
+            Math.max(1, Math.min(security.limits.maxModelCalls, 8)),
+    };
+    return {
+        ok: errors.length === 0,
+        runtimePolicy,
+        jobBudgets,
+        effectiveAllowedTools,
+        effectiveDeniedTools,
+        skippedTools: toolCompilation.skippedTools,
+        toolCapabilities: toolCompilation.capabilities,
+        toolCompilation,
+        security,
+        warnings,
+        errors,
+    };
+};
+export const compileGatewayPolicy = compileCodaliGatewayPolicy;

package/dist/gateway/GatewaySecurityPolicy.d.ts

@@ -0,0 +1,14 @@
+import type { CodaliGatewayApprovalRecord, CodaliGatewayPromptHardening, CodaliGatewayRequest, CodaliGatewaySecurityReview, CodaliGatewayTenantLimitProfile, CodaliGatewayToolRiskCategory } from "./CodaliGatewayTypes.js";
+import type { CodaliGatewayCompiledToolCapability } from "./ToolCapabilityCompiler.js";
+export declare const CODALI_GATEWAY_SECURITY_PROMPT_HARDENING: CodaliGatewayPromptHardening;
+export interface ResolveCodaliGatewaySecurityPolicyInput {
+    request: Pick<CodaliGatewayRequest, "policy" | "tenant" | "metadata">;
+    effectiveAllowedTools?: string[];
+    effectiveDeniedTools?: string[];
+    toolCapabilities?: CodaliGatewayCompiledToolCapability[];
+    tenantLimits?: CodaliGatewayTenantLimitProfile;
+    approvals?: CodaliGatewayApprovalRecord[];
+}
+export declare const classifyCodaliGatewayToolRisk: (tool: string, capability?: Pick<CodaliGatewayCompiledToolCapability, "readOnly" | "riskCategory">) => CodaliGatewayToolRiskCategory;
+export declare const resolveCodaliGatewaySecurityPolicy: (input: ResolveCodaliGatewaySecurityPolicyInput) => CodaliGatewaySecurityReview;
+//# sourceMappingURL=GatewaySecurityPolicy.d.ts.map

package/dist/gateway/GatewaySecurityPolicy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"GatewaySecurityPolicy.d.ts","sourceRoot":"","sources":["../../src/gateway/GatewaySecurityPolicy.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,2BAA2B,EAI3B,4BAA4B,EAC5B,oBAAoB,EAEpB,2BAA2B,EAC3B,+BAA+B,EAE/B,6BAA6B,EAC9B,MAAM,yBAAyB,CAAC;AACjC,OAAO,KAAK,EAAE,mCAAmC,EAAE,MAAM,6BAA6B,CAAC;AAEvF,eAAO,MAAM,wCAAwC,EAAE,4BAStD,CAAC;AAiDF,MAAM,WAAW,uCAAuC;IACtD,OAAO,EAAE,IAAI,CAAC,oBAAoB,EAAE,QAAQ,GAAG,QAAQ,GAAG,UAAU,CAAC,CAAC;IACtE,qBAAqB,CAAC,EAAE,MAAM,EAAE,CAAC;IACjC,oBAAoB,CAAC,EAAE,MAAM,EAAE,CAAC;IAChC,gBAAgB,CAAC,EAAE,mCAAmC,EAAE,CAAC;IACzD,YAAY,CAAC,EAAE,+BAA+B,CAAC;IAC/C,SAAS,CAAC,EAAE,2BAA2B,EAAE,CAAC;CAC3C;AAiMD,eAAO,MAAM,6BAA6B,GACxC,MAAM,MAAM,EACZ,aAAa,IAAI,CAAC,mCAAmC,EAAE,UAAU,GAAG,cAAc,CAAC,KAClF,6BAWF,CAAC;AA2GF,eAAO,MAAM,kCAAkC,GAC7C,OAAO,uCAAuC,KAC7C,2BAmEF,CAAC"}