teamcopilot 0.2.2 → 0.3.0

package/dist/utils/chat-usage.js

@@ -0,0 +1,258 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.syncChatSessionUsage = syncChatSessionUsage;
+exports.buildUsageOverview = buildUsageOverview;
+const client_1 = __importDefault(require("../prisma/client"));
+const assert_1 = require("./assert");
+const opencode_client_1 = require("./opencode-client");
+const model_pricing_1 = require("./model-pricing");
+function assertNonNegativeNumber(value, label) {
+    (0, assert_1.assertCondition)(typeof value === "number" && Number.isFinite(value) && value >= 0, `${label} must be a non-negative number`);
+}
+function assertSessionMessages(value) {
+    (0, assert_1.assertCondition)(Array.isArray(value), "Session messages response is not an array");
+    for (const [index, message] of value.entries()) {
+        (0, assert_1.assertCondition)(message !== null && typeof message === "object", `Session message at index ${index} must be an object`);
+        const messageRecord = message;
+        (0, assert_1.assertCondition)(messageRecord.info !== null && typeof messageRecord.info === "object", `Session message at index ${index} is missing info`);
+        const info = messageRecord.info;
+        (0, assert_1.assertCondition)(info.role === "user" || info.role === "assistant", `Session message at index ${index} has invalid role`);
+        (0, assert_1.assertCondition)(info.time !== null && typeof info.time === "object", `Session message at index ${index} is missing time`);
+        const time = info.time;
+        assertNonNegativeNumber(time.created, `Session message at index ${index} time.created`);
+        (0, assert_1.assertCondition)(typeof info.id === "string" && info.id.length > 0, `Session message at index ${index} is missing id`);
+        if (info.role === "assistant") {
+            (0, assert_1.assertCondition)(typeof info.modelID === "string" && info.modelID.length > 0, `Assistant message at index ${index} is missing modelID`);
+            (0, assert_1.assertCondition)(typeof info.providerID === "string" && info.providerID.length > 0, `Assistant message at index ${index} is missing providerID`);
+            (0, assert_1.assertCondition)(info.tokens !== null && typeof info.tokens === "object", `Assistant message at index ${index} is missing tokens`);
+            const tokens = info.tokens;
+            assertNonNegativeNumber(tokens.input, `Assistant message at index ${index} tokens.input`);
+            assertNonNegativeNumber(tokens.output, `Assistant message at index ${index} tokens.output`);
+            assertNonNegativeNumber(tokens.reasoning, `Assistant message at index ${index} tokens.reasoning`);
+            (0, assert_1.assertCondition)(tokens.cache !== null && typeof tokens.cache === "object", `Assistant message at index ${index} tokens.cache is missing`);
+            const cache = tokens.cache;
+            assertNonNegativeNumber(cache.read, `Assistant message at index ${index} tokens.cache.read`);
+            assertNonNegativeNumber(cache.write, `Assistant message at index ${index} tokens.cache.write`);
+            if (time.completed !== undefined) {
+                assertNonNegativeNumber(time.completed, `Assistant message at index ${index} time.completed`);
+            }
+        }
+    }
+}
+async function syncChatSessionUsage(chatSessionId, opencodeSessionId) {
+    const client = await (0, opencode_client_1.getOpencodeClient)();
+    const result = await client.session.messages({
+        path: { id: opencodeSessionId }
+    });
+    if (result.error) {
+        throw new Error("Failed to load session messages for usage sync");
+    }
+    assertSessionMessages(result.data);
+    const messages = result.data;
+    const existingUsage = await client_1.default.chat_session_usage.findUnique({
+        where: {
+            chat_session_id: chatSessionId,
+        }
+    });
+    let startIndex = 0;
+    if (existingUsage) {
+        const lastSyncedIndex = messages.findIndex((message) => (message.info.role === "assistant"
+            && message.info.id === existingUsage.last_synced_message_id));
+        if (lastSyncedIndex === -1) {
+            return;
+        }
+        startIndex = lastSyncedIndex + 1;
+    }
+    let deltaInputTokens = 0;
+    let deltaOutputTokens = 0;
+    let deltaCachedTokens = 0;
+    let latestProcessedAssistantMessageId = null;
+    let latestProcessedProviderId = null;
+    let latestProcessedModelId = null;
+    for (const message of messages.slice(startIndex)) {
+        const info = message.info;
+        if (info.role !== "assistant") {
+            continue;
+        }
+        deltaInputTokens += info.tokens.input;
+        deltaOutputTokens += info.tokens.output;
+        deltaCachedTokens += info.tokens.cache.read;
+        latestProcessedAssistantMessageId = info.id;
+        latestProcessedProviderId = info.providerID;
+        latestProcessedModelId = info.modelID;
+    }
+    if (latestProcessedAssistantMessageId === null
+        || latestProcessedProviderId === null
+        || latestProcessedModelId === null) {
+        return;
+    }
+    const deltaCostUsd = (0, model_pricing_1.calculateEstimatedCostUsd)({
+        providerId: latestProcessedProviderId,
+        modelId: latestProcessedModelId,
+        inputTokens: deltaInputTokens,
+        outputTokens: deltaOutputTokens,
+        cachedTokens: deltaCachedTokens,
+    });
+    const nextInputTokens = (existingUsage?.input_tokens ?? 0) + deltaInputTokens;
+    const nextOutputTokens = (existingUsage?.output_tokens ?? 0) + deltaOutputTokens;
+    const nextCachedTokens = (existingUsage?.cached_tokens ?? 0) + deltaCachedTokens;
+    const nextCostUsd = (existingUsage?.cost_usd ?? 0) + deltaCostUsd;
+    await client_1.default.chat_session_usage.upsert({
+        where: {
+            chat_session_id: chatSessionId,
+        },
+        create: {
+            chat_session_id: chatSessionId,
+            last_synced_message_id: latestProcessedAssistantMessageId,
+            provider_id: latestProcessedProviderId,
+            input_tokens: nextInputTokens,
+            output_tokens: nextOutputTokens,
+            cached_tokens: nextCachedTokens,
+            cost_usd: nextCostUsd,
+            model_id: latestProcessedModelId,
+            updated_at: BigInt(Date.now()),
+        },
+        update: {
+            last_synced_message_id: latestProcessedAssistantMessageId,
+            provider_id: latestProcessedProviderId,
+            input_tokens: nextInputTokens,
+            output_tokens: nextOutputTokens,
+            cached_tokens: nextCachedTokens,
+            cost_usd: nextCostUsd,
+            model_id: latestProcessedModelId,
+            updated_at: BigInt(Date.now()),
+        }
+    });
+}
+function getRangeConfig(range) {
+    switch (range) {
+        case "24h":
+            return { bucketMs: 60 * 60 * 1000, windowMs: 24 * 60 * 60 * 1000 };
+        case "7d":
+            return { bucketMs: 24 * 60 * 60 * 1000, windowMs: 7 * 24 * 60 * 60 * 1000 };
+        case "30d":
+            return { bucketMs: 24 * 60 * 60 * 1000, windowMs: 30 * 24 * 60 * 60 * 1000 };
+        case "90d":
+            return { bucketMs: 24 * 60 * 60 * 1000, windowMs: 90 * 24 * 60 * 60 * 1000 };
+    }
+}
+function normalizeUsageRange(value) {
+    if (value === "24h" || value === "7d" || value === "30d" || value === "90d") {
+        return value;
+    }
+    return "7d";
+}
+function getBucketStart(timestamp, bucketMs) {
+    return Math.floor(timestamp / bucketMs) * bucketMs;
+}
+async function buildUsageOverview(rawRange) {
+    const range = normalizeUsageRange(rawRange);
+    const { bucketMs, windowMs } = getRangeConfig(range);
+    const now = Date.now();
+    const rangeStart = now - windowMs;
+    const usageRows = await client_1.default.chat_session_usage.findMany({
+        where: {
+            session: {
+                updated_at: {
+                    gte: BigInt(rangeStart),
+                    lte: BigInt(now),
+                }
+            }
+        },
+        include: {
+            session: {
+                select: {
+                    updated_at: true,
+                }
+            }
+        }
+    });
+    const bucketMap = new Map();
+    const modelMap = new Map();
+    let totalInputTokens = 0;
+    let totalOutputTokens = 0;
+    let totalCachedTokens = 0;
+    let totalCostUsd = 0;
+    for (const row of usageRows) {
+        const sessionUpdatedAt = Number(row.session.updated_at);
+        const bucketStart = getBucketStart(sessionUpdatedAt, bucketMs);
+        const bucket = bucketMap.get(bucketStart) ?? {
+            bucket_start: bucketStart,
+            input_tokens: 0,
+            output_tokens: 0,
+            cached_tokens: 0,
+            cost_usd: 0,
+            session_count: 0,
+        };
+        bucket.input_tokens += row.input_tokens;
+        bucket.output_tokens += row.output_tokens;
+        bucket.cached_tokens += row.cached_tokens;
+        bucket.cost_usd += row.cost_usd;
+        bucket.session_count += 1;
+        bucketMap.set(bucketStart, bucket);
+        const modelKey = `${row.provider_id}:${row.model_id}`;
+        const model = modelMap.get(modelKey) ?? {
+            provider_id: row.provider_id,
+            model_id: row.model_id,
+            input_tokens: 0,
+            output_tokens: 0,
+            cached_tokens: 0,
+            cost_usd: 0,
+            session_count: 0,
+            pricing_available: (0, model_pricing_1.getModelPricing)(row.provider_id, row.model_id) !== null,
+        };
+        model.input_tokens += row.input_tokens;
+        model.output_tokens += row.output_tokens;
+        model.cached_tokens += row.cached_tokens;
+        model.cost_usd += row.cost_usd;
+        model.session_count += 1;
+        modelMap.set(modelKey, model);
+        totalInputTokens += row.input_tokens;
+        totalOutputTokens += row.output_tokens;
+        totalCachedTokens += row.cached_tokens;
+        totalCostUsd += row.cost_usd;
+    }
+    const bucketStarts = [];
+    for (let time = getBucketStart(rangeStart, bucketMs); time <= getBucketStart(now, bucketMs); time += bucketMs) {
+        bucketStarts.push(time);
+    }
+    const timeseries = bucketStarts.map((bucketStart) => bucketMap.get(bucketStart) ?? {
+        bucket_start: bucketStart,
+        input_tokens: 0,
+        output_tokens: 0,
+        cached_tokens: 0,
+        cost_usd: 0,
+        session_count: 0,
+    });
+    const models = Array.from(modelMap.values()).sort((a, b) => b.cost_usd - a.cost_usd);
+    const pricing = {};
+    for (const model of models) {
+        const modelPricing = (0, model_pricing_1.getModelPricing)(model.provider_id, model.model_id);
+        if (!modelPricing) {
+            continue;
+        }
+        pricing[`${model.provider_id}:${model.model_id}`] = {
+            provider_id: model.provider_id,
+            input_per_million_usd: modelPricing.inputPerMillionUsd,
+            cached_input_per_million_usd: modelPricing.cachedInputPerMillionUsd,
+            output_per_million_usd: modelPricing.outputPerMillionUsd,
+        };
+    }
+    return {
+        range,
+        estimated: true,
+        summary: {
+            total_input_tokens: totalInputTokens,
+            total_output_tokens: totalOutputTokens,
+            total_cached_tokens: totalCachedTokens,
+            total_cost_usd: totalCostUsd,
+            session_count: usageRows.length,
+        },
+        timeseries,
+        models,
+        pricing,
+    };
+}

package/dist/utils/model-pricing.js

@@ -0,0 +1,107 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getModelPricing = getModelPricing;
+exports.calculateEstimatedCostUsd = calculateEstimatedCostUsd;
+const MODEL_PRICING = {
+    openai: {
+        "gpt-5.4": {
+            inputPerMillionUsd: 2.5,
+            cachedInputPerMillionUsd: 0.25,
+            outputPerMillionUsd: 15,
+        },
+        "gpt-5.4-mini": {
+            inputPerMillionUsd: 0.75,
+            cachedInputPerMillionUsd: 0.075,
+            outputPerMillionUsd: 4.5,
+        },
+        "gpt-5.4-nano": {
+            inputPerMillionUsd: 0.2,
+            cachedInputPerMillionUsd: 0.02,
+            outputPerMillionUsd: 1.25,
+        },
+        "gpt-5.3-chat-latest": {
+            inputPerMillionUsd: 1.75,
+            cachedInputPerMillionUsd: 0.175,
+            outputPerMillionUsd: 14,
+        },
+        "gpt-5.3-codex": {
+            inputPerMillionUsd: 1.75,
+            cachedInputPerMillionUsd: 0.175,
+            outputPerMillionUsd: 14,
+        },
+        "gpt-5.1": {
+            inputPerMillionUsd: 1.25,
+            cachedInputPerMillionUsd: 0.125,
+            outputPerMillionUsd: 10,
+        },
+        "gpt-5": {
+            inputPerMillionUsd: 1.25,
+            cachedInputPerMillionUsd: 0.125,
+            outputPerMillionUsd: 10,
+        },
+        "gpt-5-mini": {
+            inputPerMillionUsd: 0.25,
+            cachedInputPerMillionUsd: 0.025,
+            outputPerMillionUsd: 2,
+        },
+        "gpt-5-nano": {
+            inputPerMillionUsd: 0.05,
+            cachedInputPerMillionUsd: 0.005,
+            outputPerMillionUsd: 0.4,
+        }
+    },
+};
+function assertNonNegativeNumber(value, label) {
+    if (typeof value !== "number" || !Number.isFinite(value) || value < 0) {
+        throw new Error(`${label} must be a non-negative number`);
+    }
+}
+function parseOptionalNonNegativeNumber(raw, label) {
+    if (raw === undefined || raw.length === 0) {
+        return null;
+    }
+    const parsed = Number(raw);
+    assertNonNegativeNumber(parsed, label);
+    return parsed;
+}
+function getPricingOverrideForConfiguredModel(providerId, modelId) {
+    const configuredModel = process.env.OPENCODE_MODEL;
+    const [configuredProviderId, ...configuredModelParts] = configuredModel.split("/");
+    const configuredModelId = configuredModelParts.join("/");
+    if (!configuredProviderId || !configuredModelId) {
+        throw new Error("OPENCODE_MODEL must be in the format <provider>/<model>");
+    }
+    if (providerId !== configuredProviderId || modelId !== configuredModelId) {
+        return null;
+    }
+    const inputPerMillionUsd = parseOptionalNonNegativeNumber(process.env.TEAMCOPILOT_MODEL_INPUT_PER_MILLION_USD, "TEAMCOPILOT_MODEL_INPUT_PER_MILLION_USD");
+    const cachedInputPerMillionUsd = parseOptionalNonNegativeNumber(process.env.TEAMCOPILOT_MODEL_CACHED_INPUT_PER_MILLION_USD, "TEAMCOPILOT_MODEL_CACHED_INPUT_PER_MILLION_USD");
+    const outputPerMillionUsd = parseOptionalNonNegativeNumber(process.env.TEAMCOPILOT_MODEL_OUTPUT_PER_MILLION_USD, "TEAMCOPILOT_MODEL_OUTPUT_PER_MILLION_USD");
+    if (inputPerMillionUsd === null && cachedInputPerMillionUsd === null && outputPerMillionUsd === null) {
+        return null;
+    }
+    if (inputPerMillionUsd === null || cachedInputPerMillionUsd === null || outputPerMillionUsd === null) {
+        throw new Error("TEAMCOPILOT_MODEL_INPUT_PER_MILLION_USD, TEAMCOPILOT_MODEL_CACHED_INPUT_PER_MILLION_USD, and TEAMCOPILOT_MODEL_OUTPUT_PER_MILLION_USD must either all be set or all be unset");
+    }
+    return {
+        inputPerMillionUsd,
+        cachedInputPerMillionUsd,
+        outputPerMillionUsd,
+    };
+}
+function getModelPricing(providerId, modelId) {
+    const override = getPricingOverrideForConfiguredModel(providerId, modelId);
+    if (override) {
+        return override;
+    }
+    return MODEL_PRICING[providerId]?.[modelId] ?? null;
+}
+function calculateEstimatedCostUsd(args) {
+    const pricing = getModelPricing(args.providerId, args.modelId);
+    if (!pricing) {
+        return 0;
+    }
+    return ((args.inputTokens * pricing.inputPerMillionUsd) / 1000000
+        + (args.cachedTokens * pricing.cachedInputPerMillionUsd) / 1000000
+        + (args.outputTokens * pricing.outputPerMillionUsd) / 1000000);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "teamcopilot",
-  "version": "0.2.2",
+  "version": "0.3.0",
   "description": "A shared AI Agent for Teams",
   "homepage": "https://teamcopilot.ai",
   "repository": {
@@ -24,7 +24,7 @@
   "scripts": {
     "clean": "rm -rf dist",
     "check:unused:functions": "tsc --noEmit --noUnusedLocals --noUnusedParameters",
-    "check:unused:exports": "ts-prune -e -p tsconfig.json -i \"^src/types/shared/|^prisma/generated/|^src/index.ts:31 - createApp \\(used in module\\)$|^src/utils/secret-contract-validation.ts:45 - extractReferencedWorkflowSecrets \\(used in module\\)$|^src/utils/secret-contract-validation.ts:57 - extractReferencedSkillSecrets \\(used in module\\)$|^src/utils/secret-contract-validation.ts:158 - parseSkillRequiredSecrets \\(used in module\\)$\"",
+    "check:unused:exports": "ts-prune -e -p tsconfig.json -i \"^src/types/shared/|^prisma/generated/|^src/index.ts:[0-9]+ - createApp \\(used in module\\)$|^src/utils/secret-contract-validation.ts:45 - extractReferencedWorkflowSecrets \\(used in module\\)$|^src/utils/secret-contract-validation.ts:57 - extractReferencedSkillSecrets \\(used in module\\)$|^src/utils/secret-contract-validation.ts:158 - parseSkillRequiredSecrets \\(used in module\\)$\"",
     "check:unused": "npm run check:unused:functions && npm run check:unused:exports",
     "build": "npm run clean && npm run check:unused && cd frontend && npm run build && cd .. && prisma generate --schema prisma/schema.prisma && tsc && node scripts/copy-runtime-assets.mjs",
     "start": "node dist/index.js",