@agents-at-scale/ark 0.1.53 → 0.1.56

package/dist/commands/models/providers/azure.js

@@ -2,12 +2,8 @@ import inquirer from 'inquirer';
 /**
  * Configuration collector for Azure OpenAI models.
  *
- * Collects the necessary configuration to connect to Azure OpenAI Service:
- * - baseUrl: The Azure OpenAI endpoint URL (e.g., https://<resource>.openai.azure.com)
- * - apiVersion: The API version to use (defaults to 2024-12-01-preview)
- * - apiKey: The authentication key for the Azure OpenAI resource
- *
- * Values can be provided via command-line options or will be prompted interactively.
+ * Supports API Key, Managed Identity (AKS), and Workload Identity auth.
+ * Values can be provided via command-line options or prompted interactively.
  */
 export class AzureConfigCollector {
     async collectConfig(options) {
@@ -50,33 +46,99 @@ export class AzureConfigCollector {
             ]);
             apiVersion = answer.apiVersion;
         }
-        let apiKey = azureOptions.apiKey;
-        if (!apiKey) {
+        let authMethod = azureOptions.authMethod;
+        if (!authMethod && azureOptions.apiKey) {
+            authMethod = 'apiKey';
+        }
+        if (!authMethod) {
             const answer = await inquirer.prompt([
                 {
-                    type: 'password',
-                    name: 'apiKey',
-                    message: 'API key:',
-                    mask: '*',
-                    validate: (input) => {
-                        if (!input)
-                            return 'API key is required';
-                        return true;
-                    },
+                    type: 'list',
+                    name: 'authMethod',
+                    message: 'Authentication:',
+                    choices: [
+                        { name: 'API Key', value: 'apiKey' },
+                        { name: 'Managed Identity (AKS)', value: 'managedIdentity' },
+                        { name: 'Workload Identity', value: 'workloadIdentity' },
+                    ],
                 },
             ]);
-            apiKey = answer.apiKey;
+            authMethod = answer.authMethod;
+        }
+        let apiKey;
+        let clientId;
+        let tenantId;
+        if (authMethod === 'apiKey') {
+            apiKey = azureOptions.apiKey;
+            if (!apiKey) {
+                const answer = await inquirer.prompt([
+                    {
+                        type: 'password',
+                        name: 'apiKey',
+                        message: 'API key:',
+                        mask: '*',
+                        validate: (input) => {
+                            if (!input)
+                                return 'API key is required';
+                            return true;
+                        },
+                    },
+                ]);
+                apiKey = answer.apiKey;
+            }
+            if (!apiKey) {
+                throw new Error('API key is required');
+            }
         }
-        if (!apiKey) {
-            throw new Error('API key is required');
+        else if (authMethod === 'managedIdentity') {
+            clientId = azureOptions.clientId;
+            if (!clientId) {
+                const answer = await inquirer.prompt([
+                    {
+                        type: 'input',
+                        name: 'clientId',
+                        message: 'Managed Identity Client ID (optional for system-assigned):',
+                    },
+                ]);
+                clientId = answer.clientId || undefined;
+            }
+        }
+        else if (authMethod === 'workloadIdentity') {
+            clientId = azureOptions.clientId;
+            tenantId = azureOptions.tenantId;
+            if (!clientId) {
+                const answer = await inquirer.prompt([
+                    {
+                        type: 'input',
+                        name: 'clientId',
+                        message: 'Workload Identity Client ID:',
+                        validate: (input) => input ? true : 'Client ID is required for Workload Identity',
+                    },
+                ]);
+                clientId = answer.clientId;
+            }
+            if (!tenantId) {
+                const answer = await inquirer.prompt([
+                    {
+                        type: 'input',
+                        name: 'tenantId',
+                        message: 'Azure Tenant ID:',
+                        validate: (input) => input ? true : 'Tenant ID is required for Workload Identity',
+                    },
+                ]);
+                tenantId = answer.tenantId;
+            }
         }
         return {
             type: 'azure',
             modelValue: options.model,
             secretName: '',
             baseUrl,
-            apiKey,
             apiVersion,
+            authMethod,
+            apiKey,
+            clientId,
+            tenantId,
         };
     }
 }

package/dist/commands/models/providers/factory.js

@@ -1,6 +1,7 @@
 import { OpenAIConfigCollector } from './openai.js';
 import { AzureConfigCollector } from './azure.js';
 import { BedrockConfigCollector } from './bedrock.js';
+import { AnthropicConfigCollector } from './anthropic.js';
 /**
  * Factory for creating provider-specific configuration collectors.
  *
@@ -24,6 +25,8 @@ export class ProviderConfigCollectorFactory {
                 return new AzureConfigCollector();
             case 'bedrock':
                 return new BedrockConfigCollector();
+            case 'anthropic':
+                return new AnthropicConfigCollector();
             default:
                 throw new Error(`Unknown provider type: ${type}`);
         }

package/dist/commands/models/providers/index.d.ts

@@ -7,11 +7,10 @@ export { BaseProviderConfig, BaseCollectorOptions, ProviderConfigCollector, } fr
 export { OpenAIConfig, OpenAICollectorOptions, OpenAIConfigCollector, } from './openai.js';
 export { AzureConfig, AzureCollectorOptions, AzureConfigCollector, } from './azure.js';
 export { BedrockConfig, BedrockCollectorOptions, BedrockConfigCollector, } from './bedrock.js';
+export { AnthropicConfig, AnthropicCollectorOptions, AnthropicConfigCollector, } from './anthropic.js';
 export { ProviderConfigCollectorFactory } from './factory.js';
 import { OpenAIConfig } from './openai.js';
 import { AzureConfig } from './azure.js';
 import { BedrockConfig } from './bedrock.js';
-/**
- * Union type of all supported provider configurations.
- */
-export type ProviderConfig = OpenAIConfig | AzureConfig | BedrockConfig;
+import { AnthropicConfig } from './anthropic.js';
+export type ProviderConfig = OpenAIConfig | AzureConfig | BedrockConfig | AnthropicConfig;

package/dist/commands/models/providers/index.js

@@ -6,4 +6,5 @@
 export { OpenAIConfigCollector, } from './openai.js';
 export { AzureConfigCollector, } from './azure.js';
 export { BedrockConfigCollector, } from './bedrock.js';
+export { AnthropicConfigCollector, } from './anthropic.js';
 export { ProviderConfigCollectorFactory } from './factory.js';

package/dist/commands/uninstall/index.js

@@ -5,7 +5,7 @@ import inquirer from 'inquirer';
 import { showNoClusterError } from '../../lib/startup.js';
 import output from '../../lib/output.js';
 import { getInstallableServices } from '../../arkServices.js';
-import { isMarketplaceService, getMarketplaceItem, getAllMarketplaceServices, getAllMarketplaceAgents, } from '../../marketplaceServices.js';
+import { isMarketplaceService, getMarketplaceItem, getAllMarketplaceServices, getAllMarketplaceAgents, getAllMarketplaceExecutors, } from '../../marketplaceServices.js';
 async function uninstallService(service, verbose = false) {
     const helmArgs = ['uninstall', service.helmReleaseName, '--ignore-not-found'];
     // Only add namespace flag if service has explicit namespace
@@ -44,7 +44,13 @@ async function uninstallArk(config, serviceName, options = {}) {
                         output.info(`  marketplace/agents/${name}`);
                     }
                 }
-                if (!marketplaceServices && !marketplaceAgents) {
+                const marketplaceExecutors = await getAllMarketplaceExecutors();
+                if (marketplaceExecutors) {
+                    for (const name of Object.keys(marketplaceExecutors)) {
+                        output.info(`  marketplace/executors/${name}`);
+                    }
+                }
+                if (!marketplaceServices && !marketplaceAgents && !marketplaceExecutors) {
                     output.warning('Marketplace unavailable');
                 }
                 process.exit(1);
@@ -88,7 +94,7 @@ async function uninstallArk(config, serviceName, options = {}) {
     const services = getInstallableServices();
     const serviceEntries = Object.entries(services).reverse();
     for (const [, service] of serviceEntries) {
-        let shouldUninstall = false;
+        let shouldUninstall;
         try {
             // Ask for confirmation
             shouldUninstall =

package/dist/components/ChatUI.js

@@ -6,7 +6,6 @@ import * as React from 'react';
 import { marked } from 'marked';
 // @ts-ignore - no types available
 import TerminalRenderer from 'marked-terminal';
-import { APIError } from 'openai';
 import { TargetSelector } from '../ui/TargetSelector.js';
 import { useAsyncOperation, AsyncOperationStatus } from './AsyncOperation.js';
 import { createConnectingToArkOperation } from '../ui/asyncOperations/connectingToArk.js';
@@ -410,31 +409,32 @@ const ChatUI = ({ initialTargetId, arkApiClient, arkApiProxy, config, }) => {
             // Create abort controller for this request
             const controller = new AbortController();
             setAbortController(controller);
-            // Convert messages to format expected by OpenAI API - only include user and agent messages
             const apiMessages = messages
                 .filter((msg) => msg.type === 'user' || msg.type === 'agent' || msg.type === 'team')
-                .map((msg) => {
+                .flatMap((msg) => {
                 if (msg.type === 'user') {
-                    return {
-                        role: 'user',
-                        content: msg.content,
-                    };
+                    return [
+                        {
+                            role: 'user',
+                            content: msg.content,
+                        },
+                    ];
                 }
                 else if (msg.type === 'agent') {
-                    return {
-                        role: 'assistant',
-                        content: msg.content,
-                    };
+                    return [
+                        {
+                            role: 'assistant',
+                            content: msg.content,
+                        },
+                    ];
                 }
                 else if (msg.type === 'team') {
-                    // For teams, concatenate all member responses
-                    const content = msg.members.map((m) => m.content).join(' ');
-                    return {
+                    return msg.members.map((m) => ({
                         role: 'assistant',
-                        content: content || '',
-                    };
+                        content: m.content || '',
+                    }));
                 }
-                return { role: 'user', content: '' };
+                return [];
             });
             // Add the new user message
             apiMessages.push({
@@ -469,9 +469,9 @@ const ChatUI = ({ initialTargetId, arkApiClient, arkApiProxy, config, }) => {
             const fullResponse = await chatClientRef.current.sendMessage(target.id, apiMessages, { ...chatConfig, a2aContextId: a2aContextIdRef.current }, (chunk, toolCalls, arkMetadata) => {
                 // Extract A2A context ID from response
                 // Chat TUI always queries a single target, so contextId is in response
-                if (arkMetadata?.completedQuery?.status?.response?.a2a?.contextId) {
-                    a2aContextIdRef.current =
-                        arkMetadata.completedQuery.status.response.a2a.contextId;
+                const completed = arkMetadata?.completedQuery;
+                if (completed?.status?.response?.a2a?.contextId) {
+                    a2aContextIdRef.current = completed.status.response.a2a.contextId;
                 }
                 // Update message progressively as chunks arrive
                 setMessages((prev) => {
@@ -557,21 +557,9 @@ const ChatUI = ({ initialTargetId, arkApiClient, arkApiProxy, config, }) => {
                 return;
             }
             let errorMessage = 'Failed to send message';
-            // OpenAI SDK errors include response body in .error property
-            if (err instanceof APIError) {
-                if (err.error && typeof err.error === 'object') {
-                    const errorObj = err.error;
-                    errorMessage = errorObj.message || JSON.stringify(err.error, null, 2);
-                }
-                else {
-                    errorMessage = err.message;
-                }
-            }
-            // Standard JavaScript errors
-            else if (err instanceof Error) {
+            if (err instanceof Error) {
                 errorMessage = err.message;
             }
-            // String errors from throw statements
             else if (typeof err === 'string') {
                 errorMessage = err;
             }

package/dist/components/statusChecker.js

@@ -24,7 +24,7 @@ export const getKubectlVersion = () => ({
             throw new Error('kubectl version output missing clientVersion field');
         }
         catch (e) {
-            throw new Error(`Failed to parse kubectl version JSON: ${e instanceof Error ? e.message : 'Unknown error'}`);
+            throw new Error(`Failed to parse kubectl version JSON: ${e instanceof Error ? e.message : 'Unknown error'}`, { cause: e });
         }
     },
 });
@@ -72,7 +72,7 @@ export class StatusChecker {
             return config.versionExtract(stdout);
         }
         catch (error) {
-            throw new Error(`Failed to get ${config.command} version: ${error instanceof Error ? error.message : 'Unknown error'}`);
+            throw new Error(`Failed to get ${config.command} version: ${error instanceof Error ? error.message : 'Unknown error'}`, { cause: error });
         }
     }
     /**
@@ -341,7 +341,7 @@ export class StatusChecker {
             clusterAccess = true;
         }
         catch {
-            clusterAccess = false;
+            // clusterAccess remains false
         }
         // Get cluster info if accessible
         let clusterInfo;

package/dist/index.js

@@ -13,7 +13,6 @@ import { createClusterCommand } from './commands/cluster/index.js';
 import { createCompletionCommand } from './commands/completion/index.js';
 import { createDashboardCommand } from './commands/dashboard/index.js';
 import { createDocsCommand } from './commands/docs/index.js';
-import { createEvaluationCommand } from './commands/evaluation/index.js';
 import { createExportCommand } from './commands/export/index.js';
 import { createGenerateCommand } from './commands/generate/index.js';
 import { createImportCommand } from './commands/import/index.js';
@@ -49,7 +48,6 @@ async function main() {
     program.addCommand(createCompletionCommand(config));
     program.addCommand(createDashboardCommand(config));
     program.addCommand(createDocsCommand(config));
-    program.addCommand(createEvaluationCommand(config));
     program.addCommand(createExportCommand(config));
     program.addCommand(createGenerateCommand(config));
     program.addCommand(createImportCommand(config));

package/dist/lib/arkApiClient.d.ts

@@ -1,4 +1,3 @@
-import OpenAI from 'openai';
 export interface QueryTarget {
     id: string;
     name: string;
@@ -38,7 +37,6 @@ export interface Team {
     status?: string;
 }
 export declare class ArkApiClient {
-    private openai;
     private baseUrl;
     constructor(arkApiUrl: string);
     getBaseUrl(): string;
@@ -51,6 +49,18 @@ export declare class ArkApiClient {
     deleteSession(sessionId: string): Promise<any>;
     deleteQueryMessages(sessionId: string, queryId: string): Promise<any>;
     deleteAllSessions(): Promise<any>;
-    createChatCompletion(params: OpenAI.Chat.Completions.ChatCompletionCreateParams): Promise<OpenAI.Chat.Completions.ChatCompletion>;
-    createChatCompletionStream(params: OpenAI.Chat.Completions.ChatCompletionCreateParams): AsyncIterable<OpenAI.Chat.Completions.ChatCompletionChunk>;
+    createQuery(params: {
+        input: string;
+        target: {
+            type: string;
+            name: string;
+        };
+        sessionId?: string;
+        conversationId?: string;
+        timeout?: string;
+        metadata?: {
+            annotations?: Record<string, string>;
+        };
+    }): Promise<Record<string, unknown>>;
+    getQuery(queryName: string): Promise<Record<string, unknown>>;
 }

package/dist/lib/arkApiClient.js

@@ -1,35 +1,43 @@
-import OpenAI from 'openai';
 export class ArkApiClient {
+    baseUrl;
     constructor(arkApiUrl) {
         this.baseUrl = arkApiUrl;
-        this.openai = new OpenAI({
-            baseURL: `${arkApiUrl}/openai/v1`,
-            apiKey: 'dummy', // ark-api doesn't require an API key
-            dangerouslyAllowBrowser: false,
-            maxRetries: 0, // Disable automatic retries for query errors
-        });
     }
     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,
-                };
-            });
+            const targets = [];
+            const endpoints = [
+                { type: 'agent', path: '/v1/agents' },
+                { type: 'model', path: '/v1/models' },
+                { type: 'team', path: '/v1/teams' },
+                { type: 'tool', path: '/v1/tools' },
+            ];
+            for (const ep of endpoints) {
+                try {
+                    const response = await fetch(`${this.baseUrl}${ep.path}`);
+                    if (response.ok) {
+                        const data = (await response.json());
+                        for (const item of data.items || []) {
+                            targets.push({
+                                id: `${ep.type}/${item.name}`,
+                                name: item.name,
+                                type: ep.type,
+                                description: item.description || item.name,
+                            });
+                        }
+                    }
+                }
+                catch {
+                    // Skip unavailable resource types
+                }
+            }
             return targets;
         }
         catch (error) {
-            throw new Error(`Failed to get query targets: ${error instanceof Error ? error.message : 'Unknown error'}`);
+            throw new Error(`Failed to get query targets: ${error instanceof Error ? error.message : 'Unknown error'}`, { cause: error });
         }
     }
     async getAgents() {
@@ -42,7 +50,7 @@ export class ArkApiClient {
             return data.items || [];
         }
         catch (error) {
-            throw new Error(`Failed to get agents: ${error instanceof Error ? error.message : 'Unknown error'}`);
+            throw new Error(`Failed to get agents: ${error instanceof Error ? error.message : 'Unknown error'}`, { cause: error });
         }
     }
     async getModels() {
@@ -55,7 +63,7 @@ export class ArkApiClient {
             return data.items || [];
         }
         catch (error) {
-            throw new Error(`Failed to get models: ${error instanceof Error ? error.message : 'Unknown error'}`);
+            throw new Error(`Failed to get models: ${error instanceof Error ? error.message : 'Unknown error'}`, { cause: error });
         }
     }
     async getTools() {
@@ -68,7 +76,7 @@ export class ArkApiClient {
             return data.items || [];
         }
         catch (error) {
-            throw new Error(`Failed to get tools: ${error instanceof Error ? error.message : 'Unknown error'}`);
+            throw new Error(`Failed to get tools: ${error instanceof Error ? error.message : 'Unknown error'}`, { cause: error });
         }
     }
     async getTeams() {
@@ -81,7 +89,7 @@ export class ArkApiClient {
             return data.items || [];
         }
         catch (error) {
-            throw new Error(`Failed to get teams: ${error instanceof Error ? error.message : 'Unknown error'}`);
+            throw new Error(`Failed to get teams: ${error instanceof Error ? error.message : 'Unknown error'}`, { cause: error });
         }
     }
     async getSessions() {
@@ -94,7 +102,7 @@ export class ArkApiClient {
             return data.items || [];
         }
         catch (error) {
-            throw new Error(`Failed to get sessions: ${error instanceof Error ? error.message : 'Unknown error'}`);
+            throw new Error(`Failed to get sessions: ${error instanceof Error ? error.message : 'Unknown error'}`, { cause: error });
         }
     }
     async deleteSession(sessionId) {
@@ -108,7 +116,7 @@ export class ArkApiClient {
             return await response.json();
         }
         catch (error) {
-            throw new Error(`Failed to delete session: ${error instanceof Error ? error.message : 'Unknown error'}`);
+            throw new Error(`Failed to delete session: ${error instanceof Error ? error.message : 'Unknown error'}`, { cause: error });
         }
     }
     async deleteQueryMessages(sessionId, queryId) {
@@ -122,7 +130,7 @@ export class ArkApiClient {
             return await response.json();
         }
         catch (error) {
-            throw new Error(`Failed to delete query messages: ${error instanceof Error ? error.message : 'Unknown error'}`);
+            throw new Error(`Failed to delete query messages: ${error instanceof Error ? error.message : 'Unknown error'}`, { cause: error });
         }
     }
     async deleteAllSessions() {
@@ -136,24 +144,35 @@ export class ArkApiClient {
             return await response.json();
         }
         catch (error) {
-            throw new Error(`Failed to delete all sessions: ${error instanceof Error ? error.message : 'Unknown error'}`);
+            throw new Error(`Failed to delete all sessions: ${error instanceof Error ? error.message : 'Unknown error'}`, { cause: error });
         }
     }
-    async createChatCompletion(params) {
-        return (await this.openai.chat.completions.create({
-            ...params,
-            stream: false,
-        }));
-    }
-    async *createChatCompletionStream(params) {
-        // Errors from OpenAI SDK will automatically propagate with proper error messages
-        // and kill the CLI, so no try/catch needed here
-        const stream = await this.openai.chat.completions.create({
-            ...params,
-            stream: true,
+    async createQuery(params) {
+        const response = await fetch(`${this.baseUrl}/v1/queries/`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                name: `cli-query-${Date.now()}`,
+                type: 'user',
+                input: params.input,
+                target: params.target,
+                sessionId: params.sessionId,
+                conversationId: params.conversationId,
+                timeout: params.timeout,
+                ...(params.metadata ? { metadata: params.metadata } : {}),
+            }),
         });
-        for await (const chunk of stream) {
-            yield chunk;
+        if (!response.ok) {
+            const text = await response.text();
+            throw new Error(`Query creation failed (${response.status}): ${text}`);
+        }
+        return (await response.json());
+    }
+    async getQuery(queryName) {
+        const response = await fetch(`${this.baseUrl}/v1/queries/${queryName}`);
+        if (!response.ok) {
+            throw new Error(`Failed to get query: ${response.status}`);
         }
+        return (await response.json());
     }
 }

package/dist/lib/arkApiProxy.js

@@ -2,6 +2,7 @@ import { ArkApiClient } from './arkApiClient.js';
 import { ArkServiceProxy } from './arkServiceProxy.js';
 import { arkServices } from '../arkServices.js';
 export class ArkApiProxy {
+    serviceProxy;
     constructor(localPort, reusePortForwards = false) {
         const arkApiService = arkServices['ark-api'];
         this.serviceProxy = new ArkServiceProxy(arkApiService, localPort, reusePortForwards);

package/dist/lib/arkServiceProxy.js

@@ -3,9 +3,13 @@ import find from 'find-process';
 import Debug from 'debug';
 const debug = Debug('ark:service-proxy');
 export class ArkServiceProxy {
+    reusePortForwards;
+    kubectlProcess;
+    localPort;
+    isReady = false;
+    service;
     constructor(service, localPort, reusePortForwards = false) {
         this.reusePortForwards = reusePortForwards;
-        this.isReady = false;
         this.service = service;
         this.localPort =
             localPort || service.k8sPortForwardLocalPort || this.getRandomPort();

package/dist/lib/chatClient.d.ts

@@ -1,13 +1,12 @@
 import { ArkApiClient, QueryTarget } from './arkApiClient.js';
-import type { Query } from './types.js';
 export { QueryTarget };
 export interface ChatConfig {
     streamingEnabled: boolean;
     currentTarget?: QueryTarget;
-    a2aContextId?: string;
     sessionId?: string;
     conversationId?: string;
     queryTimeout?: string;
+    a2aContextId?: string;
 }
 export interface ToolCall {
     id: string;
@@ -23,17 +22,16 @@ export interface ArkMetadata {
     model?: string;
     query?: string;
     target?: string;
-    completedQuery?: Query;
+    completedQuery?: Record<string, unknown>;
 }
 export declare class ChatClient {
     private arkApiClient;
     constructor(arkApiClient: ArkApiClient);
     getQueryTargets(): Promise<QueryTarget[]>;
-    /**
-     * Send a chat completion request
-     */
     sendMessage(targetId: string, messages: Array<{
         role: 'user' | 'assistant' | 'system';
         content: string;
     }>, config: ChatConfig, onChunk?: (chunk: string, toolCalls?: ToolCall[], arkMetadata?: ArkMetadata) => void, signal?: AbortSignal): Promise<string>;
+    private pollResponse;
+    private pollStreamResponse;
 }