whale-code 6.4.0

package/dist/server/lib/utils.js

@@ -0,0 +1,147 @@
+// server/lib/utils.ts — Shared utility functions
+/** Escape characters that could manipulate PostgREST/ILIKE filter syntax.
+ * Escapes ILIKE wildcards (%, _) and backslashes, plus strips commas and parens
+ * that could manipulate PostgREST operators. */
+export function sanitizeFilterValue(val) {
+    // First escape ILIKE wildcards and backslashes
+    let escaped = val.replace(/[\\%_]/g, (ch) => `\\${ch}`);
+    // Then strip PostgREST operator chars
+    escaped = escaped.replace(/[,\(\)]/g, "");
+    return escaped;
+}
+/** Group array items by a key, returning counts */
+export function groupBy(arr, key) {
+    const counts = {};
+    for (const item of arr) {
+        const val = item[key] || "unknown";
+        counts[val] = (counts[val] || 0) + 1;
+    }
+    return counts;
+}
+/** Escape a value for CSV output */
+export function escapeCSV(val) {
+    if (val === null || val === undefined)
+        return "";
+    const str = String(val);
+    if (str.includes(",") || str.includes('"') || str.includes("\n")) {
+        return '"' + str.replace(/"/g, '""') + '"';
+    }
+    return str;
+}
+/** Fill {{key}} placeholders in a template string */
+export function fillTemplate(template, data) {
+    return template.replace(/\{\{(\w+(?:\.\w+)*)\}\}/g, (match, key) => {
+        const parts = key.split(".");
+        let val = data;
+        for (const p of parts) {
+            if (val === null || val === undefined)
+                return match;
+            val = val[p];
+        }
+        return val !== null && val !== undefined ? String(val) : match;
+    });
+}
+/** Extract concise metrics from tool results for audit logging (never full payloads). */
+export function summarizeResult(toolName, action, data) {
+    const d = data;
+    try {
+        switch (toolName) {
+            case "analytics": {
+                switch (action) {
+                    case "summary": {
+                        if (Array.isArray(d)) {
+                            const row = d[0] || {};
+                            return { total_revenue: row.totalRevenue || row.total_revenue, total_orders: row.totalOrders || row.total_orders, avg_order: row.avgOrderValue || row.avg_order_value, rows: d.length };
+                        }
+                        return { total_revenue: d.totalRevenue || d.total_revenue, total_orders: d.totalOrders || d.total_orders, avg_order: d.avgOrderValue, profit_margin: d.profitMargin, unique_customers: d.uniqueCustomers };
+                    }
+                    case "by_location":
+                        return { locations: Array.isArray(d) ? d.length : 0, total_revenue: Array.isArray(d) ? d.reduce((s, r) => s + (r.revenue || 0), 0) : 0 };
+                    case "detailed":
+                        return { rows: Array.isArray(d) ? d.length : 0 };
+                    case "by_category":
+                        return { categories: d.categories ? d.categories.length : 0, total_revenue: d.totalRevenue, days: d.days };
+                    case "product_sales":
+                        return { products: d.products ? d.products.length : 0, total_revenue: d.totalRevenue, total_units: d.totalUnits, days: d.days };
+                    case "category_velocity":
+                        return { items: d.results ? d.results.length : 0, days: d.days };
+                    case "customers":
+                    case "customer_intelligence":
+                        return { rows: Array.isArray(d) ? d.length : (d.customers ? d.customers.length : 0) };
+                    case "products":
+                    case "product_intelligence":
+                        return { rows: Array.isArray(d) ? d.length : 0 };
+                    case "inventory_intelligence":
+                        return { rows: Array.isArray(d) ? d.length : 0 };
+                    case "marketing":
+                    case "marketing_intelligence":
+                        return { rows: Array.isArray(d) ? d.length : 0 };
+                    case "fraud":
+                    case "fraud_detection":
+                        return { total_orders: d.totalOrders, high_risk: d.highRisk, medium_risk: d.mediumRisk, avg_risk_score: d.avgRiskScore };
+                    case "employee":
+                    case "employee_performance":
+                        return { rows: Array.isArray(d) ? d.length : 0 };
+                    case "behavior":
+                    case "behavioral_analytics":
+                        return { sessions: d.summary?.sessions, page_views: d.summary?.pageViews };
+                    case "full":
+                    case "business_intelligence":
+                        return { rows: Array.isArray(d) ? d.length : 0 };
+                    case "discover":
+                        return { rows: Array.isArray(d) ? d.length : 0 };
+                    default:
+                        return { rows: Array.isArray(d) ? d.length : 1 };
+                }
+            }
+            case "inventory":
+                return { action, rows: Array.isArray(d) ? d.length : 1 };
+            case "inventory_query":
+                return { action, rows: Array.isArray(d) ? d.length : (d.products ? d.products.length : (d.summary ? 1 : 0)) };
+            case "purchase_orders":
+                if (action === "list")
+                    return { count: Array.isArray(d) ? d.length : (d.purchase_orders ? d.purchase_orders.length : 0) };
+                return { po_id: d.id, po_number: d.po_number, status: d.status };
+            case "transfers":
+                if (action === "list")
+                    return { count: Array.isArray(d) ? d.length : 0 };
+                return { transfer_id: d.id, transfer_number: d.transfer_number, status: d.status };
+            case "orders":
+                return { count: Array.isArray(d) ? d.length : (d.orders ? d.orders.length : 1) };
+            case "customers":
+                return { count: Array.isArray(d) ? d.length : (d.customers ? d.customers.length : 1) };
+            case "products":
+                if (action === "browse")
+                    return { categories: d.data ? d.data.categories?.length || 0 : 0, status_summary: d.data ? d.data.product_status_summary : undefined };
+                return { action, count: Array.isArray(d) ? d.length : (d.count ?? (d.products ? d.products.length : (d.id ? 1 : 0))) };
+            case "audit_trail":
+                return { count: d.count, days: d.days, actions: d.summary ? Object.keys(d.summary).length : 0 };
+            case "telemetry":
+                return { action, count: d.count || (Array.isArray(d) ? d.length : 0) };
+            case "alerts":
+                return { total: d.total };
+            default:
+                return { rows: Array.isArray(d) ? d.length : 1 };
+        }
+    }
+    catch {
+        return { rows: Array.isArray(d) ? d.length : 1 };
+    }
+}
+/** Timeout wrapper for tool execution with AbortSignal support.
+ * Creates an AbortController, races the promise against a timeout,
+ * and aborts the signal on timeout so underlying work (fetch etc.) can cancel. */
+export function withTimeout(promiseOrFactory, ms, name) {
+    const controller = new AbortController();
+    const promise = typeof promiseOrFactory === "function"
+        ? promiseOrFactory(controller.signal)
+        : promiseOrFactory;
+    let timer;
+    const timeoutPromise = new Promise((_, reject) => {
+        timer = setTimeout(() => {
+            controller.abort();
+            reject(new Error(`Tool ${name} timed out after ${ms}ms`));
+        }, ms);
+    });
+    return Promise.race([promise, timeoutPromise]).finally(() => clearTimeout(timer));
+}

package/dist/server/local-agent-gateway.d.ts

@@ -0,0 +1,82 @@
+/**
+ * Local Agent Gateway — WebSocket server for local agent connections.
+ *
+ * Accepts outbound WebSocket connections from user machines running swag-agent.
+ * Authenticates per-store via API key, maintains connection pool, routes commands.
+ *
+ * Architecture:
+ *   Claude Code → MCP stdio → Fly.io server → local_agent handler
+ *     → this gateway → WebSocket → user's local swag-agent → execute locally
+ *
+ * Same pattern as kali.ts but routes through WebSocket instead of HTTP to Fly.io internal.
+ */
+import { WebSocket } from "ws";
+import type http from "node:http";
+export interface LocalAgent {
+    ws: WebSocket;
+    storeId: string;
+    userId: string | null;
+    capabilities: string[];
+    connectedAt: Date;
+    lastPong: number;
+    agentId: string;
+    platform: string;
+    hostname: string;
+}
+export interface AgentResult {
+    success: boolean;
+    stdout?: string;
+    stderr?: string;
+    exit_code?: number;
+    data?: unknown;
+    error?: string;
+    killed?: boolean;
+    cwd?: string;
+    duration_ms?: number;
+    tools?: string[];
+}
+export declare function initLocalAgentGateway(server: http.Server): void;
+/**
+ * Check if a store has a connected local agent.
+ */
+export declare function hasLocalAgent(storeId: string): boolean;
+/**
+ * Get info about connected agents for a store.
+ */
+export declare function getAgentInfo(storeId: string): Array<{
+    agent_id: string;
+    platform: string;
+    hostname: string;
+    capabilities: string[];
+    connected_at: string;
+    uptime_seconds: number;
+}>;
+/**
+ * Execute a command on the user's local machine via their connected agent.
+ */
+export declare function executeOnLocalAgent(storeId: string, command: string, options?: {
+    session_id?: string;
+    timeout?: number;
+    agent_id?: string;
+}): Promise<AgentResult>;
+/**
+ * Execute a managed tool on the local agent (burp, zap, tshark, etc.)
+ */
+export declare function executeToolOnLocalAgent(storeId: string, tool: string, args: Record<string, unknown>, options?: {
+    timeout?: number;
+    agent_id?: string;
+}): Promise<AgentResult>;
+/**
+ * Request tool discovery from agent.
+ */
+export declare function discoverLocalTools(storeId: string): Promise<AgentResult>;
+/**
+ * Get gateway statistics.
+ */
+export declare function getGatewayStats(): {
+    total_agents: number;
+    total_stores: number;
+    pending_requests: number;
+    agents_by_store: Record<string, number>;
+};
+export declare function shutdownGateway(): void;

package/dist/server/local-agent-gateway.js

@@ -0,0 +1,426 @@
+/**
+ * Local Agent Gateway — WebSocket server for local agent connections.
+ *
+ * Accepts outbound WebSocket connections from user machines running swag-agent.
+ * Authenticates per-store via API key, maintains connection pool, routes commands.
+ *
+ * Architecture:
+ *   Claude Code → MCP stdio → Fly.io server → local_agent handler
+ *     → this gateway → WebSocket → user's local swag-agent → execute locally
+ *
+ * Same pattern as kali.ts but routes through WebSocket instead of HTTP to Fly.io internal.
+ */
+import { WebSocketServer, WebSocket } from "ws";
+import { randomUUID, createHash } from "node:crypto";
+import { createClient } from "@supabase/supabase-js";
+// ============================================================================
+// CONNECTION POOL
+// ============================================================================
+/** Map<storeId, LocalAgent[]> — multiple agents per store (e.g. multiple machines) */
+const agentPool = new Map();
+/** Map<requestId, pending request> */
+const pendingRequests = new Map();
+const MAX_AGENTS_PER_STORE = 5;
+const HEARTBEAT_INTERVAL_MS = 30_000;
+const PONG_TIMEOUT_MS = 45_000;
+const MAX_OUTPUT_CHARS = 500 * 1024; // 500KB safety cap — context_management handles limits
+// ============================================================================
+// GATEWAY
+// ============================================================================
+let wss = null;
+let heartbeatTimer = null;
+let supabaseClient = null;
+export function initLocalAgentGateway(server) {
+    const SUPABASE_URL = process.env.SUPABASE_URL;
+    const SUPABASE_SERVICE_ROLE_KEY = process.env.SUPABASE_SERVICE_ROLE_KEY;
+    supabaseClient = createClient(SUPABASE_URL, SUPABASE_SERVICE_ROLE_KEY);
+    wss = new WebSocketServer({ noServer: true });
+    // Handle HTTP upgrade on /agent/ws path
+    server.on("upgrade", (req, socket, head) => {
+        const url = new URL(req.url || "/", `http://${req.headers.host || "localhost"}`);
+        if (url.pathname !== "/agent/ws") {
+            socket.destroy();
+            return;
+        }
+        wss.handleUpgrade(req, socket, head, (ws) => {
+            wss.emit("connection", ws, req);
+        });
+    });
+    wss.on("connection", handleConnection);
+    // Heartbeat — ping all agents, disconnect stale ones
+    heartbeatTimer = setInterval(() => {
+        const now = Date.now();
+        for (const [storeId, agents] of agentPool) {
+            for (let i = agents.length - 1; i >= 0; i--) {
+                const agent = agents[i];
+                if (now - agent.lastPong > PONG_TIMEOUT_MS) {
+                    console.log(`[local-agent] Disconnecting stale agent ${agent.agentId} (store=${storeId})`);
+                    agent.ws.terminate();
+                    agents.splice(i, 1);
+                }
+                else if (agent.ws.readyState === WebSocket.OPEN) {
+                    send(agent.ws, { type: "ping" });
+                }
+            }
+            if (agents.length === 0)
+                agentPool.delete(storeId);
+        }
+    }, HEARTBEAT_INTERVAL_MS);
+    heartbeatTimer.unref();
+    console.log("[local-agent] Gateway initialized on /agent/ws");
+}
+function handleConnection(ws, _req) {
+    let authenticated = false;
+    let agent = null;
+    // Auth timeout — must authenticate within 10 seconds
+    const authTimer = setTimeout(() => {
+        if (!authenticated) {
+            send(ws, { type: "error", error: "Authentication timeout" });
+            ws.close(4001, "Authentication timeout");
+        }
+    }, 10_000);
+    ws.on("message", async (raw) => {
+        let msg;
+        try {
+            msg = JSON.parse(raw.toString());
+        }
+        catch {
+            send(ws, { type: "error", error: "Invalid JSON" });
+            return;
+        }
+        // Handle auth
+        if (msg.type === "auth") {
+            clearTimeout(authTimer);
+            const authResult = await authenticateAgent(msg);
+            if (!authResult) {
+                send(ws, { type: "error", error: "Invalid API key" });
+                ws.close(4003, "Authentication failed");
+                return;
+            }
+            agent = {
+                ws,
+                storeId: authResult.storeId.toLowerCase(),
+                userId: authResult.userId,
+                capabilities: msg.capabilities || [],
+                connectedAt: new Date(),
+                lastPong: Date.now(),
+                agentId: randomUUID(),
+                platform: msg.platform || "unknown",
+                hostname: msg.hostname || "unknown",
+            };
+            // Add to pool
+            const existing = agentPool.get(agent.storeId) || [];
+            if (existing.length >= MAX_AGENTS_PER_STORE) {
+                // Disconnect oldest
+                const oldest = existing.shift();
+                send(oldest.ws, { type: "error", error: "Replaced by newer agent connection" });
+                oldest.ws.close(4004, "Replaced by newer connection");
+            }
+            existing.push(agent);
+            agentPool.set(agent.storeId, existing);
+            authenticated = true;
+            send(ws, {
+                type: "authenticated",
+                agent_id: agent.agentId,
+                message: `Connected to SwagManager. ${agent.capabilities.length} local tools registered.`,
+            });
+            console.log(`[local-agent] Agent connected: store=${agent.storeId} platform=${agent.platform} hostname=${agent.hostname} tools=${agent.capabilities.length}`);
+            // Audit log
+            if (supabaseClient) {
+                supabaseClient.from("audit_logs").insert({
+                    action: "local_agent.connected",
+                    severity: "info",
+                    store_id: agent.storeId,
+                    resource_type: "local_agent",
+                    resource_id: agent.agentId,
+                    source: "local_agent",
+                    details: {
+                        platform: agent.platform,
+                        hostname: agent.hostname,
+                        capabilities: agent.capabilities,
+                    },
+                    user_id: agent.userId,
+                }).then(({ error }) => {
+                    if (error)
+                        console.error("[local-agent] audit insert failed:", error.message);
+                });
+            }
+            return;
+        }
+        if (!authenticated || !agent) {
+            send(ws, { type: "error", error: "Not authenticated" });
+            return;
+        }
+        // Handle pong
+        if (msg.type === "pong") {
+            agent.lastPong = Date.now();
+            return;
+        }
+        // Handle tool discovery response
+        if (msg.type === "tools") {
+            agent.capabilities = msg.tools;
+            console.log(`[local-agent] Updated tools for ${agent.agentId}: ${msg.tools.join(", ")}`);
+            return;
+        }
+        // Handle command result
+        if (msg.type === "result") {
+            const pending = pendingRequests.get(msg.request_id);
+            if (!pending)
+                return; // Already timed out or cancelled
+            clearTimeout(pending.timer);
+            pendingRequests.delete(msg.request_id);
+            // Truncate large outputs
+            const result = {
+                success: msg.success,
+                stdout: truncate(msg.stdout),
+                stderr: truncate(msg.stderr),
+                exit_code: msg.exit_code,
+                data: msg.data,
+                error: msg.error,
+                killed: msg.killed,
+                cwd: msg.cwd,
+                duration_ms: msg.duration_ms,
+            };
+            pending.resolve(result);
+        }
+    });
+    ws.on("close", () => {
+        clearTimeout(authTimer);
+        if (agent) {
+            const agents = agentPool.get(agent.storeId);
+            if (agents) {
+                const idx = agents.findIndex(a => a.agentId === agent.agentId);
+                if (idx >= 0)
+                    agents.splice(idx, 1);
+                if (agents.length === 0)
+                    agentPool.delete(agent.storeId);
+            }
+            console.log(`[local-agent] Agent disconnected: ${agent.agentId} (store=${agent.storeId})`);
+            // Pending requests for this agent will be cleaned up by their timeouts
+        }
+    });
+    ws.on("error", (err) => {
+        console.error("[local-agent] WebSocket error:", err.message);
+    });
+}
+// ============================================================================
+// AUTHENTICATION
+// ============================================================================
+async function authenticateAgent(msg) {
+    if (!supabaseClient || !msg.api_key)
+        return null;
+    const keyHash = createHash("sha256").update(msg.api_key).digest("hex");
+    // Look up API key by hash in api_keys table
+    const { data, error } = await supabaseClient
+        .from("api_keys")
+        .select("id, store_id, owner_user_id")
+        .eq("key_hash", keyHash)
+        .eq("is_active", true)
+        .single();
+    if (error || !data)
+        return null;
+    // Update last_used_at
+    supabaseClient.from("api_keys")
+        .update({ last_used_at: new Date().toISOString() })
+        .eq("id", data.id)
+        .then(() => { });
+    return { storeId: data.store_id, userId: data.owner_user_id || null };
+}
+// ============================================================================
+// PUBLIC API — used by local-agent handler
+// ============================================================================
+/**
+ * Check if a store has a connected local agent.
+ */
+export function hasLocalAgent(storeId) {
+    const agents = agentPool.get(storeId.toLowerCase());
+    return !!agents?.some(a => a.ws.readyState === WebSocket.OPEN);
+}
+/**
+ * Get info about connected agents for a store.
+ */
+export function getAgentInfo(storeId) {
+    const agents = agentPool.get(storeId.toLowerCase()) || [];
+    return agents
+        .filter(a => a.ws.readyState === WebSocket.OPEN)
+        .map(a => ({
+        agent_id: a.agentId,
+        platform: a.platform,
+        hostname: a.hostname,
+        capabilities: a.capabilities,
+        connected_at: a.connectedAt.toISOString(),
+        uptime_seconds: Math.floor((Date.now() - a.connectedAt.getTime()) / 1000),
+    }));
+}
+/**
+ * Execute a command on the user's local machine via their connected agent.
+ */
+export async function executeOnLocalAgent(storeId, command, options = {}) {
+    const agent = pickAgent(storeId, options.agent_id);
+    if (!agent) {
+        return {
+            success: false,
+            error: `No local agent connected for this store. Install and run: npx swagmanager-agent`,
+        };
+    }
+    const requestId = randomUUID();
+    const timeout = Math.min(options.timeout || 30000, 600000);
+    return new Promise((resolve, reject) => {
+        const timer = setTimeout(() => {
+            pendingRequests.delete(requestId);
+            resolve({
+                success: false,
+                error: `Local agent command timed out after ${timeout}ms`,
+            });
+        }, timeout + 5000); // 5s buffer over command timeout
+        pendingRequests.set(requestId, { resolve, reject, timer });
+        const msg = {
+            type: "exec",
+            request_id: requestId,
+            command,
+            session_id: options.session_id,
+            timeout,
+        };
+        send(agent.ws, msg);
+    });
+}
+/**
+ * Execute a managed tool on the local agent (burp, zap, tshark, etc.)
+ */
+export async function executeToolOnLocalAgent(storeId, tool, args, options = {}) {
+    const agent = pickAgent(storeId, options.agent_id);
+    if (!agent) {
+        return {
+            success: false,
+            error: `No local agent connected. Install: npx swagmanager-agent`,
+        };
+    }
+    // Check if agent has this tool
+    if (!agent.capabilities.includes(tool)) {
+        return {
+            success: false,
+            error: `Local agent does not have tool "${tool}" installed. Available: ${agent.capabilities.join(", ") || "none"}`,
+        };
+    }
+    const requestId = randomUUID();
+    const timeout = Math.min(options.timeout || 30000, 600000);
+    return new Promise((resolve, reject) => {
+        const timer = setTimeout(() => {
+            pendingRequests.delete(requestId);
+            resolve({
+                success: false,
+                error: `Local tool "${tool}" timed out after ${timeout}ms`,
+            });
+        }, timeout + 5000);
+        pendingRequests.set(requestId, { resolve, reject, timer });
+        const msg = {
+            type: "tool_exec",
+            request_id: requestId,
+            tool,
+            args,
+            timeout,
+        };
+        send(agent.ws, msg);
+    });
+}
+/**
+ * Request tool discovery from agent.
+ */
+export async function discoverLocalTools(storeId) {
+    const agent = pickAgent(storeId.toLowerCase());
+    if (!agent) {
+        return {
+            success: false,
+            error: `No local agent connected. Install: npx swagmanager-agent`,
+        };
+    }
+    const requestId = randomUUID();
+    return new Promise((resolve) => {
+        const timer = setTimeout(() => {
+            pendingRequests.delete(requestId);
+            resolve({ success: false, error: "Discovery timed out" });
+        }, 15000);
+        pendingRequests.set(requestId, {
+            resolve,
+            reject: () => resolve({ success: false, error: "Discovery failed" }),
+            timer,
+        });
+        send(agent.ws, { type: "discover", request_id: requestId });
+    });
+}
+/**
+ * Get gateway statistics.
+ */
+export function getGatewayStats() {
+    const agentsByStore = {};
+    let totalAgents = 0;
+    for (const [storeId, agents] of agentPool) {
+        const active = agents.filter(a => a.ws.readyState === WebSocket.OPEN).length;
+        if (active > 0) {
+            agentsByStore[storeId] = active;
+            totalAgents += active;
+        }
+    }
+    return {
+        total_agents: totalAgents,
+        total_stores: Object.keys(agentsByStore).length,
+        pending_requests: pendingRequests.size,
+        agents_by_store: agentsByStore,
+    };
+}
+// ============================================================================
+// INTERNALS
+// ============================================================================
+function pickAgent(storeId, agentId) {
+    const agents = agentPool.get(storeId.toLowerCase());
+    if (!agents?.length)
+        return null;
+    // Filter to open connections
+    const open = agents.filter(a => a.ws.readyState === WebSocket.OPEN);
+    if (open.length === 0)
+        return null;
+    // Target specific agent if requested
+    if (agentId) {
+        return open.find(a => a.agentId === agentId) || null;
+    }
+    // Pick agent with most recent pong (most responsive)
+    return open.reduce((best, a) => a.lastPong > best.lastPong ? a : best);
+}
+function send(ws, data) {
+    if (ws.readyState === WebSocket.OPEN) {
+        ws.send(JSON.stringify(data));
+    }
+}
+function truncate(text) {
+    if (!text || text.length <= MAX_OUTPUT_CHARS)
+        return text;
+    return text.substring(0, MAX_OUTPUT_CHARS) + `\n...[truncated, ${text.length} total chars]`;
+}
+// ============================================================================
+// SHUTDOWN
+// ============================================================================
+export function shutdownGateway() {
+    if (heartbeatTimer) {
+        clearInterval(heartbeatTimer);
+        heartbeatTimer = null;
+    }
+    // Close all agent connections
+    for (const [, agents] of agentPool) {
+        for (const agent of agents) {
+            send(agent.ws, { type: "shutdown", message: "Server shutting down" });
+            agent.ws.close(1001, "Server shutdown");
+        }
+    }
+    agentPool.clear();
+    // Reject all pending requests
+    for (const [, pending] of pendingRequests) {
+        clearTimeout(pending.timer);
+        pending.resolve({ success: false, error: "Gateway shutting down" });
+    }
+    pendingRequests.clear();
+    if (wss) {
+        wss.close();
+        wss = null;
+    }
+    console.log("[local-agent] Gateway shut down");
+}

package/dist/server/providers/anthropic.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Anthropic Provider Adapter — direct Anthropic API passthrough.
+ *
+ * Simplest adapter: system prompt gets cache_control blocks, tools get
+ * { name, description, input_schema }, streaming events pass through as-is.
+ *
+ * Phase 7.1: Also encapsulates thinking config, context management,
+ * output token limits, and compaction config for Anthropic/Claude models.
+ */
+import type { ProviderAdapter, ProviderStreamConfig, ProviderCapabilities, ThinkingConfigResult, ContextManagementConfig, CompactionConfig } from "./types.js";
+import type http from "node:http";
+export declare class AnthropicAdapter implements ProviderAdapter {
+    name: string;
+    handleStream(res: http.ServerResponse, config: ProviderStreamConfig, corsHeaders: Record<string, string>): Promise<void>;
+    getThinkingConfig(model: string, enabled: boolean): ThinkingConfigResult;
+    getMaxOutputTokens(model: string, agentMax?: number): number;
+    getContextManagement(model: string): ContextManagementConfig;
+    getCompactionConfig(_model: string): CompactionConfig;
+    getCapabilities(): ProviderCapabilities;
+}