@codemieai/code 0.0.58 → 0.1.0

package/scripts/sonar/run-local-sonar.js

@@ -0,0 +1,405 @@
+// Copyright 2026 EPAM Systems, Inc. (“EPAM”)
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+const { spawn } = require('node:child_process');
+const fs = require('node:fs');
+const http = require('node:http');
+const https = require('node:https');
+const path = require('node:path');
+
+const REPOSITORY_ROOT = path.resolve(__dirname, '../..');
+const CONNECTED_MODE_PATH = path.resolve(REPOSITORY_ROOT, '.sonarlint/connectedMode.json');
+const SONAR_PROPERTIES_PATH = path.resolve(REPOSITORY_ROOT, 'sonar-project.properties');
+const SERVER_TIMEOUT_MS = 5000;
+const PAGE_SIZE = 500;
+
+function log(message) {
+    process.stdout.write(`[sonar-local] ${message}\n`);
+}
+
+function logError(message) {
+    process.stderr.write(`[sonar-local] ${message}\n`);
+}
+
+function readConnectedModeConfig() {
+    if (!fs.existsSync(CONNECTED_MODE_PATH)) {
+        throw new Error(`Missing SonarLint connected mode config: ${CONNECTED_MODE_PATH}`);
+    }
+
+    const rawContent = fs.readFileSync(CONNECTED_MODE_PATH, 'utf8');
+    const parsedConfig = JSON.parse(rawContent);
+    const sonarHostUrl = parsedConfig.sonarQubeUri;
+    const sonarProjectKey = parsedConfig.projectKey;
+
+    if (!sonarHostUrl || !sonarProjectKey) {
+        throw new Error(
+            `SonarLint connected mode config must define both "sonarQubeUri" and "projectKey": ${CONNECTED_MODE_PATH}`,
+        );
+    }
+
+    return { sonarHostUrl, sonarProjectKey };
+}
+
+function readSonarProperties() {
+    if (!fs.existsSync(SONAR_PROPERTIES_PATH)) {
+        throw new Error(`Missing Sonar project configuration: ${SONAR_PROPERTIES_PATH}`);
+    }
+
+    const properties = {};
+    const rawContent = fs.readFileSync(SONAR_PROPERTIES_PATH, 'utf8');
+
+    for (const rawLine of rawContent.split(/\r?\n/u)) {
+        const line = rawLine.trim();
+        if (!line || line.startsWith('#')) {
+            continue;
+        }
+
+        const separatorIndex = line.indexOf('=');
+        if (separatorIndex === -1) {
+            continue;
+        }
+
+        const key = line.slice(0, separatorIndex).trim();
+        const value = line.slice(separatorIndex + 1).trim();
+        properties[key] = value;
+    }
+
+    return properties;
+}
+
+function createRequestModule(targetUrl) {
+    return targetUrl.protocol === 'https:' ? https : http;
+}
+
+function resolveBranchName() {
+    const overrideBranchName = process.env.SONAR_BRANCH_NAME?.trim();
+    if (overrideBranchName) {
+        return overrideBranchName;
+    }
+
+    const gitEntryPath = path.resolve(REPOSITORY_ROOT, '.git');
+    if (!fs.existsSync(gitEntryPath)) {
+        throw new Error('Unable to locate .git metadata. Set SONAR_BRANCH_NAME explicitly and retry.');
+    }
+
+    let gitDirPath = gitEntryPath;
+    const gitEntryStat = fs.statSync(gitEntryPath);
+    if (gitEntryStat.isFile()) {
+        const gitPointer = fs.readFileSync(gitEntryPath, 'utf8').trim();
+        const gitDirPrefix = 'gitdir:';
+        if (!gitPointer.startsWith(gitDirPrefix)) {
+            throw new Error('Unable to resolve git metadata directory. Set SONAR_BRANCH_NAME explicitly and retry.');
+        }
+
+        gitDirPath = path.resolve(REPOSITORY_ROOT, gitPointer.slice(gitDirPrefix.length).trim());
+    }
+
+    const headPath = path.join(gitDirPath, 'HEAD');
+    if (!fs.existsSync(headPath)) {
+        throw new Error('Unable to locate git HEAD. Set SONAR_BRANCH_NAME explicitly and retry.');
+    }
+
+    const headContents = fs.readFileSync(headPath, 'utf8').trim();
+    const refPrefix = 'ref: refs/heads/';
+    if (!headContents.startsWith(refPrefix)) {
+        throw new Error('Unable to determine the current git branch from HEAD. Set SONAR_BRANCH_NAME explicitly.');
+    }
+
+    return headContents.slice(refPrefix.length);
+}
+
+function runCommand(command, args, options = {}) {
+    const { env = process.env, description = command } = options;
+
+    return new Promise((resolve, reject) => {
+        const child = spawn(command, args, {
+            cwd: REPOSITORY_ROOT,
+            env,
+            stdio: 'inherit',
+            shell: process.platform === 'win32',
+        });
+
+        child.on('error', (error) => {
+            reject(new Error(`Failed to start ${description}: ${error.message}`));
+        });
+
+        child.on('exit', (code) => {
+            if (code === 0) {
+                resolve();
+                return;
+            }
+
+            reject(new Error(`${description} exited with code ${code}`));
+        });
+    });
+}
+
+function resolveScannerCommand() {
+    const scannerCommand = process.env.SONAR_SCANNER_PATH?.trim() || 'sonar-scanner';
+
+    if (scannerCommand === 'sonar-scanner') {
+        const pathEntries = (process.env.PATH || '').split(path.delimiter);
+        const executableNames =
+            process.platform === 'win32'
+                ? ['sonar-scanner.cmd', 'sonar-scanner.bat', 'sonar-scanner.exe']
+                : ['sonar-scanner'];
+
+        const foundScanner = pathEntries.some((entry) =>
+            executableNames.some((name) => fs.existsSync(path.join(entry, name))),
+        );
+        if (!foundScanner) {
+            throw new Error(
+                'sonar-scanner was not found. Install the official SonarScanner CLI or set SONAR_SCANNER_PATH.',
+            );
+        }
+    } else if (!fs.existsSync(scannerCommand)) {
+        throw new Error(`SONAR_SCANNER_PATH does not exist: ${scannerCommand}`);
+    }
+
+    return scannerCommand;
+}
+
+function sonarRequestJson(sonarHostUrl, sonarToken, endpoint, searchParams = {}) {
+    return new Promise((resolve, reject) => {
+        const requestUrl = new URL(endpoint, sonarHostUrl);
+        for (const [key, value] of Object.entries(searchParams)) {
+            if (value !== undefined && value !== null && value !== '') {
+                requestUrl.searchParams.set(key, String(value));
+            }
+        }
+
+        const request = createRequestModule(requestUrl).request(
+            requestUrl,
+            {
+                method: 'GET',
+                timeout: SERVER_TIMEOUT_MS,
+                headers: {
+                    Authorization: `Basic ${Buffer.from(`${sonarToken}:`).toString('base64')}`,
+                    Accept: 'application/json',
+                },
+            },
+            (response) => {
+                const chunks = [];
+                response.on('data', (chunk) => chunks.push(chunk));
+                response.on('end', () => {
+                    const rawBody = Buffer.concat(chunks).toString('utf8');
+                    if (response.statusCode && response.statusCode >= 400) {
+                        reject(new Error(`Sonar API request failed (${response.statusCode}) for ${requestUrl.pathname}.`));
+                        return;
+                    }
+
+                    try {
+                        resolve(JSON.parse(rawBody));
+                    } catch (error) {
+                        reject(new Error(`Failed to parse Sonar API response for ${requestUrl.pathname}: ${error.message}`));
+                    }
+                });
+            },
+        );
+
+        request.on('timeout', () => {
+            request.destroy(new Error(`Timed out after ${SERVER_TIMEOUT_MS}ms`));
+        });
+
+        request.on('error', (error) => {
+            reject(new Error(`Sonar API request failed for ${requestUrl.pathname}: ${error.message}`));
+        });
+
+        request.end();
+    });
+}
+
+async function fetchPaginatedItems(fetchPage) {
+    const items = [];
+    let page = 1;
+    let total = 0;
+    let pageSize = 0;
+
+    do {
+        const response = await fetchPage(page);
+        const responseItems = response.issues ?? response.hotspots ?? [];
+        items.push(...responseItems);
+        total = response.total ?? response.paging?.total ?? responseItems.length;
+        pageSize = response.ps ?? response.paging?.pageSize ?? responseItems.length;
+        page += 1;
+    } while (items.length < total && pageSize > 0);
+
+    return items;
+}
+
+function stripProjectKey(component, projectKey) {
+    const componentPrefix = `${projectKey}:`;
+    if (!component) {
+        return '(unknown component)';
+    }
+
+    return component.startsWith(componentPrefix) ? component.slice(componentPrefix.length) : component;
+}
+
+function formatIssue(issue, projectKey) {
+    const location = `${stripProjectKey(issue.component, projectKey)}:${issue.line ?? 1}`;
+    return `- [${issue.severity}] [${issue.type}] ${location} ${issue.rule}: ${issue.message}`;
+}
+
+function formatHotspot(hotspot, projectKey) {
+    const location = `${stripProjectKey(hotspot.component, projectKey)}:${hotspot.line ?? 1}`;
+    return `- ${location} ${hotspot.ruleKey ?? hotspot.rule ?? 'unknown-rule'}: ${hotspot.message}`;
+}
+
+async function collectSonarDetails({ sonarHostUrl, sonarProjectKey, branchName, sonarToken }) {
+    const qualityGate = await sonarRequestJson(sonarHostUrl, sonarToken, '/api/qualitygates/project_status', {
+        projectKey: sonarProjectKey,
+        branch: branchName,
+    });
+
+    const issues = await fetchPaginatedItems((page) =>
+        sonarRequestJson(sonarHostUrl, sonarToken, '/api/issues/search', {
+            componentKeys: sonarProjectKey,
+            branch: branchName,
+            resolved: 'false',
+            p: page,
+            ps: PAGE_SIZE,
+            s: 'FILE_LINE',
+            asc: 'true',
+        }),
+    );
+
+    const hotspots = await fetchPaginatedItems((page) =>
+        sonarRequestJson(sonarHostUrl, sonarToken, '/api/hotspots/search', {
+            projectKey: sonarProjectKey,
+            branch: branchName,
+            status: 'TO_REVIEW',
+            p: page,
+            ps: PAGE_SIZE,
+        }),
+    );
+
+    return { hotspots, issues, qualityGate };
+}
+
+function printSonarDetails(details, context) {
+    const { hotspots, issues, qualityGate } = details;
+    const { branchName, sonarProjectKey } = context;
+
+    log(`Project: ${sonarProjectKey}`);
+    log(`Branch: ${branchName}`);
+    log(`Quality gate: ${qualityGate.projectStatus.status}`);
+
+    const failedConditions = (qualityGate.projectStatus.conditions ?? []).filter(
+        (condition) => condition.status === 'ERROR',
+    );
+    if (failedConditions.length > 0) {
+        log('Failing gate conditions:');
+        for (const condition of failedConditions) {
+            log(
+                `- ${condition.metricKey}: actual=${condition.actualValue ?? 'n/a'}, threshold=${condition.errorThreshold ?? 'n/a'}`,
+            );
+        }
+    } else {
+        log('Failing gate conditions: none');
+    }
+
+    log(`Blocking security hotspots: ${hotspots.length}`);
+    for (const hotspot of hotspots) {
+        log(formatHotspot(hotspot, sonarProjectKey));
+    }
+
+    const bugsAndVulnerabilities = issues.filter((issue) => issue.type === 'BUG' || issue.type === 'VULNERABILITY');
+    log(`Bugs and vulnerabilities: ${bugsAndVulnerabilities.length}`);
+    for (const issue of bugsAndVulnerabilities) {
+        log(formatIssue(issue, sonarProjectKey));
+    }
+
+    log(`All unresolved issues: ${issues.length}`);
+    for (const issue of issues) {
+        log(formatIssue(issue, sonarProjectKey));
+    }
+}
+
+async function printFailureDetails(context) {
+    try {
+        const details = await collectSonarDetails(context);
+        printSonarDetails(details, context);
+    } catch (detailsError) {
+        logError(`Failed to fetch Sonar details after scan failure: ${detailsError.message}`);
+    }
+}
+
+async function main() {
+    const { sonarHostUrl, sonarProjectKey } = readConnectedModeConfig();
+    const sonarProperties = readSonarProperties();
+    const sonarToken = process.env.SONAR_TOKEN?.trim();
+    const branchName = resolveBranchName();
+
+    if (!sonarToken) {
+        log('Skipping Sonar scan because SONAR_TOKEN is not set.');
+        process.exit(0);
+    }
+
+    log(`Using SonarQube project "${sonarProjectKey}" from .sonarlint/connectedMode.json.`);
+    log(`Running analysis for branch "${branchName}".`);
+
+    if (sonarProperties['sonar.projectKey'] && sonarProperties['sonar.projectKey'] !== sonarProjectKey) {
+        log(
+            `Overriding sonar.projectKey="${sonarProperties['sonar.projectKey']}" with connected-mode project key "${sonarProjectKey}".`,
+        );
+    }
+
+    if (process.env.SONAR_SKIP_TESTS?.trim()) {
+        log('Skipping test run (SONAR_SKIP_TESTS is set). Using existing coverage.xml.');
+    } else {
+        log('Generating coverage.xml...');
+        await runCommand(
+            'poetry',
+            ['run', 'pytest', 'tests/', '-W', 'ignore::DeprecationWarning', '--cov', '--cov-report=xml:coverage.xml'],
+            { description: 'coverage generation' },
+        );
+    }
+
+    const scannerCommand = resolveScannerCommand();
+    log(`Running sonar-scanner against ${sonarHostUrl}.`);
+    try {
+        await runCommand(
+            scannerCommand,
+            [
+                `-Dsonar.projectKey=${sonarProjectKey}`,
+                `-Dsonar.branch.name=${branchName}`,
+                '-Dsonar.qualitygate.wait=true',
+            ],
+            {
+                description: 'sonar-scanner',
+                env: {
+                    ...process.env,
+                    SONAR_HOST_URL: sonarHostUrl,
+                    SONAR_TOKEN: sonarToken,
+                },
+            },
+        );
+    } catch (error) {
+        await printFailureDetails({
+            branchName,
+            sonarHostUrl,
+            sonarProjectKey,
+            sonarToken,
+        });
+        throw error;
+    }
+
+    log('Sonar scan completed successfully.');
+}
+
+main().catch((error) => {
+    logError(error.message);
+    process.exit(1);
+});

package/dist/agents/plugins/claude/plugin/commands/codemie-commit.md

@@ -1,31 +0,0 @@
----
-allowed-tools: Bash(git add:*), Bash(git commit:*), Bash(git checkout:*)
-description: Create a git commit (not on main branch)
----
-
-## Context
-
-- Current branch: !`git branch --show-current`
-- Current git status: !`git status`
-- Current git diff (staged and unstaged changes): !`git diff HEAD`
-- Recent commits: !`git log --oneline -5`
-
-## Your task
-
-Based on the above changes, create a single git commit.
-
-**IMPORTANT**: If the current branch is `main` or `master`:
-1. Analyze the changes to determine the type (feat, fix, refactor, etc.)
-2. Suggest a branch name in format `<type>/<short-description>` (e.g., `feat/add-auth-header-support`, `fix/proxy-timeout-issue`)
-3. Ask user to confirm the branch name or provide an alternative
-4. After confirmation, create the branch with `git checkout -b <branch-name>` and proceed with the commit
-
-If on a feature branch:
-1. Stage all relevant changes
-2. Create a commit message following commitlint rules:
-   - Format: `<type>(<scope>): <subject>` or `<type>: <subject>`
-   - Types: feat, fix, docs, style, refactor, perf, test, chore, ci, revert
-   - Scopes (optional): cli, agents, providers, config, proxy, workflows, ci, analytics, utils, deps, tests
-   - Subject: max 100 characters, lowercase start, no period at end
-
-You have the capability to call multiple tools in a single response. Stage and create the commit using a single message. Do not use any other tools or do anything else. Do not send any other text or messages besides these tool calls.

package/dist/agents/plugins/claude/plugin/scripts/bash/rtk-auto-wrapper.sh

@@ -1,81 +0,0 @@
-#!/bin/bash
-# RTK Auto-Wrapper Hook
-# Automatically wraps high-verbosity commands with RTK for token optimization
-#
-# Hook: PreToolUse
-# Matcher: Bash
-# Purpose: Intercept bash commands and suggest RTK wrapper if applicable
-#
-# Installation:
-# 1. Copy to .claude/hooks/bash/rtk-auto-wrapper.sh
-# 2. Make executable: chmod +x .claude/hooks/bash/rtk-auto-wrapper.sh
-# 3. Add to settings.json:
-#    {
-#      "hooks": {
-#        "PreToolUse": [{
-#          "matcher": "Bash",
-#          "hooks": [".claude/hooks/bash/rtk-auto-wrapper.sh"]
-#        }]
-#      }
-#    }
-#
-# Or use `rtk init` for automatic hook setup.
-
-# Check if RTK is installed
-if ! command -v rtk &> /dev/null; then
-    # RTK not installed, skip silently
-    exit 0
-fi
-
-# Parse tool input to get the bash command
-COMMAND=$(echo "$TOOL_INPUT" | jq -r '.command // empty' 2>/dev/null)
-
-if [ -z "$COMMAND" ]; then
-    # No command found, continue
-    exit 0
-fi
-
-# Define RTK-optimizable commands with their savings
-declare -A RTK_COMMANDS=(
-    ["git log"]="92.3"
-    ["git status"]="76.0"
-    ["git diff"]="55.9"
-    ["find"]="76.3"
-    ["cargo test"]="90.0"
-    ["cargo build"]="80.0"
-    ["cargo clippy"]="80.0"
-    ["pnpm list"]="82.0"
-    ["pnpm outdated"]="90.0"
-    ["pnpm test"]="90.0"
-    ["python pytest"]="90.0"
-    ["python -m pytest"]="90.0"
-    ["go test"]="90.0"
-)
-
-# Check if command matches RTK-optimizable pattern
-for cmd in "${!RTK_COMMANDS[@]}"; do
-    if [[ "$COMMAND" == "$cmd"* ]] && [[ "$COMMAND" != "rtk "* ]]; then
-        savings="${RTK_COMMANDS[$cmd]}"
-
-        # Suggest RTK wrapper
-        cat << EOF
-RTK Optimization Available
-
-Command: $COMMAND
-Suggested: rtk $COMMAND
-Token Savings: ~${savings}%
-
-Using RTK wrapper automatically.
-EOF
-
-        # Modify command to use RTK
-        # Note: This is informational only - actual command modification
-        # requires additionalContext return (Claude Code v2.1.9+)
-
-        # For now, just inform user
-        exit 0
-    fi
-done
-
-# Continue with original command
-exit 0

package/dist/providers/plugins/sso/proxy/plugins/claude-thinking-transformer.plugin.d.ts

@@ -1,30 +0,0 @@
-/**
- * Claude Thinking Transformer Plugin
- * Priority: 16 (runs after Request Sanitizer at 15, before header injection at 20)
- *
- * Transforms thinking parameters for Claude models that require the new adaptive
- * thinking API (e.g. claude-opus-4-7).
- *
- * Problem: Claude Code sends `thinking: { type: "enabled", budget_tokens: N }`
- * for Opus models. claude-opus-4-7 rejects this with HTTP 400:
- *   "thinking.type.enabled" is not supported for this model. Use
- *   "thinking.type.adaptive" and "output_config.effort" instead.
- *
- * Fix: When the request model matches a Claude 4.7+ pattern:
- *   - "enabled"  → thinking: { type: "adaptive" } + output_config.effort (derived
- *                  from budget_tokens; only written if not already present)
- *   - "disabled" → delete the thinking field entirely (model does not accept this value)
- *
- * Scope: Only enabled for codemie-claude agent (Claude Code via SSO proxy).
- *
- * To add support for a new model: append a pattern to ADAPTIVE_THINKING_MODEL_PATTERNS.
- */
-import { ProxyPlugin, PluginContext, ProxyInterceptor } from './types.js';
-export declare class ClaudeThinkingTransformerPlugin implements ProxyPlugin {
-    id: string;
-    name: string;
-    version: string;
-    priority: number;
-    createInterceptor(context: PluginContext): Promise<ProxyInterceptor>;
-}
-//# sourceMappingURL=claude-thinking-transformer.plugin.d.ts.map

package/dist/providers/plugins/sso/proxy/plugins/claude-thinking-transformer.plugin.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"claude-thinking-transformer.plugin.d.ts","sourceRoot":"","sources":["../../../../../../src/providers/plugins/sso/proxy/plugins/claude-thinking-transformer.plugin.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,OAAO,EAAE,WAAW,EAAE,aAAa,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAiC1E,qBAAa,+BAAgC,YAAW,WAAW;IACjE,EAAE,SAAgD;IAClD,IAAI,SAAiC;IACrC,OAAO,SAAW;IAClB,QAAQ,SAAM;IAER,iBAAiB,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,gBAAgB,CAAC;CAS3E"}

package/dist/providers/plugins/sso/proxy/plugins/claude-thinking-transformer.plugin.js

@@ -1,111 +0,0 @@
-/**
- * Claude Thinking Transformer Plugin
- * Priority: 16 (runs after Request Sanitizer at 15, before header injection at 20)
- *
- * Transforms thinking parameters for Claude models that require the new adaptive
- * thinking API (e.g. claude-opus-4-7).
- *
- * Problem: Claude Code sends `thinking: { type: "enabled", budget_tokens: N }`
- * for Opus models. claude-opus-4-7 rejects this with HTTP 400:
- *   "thinking.type.enabled" is not supported for this model. Use
- *   "thinking.type.adaptive" and "output_config.effort" instead.
- *
- * Fix: When the request model matches a Claude 4.7+ pattern:
- *   - "enabled"  → thinking: { type: "adaptive" } + output_config.effort (derived
- *                  from budget_tokens; only written if not already present)
- *   - "disabled" → delete the thinking field entirely (model does not accept this value)
- *
- * Scope: Only enabled for codemie-claude agent (Claude Code via SSO proxy).
- *
- * To add support for a new model: append a pattern to ADAPTIVE_THINKING_MODEL_PATTERNS.
- */
-import { logger } from '../../../../../utils/logger.js';
-/**
- * Model name patterns that require the adaptive thinking API.
- * Matches claude-opus-4-7, claude-opus-4-7-20250514, and future date-tagged variants.
- * Extend this list as Anthropic migrates additional models — see EPMCDME-11821.
- */
-const ADAPTIVE_THINKING_MODEL_PATTERNS = [
-    /claude-opus-4-[7-9](?:[^0-9]|$)/i, // claude-opus-4-7/8/9 and date-tagged variants (e.g. claude-opus-4-7-20250514); excludes claude-opus-4-70+
-];
-function modelRequiresAdaptiveThinking(modelName) {
-    return ADAPTIVE_THINKING_MODEL_PATTERNS.some(p => p.test(modelName));
-}
-/**
- * Map legacy budget_tokens to the closest output_config.effort level.
- *
- * budget_tokens was the maximum token budget for thinking in the old API.
- * effort is a coarser control in the new API: low / medium / high.
- */
-function budgetTokensToEffort(budgetTokens) {
-    const tokens = typeof budgetTokens === 'number' ? budgetTokens : 0;
-    if (tokens <= 2048)
-        return 'low';
-    if (tokens <= 8192)
-        return 'medium';
-    return 'high';
-}
-/** Agent that sends Claude API requests through the codemie proxy */
-const ALLOWED_AGENT = 'codemie-claude';
-export class ClaudeThinkingTransformerPlugin {
-    id = '@codemie/proxy-claude-thinking-transformer';
-    name = 'Claude Thinking Transformer';
-    version = '1.0.0';
-    priority = 16; // After RequestSanitizer (15), before HeaderInjection (20)
-    async createInterceptor(context) {
-        const clientType = context.config.clientType;
-        if (!clientType || clientType !== ALLOWED_AGENT) {
-            throw new Error(`Plugin disabled for agent: ${clientType}`);
-        }
-        // Pass the configured model as a fallback for requests that omit body.model
-        const configModel = context.config.model;
-        return new ClaudeThinkingTransformerInterceptor(configModel);
-    }
-}
-class ClaudeThinkingTransformerInterceptor {
-    configModel;
-    name = 'claude-thinking-transformer';
-    constructor(configModel) {
-        this.configModel = configModel;
-    }
-    async onRequest(context) {
-        if (!context.requestBody || !context.headers['content-type']?.includes('application/json')) {
-            return;
-        }
-        try {
-            const bodyStr = context.requestBody.toString('utf-8');
-            const body = JSON.parse(bodyStr);
-            const thinkingType = body.thinking?.type;
-            if (thinkingType !== 'enabled' && thinkingType !== 'disabled') {
-                return;
-            }
-            // Resolve model: prefer request body, fall back to proxy config
-            const model = (typeof body.model === 'string' && body.model) || this.configModel || '';
-            if (!model || !modelRequiresAdaptiveThinking(model)) {
-                return;
-            }
-            if (thinkingType === 'enabled') {
-                const effort = budgetTokensToEffort(body.thinking.budget_tokens);
-                // Replace old thinking object with new adaptive format
-                body.thinking = { type: 'adaptive' };
-                // Set output_config.effort only if the caller hasn't already specified it
-                if (!body.output_config?.effort) {
-                    body.output_config = { ...(body.output_config ?? {}), effort };
-                }
-                logger.debug(`[${this.name}] Transformed thinking: "enabled" → "adaptive", effort="${effort}" for model: ${model}`);
-            }
-            else {
-                // thinking.type === 'disabled': model does not accept this value — remove the field
-                delete body.thinking;
-                logger.debug(`[${this.name}] Removed unsupported thinking.type="disabled" for model: ${model}`);
-            }
-            const newBodyStr = JSON.stringify(body);
-            context.requestBody = Buffer.from(newBodyStr, 'utf-8');
-            context.headers['content-length'] = String(context.requestBody.length);
-        }
-        catch {
-            // Not valid JSON or unexpected structure — pass through unchanged
-        }
-    }
-}
-//# sourceMappingURL=claude-thinking-transformer.plugin.js.map

package/dist/providers/plugins/sso/proxy/plugins/claude-thinking-transformer.plugin.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"claude-thinking-transformer.plugin.js","sourceRoot":"","sources":["../../../../../../src/providers/plugins/sso/proxy/plugins/claude-thinking-transformer.plugin.ts"],"names":[],"mappings":"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"}