archbyte 0.3.5 → 0.4.1

package/README.md

@@ -76,6 +76,48 @@ Run `/archbyte-help` in Claude Code to see all commands.
 
 ## CLI Commands
 
+### `archbyte login`
+
+Sign in or create a free account. Shows an interactive provider picker (GitHub, Google, Email & Password).
+
+```bash
+archbyte login              # interactive provider picker
+archbyte login --github     # sign in with GitHub
+archbyte login --google     # sign in with Google
+archbyte login --email      # sign in with email and password
+archbyte login --token JWT  # login with a pre-existing JWT token
+```
+
+Multiple accounts are supported. If already logged in, you'll be prompted to add a different account.
+
+### `archbyte logout`
+
+Sign out of ArchByte.
+
+```bash
+archbyte logout              # logout active account
+archbyte logout user@co.com  # logout specific account
+archbyte logout --all        # logout all accounts
+```
+
+### `archbyte accounts`
+
+List and manage logged-in accounts.
+
+```bash
+archbyte accounts                    # list all accounts
+archbyte accounts switch             # interactive account switcher
+archbyte accounts switch user@co.com # switch to specific account
+```
+
+### `archbyte status`
+
+Show account status, tier, and usage.
+
+```bash
+archbyte status
+```
+
 ### `archbyte init`
 
 Scaffold an `archbyte.yaml` config and `.archbyte/` directory.

package/bin/archbyte.js

@@ -18,7 +18,7 @@ import { handlePatrol } from '../dist/cli/patrol.js';
 import { handleWorkflow } from '../dist/cli/workflow.js';
 import { handleAnalyze } from '../dist/cli/analyze.js';
 import { handleConfig } from '../dist/cli/config.js';
-import { handleLogin, handleLoginWithToken, handleLogout, handleStatus } from '../dist/cli/auth.js';
+import { handleLogin, handleLoginWithToken, handleLogout, handleStatus, handleAccounts, handleAccountSwitch } from '../dist/cli/auth.js';
 import { handleRun } from '../dist/cli/run.js';
 import { handleSetup } from '../dist/cli/setup.js';
 import { handleVersion, handleUpdate } from '../dist/cli/version.js';
@@ -51,11 +51,13 @@ program
   .option('--token <jwt>', 'Login with a pre-existing JWT token')
   .option('--github', 'Sign in with GitHub')
   .option('--google', 'Sign in with Google')
+  .option('--email', 'Sign in with email and password')
   .action(async (options) => {
     if (options.token) {
       await handleLoginWithToken(options.token);
     } else {
-      const provider = options.google ? 'google' : 'github';
+      // Explicit provider flag, or null for interactive picker
+      const provider = options.github ? 'github' : options.google ? 'google' : options.email ? 'email' : undefined;
       await handleLogin(provider);
     }
   });
@@ -63,8 +65,10 @@ program
 program
   .command('logout')
   .description('Sign out of ArchByte')
-  .action(async () => {
-    await handleLogout();
+  .argument('[email]', 'Logout a specific account by email')
+  .option('--all', 'Logout all accounts')
+  .action(async (email, options) => {
+    await handleLogout({ email, all: options.all });
   });
 
 program
@@ -147,7 +151,6 @@ program
   .option('-d, --diagram <path>', 'Path to architecture JSON (default: .archbyte/architecture.json)')
   .option('-c, --config <path>', 'Path to archbyte.yaml config')
   .option('--ci', 'Machine-readable JSON output for CI pipelines')
-  .option('-w, --watch', 'Watch for changes and re-validate')
   .action(async (options) => {
     await requireLicense('analyze');
     await handleValidate(options);
@@ -167,7 +170,7 @@ program
   .command('export')
   .description('Export architecture to various formats')
   .option('-d, --diagram <path>', 'Path to architecture JSON (default: .archbyte/architecture.json)')
-  .option('-f, --format <format>', 'Output format: mermaid, markdown, json, plantuml, dot (default: mermaid)')
+  .option('-f, --format <format>', 'Output format: mermaid, markdown, json, plantuml, dot, html [Pro] (default: mermaid)')
   .option('-o, --output <path>', 'Write to file instead of stdout')
   .action(async (options) => {
     await handleExport(options);
@@ -182,7 +185,8 @@ program
   .option('-c, --config <path>', 'Path to archbyte.yaml config')
   .option('-i, --interval <duration>', 'Patrol interval: 30s, 5m, 1h (default: 5m)')
   .option('--on-violation <action>', 'Action on new violations: log, json (default: log)')
-  .option('--rescan', 'Incremental re-scan when git commit changes')
+  .option('--once', 'Run a single patrol cycle then exit')
+  .option('-w, --watch', 'Watch source files for changes instead of polling on interval')
   .option('--history', 'Show patrol history dashboard')
   .action(async (options) => {
     await requireLicense('analyze');
@@ -212,6 +216,21 @@ program
     await handleStatus();
   });
 
+const accountsCmd = program
+  .command('accounts')
+  .description('List and manage logged-in accounts')
+  .action(async () => {
+    await handleAccounts();
+  });
+
+accountsCmd
+  .command('switch')
+  .description('Switch the active account')
+  .argument('[email]', 'Switch to a specific account by email')
+  .action(async (email) => {
+    await handleAccountSwitch(email);
+  });
+
 program
   .command('config')
   .description('Manage ArchByte configuration (provider, API key)')
@@ -237,24 +256,6 @@ program
     await handleUpdate();
   });
 
-// — MCP server —
-
-const mcpCmd = program
-  .command('mcp')
-  .description('Start MCP server for AI coding tools (Claude Code, Codex)')
-  .action(async () => {
-    const { startMcpServer } = await import('../dist/cli/mcp-server.js');
-    await startMcpServer();
-  });
-
-mcpCmd
-  .command('install')
-  .description('Auto-configure Claude Code and/or Codex CLI')
-  .action(async () => {
-    const { handleMcpInstall } = await import('../dist/cli/mcp.js');
-    await handleMcpInstall();
-  });
-
 // Default: show help
 program
   .action(() => {

package/dist/agents/pipeline/merger.d.ts

@@ -1,7 +1,7 @@
 import type { StaticAnalysisResult, StaticContext } from "../static/types.js";
-import type { ComponentIdentifierOutput, ServiceDescriberOutput, FlowDetectorOutput, ConnectionMapperOutput, ValidatorOutput, IncrementalContext } from "./types.js";
+import type { ComponentIdentifierOutput, ServiceDescriberOutput, FlowDetectorOutput, ConnectionMapperOutput, ValidatorOutput, IncrementalContext, ArchitectureEnricherOutput } from "./types.js";
 /**
  * Merge all pipeline agent outputs into a StaticAnalysisResult
  * compatible with the existing buildAnalysisFromStatic() in cli/analyze.ts.
  */
-export declare function mergeAgentOutputs(ctx: StaticContext, componentId: ComponentIdentifierOutput | null, serviceDesc: ServiceDescriberOutput | null, flowDet: FlowDetectorOutput | null, connMap: ConnectionMapperOutput | null, validatorOut: ValidatorOutput | null, incrementalContext?: IncrementalContext): StaticAnalysisResult;
+export declare function mergeAgentOutputs(ctx: StaticContext, componentId: ComponentIdentifierOutput | null, serviceDesc: ServiceDescriberOutput | null, flowDet: FlowDetectorOutput | null, connMap: ConnectionMapperOutput | null, validatorOut: ValidatorOutput | null, incrementalContext?: IncrementalContext, enricherOut?: ArchitectureEnricherOutput | null): StaticAnalysisResult;

package/dist/agents/pipeline/merger.js

@@ -1,21 +1,112 @@
 // Pipeline — Merger
 // Assembles all agent outputs into a StaticAnalysisResult
+function sanitize(s) {
+    if (!s)
+        return s;
+    return s.replace(/\u2014/g, "-").replace(/\u2013/g, "-").replace(/\u2018|\u2019/g, "'").replace(/\u201C|\u201D/g, '"');
+}
+/**
+ * Build a set of "evidence tokens" from the static context — things that concretely
+ * exist in the codebase (dependencies, env vars, docker images/services).
+ * Used to gate LLM-generated databases/external services against hallucination.
+ */
+function buildEvidenceTokens(ctx) {
+    const tokens = new Set();
+    // Package dependencies from import map (codeSamples.importMap: file → imported modules)
+    for (const imports of Object.values(ctx.codeSamples.importMap)) {
+        for (const imp of imports) {
+            tokens.add(imp.toLowerCase());
+            // Also add short name for scoped packages: @aws-sdk/client-s3 → client-s3, aws-sdk
+            if (imp.startsWith("@")) {
+                const parts = imp.split("/");
+                if (parts[1])
+                    tokens.add(parts[1].toLowerCase());
+                tokens.add(parts[0].slice(1).toLowerCase());
+            }
+        }
+    }
+    // Config files may contain dependency info (package.json deps etc.)
+    for (const cfg of ctx.codeSamples.configFiles) {
+        if (cfg.path.endsWith("package.json")) {
+            try {
+                const pkg = JSON.parse(cfg.content);
+                for (const dep of Object.keys({ ...pkg.dependencies, ...pkg.devDependencies })) {
+                    tokens.add(dep.toLowerCase());
+                    if (dep.startsWith("@")) {
+                        const parts = dep.split("/");
+                        if (parts[1])
+                            tokens.add(parts[1].toLowerCase());
+                        tokens.add(parts[0].slice(1).toLowerCase());
+                    }
+                }
+            }
+            catch { /* ignore parse errors */ }
+        }
+    }
+    // Environment variable names
+    for (const env of ctx.envs.environments) {
+        for (const v of env.variables) {
+            tokens.add(v.toLowerCase());
+        }
+    }
+    // Docker compose service names and images
+    for (const svc of ctx.infra.docker.services) {
+        tokens.add(svc.name.toLowerCase());
+        if (svc.image)
+            tokens.add(svc.image.toLowerCase().split(":")[0]);
+    }
+    // Cloud services detected by infra scanner
+    for (const s of ctx.infra.cloud.services) {
+        tokens.add(s.toLowerCase());
+    }
+    // External dependencies mentioned in docs
+    for (const dep of ctx.docs.externalDependencies) {
+        tokens.add(dep.toLowerCase());
+    }
+    return tokens;
+}
+/**
+ * Check if a service/database ID and type have concrete evidence in the static context.
+ * Uses fuzzy matching: checks if any evidence token contains or is contained by the service keywords.
+ */
+function hasEvidence(id, name, type, evidenceTokens) {
+    // Build candidate keywords from the service
+    const candidates = [
+        id.toLowerCase(),
+        name.toLowerCase(),
+        type.toLowerCase(),
+        // Split hyphenated IDs: "aws-sqs" → ["aws", "sqs"]
+        ...id.toLowerCase().split("-"),
+    ].filter(Boolean);
+    for (const candidate of candidates) {
+        for (const token of evidenceTokens) {
+            // Direct match or substring match (in both directions)
+            if (token === candidate)
+                return true;
+            if (token.includes(candidate) && candidate.length >= 3)
+                return true;
+            if (candidate.includes(token) && token.length >= 3)
+                return true;
+        }
+    }
+    return false;
+}
 /**
  * Merge all pipeline agent outputs into a StaticAnalysisResult
  * compatible with the existing buildAnalysisFromStatic() in cli/analyze.ts.
  */
-export function mergeAgentOutputs(ctx, componentId, serviceDesc, flowDet, connMap, validatorOut, incrementalContext) {
+export function mergeAgentOutputs(ctx, componentId, serviceDesc, flowDet, connMap, validatorOut, incrementalContext, enricherOut) {
     // Start with components from component-identifier
     const components = [];
     if (componentId?.components) {
         for (const c of componentId.components) {
             components.push({
                 id: c.id,
-                name: c.name,
+                name: sanitize(c.name) ?? c.name,
                 type: c.type,
                 layer: c.layer,
                 path: c.path,
-                description: c.description,
+                description: sanitize(c.description),
                 technologies: c.technologies,
             });
         }
@@ -36,38 +127,44 @@ export function mergeAgentOutputs(ctx, componentId, serviceDesc, flowDet, connMa
         }
     }
     const componentIds = new Set(components.map((c) => c.id));
-    // Add databases from service-describer as components
+    // Build evidence tokens for hallucination gating
+    const evidenceTokens = buildEvidenceTokens(ctx);
+    // Add databases from service-describer as components (evidence-gated)
     if (serviceDesc?.databases) {
         for (const db of serviceDesc.databases) {
-            if (!componentIds.has(db.id)) {
-                components.push({
-                    id: db.id,
-                    name: db.name,
-                    type: "database",
-                    layer: "data",
-                    path: "",
-                    description: db.description,
-                    technologies: [db.type],
-                });
-                componentIds.add(db.id);
-            }
+            if (componentIds.has(db.id))
+                continue;
+            if (!hasEvidence(db.id, db.name, db.type, evidenceTokens))
+                continue;
+            components.push({
+                id: db.id,
+                name: db.name,
+                type: "database",
+                layer: "data",
+                path: "",
+                description: sanitize(db.description),
+                technologies: [db.type],
+            });
+            componentIds.add(db.id);
         }
     }
-    // Add external services from service-describer as components
+    // Add external services from service-describer as components (evidence-gated)
     if (serviceDesc?.externalServices) {
         for (const svc of serviceDesc.externalServices) {
-            if (!componentIds.has(svc.id)) {
-                components.push({
-                    id: svc.id,
-                    name: svc.name,
-                    type: "service",
-                    layer: "external",
-                    path: "",
-                    description: svc.description,
-                    technologies: [svc.type],
-                });
-                componentIds.add(svc.id);
-            }
+            if (componentIds.has(svc.id))
+                continue;
+            if (!hasEvidence(svc.id, svc.name, svc.type, evidenceTokens))
+                continue;
+            components.push({
+                id: svc.id,
+                name: sanitize(svc.name) ?? svc.name,
+                type: "service",
+                layer: "external",
+                path: "",
+                description: sanitize(svc.description),
+                technologies: [svc.type],
+            });
+            componentIds.add(svc.id);
         }
     }
     // Incremental fallback: if service-describer returned nothing, restore from spec
@@ -96,7 +193,7 @@ export function mergeAgentOutputs(ctx, componentId, serviceDesc, flowDet, connMa
     // Apply validator description improvements
     if (validatorOut?.componentDescriptions) {
         for (const comp of components) {
-            const better = validatorOut.componentDescriptions[comp.id];
+            const better = sanitize(validatorOut.componentDescriptions[comp.id]);
             if (better && better.length > (comp.description?.length ?? 0)) {
                 comp.description = better;
             }
@@ -118,7 +215,7 @@ export function mergeAgentOutputs(ctx, componentId, serviceDesc, flowDet, connMa
                 from: c.from,
                 to: c.to,
                 type: c.type,
-                description: c.description,
+                description: sanitize(c.description),
                 confidence: 80,
                 async: c.async,
             });
@@ -198,7 +295,7 @@ export function mergeAgentOutputs(ctx, componentId, serviceDesc, flowDet, connMa
                 from: c.from,
                 to: c.to,
                 type: c.type,
-                description: c.description,
+                description: sanitize(c.description),
                 confidence: 65,
                 async: c.async,
             });
@@ -247,7 +344,38 @@ export function mergeAgentOutputs(ctx, componentId, serviceDesc, flowDet, connMa
     // Override docs from service-describer
     const docs = { ...ctx.docs };
     if (serviceDesc?.projectDescription && serviceDesc.projectDescription.length > (docs.projectDescription?.length ?? 0)) {
-        docs.projectDescription = serviceDesc.projectDescription;
+        docs.projectDescription = sanitize(serviceDesc.projectDescription);
+    }
+    // Apply enricher overlays (non-destructive)
+    if (enricherOut) {
+        // Overlay coupling weight on connections
+        if (enricherOut.connectionEnrichments?.length) {
+            for (const ce of enricherOut.connectionEnrichments) {
+                const conn = filteredConnections.find((c) => c.from === ce.from && c.to === ce.to && c.type === ce.type);
+                if (conn) {
+                    if (ce.weight != null)
+                        conn.weight = ce.weight;
+                    if (ce.verifiedByTool)
+                        conn.confidence = Math.min(100, (conn.confidence ?? 80) + 10);
+                }
+            }
+        }
+        // Overlay component enrichments
+        if (enricherOut.componentEnrichments?.length) {
+            for (const ce of enricherOut.componentEnrichments) {
+                const comp = components.find((c) => c.id === ce.id);
+                if (comp) {
+                    if (ce.interfaceSurface != null)
+                        comp.interfaceSurface = ce.interfaceSurface;
+                    if (ce.hasBoundary != null)
+                        comp.hasBoundary = ce.hasBoundary;
+                    if (ce.boundaryType)
+                        comp.boundaryType = ce.boundaryType;
+                    if (ce.publicExports?.length)
+                        comp.publicExports = ce.publicExports;
+                }
+            }
+        }
     }
     return {
         structure,
@@ -259,13 +387,15 @@ export function mergeAgentOutputs(ctx, componentId, serviceDesc, flowDet, connMa
         connections: {
             connections: filteredConnections,
             flows: flows.map((f) => ({
-                name: f.name,
-                description: f.description,
+                name: sanitize(f.name) ?? f.name,
+                description: sanitize(f.description),
                 category: f.category,
                 steps: f.steps,
             })),
         },
         validation: { valid: true, repairs: [], errors: [] },
         gaps: [],
+        enrichmentInsights: enricherOut?.insights,
+        flowVerifications: enricherOut?.flowVerifications,
     };
 }

package/dist/agents/pipeline/types.d.ts

@@ -5,7 +5,11 @@ export interface PipelineAgent {
     name: string;
     modelTier: ModelTier;
     phase: "parallel" | "sequential";
-    buildPrompt(ctx: StaticContext, priorResults?: Record<string, unknown>): {
+    /** Tool names this agent can use: ["read_file", "grep", "glob"] */
+    tools?: string[];
+    /** Max tool loop iterations (default 1 = no tools) */
+    maxTurns?: number;
+    buildPrompt(ctx: StaticContext, priorResults?: Record<string, unknown>, toolsAvailable?: boolean): {
         system: string;
         user: string;
     };
@@ -135,6 +139,30 @@ export interface IncrementalContext {
     neighborComponents: string[];
     hasUnmappedFiles: boolean;
 }
+export interface ArchitectureEnricherOutput {
+    connectionEnrichments: Array<{
+        from: string;
+        to: string;
+        type: string;
+        weight?: number;
+        verifiedByTool?: boolean;
+    }>;
+    componentEnrichments: Array<{
+        id: string;
+        interfaceSurface?: number;
+        hasBoundary?: boolean;
+        boundaryType?: string;
+        publicExports?: string[];
+    }>;
+    flowVerifications: Array<{
+        flowName: string;
+        verified: boolean;
+        stepsVerified: number;
+        stepsTotal: number;
+        issues?: string[];
+    }>;
+    insights: string[];
+}
 export interface PipelineAgentResult {
     agentId: string;
     data: unknown;

package/dist/agents/pipeline/types.js

@@ -1,3 +1,2 @@
 // Pipeline Agent Framework — Types
-// Simpler than ArchByteAgent: no tools, just prompt → JSON
 export {};

package/dist/agents/providers/claude-sdk.d.ts

@@ -0,0 +1,7 @@
+import type { LLMProvider, ChatParams, LLMResponse, LLMChunk } from "../runtime/types.js";
+export declare class ClaudeSdkProvider implements LLMProvider {
+    name: "claude-sdk";
+    chat(params: ChatParams): Promise<LLMResponse>;
+    stream(params: ChatParams): AsyncIterable<LLMChunk>;
+    private extractPrompt;
+}

package/dist/agents/providers/claude-sdk.js

@@ -0,0 +1,83 @@
+export class ClaudeSdkProvider {
+    name = "claude-sdk";
+    async chat(params) {
+        const { query } = await import("@anthropic-ai/claude-agent-sdk");
+        const prompt = this.extractPrompt(params.messages);
+        // Dynamic tool config: empty = text-only, populated = tool-enabled
+        const sdkTools = params.sdkTools?.length ? params.sdkTools : [];
+        const maxTurns = params.sdkMaxTurns ?? 1;
+        const result = query({
+            prompt,
+            options: {
+                systemPrompt: params.system,
+                tools: sdkTools,
+                maxTurns,
+                ...(params.model ? { model: params.model } : {}),
+                permissionMode: "bypassPermissions",
+                allowDangerouslySkipPermissions: true,
+            },
+        });
+        let resultText = "";
+        let assistantText = "";
+        let usage = { inputTokens: 0, outputTokens: 0 };
+        for await (const message of result) {
+            if (message.type === "assistant") {
+                // Capture text from assistant content blocks as fallback
+                const msg = message.message;
+                if (msg && "content" in msg && Array.isArray(msg.content)) {
+                    for (const block of msg.content) {
+                        if (block.type === "text" && typeof block.text === "string") {
+                            assistantText += block.text;
+                        }
+                    }
+                }
+            }
+            else if (message.type === "result") {
+                if (message.subtype === "success") {
+                    resultText = message.result;
+                }
+                else {
+                    // Error result — log the errors for debugging
+                    const errors = "errors" in message ? message.errors : [];
+                    console.error(`[claude-sdk] Result subtype="${message.subtype}" errors=${JSON.stringify(errors)}`);
+                }
+                if (message.usage) {
+                    usage = {
+                        inputTokens: message.usage.input_tokens ?? 0,
+                        outputTokens: message.usage.output_tokens ?? 0,
+                    };
+                }
+            }
+        }
+        // Use result text if available, otherwise fall back to assistant message text
+        const text = resultText || assistantText;
+        return {
+            content: [{ type: "text", text }],
+            stopReason: "end_turn",
+            usage,
+        };
+    }
+    async *stream(params) {
+        // Pipeline agents don't use streaming — delegate to chat()
+        const response = await this.chat(params);
+        const text = response.content.find((b) => b.type === "text")?.text ?? "";
+        if (text) {
+            yield { type: "text", text };
+        }
+        yield { type: "done" };
+    }
+    extractPrompt(messages) {
+        for (let i = messages.length - 1; i >= 0; i--) {
+            if (messages[i].role === "user") {
+                const content = messages[i].content;
+                if (typeof content === "string")
+                    return content;
+                return content
+                    .filter((b) => b.type === "text")
+                    .map((b) => b.text ?? "")
+                    .join("\n");
+            }
+        }
+        return "";
+    }
+}

package/dist/agents/providers/router.d.ts

@@ -1,7 +1,12 @@
 import type { LLMProvider, ArchByteConfig } from "../runtime/types.js";
 export declare function createProvider(config: ArchByteConfig): LLMProvider;
+/**
+ * Check if Claude Code CLI is available on PATH.
+ */
+export declare function isClaudeCodeAvailable(): boolean;
 /**
  * Auto-detect provider from environment variables.
  * Checks in order: ARCHBYTE_PROVIDER, then falls back to whichever API key is set.
+ * Last resort: Claude Code on PATH → claude-sdk (zero config).
  */
 export declare function detectConfig(): ArchByteConfig | null;

package/dist/agents/providers/router.js

@@ -1,6 +1,8 @@
+import { execSync } from "child_process";
 import { AnthropicProvider } from "./anthropic.js";
 import { OpenAIProvider } from "./openai.js";
 import { GoogleProvider } from "./google.js";
+import { ClaudeSdkProvider } from "./claude-sdk.js";
 export function createProvider(config) {
     switch (config.provider) {
         case "anthropic":
@@ -9,13 +11,29 @@ export function createProvider(config) {
             return new OpenAIProvider(config.apiKey);
         case "google":
             return new GoogleProvider(config.apiKey);
+        case "claude-sdk":
+            return new ClaudeSdkProvider();
         default:
             throw new Error(`Unknown provider: ${config.provider}`);
     }
 }
+/**
+ * Check if Claude Code CLI is available on PATH.
+ */
+export function isClaudeCodeAvailable() {
+    try {
+        const cmd = process.platform === "win32" ? "where claude" : "which claude";
+        execSync(cmd, { stdio: "pipe" });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
 /**
  * Auto-detect provider from environment variables.
  * Checks in order: ARCHBYTE_PROVIDER, then falls back to whichever API key is set.
+ * Last resort: Claude Code on PATH → claude-sdk (zero config).
  */
 export function detectConfig() {
     const explicit = process.env.ARCHBYTE_PROVIDER;
@@ -23,7 +41,11 @@ export function detectConfig() {
     if (explicit && apiKey) {
         return { provider: explicit, apiKey };
     }
-    // Auto-detect from known env vars
+    // Claude Code on PATH → zero-config, preferred
+    if (isClaudeCodeAvailable()) {
+        return { provider: "claude-sdk" };
+    }
+    // Fall back to API key env vars
     if (process.env.ANTHROPIC_API_KEY) {
         return { provider: "anthropic", apiKey: process.env.ANTHROPIC_API_KEY };
     }

package/dist/agents/runtime/types.d.ts

@@ -23,6 +23,10 @@ export interface ChatParams {
     messages: Message[];
     tools?: ToolDefinition[];
     maxTokens?: number;
+    /** Claude SDK tool names: ["Read", "Grep", "Glob"] */
+    sdkTools?: string[];
+    /** Claude SDK max agentic turns (default 1) */
+    sdkMaxTurns?: number;
 }
 export interface LLMResponse {
     content: ContentBlock[];
@@ -97,14 +101,14 @@ export interface License {
     expiresAt: string;
     isValid: boolean;
 }
-export type ProviderName = "anthropic" | "openai" | "google";
+export type ProviderName = "anthropic" | "openai" | "google" | "claude-sdk";
 export interface ProviderProfile {
     apiKey?: string;
     model?: string;
 }
 export interface ArchByteConfig {
     provider: ProviderName;
-    apiKey: string;
+    apiKey?: string;
     model?: string;
     modelOverrides?: Partial<Record<ModelTier, string>>;
     profiles?: Record<string, ProviderProfile>;