teamcopilot 0.2.2 → 0.3.1

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/dist/workspace_files/.opencode/plugins/runWorkflow.ts

@@ -108,19 +108,21 @@ export const RunWorkflowPlugin: Plugin = async ({ client }) => {
             ),
           inputs: tool.schema
             .record(tool.schema.string(), tool.schema.unknown())
-            .optional()
-            .default({})
             .describe(
-              "Runtime workflow arguments. Provide key-value pairs matching the `inputs` schema in workflow.json; these values are validated and passed through to `run.py`."
+              "Runtime workflow arguments. Provide key-value pairs matching the `inputs` schema in workflow.json for the workflow you want to run; these values are validated and passed through to `run.py`. If the workflow takes no arguments, then pass an empty object assigned to this key, otherwise, pass all the expected arguments always (even if there are default values assigned to them)."
             ),
         },
         async execute(args, context) {
           const { sessionID } = context
           const authSessionID = await resolveRootSessionID(sessionID)
-          const { slug, inputs = {} } = args
+          const { slug, inputs } = args
           const messageId = extractMessageId(context)
           const callId = extractCallId(context)
 
+          if (inputs === undefined) {
+            throw new Error(`You must pass an inputs object when calling runWorkflow. The inputs object contains the workflow arguments. Inspect the workflow README or use the findSimilarWorkflow tool to see the available arguments and their default values. If a workflow has arguments, it's best practice to pass all of them even if they have default values, so that the user can see exactly what's passed. Example: {"inputs":{"topic":"weekly update","dry_run":true}}. If the workflow has no arguments, pass {"inputs":{}}.`)
+          }
+
           if (!messageId) {
             throw new Error("Could not determine message id from tool context.")
           }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "teamcopilot",
-  "version": "0.2.2",
+  "version": "0.3.1",
   "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",