@wingman-ai/gateway 0.4.2 → 0.4.4

package/dist/bench/scoring.js

@@ -0,0 +1,137 @@
+import { readFile } from "node:fs/promises";
+function average(values) {
+    if (0 === values.length) return 0;
+    return values.reduce((total, value)=>total + value, 0) / values.length;
+}
+function percentile(values, p) {
+    if (0 === values.length) return 0;
+    const sorted = [
+        ...values
+    ].sort((a, b)=>a - b);
+    const index = Math.ceil(p / 100 * sorted.length) - 1;
+    return sorted[Math.max(0, Math.min(index, sorted.length - 1))];
+}
+function clamp(value, min = 0, max = 1) {
+    return Math.max(min, Math.min(max, value));
+}
+function computeCostUsd(inputTokens, outputTokens, config) {
+    const inputCost = inputTokens / 1000 * config.scoring.pricing.inputPer1kTokensUsd;
+    const outputCost = outputTokens / 1000 * config.scoring.pricing.outputPer1kTokensUsd;
+    return inputCost + outputCost;
+}
+function normalizeWeightedScore(input) {
+    const weightTotal = input.weights.passRate + input.weights.reliability + input.weights.duration + input.weights.cost;
+    if (weightTotal <= 0) return 0;
+    const weighted = input.passRate * input.weights.passRate + input.reliability * input.weights.reliability + input.duration * input.weights.duration + input.cost * input.weights.cost;
+    return weighted / weightTotal;
+}
+async function compareToBaseline(summary, config) {
+    if (!config.qualityGate.enabled || !config.qualityGate.baselineFile) return {
+        passed: true,
+        messages: []
+    };
+    let baseline;
+    try {
+        baseline = JSON.parse(await readFile(config.qualityGate.baselineFile, "utf-8"));
+    } catch (error) {
+        return {
+            passed: false,
+            messages: [
+                `Unable to read baseline file ${config.qualityGate.baselineFile}: ${error instanceof Error ? error.message : String(error)}`
+            ]
+        };
+    }
+    const messages = [];
+    let passed = true;
+    const passRateDelta = summary.metrics.passRate - baseline.metrics.passRate;
+    if (passRateDelta < config.qualityGate.minPassRateDelta) {
+        passed = false;
+        messages.push(`Pass rate delta ${passRateDelta.toFixed(4)} is below threshold ${config.qualityGate.minPassRateDelta.toFixed(4)}.`);
+    }
+    if (baseline.metrics.totalCostUsd > 0) {
+        const costIncreaseRatio = (summary.metrics.totalCostUsd - baseline.metrics.totalCostUsd) / baseline.metrics.totalCostUsd;
+        if (costIncreaseRatio > config.qualityGate.maxCostIncreaseRatio) {
+            passed = false;
+            messages.push(`Cost increase ratio ${(100 * costIncreaseRatio).toFixed(2)}% exceeded threshold ${(100 * config.qualityGate.maxCostIncreaseRatio).toFixed(2)}%.`);
+        }
+    }
+    if (baseline.metrics.avgDurationMs > 0) {
+        const durationIncreaseRatio = (summary.metrics.avgDurationMs - baseline.metrics.avgDurationMs) / baseline.metrics.avgDurationMs;
+        if (durationIncreaseRatio > config.qualityGate.maxAvgDurationIncreaseRatio) {
+            passed = false;
+            messages.push(`Average duration increase ratio ${(100 * durationIncreaseRatio).toFixed(2)}% exceeded threshold ${(100 * config.qualityGate.maxAvgDurationIncreaseRatio).toFixed(2)}%.`);
+        }
+    }
+    return {
+        passed,
+        messages
+    };
+}
+async function buildTerminalBenchSummary(input) {
+    const totalTasks = input.tasks.length;
+    const passedTasks = input.tasks.filter((task)=>"passed" === task.status).length;
+    const failedTasks = totalTasks - passedTasks;
+    const passRate = totalTasks > 0 ? passedTasks / totalTasks : 0;
+    const timeoutRate = totalTasks > 0 ? input.tasks.filter((task)=>task.adapter.timedOut).length / totalTasks : 0;
+    const durationValues = input.tasks.map((task)=>task.durationMs);
+    const totalDurationMs = durationValues.reduce((total, value)=>total + value, 0);
+    const avgDurationMs = average(durationValues);
+    const p95DurationMs = percentile(durationValues, 95);
+    const totalInputTokens = input.tasks.reduce((total, task)=>total + task.adapter.tokens.inputTokens, 0);
+    const totalOutputTokens = input.tasks.reduce((total, task)=>total + task.adapter.tokens.outputTokens, 0);
+    const totalTokens = input.tasks.reduce((total, task)=>total + task.adapter.tokens.totalTokens, 0);
+    const totalCostUsd = computeCostUsd(totalInputTokens, totalOutputTokens, input.config);
+    const avgCostPerTaskUsd = totalTasks > 0 ? totalCostUsd / totalTasks : 0;
+    const costPerPassUsd = passedTasks > 0 ? totalCostUsd / passedTasks : totalCostUsd;
+    const durationBudget = input.config.scoring.budgets.targetAvgDurationMs;
+    const durationScore = durationBudget ? 100 * clamp(durationBudget / Math.max(avgDurationMs, 1)) : 100;
+    const costBudget = input.config.scoring.budgets.targetCostPerTaskUsd;
+    const costScore = costBudget ? 100 * clamp(costBudget / Math.max(avgCostPerTaskUsd, Number.EPSILON)) : 100;
+    const reliabilityScore = (1 - timeoutRate) * 100;
+    const passRateScore = 100 * passRate;
+    const overallScore = normalizeWeightedScore({
+        passRate: passRateScore,
+        reliability: reliabilityScore,
+        duration: durationScore,
+        cost: costScore,
+        weights: input.config.scoring.weights
+    });
+    const summary = {
+        runId: input.runId,
+        startedAt: input.startedAt,
+        endedAt: input.endedAt,
+        configPath: input.config.configPath,
+        taskFilePath: input.config.taskFilePath,
+        resultsDir: input.resultsDir,
+        metrics: {
+            totalTasks,
+            passedTasks,
+            failedTasks,
+            passRate,
+            timeoutRate,
+            totalDurationMs,
+            avgDurationMs,
+            p95DurationMs,
+            totalInputTokens,
+            totalOutputTokens,
+            totalTokens,
+            totalCostUsd,
+            avgCostPerTaskUsd,
+            costPerPassUsd,
+            overallScore
+        },
+        qualityGate: {
+            enabled: input.config.qualityGate.enabled,
+            passed: true,
+            messages: [],
+            baselineFile: input.config.qualityGate.baselineFile
+        },
+        tasks: input.tasks,
+        metadata: input.config.metadata
+    };
+    const qualityGateResult = await compareToBaseline(summary, input.config);
+    summary.qualityGate.passed = qualityGateResult.passed;
+    summary.qualityGate.messages = qualityGateResult.messages;
+    return summary;
+}
+export { buildTerminalBenchSummary };

package/dist/bench/types.cjs

@@ -0,0 +1,18 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/bench/types.d.ts

@@ -0,0 +1,200 @@
+export type BenchCommand = {
+    command: string;
+    args?: string[];
+    shell?: boolean;
+    env?: Record<string, string>;
+    allowFailure?: boolean;
+};
+export type BenchValidator = {
+    type: "command";
+    command: BenchCommand;
+    expectedExitCode?: number;
+} | {
+    type: "assistant_contains";
+    includes: string[];
+} | {
+    type: "file_contains";
+    path: string;
+    includes: string[];
+};
+export interface TerminalBenchTask {
+    id: string;
+    description?: string;
+    prompt: string;
+    workingDirectory?: string;
+    timeoutMs?: number;
+    setup?: BenchCommand[];
+    validator: BenchValidator;
+    metadata?: Record<string, string>;
+    adapterOverrides?: {
+        agent?: string;
+        extraArgs?: string[];
+    };
+}
+export interface TerminalBenchTaskFile {
+    tasks: TerminalBenchTask[];
+}
+export type WingmanCliAdapterConfig = {
+    type: "wingman-cli";
+    agent: string;
+    cliPath?: string;
+    extraArgs?: string[];
+    env?: Record<string, string>;
+};
+export type CommandAdapterConfig = {
+    type: "command";
+    command: BenchCommand;
+};
+export type TerminalBenchAdapterConfig = WingmanCliAdapterConfig | CommandAdapterConfig;
+export interface TerminalBenchConfigFile {
+    version?: 1;
+    taskFile: string;
+    resultsDir?: string;
+    run?: {
+        defaultTimeoutMs?: number;
+        continueOnFailure?: boolean;
+    };
+    adapter: TerminalBenchAdapterConfig;
+    scoring?: {
+        weights?: {
+            passRate?: number;
+            reliability?: number;
+            duration?: number;
+            cost?: number;
+        };
+        budgets?: {
+            targetAvgDurationMs?: number;
+            targetCostPerTaskUsd?: number;
+        };
+        pricing?: {
+            inputPer1kTokensUsd?: number;
+            outputPer1kTokensUsd?: number;
+        };
+    };
+    qualityGate?: {
+        enabled?: boolean;
+        baselineFile?: string;
+        minPassRateDelta?: number;
+        maxCostIncreaseRatio?: number;
+        maxAvgDurationIncreaseRatio?: number;
+    };
+    metadata?: Record<string, string>;
+}
+export interface TerminalBenchResolvedConfig {
+    version: 1;
+    configPath: string;
+    taskFilePath: string;
+    resultsDir: string;
+    run: {
+        defaultTimeoutMs: number;
+        continueOnFailure: boolean;
+    };
+    adapter: TerminalBenchAdapterConfig;
+    tasks: TerminalBenchTask[];
+    scoring: {
+        weights: {
+            passRate: number;
+            reliability: number;
+            duration: number;
+            cost: number;
+        };
+        budgets: {
+            targetAvgDurationMs?: number;
+            targetCostPerTaskUsd?: number;
+        };
+        pricing: {
+            inputPer1kTokensUsd: number;
+            outputPer1kTokensUsd: number;
+        };
+    };
+    qualityGate: {
+        enabled: boolean;
+        baselineFile?: string;
+        minPassRateDelta: number;
+        maxCostIncreaseRatio: number;
+        maxAvgDurationIncreaseRatio: number;
+    };
+    metadata: Record<string, string>;
+}
+export interface AdapterTokenUsage {
+    inputTokens: number;
+    outputTokens: number;
+    totalTokens: number;
+}
+export interface AdapterInvocationResult {
+    exitCode: number;
+    timedOut: boolean;
+    durationMs: number;
+    stdout: string;
+    stderr: string;
+    assistantText: string;
+    errorMessage?: string;
+    tokens: AdapterTokenUsage;
+}
+export interface TaskRunContext {
+    task: TerminalBenchTask;
+    workingDirectory: string;
+    timeoutMs: number;
+}
+export interface TerminalBenchAdapter {
+    invoke(context: TaskRunContext): Promise<AdapterInvocationResult>;
+}
+export interface TaskValidatorResult {
+    passed: boolean;
+    details: string;
+}
+export interface TaskRunResult {
+    taskId: string;
+    description?: string;
+    workingDirectory: string;
+    prompt: string;
+    status: "passed" | "failed";
+    startedAt: string;
+    endedAt: string;
+    durationMs: number;
+    adapter: AdapterInvocationResult;
+    validator: TaskValidatorResult;
+    setup: {
+        runCount: number;
+        failed?: string;
+    };
+    artifacts: {
+        stdoutFile: string;
+        stderrFile: string;
+        assistantFile: string;
+        recordFile: string;
+    };
+}
+export interface TerminalBenchSummary {
+    runId: string;
+    startedAt: string;
+    endedAt: string;
+    configPath: string;
+    taskFilePath: string;
+    resultsDir: string;
+    metrics: {
+        totalTasks: number;
+        passedTasks: number;
+        failedTasks: number;
+        passRate: number;
+        timeoutRate: number;
+        totalDurationMs: number;
+        avgDurationMs: number;
+        p95DurationMs: number;
+        totalInputTokens: number;
+        totalOutputTokens: number;
+        totalTokens: number;
+        totalCostUsd: number;
+        avgCostPerTaskUsd: number;
+        costPerPassUsd: number;
+        overallScore: number;
+    };
+    qualityGate: {
+        enabled: boolean;
+        passed: boolean;
+        messages: string[];
+        baselineFile?: string;
+    };
+    tasks: TaskRunResult[];
+    metadata: Record<string, string>;
+}

package/dist/bench/validator.cjs

@@ -0,0 +1,92 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    runTaskValidator: ()=>runTaskValidator
+});
+const promises_namespaceObject = require("node:fs/promises");
+const external_node_path_namespaceObject = require("node:path");
+const external_process_cjs_namespaceObject = require("./process.cjs");
+function includesAll(haystack, needles) {
+    const missing = [];
+    for (const needle of needles)if (!haystack.includes(needle)) missing.push(needle);
+    return missing;
+}
+async function runTaskValidator(context, adapterResult) {
+    const validator = context.task.validator;
+    if ("assistant_contains" === validator.type) {
+        const missing = includesAll(adapterResult.assistantText, validator.includes);
+        if (0 === missing.length) return {
+            passed: true,
+            details: "Assistant response contains all required strings."
+        };
+        return {
+            passed: false,
+            details: `Missing assistant substrings: ${missing.join(", ")}`
+        };
+    }
+    if ("file_contains" === validator.type) {
+        const filePath = (0, external_node_path_namespaceObject.resolve)(context.workingDirectory, validator.path);
+        try {
+            const content = await (0, promises_namespaceObject.readFile)(filePath, "utf-8");
+            const missing = includesAll(content, validator.includes);
+            if (0 === missing.length) return {
+                passed: true,
+                details: `File ${validator.path} contains all required strings.`
+            };
+            return {
+                passed: false,
+                details: `File ${validator.path} missing: ${missing.join(", ")}`
+            };
+        } catch (error) {
+            return {
+                passed: false,
+                details: `Unable to read ${validator.path}: ${error instanceof Error ? error.message : String(error)}`
+            };
+        }
+    }
+    const run = await (0, external_process_cjs_namespaceObject.runCommand)(validator.command.command, validator.command.args || [], {
+        cwd: context.workingDirectory,
+        timeoutMs: context.timeoutMs,
+        shell: validator.command.shell,
+        env: validator.command.env
+    });
+    const expectedExitCode = validator.expectedExitCode ?? 0;
+    if (run.exitCode === expectedExitCode) return {
+        passed: true,
+        details: `Validator command exit code matched ${expectedExitCode}.`
+    };
+    return {
+        passed: false,
+        details: `Validator command exit code ${run.exitCode} did not match ${expectedExitCode}. stderr: ${run.stderr.trim()}`
+    };
+}
+exports.runTaskValidator = __webpack_exports__.runTaskValidator;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "runTaskValidator"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/bench/validator.d.ts

@@ -0,0 +1,2 @@
+import type { AdapterInvocationResult, TaskRunContext, TaskValidatorResult } from "./types.js";
+export declare function runTaskValidator(context: TaskRunContext, adapterResult: AdapterInvocationResult): Promise<TaskValidatorResult>;

package/dist/bench/validator.js

@@ -0,0 +1,58 @@
+import { readFile } from "node:fs/promises";
+import { resolve } from "node:path";
+import { runCommand } from "./process.js";
+function includesAll(haystack, needles) {
+    const missing = [];
+    for (const needle of needles)if (!haystack.includes(needle)) missing.push(needle);
+    return missing;
+}
+async function runTaskValidator(context, adapterResult) {
+    const validator = context.task.validator;
+    if ("assistant_contains" === validator.type) {
+        const missing = includesAll(adapterResult.assistantText, validator.includes);
+        if (0 === missing.length) return {
+            passed: true,
+            details: "Assistant response contains all required strings."
+        };
+        return {
+            passed: false,
+            details: `Missing assistant substrings: ${missing.join(", ")}`
+        };
+    }
+    if ("file_contains" === validator.type) {
+        const filePath = resolve(context.workingDirectory, validator.path);
+        try {
+            const content = await readFile(filePath, "utf-8");
+            const missing = includesAll(content, validator.includes);
+            if (0 === missing.length) return {
+                passed: true,
+                details: `File ${validator.path} contains all required strings.`
+            };
+            return {
+                passed: false,
+                details: `File ${validator.path} missing: ${missing.join(", ")}`
+            };
+        } catch (error) {
+            return {
+                passed: false,
+                details: `Unable to read ${validator.path}: ${error instanceof Error ? error.message : String(error)}`
+            };
+        }
+    }
+    const run = await runCommand(validator.command.command, validator.command.args || [], {
+        cwd: context.workingDirectory,
+        timeoutMs: context.timeoutMs,
+        shell: validator.command.shell,
+        env: validator.command.env
+    });
+    const expectedExitCode = validator.expectedExitCode ?? 0;
+    if (run.exitCode === expectedExitCode) return {
+        passed: true,
+        details: `Validator command exit code matched ${expectedExitCode}.`
+    };
+    return {
+        passed: false,
+        details: `Validator command exit code ${run.exitCode} did not match ${expectedExitCode}. stderr: ${run.stderr.trim()}`
+    };
+}
+export { runTaskValidator };

package/dist/cli/config/schema.cjs

@@ -225,8 +225,43 @@ const DiscordAdapterSchema = external_zod_namespaceObject.object({
     sessionCommand: "!session",
     responseChunkSize: 1900
 });
+const TeamsAdapterSchema = external_zod_namespaceObject.object({
+    enabled: external_zod_namespaceObject.boolean().default(false),
+    appId: external_zod_namespaceObject.string().optional(),
+    appPassword: external_zod_namespaceObject.string().optional(),
+    appType: external_zod_namespaceObject["enum"]([
+        "MultiTenant",
+        "SingleTenant",
+        "UserAssignedMsi",
+        "UserAssignedMSI"
+    ]).default("MultiTenant"),
+    tenantId: external_zod_namespaceObject.string().optional(),
+    endpointPath: external_zod_namespaceObject.string().default("/api/adapters/teams/messages"),
+    mentionOnly: external_zod_namespaceObject.boolean().default(true),
+    allowBots: external_zod_namespaceObject.boolean().default(false),
+    allowedTeamIds: external_zod_namespaceObject.array(external_zod_namespaceObject.string()).default([]),
+    allowedChannelIds: external_zod_namespaceObject.array(external_zod_namespaceObject.string()).default([]),
+    channelSessions: external_zod_namespaceObject.record(external_zod_namespaceObject.string(), external_zod_namespaceObject.string()).default({}),
+    sessionCommand: external_zod_namespaceObject.string().default("!session"),
+    gatewayUrl: external_zod_namespaceObject.string().optional(),
+    gatewayToken: external_zod_namespaceObject.string().optional(),
+    gatewayPassword: external_zod_namespaceObject.string().optional(),
+    responseChunkSize: external_zod_namespaceObject.number().min(500).max(5000).default(3500)
+}).default({
+    enabled: false,
+    appType: "MultiTenant",
+    endpointPath: "/api/adapters/teams/messages",
+    mentionOnly: true,
+    allowBots: false,
+    allowedTeamIds: [],
+    allowedChannelIds: [],
+    channelSessions: {},
+    sessionCommand: "!session",
+    responseChunkSize: 3500
+});
 const GatewayAdaptersSchema = external_zod_namespaceObject.object({
-    discord: DiscordAdapterSchema.optional()
+    discord: DiscordAdapterSchema.optional(),
+    teams: TeamsAdapterSchema.optional()
 }).default({});
 const GatewayMcpProxySchema = external_zod_namespaceObject.object({
     enabled: external_zod_namespaceObject.boolean().optional().default(false).describe("Enable MCP stdio proxy wrapper for gateway agent execution"),

package/dist/cli/config/schema.d.ts

@@ -154,6 +154,29 @@ export declare const GatewayConfigSchema: z.ZodDefault<z.ZodObject<{
             gatewayPassword: z.ZodOptional<z.ZodString>;
             responseChunkSize: z.ZodDefault<z.ZodNumber>;
         }, z.core.$strip>>>;
+        teams: z.ZodOptional<z.ZodDefault<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodBoolean>;
+            appId: z.ZodOptional<z.ZodString>;
+            appPassword: z.ZodOptional<z.ZodString>;
+            appType: z.ZodDefault<z.ZodEnum<{
+                MultiTenant: "MultiTenant";
+                SingleTenant: "SingleTenant";
+                UserAssignedMsi: "UserAssignedMsi";
+                UserAssignedMSI: "UserAssignedMSI";
+            }>>;
+            tenantId: z.ZodOptional<z.ZodString>;
+            endpointPath: z.ZodDefault<z.ZodString>;
+            mentionOnly: z.ZodDefault<z.ZodBoolean>;
+            allowBots: z.ZodDefault<z.ZodBoolean>;
+            allowedTeamIds: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            allowedChannelIds: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            channelSessions: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
+            sessionCommand: z.ZodDefault<z.ZodString>;
+            gatewayUrl: z.ZodOptional<z.ZodString>;
+            gatewayToken: z.ZodOptional<z.ZodString>;
+            gatewayPassword: z.ZodOptional<z.ZodString>;
+            responseChunkSize: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strip>>>;
     }, z.core.$strip>>>>;
 }, z.core.$strip>>;
 export type GatewayConfig = z.infer<typeof GatewayConfigSchema>;
@@ -409,6 +432,29 @@ export declare const WingmanConfigSchema: z.ZodObject<{
                 gatewayPassword: z.ZodOptional<z.ZodString>;
                 responseChunkSize: z.ZodDefault<z.ZodNumber>;
             }, z.core.$strip>>>;
+            teams: z.ZodOptional<z.ZodDefault<z.ZodObject<{
+                enabled: z.ZodDefault<z.ZodBoolean>;
+                appId: z.ZodOptional<z.ZodString>;
+                appPassword: z.ZodOptional<z.ZodString>;
+                appType: z.ZodDefault<z.ZodEnum<{
+                    MultiTenant: "MultiTenant";
+                    SingleTenant: "SingleTenant";
+                    UserAssignedMsi: "UserAssignedMsi";
+                    UserAssignedMSI: "UserAssignedMSI";
+                }>>;
+                tenantId: z.ZodOptional<z.ZodString>;
+                endpointPath: z.ZodDefault<z.ZodString>;
+                mentionOnly: z.ZodDefault<z.ZodBoolean>;
+                allowBots: z.ZodDefault<z.ZodBoolean>;
+                allowedTeamIds: z.ZodDefault<z.ZodArray<z.ZodString>>;
+                allowedChannelIds: z.ZodDefault<z.ZodArray<z.ZodString>>;
+                channelSessions: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
+                sessionCommand: z.ZodDefault<z.ZodString>;
+                gatewayUrl: z.ZodOptional<z.ZodString>;
+                gatewayToken: z.ZodOptional<z.ZodString>;
+                gatewayPassword: z.ZodOptional<z.ZodString>;
+                responseChunkSize: z.ZodDefault<z.ZodNumber>;
+            }, z.core.$strip>>>;
         }, z.core.$strip>>>>;
     }, z.core.$strip>>>>;
     agents: z.ZodDefault<z.ZodOptional<z.ZodDefault<z.ZodObject<{

package/dist/cli/config/schema.js

@@ -185,8 +185,43 @@ const DiscordAdapterSchema = object({
     sessionCommand: "!session",
     responseChunkSize: 1900
 });
+const TeamsAdapterSchema = object({
+    enabled: external_zod_boolean().default(false),
+    appId: string().optional(),
+    appPassword: string().optional(),
+    appType: external_zod_enum([
+        "MultiTenant",
+        "SingleTenant",
+        "UserAssignedMsi",
+        "UserAssignedMSI"
+    ]).default("MultiTenant"),
+    tenantId: string().optional(),
+    endpointPath: string().default("/api/adapters/teams/messages"),
+    mentionOnly: external_zod_boolean().default(true),
+    allowBots: external_zod_boolean().default(false),
+    allowedTeamIds: array(string()).default([]),
+    allowedChannelIds: array(string()).default([]),
+    channelSessions: record(string(), string()).default({}),
+    sessionCommand: string().default("!session"),
+    gatewayUrl: string().optional(),
+    gatewayToken: string().optional(),
+    gatewayPassword: string().optional(),
+    responseChunkSize: number().min(500).max(5000).default(3500)
+}).default({
+    enabled: false,
+    appType: "MultiTenant",
+    endpointPath: "/api/adapters/teams/messages",
+    mentionOnly: true,
+    allowBots: false,
+    allowedTeamIds: [],
+    allowedChannelIds: [],
+    channelSessions: {},
+    sessionCommand: "!session",
+    responseChunkSize: 3500
+});
 const GatewayAdaptersSchema = object({
-    discord: DiscordAdapterSchema.optional()
+    discord: DiscordAdapterSchema.optional(),
+    teams: TeamsAdapterSchema.optional()
 }).default({});
 const GatewayMcpProxySchema = object({
     enabled: external_zod_boolean().optional().default(false).describe("Enable MCP stdio proxy wrapper for gateway agent execution"),