@agent-finops/core 0.1.0

package/dist/sampleData.d.ts

@@ -0,0 +1,5 @@
+import { type UsageRecord } from "./schema.js";
+export declare const sampleFiles: readonly ["samples/openai-usage.csv", "samples/anthropic-usage.csv"];
+export declare function loadSampleUsageData(rootDir?: string): Promise<UsageRecord[]>;
+export declare function parseUsageCsv(contents: string): UsageRecord[];
+//# sourceMappingURL=sampleData.d.ts.map

package/dist/sampleData.js

@@ -0,0 +1,59 @@
+import { readFile } from "node:fs/promises";
+import { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { usageRecordSchema } from "./schema.js";
+// One level up from dist/ = the package root, where samples/ ships (see
+// "files" in package.json). Must survive npm installation — never resolve
+// relative to the repo.
+const packageRoot = resolve(dirname(fileURLToPath(import.meta.url)), "..");
+export const sampleFiles = [
+    "samples/openai-usage.csv",
+    "samples/anthropic-usage.csv"
+];
+export async function loadSampleUsageData(rootDir = packageRoot) {
+    const records = await Promise.all(sampleFiles.map((file) => loadUsageCsv(resolve(rootDir, file))));
+    return records.flat().sort((left, right) => left.timestamp.localeCompare(right.timestamp));
+}
+async function loadUsageCsv(path) {
+    const contents = await readFile(path, "utf8");
+    return parseUsageCsv(contents);
+}
+export function parseUsageCsv(contents) {
+    const lines = contents.trim().split(/\r?\n/).filter(Boolean);
+    const [headerLine, ...recordLines] = lines;
+    if (!headerLine) {
+        return [];
+    }
+    const headers = headerLine.split(",").map((header) => header.trim());
+    return recordLines.map((line) => {
+        const values = line.split(",");
+        const row = Object.fromEntries(headers.map((header, index) => [header, values[index]?.trim() ?? ""]));
+        return usageRecordSchema.parse({
+            id: row.id,
+            timestamp: row.timestamp,
+            source: {
+                id: row.source_id,
+                name: row.source_name,
+                provider: row.provider,
+                confidence: row.source_confidence,
+                observedFrom: row.observed_from
+            },
+            model: row.model,
+            inputTokens: Number(row.input_tokens),
+            outputTokens: Number(row.output_tokens),
+            amountUsd: row.amount_usd === "" ? null : Number(row.amount_usd),
+            costConfidence: row.cost_confidence,
+            clientId: optionalValue(row.client_id),
+            projectId: optionalValue(row.project_id),
+            agentId: optionalValue(row.agent_id),
+            userId: optionalValue(row.user_id),
+            workspaceId: optionalValue(row.workspace_id),
+            apiKeyId: optionalValue(row.api_key_id),
+            operation: optionalValue(row.operation)
+        });
+    });
+}
+function optionalValue(value) {
+    return value === "" ? undefined : value;
+}
+//# sourceMappingURL=sampleData.js.map

package/dist/schema.d.ts

@@ -0,0 +1,431 @@
+import { z } from "zod";
+export declare const costConfidenceValues: readonly ["verified", "estimated", "detected_unverified", "missing"];
+export declare const costConfidenceSchema: z.ZodEnum<{
+    verified: "verified";
+    estimated: "estimated";
+    detected_unverified: "detected_unverified";
+    missing: "missing";
+}>;
+export type CostConfidence = z.infer<typeof costConfidenceSchema>;
+export declare const spendSourceSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    provider: z.ZodString;
+    confidence: z.ZodEnum<{
+        verified: "verified";
+        estimated: "estimated";
+        detected_unverified: "detected_unverified";
+        missing: "missing";
+    }>;
+    observedFrom: z.ZodString;
+}, z.core.$strip>;
+export type SpendSource = z.infer<typeof spendSourceSchema>;
+export declare const usageRecordSchema: z.ZodObject<{
+    id: z.ZodString;
+    timestamp: z.ZodString;
+    source: z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        provider: z.ZodString;
+        confidence: z.ZodEnum<{
+            verified: "verified";
+            estimated: "estimated";
+            detected_unverified: "detected_unverified";
+            missing: "missing";
+        }>;
+        observedFrom: z.ZodString;
+    }, z.core.$strip>;
+    model: z.ZodString;
+    inputTokens: z.ZodNumber;
+    outputTokens: z.ZodNumber;
+    amountUsd: z.ZodNullable<z.ZodNumber>;
+    costConfidence: z.ZodEnum<{
+        verified: "verified";
+        estimated: "estimated";
+        detected_unverified: "detected_unverified";
+        missing: "missing";
+    }>;
+    clientId: z.ZodOptional<z.ZodString>;
+    projectId: z.ZodOptional<z.ZodString>;
+    userId: z.ZodOptional<z.ZodString>;
+    apiKeyId: z.ZodOptional<z.ZodString>;
+    workspaceId: z.ZodOptional<z.ZodString>;
+    providerCostType: z.ZodOptional<z.ZodString>;
+    quantity: z.ZodOptional<z.ZodNumber>;
+    agentId: z.ZodOptional<z.ZodString>;
+    operation: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type UsageRecord = z.infer<typeof usageRecordSchema>;
+export declare const attributionCandidateSchema: z.ZodObject<{
+    entityType: z.ZodEnum<{
+        client: "client";
+        project: "project";
+        agent: "agent";
+        user: "user";
+        workspace: "workspace";
+        api_key: "api_key";
+    }>;
+    entityId: z.ZodString;
+    confidence: z.ZodNumber;
+    evidence: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+export type AttributionCandidate = z.infer<typeof attributionCandidateSchema>;
+export declare const attributionMappingSchema: z.ZodObject<{
+    usageRecordId: z.ZodString;
+    candidates: z.ZodArray<z.ZodObject<{
+        entityType: z.ZodEnum<{
+            client: "client";
+            project: "project";
+            agent: "agent";
+            user: "user";
+            workspace: "workspace";
+            api_key: "api_key";
+        }>;
+        entityId: z.ZodString;
+        confidence: z.ZodNumber;
+        evidence: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>>;
+    selected: z.ZodOptional<z.ZodObject<{
+        entityType: z.ZodEnum<{
+            client: "client";
+            project: "project";
+            agent: "agent";
+            user: "user";
+            workspace: "workspace";
+            api_key: "api_key";
+        }>;
+        entityId: z.ZodString;
+        confidence: z.ZodNumber;
+        evidence: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>>;
+    status: z.ZodEnum<{
+        auto_mapped: "auto_mapped";
+        needs_confirmation: "needs_confirmation";
+        needs_question: "needs_question";
+        unmapped: "unmapped";
+    }>;
+    evidence: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+export type AttributionMapping = z.infer<typeof attributionMappingSchema>;
+export declare const spendBreakdownEntrySchema: z.ZodObject<{
+    key: z.ZodString;
+    amountUsd: z.ZodNumber;
+    recordCount: z.ZodNumber;
+    confidence: z.ZodEnum<{
+        verified: "verified";
+        estimated: "estimated";
+        detected_unverified: "detected_unverified";
+        missing: "missing";
+    }>;
+}, z.core.$strip>;
+export type SpendBreakdownEntry = z.infer<typeof spendBreakdownEntrySchema>;
+export declare const spendAnomalySchema: z.ZodObject<{
+    kind: z.ZodEnum<{
+        day_over_day_spike: "day_over_day_spike";
+        week_over_week_spike: "week_over_week_spike";
+    }>;
+    key: z.ZodString;
+    previousAmountUsd: z.ZodNumber;
+    currentAmountUsd: z.ZodNumber;
+    multiplier: z.ZodNumber;
+    confidence: z.ZodEnum<{
+        verified: "verified";
+        estimated: "estimated";
+        detected_unverified: "detected_unverified";
+        missing: "missing";
+    }>;
+}, z.core.$strip>;
+export type SpendAnomaly = z.infer<typeof spendAnomalySchema>;
+export declare const workflowWatchEntrySchema: z.ZodObject<{
+    id: z.ZodString;
+    clientId: z.ZodString;
+    projectId: z.ZodString;
+    workflowKey: z.ZodString;
+    agentId: z.ZodString;
+    amountUsd: z.ZodNumber;
+    shareOfSpend: z.ZodNumber;
+    recordCount: z.ZodNumber;
+    confidence: z.ZodEnum<{
+        verified: "verified";
+        estimated: "estimated";
+        detected_unverified: "detected_unverified";
+        missing: "missing";
+    }>;
+    estimatedMarginRiskUsd: z.ZodNumber;
+    estimatedSavingsUsd: z.ZodNumber;
+    suggestedOptimization: z.ZodString;
+    applyArtifact: z.ZodString;
+    verificationPlan: z.ZodString;
+}, z.core.$strip>;
+export type WorkflowWatchEntry = z.infer<typeof workflowWatchEntrySchema>;
+export declare const recommendationSchema: z.ZodObject<{
+    id: z.ZodString;
+    title: z.ZodString;
+    rationale: z.ZodString;
+    whyItMatters: z.ZodString;
+    nextAction: z.ZodString;
+    priority: z.ZodEnum<{
+        high: "high";
+        medium: "medium";
+        low: "low";
+    }>;
+    estimatedImpactUsd: z.ZodNumber;
+    confidence: z.ZodEnum<{
+        verified: "verified";
+        estimated: "estimated";
+        detected_unverified: "detected_unverified";
+        missing: "missing";
+    }>;
+    relatedKeys: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+export type Recommendation = z.infer<typeof recommendationSchema>;
+export declare const evidenceItemSchema: z.ZodObject<{
+    label: z.ZodString;
+    value: z.ZodString;
+    detail: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type EvidenceItem = z.infer<typeof evidenceItemSchema>;
+export declare const spendInsightSchema: z.ZodObject<{
+    id: z.ZodString;
+    kind: z.ZodEnum<{
+        spike_explanation: "spike_explanation";
+        margin_risk: "margin_risk";
+        agent_runaway: "agent_runaway";
+        model_misuse: "model_misuse";
+        context_bloat: "context_bloat";
+        unmapped_spend: "unmapped_spend";
+        connector_gap: "connector_gap";
+        optimization_opportunity: "optimization_opportunity";
+    }>;
+    severity: z.ZodEnum<{
+        high: "high";
+        medium: "medium";
+        low: "low";
+        critical: "critical";
+    }>;
+    title: z.ZodString;
+    summary: z.ZodString;
+    evidence: z.ZodArray<z.ZodObject<{
+        label: z.ZodString;
+        value: z.ZodString;
+        detail: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    affectedClients: z.ZodArray<z.ZodString>;
+    affectedProjects: z.ZodArray<z.ZodString>;
+    affectedAgents: z.ZodArray<z.ZodString>;
+    affectedModels: z.ZodArray<z.ZodString>;
+    estimatedImpactUsd: z.ZodNumber;
+    confidence: z.ZodEnum<{
+        verified: "verified";
+        estimated: "estimated";
+        detected_unverified: "detected_unverified";
+        missing: "missing";
+    }>;
+    recommendedAction: z.ZodString;
+    verificationNeeded: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type SpendInsight = z.infer<typeof spendInsightSchema>;
+export declare const spendSummarySchema: z.ZodObject<{
+    totalUsd: z.ZodNumber;
+    recordCount: z.ZodNumber;
+    confidence: z.ZodEnum<{
+        verified: "verified";
+        estimated: "estimated";
+        detected_unverified: "detected_unverified";
+        missing: "missing";
+    }>;
+    confidenceBreakdown: z.ZodRecord<z.ZodEnum<{
+        verified: "verified";
+        estimated: "estimated";
+        detected_unverified: "detected_unverified";
+        missing: "missing";
+    }>, z.ZodNumber>;
+    bySource: z.ZodArray<z.ZodObject<{
+        key: z.ZodString;
+        amountUsd: z.ZodNumber;
+        recordCount: z.ZodNumber;
+        confidence: z.ZodEnum<{
+            verified: "verified";
+            estimated: "estimated";
+            detected_unverified: "detected_unverified";
+            missing: "missing";
+        }>;
+    }, z.core.$strip>>;
+    byModel: z.ZodArray<z.ZodObject<{
+        key: z.ZodString;
+        amountUsd: z.ZodNumber;
+        recordCount: z.ZodNumber;
+        confidence: z.ZodEnum<{
+            verified: "verified";
+            estimated: "estimated";
+            detected_unverified: "detected_unverified";
+            missing: "missing";
+        }>;
+    }, z.core.$strip>>;
+    byClient: z.ZodArray<z.ZodObject<{
+        key: z.ZodString;
+        amountUsd: z.ZodNumber;
+        recordCount: z.ZodNumber;
+        confidence: z.ZodEnum<{
+            verified: "verified";
+            estimated: "estimated";
+            detected_unverified: "detected_unverified";
+            missing: "missing";
+        }>;
+    }, z.core.$strip>>;
+    byProject: z.ZodArray<z.ZodObject<{
+        key: z.ZodString;
+        amountUsd: z.ZodNumber;
+        recordCount: z.ZodNumber;
+        confidence: z.ZodEnum<{
+            verified: "verified";
+            estimated: "estimated";
+            detected_unverified: "detected_unverified";
+            missing: "missing";
+        }>;
+    }, z.core.$strip>>;
+    byAgent: z.ZodArray<z.ZodObject<{
+        key: z.ZodString;
+        amountUsd: z.ZodNumber;
+        recordCount: z.ZodNumber;
+        confidence: z.ZodEnum<{
+            verified: "verified";
+            estimated: "estimated";
+            detected_unverified: "detected_unverified";
+            missing: "missing";
+        }>;
+    }, z.core.$strip>>;
+    byUser: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        key: z.ZodString;
+        amountUsd: z.ZodNumber;
+        recordCount: z.ZodNumber;
+        confidence: z.ZodEnum<{
+            verified: "verified";
+            estimated: "estimated";
+            detected_unverified: "detected_unverified";
+            missing: "missing";
+        }>;
+    }, z.core.$strip>>>;
+    byWorkspace: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        key: z.ZodString;
+        amountUsd: z.ZodNumber;
+        recordCount: z.ZodNumber;
+        confidence: z.ZodEnum<{
+            verified: "verified";
+            estimated: "estimated";
+            detected_unverified: "detected_unverified";
+            missing: "missing";
+        }>;
+    }, z.core.$strip>>>;
+    byApiKey: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        key: z.ZodString;
+        amountUsd: z.ZodNumber;
+        recordCount: z.ZodNumber;
+        confidence: z.ZodEnum<{
+            verified: "verified";
+            estimated: "estimated";
+            detected_unverified: "detected_unverified";
+            missing: "missing";
+        }>;
+    }, z.core.$strip>>>;
+    workflowWatch: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        clientId: z.ZodString;
+        projectId: z.ZodString;
+        workflowKey: z.ZodString;
+        agentId: z.ZodString;
+        amountUsd: z.ZodNumber;
+        shareOfSpend: z.ZodNumber;
+        recordCount: z.ZodNumber;
+        confidence: z.ZodEnum<{
+            verified: "verified";
+            estimated: "estimated";
+            detected_unverified: "detected_unverified";
+            missing: "missing";
+        }>;
+        estimatedMarginRiskUsd: z.ZodNumber;
+        estimatedSavingsUsd: z.ZodNumber;
+        suggestedOptimization: z.ZodString;
+        applyArtifact: z.ZodString;
+        verificationPlan: z.ZodString;
+    }, z.core.$strip>>;
+    anomalies: z.ZodArray<z.ZodObject<{
+        kind: z.ZodEnum<{
+            day_over_day_spike: "day_over_day_spike";
+            week_over_week_spike: "week_over_week_spike";
+        }>;
+        key: z.ZodString;
+        previousAmountUsd: z.ZodNumber;
+        currentAmountUsd: z.ZodNumber;
+        multiplier: z.ZodNumber;
+        confidence: z.ZodEnum<{
+            verified: "verified";
+            estimated: "estimated";
+            detected_unverified: "detected_unverified";
+            missing: "missing";
+        }>;
+    }, z.core.$strip>>;
+    recommendations: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        title: z.ZodString;
+        rationale: z.ZodString;
+        whyItMatters: z.ZodString;
+        nextAction: z.ZodString;
+        priority: z.ZodEnum<{
+            high: "high";
+            medium: "medium";
+            low: "low";
+        }>;
+        estimatedImpactUsd: z.ZodNumber;
+        confidence: z.ZodEnum<{
+            verified: "verified";
+            estimated: "estimated";
+            detected_unverified: "detected_unverified";
+            missing: "missing";
+        }>;
+        relatedKeys: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>>;
+    insights: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        kind: z.ZodEnum<{
+            spike_explanation: "spike_explanation";
+            margin_risk: "margin_risk";
+            agent_runaway: "agent_runaway";
+            model_misuse: "model_misuse";
+            context_bloat: "context_bloat";
+            unmapped_spend: "unmapped_spend";
+            connector_gap: "connector_gap";
+            optimization_opportunity: "optimization_opportunity";
+        }>;
+        severity: z.ZodEnum<{
+            high: "high";
+            medium: "medium";
+            low: "low";
+            critical: "critical";
+        }>;
+        title: z.ZodString;
+        summary: z.ZodString;
+        evidence: z.ZodArray<z.ZodObject<{
+            label: z.ZodString;
+            value: z.ZodString;
+            detail: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        affectedClients: z.ZodArray<z.ZodString>;
+        affectedProjects: z.ZodArray<z.ZodString>;
+        affectedAgents: z.ZodArray<z.ZodString>;
+        affectedModels: z.ZodArray<z.ZodString>;
+        estimatedImpactUsd: z.ZodNumber;
+        confidence: z.ZodEnum<{
+            verified: "verified";
+            estimated: "estimated";
+            detected_unverified: "detected_unverified";
+            missing: "missing";
+        }>;
+        recommendedAction: z.ZodString;
+        verificationNeeded: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export type SpendSummary = z.infer<typeof spendSummarySchema>;
+export declare function parseUsageRecord(value: unknown): UsageRecord;
+export declare function parseSpendSummary(value: unknown): SpendSummary;
+//# sourceMappingURL=schema.d.ts.map

package/dist/schema.js

@@ -0,0 +1,158 @@
+import { z } from "zod";
+export const costConfidenceValues = [
+    "verified",
+    "estimated",
+    "detected_unverified",
+    "missing"
+];
+export const costConfidenceSchema = z.enum(costConfidenceValues);
+export const spendSourceSchema = z.object({
+    id: z.string().min(1),
+    name: z.string().min(1),
+    provider: z.string().min(1),
+    confidence: costConfidenceSchema,
+    observedFrom: z.string().min(1)
+});
+export const usageRecordSchema = z.object({
+    id: z.string().min(1),
+    timestamp: z.string().datetime({ offset: true }),
+    source: spendSourceSchema,
+    model: z.string().min(1),
+    inputTokens: z.number().int().nonnegative(),
+    outputTokens: z.number().int().nonnegative(),
+    amountUsd: z.number().nonnegative().nullable(),
+    costConfidence: costConfidenceSchema,
+    clientId: z.string().min(1).optional(),
+    projectId: z.string().min(1).optional(),
+    userId: z.string().min(1).optional(),
+    apiKeyId: z.string().min(1).optional(),
+    workspaceId: z.string().min(1).optional(),
+    providerCostType: z.string().min(1).optional(),
+    quantity: z.number().nonnegative().optional(),
+    agentId: z.string().min(1).optional(),
+    operation: z.string().min(1).optional()
+}).superRefine((record, context) => {
+    if (record.costConfidence === "missing" && record.amountUsd !== null) {
+        context.addIssue({
+            code: "custom",
+            path: ["amountUsd"],
+            message: "Records with missing cost confidence must not include a cost."
+        });
+    }
+    if (record.costConfidence !== "missing" && record.amountUsd === null) {
+        context.addIssue({
+            code: "custom",
+            path: ["amountUsd"],
+            message: "Records with cost confidence require a cost amount."
+        });
+    }
+});
+export const attributionCandidateSchema = z.object({
+    entityType: z.enum(["client", "project", "agent", "user", "workspace", "api_key"]),
+    entityId: z.string().min(1),
+    confidence: z.number().min(0).max(1),
+    evidence: z.array(z.string().min(1)).min(1)
+});
+export const attributionMappingSchema = z.object({
+    usageRecordId: z.string().min(1),
+    candidates: z.array(attributionCandidateSchema),
+    selected: attributionCandidateSchema.optional(),
+    status: z.enum(["auto_mapped", "needs_confirmation", "needs_question", "unmapped"]),
+    evidence: z.array(z.string().min(1))
+});
+export const spendBreakdownEntrySchema = z.object({
+    key: z.string().min(1),
+    amountUsd: z.number().nonnegative(),
+    recordCount: z.number().int().nonnegative(),
+    confidence: costConfidenceSchema
+});
+export const spendAnomalySchema = z.object({
+    kind: z.enum(["day_over_day_spike", "week_over_week_spike"]),
+    key: z.string().min(1),
+    previousAmountUsd: z.number().nonnegative(),
+    currentAmountUsd: z.number().nonnegative(),
+    multiplier: z.number().nonnegative(),
+    confidence: costConfidenceSchema
+});
+export const workflowWatchEntrySchema = z.object({
+    id: z.string().min(1),
+    clientId: z.string().min(1),
+    projectId: z.string().min(1),
+    workflowKey: z.string().min(1),
+    agentId: z.string().min(1),
+    amountUsd: z.number().nonnegative(),
+    shareOfSpend: z.number().min(0).max(1),
+    recordCount: z.number().int().nonnegative(),
+    confidence: costConfidenceSchema,
+    estimatedMarginRiskUsd: z.number().nonnegative(),
+    estimatedSavingsUsd: z.number().nonnegative(),
+    suggestedOptimization: z.string().min(1),
+    applyArtifact: z.string().min(1),
+    verificationPlan: z.string().min(1)
+});
+export const recommendationSchema = z.object({
+    id: z.string().min(1),
+    title: z.string().min(1),
+    rationale: z.string().min(1),
+    whyItMatters: z.string().min(1),
+    nextAction: z.string().min(1),
+    priority: z.enum(["high", "medium", "low"]),
+    estimatedImpactUsd: z.number().nonnegative(),
+    confidence: costConfidenceSchema,
+    relatedKeys: z.array(z.string().min(1))
+});
+export const evidenceItemSchema = z.object({
+    label: z.string().min(1),
+    value: z.string().min(1),
+    detail: z.string().min(1).optional()
+});
+export const spendInsightSchema = z.object({
+    id: z.string().min(1),
+    kind: z.enum([
+        "spike_explanation",
+        "margin_risk",
+        "agent_runaway",
+        "model_misuse",
+        "context_bloat",
+        "unmapped_spend",
+        "connector_gap",
+        "optimization_opportunity"
+    ]),
+    severity: z.enum(["critical", "high", "medium", "low"]),
+    title: z.string().min(1),
+    summary: z.string().min(1),
+    evidence: z.array(evidenceItemSchema).min(1),
+    affectedClients: z.array(z.string().min(1)),
+    affectedProjects: z.array(z.string().min(1)),
+    affectedAgents: z.array(z.string().min(1)),
+    affectedModels: z.array(z.string().min(1)),
+    estimatedImpactUsd: z.number().nonnegative(),
+    confidence: costConfidenceSchema,
+    recommendedAction: z.string().min(1),
+    verificationNeeded: z.string().min(1).optional()
+});
+export const spendSummarySchema = z.object({
+    totalUsd: z.number().nonnegative(),
+    recordCount: z.number().int().nonnegative(),
+    confidence: costConfidenceSchema,
+    confidenceBreakdown: z.record(costConfidenceSchema, z.number().nonnegative()),
+    bySource: z.array(spendBreakdownEntrySchema),
+    byModel: z.array(spendBreakdownEntrySchema),
+    byClient: z.array(spendBreakdownEntrySchema),
+    byProject: z.array(spendBreakdownEntrySchema),
+    byAgent: z.array(spendBreakdownEntrySchema),
+    byUser: z.array(spendBreakdownEntrySchema).default([]),
+    byWorkspace: z.array(spendBreakdownEntrySchema).default([]),
+    byApiKey: z.array(spendBreakdownEntrySchema).default([]),
+    workflowWatch: z.array(workflowWatchEntrySchema),
+    anomalies: z.array(spendAnomalySchema),
+    recommendations: z.array(recommendationSchema),
+    insights: z.array(spendInsightSchema).default([])
+});
+export function parseUsageRecord(value) {
+    return usageRecordSchema.parse(value);
+}
+export function parseSpendSummary(value) {
+    return spendSummarySchema.parse(value);
+}
+//# sourceMappingURL=schema.js.map