@agents-at-scale/ark 0.1.55 → 0.1.56

package/dist/arkServices.js

@@ -66,6 +66,7 @@ const defaultArkServices = {
         helmReleaseName: 'ark-controller',
         description: 'Core Ark controller for managing AI resources',
         enabled: true,
+        mandatory: true,
         category: 'core',
         namespace: 'ark-system',
         chartPath: `${REGISTRY_BASE}/ark-controller:${CHART_VERSION}`,
@@ -73,11 +74,24 @@ const defaultArkServices = {
         k8sDeploymentName: 'ark-controller',
         k8sDevDeploymentName: 'ark-controller-devspace',
     },
+    'ark-completions': {
+        name: 'ark-completions',
+        helmReleaseName: 'ark-completions',
+        description: 'Completions execution engine for Ark queries',
+        enabled: true,
+        mandatory: true,
+        category: 'core',
+        namespace: 'ark-system',
+        chartPath: `${REGISTRY_BASE}/ark-completions:${CHART_VERSION}`,
+        installArgs: ['--create-namespace'],
+        k8sDeploymentName: 'ark-completions',
+    },
     'ark-tenant': {
         name: 'ark-tenant',
         helmReleaseName: 'ark-tenant',
         description: 'Tenant provisioning with RBAC and resource quotas',
         enabled: true,
+        mandatory: true,
         category: 'core',
         chartPath: `${REGISTRY_BASE}/ark-tenant:${CHART_VERSION}`,
         installArgs: [],

package/dist/commands/completion/index.js

@@ -28,7 +28,7 @@ _ark_completion() {
   
   case \${COMP_CWORD} in
     1)
-      opts="agents chat cluster completion config dashboard docs evaluation export generate import install marketplace memory models queries query routes status targets teams tools uninstall help"
+      opts="agents chat cluster completion config dashboard docs export generate import install marketplace memory models queries query routes status targets teams tools uninstall help"
       COMPREPLY=( $(compgen -W "\${opts}" -- \${cur}) )
       return 0
       ;;
@@ -90,12 +90,12 @@ _ark_completion() {
           return 0
           ;;
         install)
-          opts="marketplace/services/phoenix marketplace/services/langfuse marketplace/agents/noah"
+          opts="marketplace/services/phoenix marketplace/services/langfuse marketplace/agents/noah marketplace/executors/langchain marketplace/executors/claude-agent-sdk"
           COMPREPLY=( $(compgen -W "\${opts}" -- \${cur}) )
           return 0
           ;;
         uninstall)
-          opts="marketplace/services/phoenix marketplace/services/langfuse marketplace/agents/noah"
+          opts="marketplace/services/phoenix marketplace/services/langfuse marketplace/agents/noah marketplace/executors/langchain marketplace/executors/claude-agent-sdk"
           COMPREPLY=( $(compgen -W "\${opts}" -- \${cur}) )
           return 0
           ;;
@@ -160,7 +160,6 @@ _ark() {
         'config[Configuration management]' \\
         'dashboard[Open ARK dashboard]' \\
         'docs[Open ARK documentation]' \\
-        'evaluation[Execute evaluations against evaluators]' \\
         'export[Export ARK resources to a file]' \\
         'generate[Generate ARK resources]' \\
         'import[Import ARK resources from a file]' \\
@@ -244,12 +243,16 @@ _ark() {
         install)
           _values 'services to install' \\
             'marketplace/services/phoenix[Phoenix observability platform]' \\
-            'marketplace/services/langfuse[Langfuse LLM analytics]'
+            'marketplace/services/langfuse[Langfuse LLM analytics]' \\
+            'marketplace/executors/langchain[LangChain execution engine]' \\
+            'marketplace/executors/claude-agent-sdk[Claude Agent SDK executor]'
           ;;
         uninstall)
           _values 'services to uninstall' \\
             'marketplace/services/phoenix[Phoenix observability platform]' \\
-            'marketplace/services/langfuse[Langfuse LLM analytics]'
+            'marketplace/services/langfuse[Langfuse LLM analytics]' \\
+            'marketplace/executors/langchain[LangChain execution engine]' \\
+            'marketplace/executors/claude-agent-sdk[Claude Agent SDK executor]'
           ;;
         chat)
           # Get available targets dynamically

package/dist/commands/export/index.js

@@ -11,7 +11,6 @@ const RESOURCE_ORDER = [
     'models',
     'agents',
     'teams',
-    'evaluators',
     'mcpservers',
     'a2aservers',
 ];

package/dist/commands/generate/generators/team.js

@@ -91,7 +91,6 @@ class TeamGenerator {
                 choices: [
                     { name: 'Sequential - Agents execute in order', value: 'sequential' },
                     { name: 'Round Robin - Agents take turns', value: 'round-robin' },
-                    { name: 'Graph - Custom workflow with dependencies', value: 'graph' },
                     {
                         name: 'Selector - AI chooses the next agent (can add graph constraints)',
                         value: 'selector',

package/dist/commands/install/index.js

@@ -5,7 +5,7 @@ import inquirer from 'inquirer';
 import { showNoClusterError } from '../../lib/startup.js';
 import output from '../../lib/output.js';
 import { getInstallableServices, arkDependencies, arkServices, } from '../../arkServices.js';
-import { isMarketplaceService, getMarketplaceItem, getAllMarketplaceServices, getAllMarketplaceAgents, } from '../../marketplaceServices.js';
+import { isMarketplaceService, getMarketplaceItem, getAllMarketplaceServices, getAllMarketplaceAgents, getAllMarketplaceExecutors, } from '../../marketplaceServices.js';
 import { printNextSteps } from '../../lib/nextSteps.js';
 import ora from 'ora';
 import { waitForServicesReady, } from '../../lib/waitForReady.js';
@@ -95,7 +95,13 @@ export async function installArk(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);
@@ -137,39 +143,35 @@ export async function installArk(config, serviceName, options = {}) {
     }
     // If not using -y flag, show checklist interface
     if (!options.yes) {
-        console.log(chalk.cyan.bold('\nSelect components to install:'));
-        console.log(chalk.gray('Use arrow keys to navigate, space to toggle, enter to confirm\n'));
-        // Build choices for the checkbox prompt
         const coreServices = Object.values(arkServices)
             .filter((s) => s.category === 'core')
             .sort((a, b) => a.name.localeCompare(b.name));
         const otherServices = Object.values(arkServices)
             .filter((s) => s.category === 'service')
             .sort((a, b) => a.name.localeCompare(b.name));
-        const allChoices = [
-            new inquirer.Separator(chalk.bold('──── Dependencies ────')),
-            {
-                name: `cert-manager ${chalk.gray('- Certificate management')}`,
-                value: 'cert-manager',
-                checked: true,
-            },
-            {
-                name: `gateway-api ${chalk.gray('- Gateway API CRDs')}`,
-                value: 'gateway-api',
-                checked: true,
-            },
-            new inquirer.Separator(chalk.bold('──── Ark Core ────')),
-            ...coreServices.map((service) => ({
+        const mandatoryServiceNames = [...coreServices, ...otherServices]
+            .filter((s) => s.mandatory)
+            .map((s) => s.helmReleaseName);
+        console.log(chalk.cyan.bold('\nSelect components to install:'));
+        console.log(chalk.gray('Use arrow keys to navigate, space to toggle, enter to confirm\n'));
+        const formatServiceChoice = (service) => {
+            if (service.mandatory) {
+                return new inquirer.Separator(`${chalk.dim.green('◉')} ${chalk.dim(`${service.name} - ${service.description}`)}`);
+            }
+            return {
                 name: `${service.name} ${chalk.gray(`- ${service.description}`)}`,
                 value: service.helmReleaseName,
                 checked: Boolean(service.enabled),
-            })),
+            };
+        };
+        const allChoices = [
+            new inquirer.Separator(chalk.bold('──── Dependencies ────')),
+            new inquirer.Separator(`${chalk.dim.green('◉')} ${chalk.dim('cert-manager - Certificate management')}`),
+            new inquirer.Separator(`${chalk.dim.green('◉')} ${chalk.dim('gateway-api - Gateway API CRDs')}`),
+            new inquirer.Separator(chalk.bold('──── Ark Core ────')),
+            ...coreServices.map(formatServiceChoice),
             new inquirer.Separator(chalk.bold('──── Ark Services ────')),
-            ...otherServices.map((service) => ({
-                name: `${service.name} ${chalk.gray(`- ${service.description}`)}`,
-                value: service.helmReleaseName,
-                checked: Boolean(service.enabled),
-            })),
+            ...otherServices.map(formatServiceChoice),
         ];
         let selectedComponents;
         try {
@@ -182,11 +184,12 @@ export async function installArk(config, serviceName, options = {}) {
                     pageSize: 15,
                 },
             ]);
-            selectedComponents = answers.components;
-            if (selectedComponents.length === 0) {
-                output.warning('No components selected. Exiting.');
-                process.exit(0);
-            }
+            selectedComponents = [
+                'cert-manager',
+                'gateway-api',
+                ...mandatoryServiceNames,
+                ...answers.components,
+            ];
         }
         catch (error) {
             // Handle Ctrl-C gracefully

package/dist/commands/marketplace/index.js

@@ -1,7 +1,7 @@
 import { Command } from 'commander';
 import chalk from 'chalk';
 import { getMarketplaceRepoUrl, getMarketplaceRegistry, } from '../../lib/config.js';
-import { getAllMarketplaceServices, getAllMarketplaceAgents, } from '../../marketplaceServices.js';
+import { getAllMarketplaceServices, getAllMarketplaceAgents, getAllMarketplaceExecutors, } from '../../marketplaceServices.js';
 import { fetchMarketplaceManifest } from '../../lib/marketplaceFetcher.js';
 function createMarketplaceCommand(_config) {
     const repoUrl = getMarketplaceRepoUrl();
@@ -18,19 +18,21 @@ Registry: ${chalk.cyan(registry.replace('oci://', ''))}
 `)
         .addHelpText('after', `
 ${chalk.cyan('Examples:')}
-  ${chalk.yellow('ark marketplace list')}                        # List available services and agents
+  ${chalk.yellow('ark marketplace list')}                        # List available marketplace items
   ${chalk.yellow('ark install marketplace/services/phoenix')}    # Install Phoenix service
   ${chalk.yellow('ark install marketplace/agents/noah')}         # Install Noah agent
+  ${chalk.yellow('ark install marketplace/executors/langchain')} # Install LangChain executor
   ${chalk.yellow('ark uninstall marketplace/services/phoenix')}  # Uninstall Phoenix
 `);
     // List command
     const list = new Command('list');
     list
         .alias('ls')
-        .description('List available marketplace services and agents')
+        .description('List available marketplace items')
         .action(async () => {
         const services = await getAllMarketplaceServices();
         const agents = await getAllMarketplaceAgents();
+        const executors = await getAllMarketplaceExecutors();
         const manifest = await fetchMarketplaceManifest();
         console.log(chalk.blue('\n🏪 ARK Marketplace\n'));
         if (!manifest) {
@@ -68,6 +70,19 @@ ${chalk.cyan('Examples:')}
                 console.log();
             }
         }
+        if (executors && Object.keys(executors).length > 0) {
+            console.log(chalk.bold('Executors:'));
+            console.log(chalk.gray('Install with: ark install marketplace/executors/<name>\n'));
+            for (const [key, executor] of Object.entries(executors)) {
+                const icon = '⚙️';
+                const executorName = `marketplace/executors/${key.padEnd(12)}`;
+                const executorDesc = executor.description;
+                console.log(`${icon} ${chalk.green(executorName)} ${chalk.gray(executorDesc)}`);
+                const namespaceInfo = `namespace: ${executor.namespace || 'default'}`;
+                console.log(`   ${chalk.dim(namespaceInfo)}`);
+                console.log();
+            }
+        }
         console.log(chalk.cyan(`Repository: ${repoUrl}`));
         console.log(chalk.cyan(`Registry: ${registry}`));
         console.log();

package/dist/commands/models/create.js

@@ -59,6 +59,7 @@ export async function createModel(modelName, options = {}) {
                 choices: [
                     { name: 'Azure OpenAI', value: 'azure' },
                     { name: 'OpenAI', value: 'openai' },
+                    { name: 'Anthropic', value: 'anthropic' },
                     { name: 'AWS Bedrock', value: 'bedrock' },
                 ],
                 default: 'azure',

package/dist/commands/models/kubernetes/manifest-builder.js

@@ -79,6 +79,28 @@ export class KubernetesModelManifestBuilder {
                 },
             };
         }
+        if (config.type === 'anthropic') {
+            const anthropicConfig = config;
+            const anthropic = {
+                apiKey: {
+                    valueFrom: {
+                        secretKeyRef: {
+                            name: config.secretName,
+                            key: 'api-key',
+                        },
+                    },
+                },
+                baseUrl: {
+                    value: anthropicConfig.baseUrl,
+                },
+            };
+            if (anthropicConfig.version) {
+                anthropic.version = {
+                    value: anthropicConfig.version,
+                };
+            }
+            return { anthropic };
+        }
         throw new Error(`Unknown provider type: ${config.type}`);
     }
     buildBedrockConfig(config) {

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

@@ -0,0 +1,15 @@
+import { BaseProviderConfig, BaseCollectorOptions, ProviderConfigCollector } from './types.js';
+export interface AnthropicConfig extends BaseProviderConfig {
+    type: 'anthropic';
+    baseUrl: string;
+    apiKey: string;
+    version?: string;
+}
+export interface AnthropicCollectorOptions extends BaseCollectorOptions {
+    baseUrl?: string;
+    apiKey?: string;
+    version?: string;
+}
+export declare class AnthropicConfigCollector implements ProviderConfigCollector {
+    collectConfig(options: BaseCollectorOptions): Promise<AnthropicConfig>;
+}

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

@@ -0,0 +1,72 @@
+import inquirer from 'inquirer';
+export class AnthropicConfigCollector {
+    async collectConfig(options) {
+        const anthropicOptions = options;
+        let baseUrl = anthropicOptions.baseUrl;
+        if (!baseUrl) {
+            const answer = await inquirer.prompt([
+                {
+                    type: 'input',
+                    name: 'baseUrl',
+                    message: 'base URL:',
+                    validate: (input) => {
+                        if (!input)
+                            return 'base URL is required';
+                        try {
+                            new URL(input);
+                            return true;
+                        }
+                        catch {
+                            return 'please enter a valid URL';
+                        }
+                    },
+                },
+            ]);
+            baseUrl = answer.baseUrl;
+        }
+        if (!baseUrl) {
+            throw new Error('base URL is required');
+        }
+        baseUrl = baseUrl.replace(/\/$/, '');
+        let apiKey = anthropicOptions.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');
+        }
+        let version = anthropicOptions.version;
+        if (!version) {
+            const answer = await inquirer.prompt([
+                {
+                    type: 'input',
+                    name: 'version',
+                    message: 'anthropic version:',
+                    default: '2023-06-01',
+                },
+            ]);
+            version = answer.version;
+        }
+        return {
+            type: 'anthropic',
+            modelValue: options.model,
+            secretName: '',
+            baseUrl,
+            apiKey,
+            ...(version ? { version } : {}),
+        };
+    }
+}

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);

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';
@@ -470,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) => {
@@ -558,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/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,33 +1,39 @@
-import OpenAI from 'openai';
 export class ArkApiClient {
-    openai;
     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) {
@@ -141,21 +147,32 @@ export class ArkApiClient {
             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());
     }
 }