@agents-at-scale/ark 0.1.33 → 0.1.35-rc.1

package/dist/components/StatusView.d.ts

@@ -0,0 +1,10 @@
+import * as React from 'react';
+import { StatusData } from '../lib/types.js';
+interface StatusViewProps {
+    statusData: StatusData | null;
+    isLoading: boolean;
+    error: string | null;
+    onBack: () => void;
+}
+declare const StatusView: React.FC<StatusViewProps>;
+export default StatusView;

package/dist/components/StatusView.js

@@ -0,0 +1,39 @@
+import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+import { Box, Text, useInput } from 'ink';
+const StatusView = ({ statusData, isLoading, error, onBack, }) => {
+    useInput((input, key) => {
+        if (key.escape || input === 'q' || key.return) {
+            onBack();
+        }
+    });
+    const renderServiceStatus = (service) => {
+        const statusColor = service.status === 'healthy'
+            ? 'green'
+            : service.status === 'unhealthy'
+                ? 'red'
+                : 'yellow';
+        const statusIcon = service.status === 'healthy'
+            ? '✓'
+            : service.status === 'unhealthy'
+                ? '✗'
+                : '?';
+        return (_jsxs(Box, { flexDirection: "column", marginLeft: 2, children: [_jsxs(Box, { children: [_jsxs(Text, { color: statusColor, children: [statusIcon, " "] }), _jsxs(Text, { bold: true, children: [service.name, ": "] }), _jsx(Text, { color: statusColor, children: service.status })] }), service.url && (_jsx(Box, { marginLeft: 2, children: _jsxs(Text, { color: "gray", children: ["URL: ", service.url] }) })), service.details && (_jsx(Box, { marginLeft: 2, children: _jsx(Text, { color: "gray", children: service.details }) }))] }, service.name));
+    };
+    const renderDependencyStatus = (dep) => {
+        const statusColor = dep.installed ? 'green' : 'red';
+        const statusIcon = dep.installed ? '✓' : '✗';
+        const statusText = dep.installed ? 'installed' : 'missing';
+        return (_jsxs(Box, { flexDirection: "column", marginLeft: 2, children: [_jsxs(Box, { children: [_jsxs(Text, { color: statusColor, children: [statusIcon, " "] }), _jsxs(Text, { bold: true, children: [dep.name, ": "] }), _jsx(Text, { color: statusColor, children: statusText })] }), dep.version && (_jsx(Box, { marginLeft: 2, children: _jsxs(Text, { color: "gray", children: ["Version: ", dep.version] }) })), dep.details && (_jsx(Box, { marginLeft: 2, children: _jsx(Text, { color: "gray", children: dep.details }) }))] }, dep.name));
+    };
+    if (isLoading) {
+        return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { color: "yellow", children: "\uD83D\uDD0D Checking ARK system status..." }), _jsx(Text, { color: "gray", children: "Please wait while we verify services and dependencies." })] }));
+    }
+    if (error) {
+        return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { color: "red", children: "\u274C Error checking status:" }), _jsx(Text, { color: "red", children: error }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { color: "gray", children: "Press ESC, 'q', or Enter to return to menu..." }) })] }));
+    }
+    if (!statusData) {
+        return null;
+    }
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { color: "cyan", bold: true, children: "\uD83D\uDD0D ARK System Status" }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { color: "cyan", bold: true, children: "\uD83D\uDCE1 ARK Services:" }) }), statusData.services.map(renderServiceStatus), _jsx(Box, { marginTop: 1, children: _jsx(Text, { color: "cyan", bold: true, children: "\uD83D\uDEE0\uFE0F System Dependencies:" }) }), statusData.dependencies.map(renderDependencyStatus), _jsx(Box, { marginTop: 1, children: _jsx(Text, { color: "gray", children: "Press ESC, 'q', or Enter to return to menu..." }) })] }));
+};
+export default StatusView;

package/dist/components/statusChecker.d.ts

@@ -5,26 +5,24 @@ export declare const getNpmVersion: () => CommandVersionConfig;
 export declare const getKubectlVersion: () => CommandVersionConfig;
 export declare const getDockerVersion: () => CommandVersionConfig;
 export declare const getHelmVersion: () => CommandVersionConfig;
+export declare const getMinikubeVersion: () => CommandVersionConfig;
+export declare const getKindVersion: () => CommandVersionConfig;
 export declare class StatusChecker {
     private arkClient;
     private kubernetesManager;
     constructor(arkClient: ArkClient);
-    /**
-     * Check if a command is available in the system
-     */
-    private isCommandAvailable;
     /**
      * Get version of a command
      */
     private getCommandVersion;
     /**
-     * Check health of a service by URL
+     * Check deployment status
      */
-    private checkServiceHealth;
+    private checkDeploymentStatus;
     /**
-     * Check if ark-api is running and healthy
+     * Check helm release status (fallback for services without deployments)
      */
-    private checkArkApi;
+    private checkHelmStatus;
     /**
      * Return a "not installed" status for a service
      */
@@ -40,9 +38,8 @@ export declare class StatusChecker {
     /**
      * Run all checks and return results
      */
-    checkAll(serviceUrls?: Record<string, string>, arkApiUrl?: string): Promise<StatusData>;
-    /**
-     * Get appropriate health check path for different service types
-     */
-    private getHealthPath;
+    checkAll(): Promise<StatusData & {
+        clusterAccess: boolean;
+        clusterInfo?: any;
+    }>;
 }

package/dist/components/statusChecker.js

@@ -2,7 +2,9 @@ import { exec } from 'child_process';
 import { promisify } from 'util';
 import { KubernetesConfigManager } from '../lib/kubernetes.js';
 import * as k8s from '@kubernetes/client-node';
-import axios from 'axios';
+import { isCommandAvailable } from '../lib/commandUtils.js';
+import { arkServices } from '../arkServices.js';
+import { isArkReady } from '../lib/arkStatus.js';
 const execAsync = promisify(exec);
 export const getNodeVersion = () => ({
     command: 'node',
@@ -40,6 +42,20 @@ export const getHelmVersion = () => ({
     versionArgs: 'version --short',
     versionExtract: (output) => output.trim(),
 });
+export const getMinikubeVersion = () => ({
+    command: 'minikube',
+    versionArgs: 'version --short',
+    versionExtract: (output) => output.trim(),
+});
+export const getKindVersion = () => ({
+    command: 'kind',
+    versionArgs: 'version',
+    versionExtract: (output) => {
+        // kind version output is like "kind v0.20.0 go1.21.0 linux/amd64"
+        const match = output.match(/kind (v[\d.]+)/);
+        return match ? match[1] : output.trim();
+    },
+});
 function createErrorServiceStatus(name, url, error, defaultStatus = 'unhealthy', defaultDetails) {
     const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
     return {
@@ -54,21 +70,6 @@ export class StatusChecker {
         this.arkClient = arkClient;
         this.kubernetesManager = new KubernetesConfigManager();
     }
-    /**
-     * Check if a command is available in the system
-     */
-    async isCommandAvailable(command) {
-        try {
-            const checkCommand = process.platform === 'win32'
-                ? `where ${command}`
-                : `command -v ${command}`;
-            await execAsync(checkCommand);
-            return true;
-        }
-        catch (_error) {
-            return false;
-        }
-    }
     /**
      * Get version of a command
      */
@@ -83,29 +84,81 @@ export class StatusChecker {
         }
     }
     /**
-     * Check health of a service by URL
+     * Check deployment status
      */
-    async checkServiceHealth(serviceName, serviceUrl, successMessage, healthPath = '') {
-        const fullUrl = `${serviceUrl}${healthPath}`;
+    async checkDeploymentStatus(serviceName, deploymentName, namespace) {
         try {
-            await axios.get(fullUrl, { timeout: 5000 });
+            const cmd = `kubectl get deployment ${deploymentName} --namespace ${namespace} -o json`;
+            const { stdout } = await execAsync(cmd);
+            const deployment = JSON.parse(stdout);
+            const replicas = deployment.spec?.replicas || 0;
+            const readyReplicas = deployment.status?.readyReplicas || 0;
+            const availableReplicas = deployment.status?.availableReplicas || 0;
+            // Check Kubernetes 'Available' condition - only 'available' deployments are healthy
+            const availableCondition = deployment.status?.conditions?.find((condition) => condition.type === 'Available');
+            const isAvailable = availableCondition?.status === 'True';
+            const allReplicasReady = readyReplicas === replicas && availableReplicas === replicas;
+            // Determine status: not ready if 0 replicas, healthy if available and all ready, warning otherwise
+            let status;
+            if (replicas === 0 || readyReplicas === 0) {
+                status = 'not ready';
+            }
+            else if (isAvailable && allReplicasReady) {
+                status = 'healthy';
+            }
+            else {
+                status = 'warning';
+            }
             return {
                 name: serviceName,
-                status: 'healthy',
-                url: serviceUrl,
-                details: successMessage,
+                status,
+                details: `${readyReplicas}/${replicas} replicas ready`,
             };
         }
         catch (error) {
-            return createErrorServiceStatus(serviceName, serviceUrl, error, 'unhealthy', `${serviceName} is not running or not accessible`);
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+            if (errorMessage.includes('not found')) {
+                return {
+                    name: serviceName,
+                    status: 'not installed',
+                    details: `Deployment '${deploymentName}' not found in namespace '${namespace}'`,
+                };
+            }
+            return createErrorServiceStatus(serviceName, '', error, 'unhealthy', `Failed to check deployment: ${errorMessage}`);
         }
     }
     /**
-     * Check if ark-api is running and healthy
+     * Check helm release status (fallback for services without deployments)
      */
-    async checkArkApi(customUrl) {
-        const url = customUrl || this.arkClient.getBaseURL();
-        return this.checkServiceHealth('ark-api', url, 'ARK API is running', '/health');
+    async checkHelmStatus(serviceName, helmReleaseName, namespace) {
+        try {
+            const cmd = `helm list --filter ${helmReleaseName} --namespace ${namespace} --output json`;
+            const { stdout } = await execAsync(cmd);
+            const helmList = JSON.parse(stdout);
+            if (helmList.length === 0) {
+                return {
+                    name: serviceName,
+                    status: 'not installed',
+                    details: `Helm release '${helmReleaseName}' not found in namespace '${namespace}'`,
+                };
+            }
+            const release = helmList[0];
+            const status = release.status?.toLowerCase() || 'unknown';
+            const revision = release.revision || 'unknown';
+            const appVersion = release.app_version || 'unknown';
+            const isHealthy = status === 'deployed';
+            return {
+                name: serviceName,
+                status: isHealthy ? 'healthy' : 'unhealthy',
+                version: appVersion,
+                revision: revision,
+                details: `Status: ${status}`,
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+            return createErrorServiceStatus(serviceName, '', error, 'unhealthy', `Failed to check helm status: ${errorMessage}`);
+        }
     }
     /**
      * Return a "not installed" status for a service
@@ -180,10 +233,12 @@ export class StatusChecker {
             { name: 'kubectl', ...getKubectlVersion() },
             { name: 'docker', ...getDockerVersion() },
             { name: 'helm', ...getHelmVersion() },
+            { name: 'minikube', ...getMinikubeVersion() },
+            { name: 'kind', ...getKindVersion() },
         ];
         const results = [];
         for (const dep of dependencies) {
-            const installed = await this.isCommandAvailable(dep.command);
+            const installed = await isCommandAvailable(dep.command);
             const version = installed
                 ? await this.getCommandVersion({
                     command: dep.command,
@@ -205,47 +260,55 @@ export class StatusChecker {
     /**
      * Run all checks and return results
      */
-    async checkAll(serviceUrls = {}, arkApiUrl) {
-        // Always check ark-api if provided
-        const serviceChecks = [];
-        if (arkApiUrl) {
-            serviceChecks.push(this.checkArkApi(arkApiUrl));
+    async checkAll() {
+        // Check dependencies first
+        const dependencies = await this.checkDependencies();
+        // Test cluster access
+        const configManager = new (await import('../config.js')).ConfigManager();
+        const clusterAccess = await configManager.testClusterAccess();
+        // Get cluster info if accessible
+        let clusterInfo;
+        if (clusterAccess) {
+            const { getClusterInfo } = await import('../lib/cluster.js');
+            clusterInfo = await getClusterInfo();
+        }
+        let services = [];
+        // Only check ARK services if we have cluster access
+        if (clusterAccess) {
+            const serviceChecks = [];
+            for (const [serviceName, service] of Object.entries(arkServices)) {
+                if (service.k8sDeploymentName) {
+                    serviceChecks.push(this.checkDeploymentStatus(serviceName, service.k8sDeploymentName, service.namespace));
+                }
+                else {
+                    serviceChecks.push(this.checkHelmStatus(serviceName, service.helmReleaseName, service.namespace));
+                }
+            }
+            services = await Promise.all(serviceChecks);
         }
-        // Dynamically check all discovered services
-        for (const [serviceName, serviceUrl] of Object.entries(serviceUrls)) {
-            if (serviceName === 'ark-api' && arkApiUrl) {
-                // Skip if we already added ark-api above
-                continue;
+        // Check if ARK is ready (controller is running)
+        let arkReady = false;
+        let defaultModelExists = false;
+        if (clusterAccess) {
+            arkReady = await isArkReady();
+            // Check for default model
+            if (arkReady) {
+                try {
+                    await execAsync('kubectl get model default -o name');
+                    defaultModelExists = true;
+                }
+                catch {
+                    defaultModelExists = false;
+                }
             }
-            serviceChecks.push(this.checkServiceHealth(serviceName, serviceUrl, `${serviceName} is running`, this.getHealthPath(serviceName)));
         }
-        // Always check dependencies
-        const dependenciesCheck = this.checkDependencies();
-        const [dependencies, ...serviceStatuses] = await Promise.all([
-            dependenciesCheck,
-            ...serviceChecks,
-        ]);
         return {
-            services: serviceStatuses,
+            services,
             dependencies,
+            clusterAccess,
+            clusterInfo,
+            arkReady,
+            defaultModelExists,
         };
     }
-    /**
-     * Get appropriate health check path for different service types
-     */
-    getHealthPath(serviceName) {
-        // Some services might need specific health check paths
-        switch (serviceName) {
-            case 'ark-api':
-                return '/health';
-            case 'ark-api-a2a':
-                return '/health'; // ark-api-a2a has a working /health endpoint
-            case 'ark-dashboard':
-                return ''; // Dashboard typically responds to root
-            case 'langfuse':
-                return ''; // Langfuse responds to root path
-            default:
-                return ''; // Default to root path
-        }
-    }
 }

package/dist/config.js

@@ -7,6 +7,7 @@ import { ArkClient } from './lib/arkClient.js';
 import { DEFAULT_ADDRESS_ARK_API, CONFIG_DIR_NAME, CONFIG_FILE_NAME, } from './lib/consts.js';
 import { GatewayManager } from './lib/gatewayManager.js';
 import { KubernetesConfigManager } from './lib/kubernetes.js';
+import { getStatusCheckableServices } from './arkServices.js';
 const debug = Debug('ark:config');
 /**
  * ConfigManager handles ARK CLI configuration with automatic service discovery
@@ -163,16 +164,8 @@ export class ConfigManager {
      * Construct standard localhost-gateway URLs for known ARK services
      */
     getLocalhostGatewayUrls() {
-        const port = 8080;
-        // Known services that are typically exposed via localhost-gateway
-        const knownServices = {
-            'ark-api': `http://ark-api.127.0.0.1.nip.io:${port}`,
-            'ark-dashboard': `http://dashboard.127.0.0.1.nip.io:${port}`,
-            'ark-api-a2a': `http://ark-api-a2a.127.0.0.1.nip.io:${port}`,
-            langfuse: `http://langfuse.telemetry.127.0.0.1.nip.io:${port}`, // Fixed URL to match HTTPRoute
-            // Add other services as they become available via gateway
-        };
-        return knownServices;
+        // Use centralized service definitions from arkServices
+        return getStatusCheckableServices();
     }
     async initKubernetesConfig() {
         if (!this.kubeConfig) {

package/dist/index.d.ts

@@ -1,2 +1,2 @@
-#!/usr/bin/env node
+#!/usr/bin/env NODE_NO_WARNINGS=1 node
 export {};

package/dist/index.js

@@ -1,39 +1,31 @@
-#!/usr/bin/env node
+#!/usr/bin/env NODE_NO_WARNINGS=1 node
 import { jsx as _jsx } from "react/jsx-runtime";
-import chalk from 'chalk';
 import { Command } from 'commander';
 import { render } from 'ink';
 import { createRequire } from 'module';
 const require = createRequire(import.meta.url);
 const packageJson = require('../package.json');
+import output from './lib/output.js';
+import { createAgentsCommand } from './commands/agents/index.js';
+import { createChatCommand } from './commands/chat/index.js';
 import { createClusterCommand } from './commands/cluster/index.js';
-import { createCompletionCommand } from './commands/completion.js';
+import { createCompletionCommand } from './commands/completion/index.js';
+import { createDashboardCommand } from './commands/dashboard/index.js';
+import { createDevCommand } from './commands/dev/index.js';
 import { createGenerateCommand } from './commands/generate/index.js';
-import { createConfigCommand } from './commands/config.js';
-import { StatusChecker } from './components/statusChecker.js';
-import { ConfigManager } from './config.js';
-import { ArkClient } from './lib/arkClient.js';
+import { createInstallCommand } from './commands/install/index.js';
+import { createModelsCommand } from './commands/models/index.js';
+import { createUninstallCommand } from './commands/uninstall/index.js';
+import { createStatusCommand } from './commands/status/index.js';
+import { createConfigCommand } from './commands/config/index.js';
+import { createTargetsCommand } from './commands/targets/index.js';
+import { createTeamsCommand } from './commands/teams/index.js';
+import { createToolsCommand } from './commands/tools/index.js';
+import { createRoutesCommand } from './commands/routes/index.js';
 import MainMenu from './ui/MainMenu.js';
-import { StatusFormatter } from './ui/statusFormatter.js';
 function showMainMenu() {
-    console.clear();
-    render(_jsx(MainMenu, {}));
-}
-async function handleStatusCheck() {
-    try {
-        const configManager = new ConfigManager();
-        const apiBaseUrl = await configManager.getApiBaseUrl();
-        const serviceUrls = await configManager.getServiceUrls();
-        const arkClient = new ArkClient(apiBaseUrl);
-        const statusChecker = new StatusChecker(arkClient);
-        const statusData = await statusChecker.checkAll(serviceUrls, apiBaseUrl);
-        StatusFormatter.printStatus(statusData);
-        process.exit(0); // Exit cleanly after showing status
-    }
-    catch (error) {
-        console.error(chalk.red('Failed to check status:'), error);
-        process.exit(1);
-    }
+    const app = render(_jsx(MainMenu, {}));
+    globalThis.inkApp = app;
 }
 async function main() {
     const program = new Command();
@@ -41,27 +33,30 @@ async function main() {
         .name(packageJson.name)
         .description(packageJson.description)
         .version(packageJson.version);
+    program.addCommand(createAgentsCommand());
+    program.addCommand(createChatCommand());
     program.addCommand(createClusterCommand());
     program.addCommand(createCompletionCommand());
+    program.addCommand(createDashboardCommand());
+    program.addCommand(createDevCommand());
     program.addCommand(createGenerateCommand());
+    program.addCommand(createInstallCommand());
+    program.addCommand(createModelsCommand());
+    program.addCommand(createUninstallCommand());
+    program.addCommand(createStatusCommand());
     program.addCommand(createConfigCommand());
-    // Add check status command
-    const checkCommand = new Command('check');
-    checkCommand.description('Check various ARK system components');
-    checkCommand
-        .command('status')
-        .description('Check system status')
-        .action(handleStatusCheck);
-    program.addCommand(checkCommand);
+    program.addCommand(createTargetsCommand());
+    program.addCommand(createTeamsCommand());
+    program.addCommand(createToolsCommand());
+    program.addCommand(createRoutesCommand());
     // If no args provided, show interactive menu
     if (process.argv.length === 2) {
-        console.log();
         showMainMenu();
         return;
     }
     await program.parseAsync(process.argv);
 }
 main().catch((error) => {
-    console.error(chalk.red('Failed to start ARK CLI:'), error);
+    output.error('failed to start ark cli: ', error);
     process.exit(1);
 });

package/dist/lib/arkApiClient.d.ts

@@ -0,0 +1,53 @@
+import OpenAI from 'openai';
+export interface QueryTarget {
+    id: string;
+    name: string;
+    type: 'agent' | 'model' | 'tool' | string;
+    description?: string;
+}
+export interface Agent {
+    name: string;
+    namespace: string;
+    description?: string;
+    model_ref?: string;
+    prompt?: string;
+    status?: string;
+    annotations?: Record<string, string>;
+}
+export interface Model {
+    name: string;
+    namespace: string;
+    type: string;
+    model: string;
+    status: string;
+    annotations?: Record<string, string>;
+}
+export interface Tool {
+    name: string;
+    namespace: string;
+    description?: string;
+    labels?: Record<string, string>;
+    annotations?: Record<string, string>;
+}
+export interface Team {
+    name: string;
+    namespace: string;
+    description?: string;
+    strategy?: string;
+    members_count?: number;
+    status?: string;
+}
+export declare class ArkApiClient {
+    private openai;
+    private baseUrl;
+    private namespace;
+    constructor(arkApiUrl: string, namespace?: string);
+    getBaseUrl(): string;
+    getQueryTargets(): Promise<QueryTarget[]>;
+    getAgents(): Promise<Agent[]>;
+    getModels(): Promise<Model[]>;
+    getTools(): Promise<Tool[]>;
+    getTeams(): Promise<Team[]>;
+    createChatCompletion(params: OpenAI.Chat.Completions.ChatCompletionCreateParams): Promise<OpenAI.Chat.Completions.ChatCompletion>;
+    createChatCompletionStream(params: OpenAI.Chat.Completions.ChatCompletionCreateParams): AsyncIterable<OpenAI.Chat.Completions.ChatCompletionChunk>;
+}

package/dist/lib/arkApiClient.js

@@ -0,0 +1,102 @@
+import OpenAI from 'openai';
+export class ArkApiClient {
+    constructor(arkApiUrl, namespace = 'default') {
+        this.baseUrl = arkApiUrl;
+        this.namespace = namespace;
+        this.openai = new OpenAI({
+            baseURL: `${arkApiUrl}/openai/v1`,
+            apiKey: 'dummy', // ark-api doesn't require an API key
+            dangerouslyAllowBrowser: false,
+        });
+    }
+    getBaseUrl() {
+        return this.baseUrl;
+    }
+    async getQueryTargets() {
+        try {
+            const models = await this.openai.models.list();
+            const targets = models.data.map((model) => {
+                const parts = model.id.split('/');
+                const type = parts[0] || 'model';
+                const name = parts.slice(1).join('/') || model.id;
+                return {
+                    id: model.id,
+                    name,
+                    type,
+                    description: model.id,
+                };
+            });
+            return targets;
+        }
+        catch (error) {
+            throw new Error(`Failed to get query targets: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        }
+    }
+    async getAgents() {
+        try {
+            const response = await fetch(`${this.baseUrl}/v1/namespaces/${this.namespace}/agents`);
+            if (!response.ok) {
+                throw new Error(`HTTP error! status: ${response.status}`);
+            }
+            const data = (await response.json());
+            return data.items || [];
+        }
+        catch (error) {
+            throw new Error(`Failed to get agents: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        }
+    }
+    async getModels() {
+        try {
+            const response = await fetch(`${this.baseUrl}/v1/namespaces/${this.namespace}/models`);
+            if (!response.ok) {
+                throw new Error(`HTTP error! status: ${response.status}`);
+            }
+            const data = (await response.json());
+            return data.items || [];
+        }
+        catch (error) {
+            throw new Error(`Failed to get models: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        }
+    }
+    async getTools() {
+        try {
+            const response = await fetch(`${this.baseUrl}/v1/namespaces/${this.namespace}/tools`);
+            if (!response.ok) {
+                throw new Error(`HTTP error! status: ${response.status}`);
+            }
+            const data = (await response.json());
+            return data.items || [];
+        }
+        catch (error) {
+            throw new Error(`Failed to get tools: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        }
+    }
+    async getTeams() {
+        try {
+            const response = await fetch(`${this.baseUrl}/v1/namespaces/${this.namespace}/teams`);
+            if (!response.ok) {
+                throw new Error(`HTTP error! status: ${response.status}`);
+            }
+            const data = (await response.json());
+            return data.items || [];
+        }
+        catch (error) {
+            throw new Error(`Failed to get teams: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        }
+    }
+    async createChatCompletion(params) {
+        return (await this.openai.chat.completions.create({
+            ...params,
+            stream: false,
+        }));
+    }
+    async *createChatCompletionStream(params) {
+        const stream = await this.openai.chat.completions.create({
+            ...params,
+            stream: true,
+        });
+        for await (const chunk of stream) {
+            yield chunk;
+        }
+    }
+}

package/dist/lib/arkApiProxy.d.ts

@@ -0,0 +1,9 @@
+import { ArkApiClient } from './arkApiClient.js';
+export declare class ArkApiProxy {
+    private serviceProxy;
+    constructor(localPort?: number);
+    start(): Promise<ArkApiClient>;
+    stop(): void;
+    isRunning(): boolean;
+    getLocalUrl(): string;
+}