@agents-at-scale/ark 0.1.55 → 0.1.57

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

package/dist/lib/chatClient.js

@@ -7,120 +7,154 @@ export class ChatClient {
     async getQueryTargets() {
         return await this.arkApiClient.getQueryTargets();
     }
-    /**
-     * Send a chat completion request
-     */
     async sendMessage(targetId, messages, config, onChunk, signal) {
-        const shouldStream = config.streamingEnabled && !!onChunk;
-        const params = {
-            model: targetId,
-            messages: messages,
-            signal: signal,
-        };
-        // Build metadata object - only add if we have something to include
-        if (config.sessionId ||
-            config.conversationId ||
-            config.a2aContextId ||
-            config.queryTimeout) {
-            params.metadata = {};
-            if (config.sessionId) {
-                params.metadata.sessionId = config.sessionId;
-            }
-            if (config.conversationId) {
-                params.metadata.conversationId = config.conversationId;
-            }
-            if (config.queryTimeout) {
-                params.metadata.timeout = config.queryTimeout;
-            }
-            // Add A2A context ID to queryAnnotations (goes to annotations)
-            if (config.a2aContextId) {
-                const queryAnnotations = {
-                    [QUERY_ANNOTATIONS.A2A_CONTEXT_ID]: config.a2aContextId,
-                };
-                params.metadata.queryAnnotations = JSON.stringify(queryAnnotations);
-            }
+        const parts = targetId.split('/');
+        const targetType = parts[0] || 'agent';
+        const targetName = parts.slice(1).join('/') || targetId;
+        const lastUserMessage = messages.filter(m => m.role === 'user').pop();
+        const input = lastUserMessage?.content || '';
+        const annotations = {};
+        if (config.a2aContextId) {
+            annotations[QUERY_ANNOTATIONS.A2A_CONTEXT_ID] = config.a2aContextId;
         }
-        if (shouldStream) {
-            let fullResponse = '';
-            const toolCallsById = new Map();
-            const stream = this.arkApiClient.createChatCompletionStream(params);
-            for await (const chunk of stream) {
-                if (signal?.aborted) {
-                    break;
+        if (config.streamingEnabled && onChunk) {
+            annotations['ark.mckinsey.com/streaming-enabled'] = 'true';
+        }
+        const queryResult = await this.arkApiClient.createQuery({
+            input,
+            target: { type: targetType, name: targetName },
+            sessionId: config.sessionId,
+            conversationId: config.conversationId,
+            timeout: config.queryTimeout,
+            ...(Object.keys(annotations).length > 0
+                ? { metadata: { annotations } }
+                : {}),
+        });
+        const queryName = queryResult.name;
+        if (!queryName) {
+            throw new Error('Query creation did not return a name');
+        }
+        if (config.streamingEnabled && onChunk) {
+            return await this.pollStreamResponse(queryName, onChunk, signal);
+        }
+        else {
+            return await this.pollResponse(queryName, onChunk, signal);
+        }
+    }
+    async pollResponse(queryName, onChunk, signal) {
+        while (!signal?.aborted) {
+            const query = (await this.arkApiClient.getQuery(queryName));
+            const phase = query.status?.phase;
+            if (phase === 'done' || phase === 'error' || phase === 'canceled') {
+                const content = query.status?.response?.content || '';
+                let toolCalls;
+                if (query.status?.response?.raw) {
+                    try {
+                        const rawMessages = JSON.parse(query.status.response.raw);
+                        for (const msg of rawMessages) {
+                            if (msg.tool_calls && msg.tool_calls.length > 0) {
+                                toolCalls = msg.tool_calls.map(tc => ({
+                                    id: tc.id,
+                                    type: 'function',
+                                    function: tc.function,
+                                }));
+                            }
+                        }
+                    }
+                    catch {
+                        // ignore parse errors
+                    }
                 }
-                const delta = chunk.choices?.[0]?.delta;
-                // Extract ARK metadata if present
-                const arkMetadata = chunk.ark;
-                const content = delta?.content || '';
-                if (content) {
-                    fullResponse += content;
+                if (toolCalls && onChunk) {
+                    onChunk('', toolCalls, undefined);
                 }
-                if (onChunk) {
-                    onChunk(content, undefined, arkMetadata);
+                if (content && onChunk) {
+                    onChunk(content, undefined, undefined);
                 }
-                if (!fullResponse &&
-                    arkMetadata?.completedQuery?.status?.response?.content) {
-                    const responseContent = arkMetadata.completedQuery.status.response.content;
-                    fullResponse = responseContent;
-                    if (onChunk) {
-                        onChunk(responseContent, undefined, arkMetadata);
-                    }
+                if (phase === 'error') {
+                    throw new Error(content || 'Query failed');
                 }
-                // Handle tool calls
-                if (delta?.tool_calls) {
-                    for (const toolCallDelta of delta.tool_calls) {
-                        const index = toolCallDelta.index;
-                        // Initialize tool call if this is the first chunk for this index
-                        if (!toolCallsById.has(index)) {
-                            toolCallsById.set(index, {
-                                id: toolCallDelta.id || '',
-                                type: toolCallDelta.type || 'function',
-                                function: {
-                                    name: toolCallDelta.function?.name || '',
-                                    arguments: '',
-                                },
-                            });
-                        }
-                        // Accumulate function arguments
-                        const toolCall = toolCallsById.get(index);
-                        if (toolCallDelta.function?.arguments) {
-                            toolCall.function.arguments += toolCallDelta.function.arguments;
+                return content;
+            }
+            await new Promise(resolve => setTimeout(resolve, 1000));
+        }
+        return '';
+    }
+    async pollStreamResponse(queryName, onChunk, signal) {
+        const baseUrl = this.arkApiClient.getBaseUrl();
+        const response = await fetch(`${baseUrl}/v1/broker/chunks?watch=true&query-id=${queryName}`, { signal });
+        if (!response.ok) {
+            return await this.pollResponse(queryName, onChunk, signal);
+        }
+        const reader = response.body?.getReader();
+        if (!reader) {
+            return await this.pollResponse(queryName, onChunk, signal);
+        }
+        const decoder = new TextDecoder();
+        let buffer = '';
+        let fullResponse = '';
+        const toolCallsById = new Map();
+        try {
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done)
+                    break;
+                buffer += decoder.decode(value, { stream: true });
+                const lines = buffer.split('\n\n');
+                buffer = lines.pop() || '';
+                for (const line of lines) {
+                    const trimmed = line.trim();
+                    if (!trimmed || !trimmed.startsWith('data:'))
+                        continue;
+                    const data = trimmed.substring(5).trim();
+                    if (data === '[DONE]')
+                        continue;
+                    let chunk;
+                    try {
+                        chunk = JSON.parse(data);
+                    }
+                    catch {
+                        continue;
+                    }
+                    const arkMetadata = chunk.ark;
+                    const choices = chunk.choices;
+                    const delta = choices?.[0]?.delta;
+                    const content = delta?.content || '';
+                    if (content) {
+                        fullResponse += content;
+                        onChunk(content, undefined, arkMetadata);
+                    }
+                    if (delta?.tool_calls) {
+                        for (const tc of delta.tool_calls) {
+                            if (!toolCallsById.has(tc.index)) {
+                                toolCallsById.set(tc.index, {
+                                    id: tc.id || '',
+                                    type: 'function',
+                                    function: { name: tc.function?.name || '', arguments: '' },
+                                });
+                            }
+                            const existing = toolCallsById.get(tc.index);
+                            if (tc.function?.arguments) {
+                                existing.function.arguments += tc.function.arguments;
+                            }
+                            onChunk('', Array.from(toolCallsById.values()), arkMetadata);
                         }
-                        // Send the current state of all tool calls
-                        if (onChunk) {
-                            const toolCallsArray = Array.from(toolCallsById.values());
-                            onChunk('', toolCallsArray, arkMetadata);
+                    }
+                    if (!fullResponse &&
+                        arkMetadata?.completedQuery) {
+                        const completed = arkMetadata.completedQuery;
+                        const responseContent = completed?.status?.response?.content;
+                        if (responseContent) {
+                            fullResponse = responseContent;
+                            onChunk(responseContent, undefined, arkMetadata);
                         }
                     }
                 }
             }
-            return fullResponse;
         }
-        else {
-            const response = await this.arkApiClient.createChatCompletion(params);
-            const message = response.choices[0]?.message;
-            const content = message?.content || '';
-            const arkMetadata = response.ark;
-            // Handle tool calls in non-streaming mode
-            if (message?.tool_calls && message.tool_calls.length > 0) {
-                const toolCalls = message.tool_calls.map((tc) => ({
-                    id: tc.id,
-                    type: tc.type || 'function',
-                    function: {
-                        name: tc.function?.name || '',
-                        arguments: tc.function?.arguments || '',
-                    },
-                }));
-                // Send tool calls first
-                if (onChunk) {
-                    onChunk('', toolCalls, arkMetadata);
-                }
-            }
-            // Send content after tool calls
-            if (content && onChunk) {
-                onChunk(content, undefined, arkMetadata);
-            }
-            return content;
+        finally {
+            reader.releaseLock();
         }
+        return fullResponse;
     }
 }

package/dist/lib/errors.d.ts

@@ -6,7 +6,6 @@ export declare const ExitCodes: {
     readonly CliError: 1;
     readonly OperationError: 2;
     readonly Timeout: 3;
-    readonly EvaluationFailed: 4;
 };
 export declare enum ErrorCode {
     INVALID_INPUT = "INVALID_INPUT",

package/dist/lib/errors.js

@@ -8,7 +8,6 @@ export const ExitCodes = {
     CliError: 1,
     OperationError: 2,
     Timeout: 3,
-    EvaluationFailed: 4,
 };
 export var ErrorCode;
 (function (ErrorCode) {

package/dist/lib/marketplaceFetcher.d.ts

@@ -4,3 +4,4 @@ export declare function fetchMarketplaceManifest(): Promise<AnthropicMarketplace
 export declare function mapMarketplaceItemToArkService(item: AnthropicMarketplaceItem, registry?: string): ArkService;
 export declare function getMarketplaceServicesFromManifest(): Promise<ServiceCollection | null>;
 export declare function getMarketplaceAgentsFromManifest(): Promise<ServiceCollection | null>;
+export declare function getMarketplaceExecutorsFromManifest(): Promise<ServiceCollection | null>;

package/dist/lib/marketplaceFetcher.js

@@ -78,3 +78,20 @@ export async function getMarketplaceAgentsFromManifest() {
     }
     return Object.keys(agents).length > 0 ? agents : null;
 }
+export async function getMarketplaceExecutorsFromManifest() {
+    const manifest = await fetchMarketplaceManifest();
+    if (!manifest || !manifest.items) {
+        return null;
+    }
+    const executors = {};
+    for (const item of manifest.items) {
+        if (item.ark && item.type === 'executor') {
+            const executorName = item.name
+                .toLowerCase()
+                .replace(/[^a-z0-9-]/g, '-')
+                .replace(/^-+|-+$/g, '');
+            executors[executorName] = mapMarketplaceItemToArkService(item);
+        }
+    }
+    return Object.keys(executors).length > 0 ? executors : null;
+}

package/dist/lib/types.d.ts

@@ -136,41 +136,3 @@ export interface ClusterInfo {
     user?: string;
     namespace?: string;
 }
-export interface EvaluationManifest {
-    apiVersion: string;
-    kind: 'Evaluation';
-    metadata: {
-        name: string;
-    };
-    spec: {
-        type: 'direct' | 'query';
-        evaluator: {
-            name: string;
-        };
-        config: {
-            input?: string;
-            output?: string;
-            queryRef?: {
-                name: string;
-            };
-            responseTarget?: {
-                type: string;
-                name: string;
-            };
-        };
-        timeout?: string;
-        ttl?: string;
-    };
-}
-export interface EvaluationStatus {
-    phase?: 'pending' | 'running' | 'done' | 'error';
-    score?: string;
-    passed?: boolean;
-    message?: string;
-}
-export interface Evaluation {
-    metadata: {
-        name: string;
-    };
-    status?: EvaluationStatus;
-}

package/dist/marketplaceServices.d.ts

@@ -17,7 +17,12 @@ export declare function getAllMarketplaceServices(): Promise<ServiceCollection |
  */
 export declare function getAllMarketplaceAgents(): Promise<ServiceCollection | null>;
 /**
- * Get a marketplace item by path (supports both services and agents)
+ * Get all marketplace executors, fetching from marketplace.json
+ * Returns null if marketplace is unavailable
+ */
+export declare function getAllMarketplaceExecutors(): Promise<ServiceCollection | null>;
+/**
+ * Get a marketplace item by path (supports services, agents, and executors)
  * Returns null if marketplace is unavailable
  */
 export declare function getMarketplaceItem(path: string): Promise<ArkService | undefined | null>;

package/dist/marketplaceServices.js

@@ -5,7 +5,7 @@
  *
  * Supports Anthropic Marketplace JSON format for dynamic enumeration
  */
-import { getMarketplaceServicesFromManifest, getMarketplaceAgentsFromManifest, } from './lib/marketplaceFetcher.js';
+import { getMarketplaceServicesFromManifest, getMarketplaceAgentsFromManifest, getMarketplaceExecutorsFromManifest, } from './lib/marketplaceFetcher.js';
 /**
  * Get all marketplace services, fetching from marketplace.json
  * Returns null if marketplace is unavailable
@@ -21,7 +21,14 @@ export async function getAllMarketplaceAgents() {
     return await getMarketplaceAgentsFromManifest();
 }
 /**
- * Get a marketplace item by path (supports both services and agents)
+ * Get all marketplace executors, fetching from marketplace.json
+ * Returns null if marketplace is unavailable
+ */
+export async function getAllMarketplaceExecutors() {
+    return await getMarketplaceExecutorsFromManifest();
+}
+/**
+ * Get a marketplace item by path (supports services, agents, and executors)
  * Returns null if marketplace is unavailable
  */
 export async function getMarketplaceItem(path) {
@@ -41,9 +48,18 @@ export async function getMarketplaceItem(path) {
         }
         return agents[name];
     }
+    if (path.startsWith('marketplace/executors/')) {
+        const name = path.replace(/^marketplace\/executors\//, '');
+        const executors = await getAllMarketplaceExecutors();
+        if (!executors) {
+            return null;
+        }
+        return executors[name];
+    }
     return undefined;
 }
 export function isMarketplaceService(name) {
     return (name.startsWith('marketplace/services/') ||
-        name.startsWith('marketplace/agents/'));
+        name.startsWith('marketplace/agents/') ||
+        name.startsWith('marketplace/executors/'));
 }

package/dist/types/arkService.d.ts

@@ -7,6 +7,7 @@ export interface ArkService {
     helmReleaseName: string;
     description: string;
     enabled: boolean;
+    mandatory?: boolean;
     category: string;
     namespace?: string;
     chartPath?: string;

package/dist/types/marketplace.d.ts

@@ -2,7 +2,7 @@ export interface AnthropicMarketplaceItem {
     name: string;
     displayName?: string;
     description: string;
-    type?: 'service' | 'agent';
+    type?: 'service' | 'agent' | 'executor';
     version?: string;
     author?: string;
     homepage?: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agents-at-scale/ark",
-  "version": "0.1.55",
+  "version": "0.1.57",
   "description": "Ark CLI - Interactive terminal interface for ARK agents",
   "main": "dist/index.js",
   "type": "module",
@@ -58,8 +58,8 @@
     "marked": "^15.0.12",
     "marked-terminal": "^7.3.0",
     "open": "^10.2.0",
-    "openai": "^5.19.1",
     "ora": "^8.2.0",
+    "picomatch": "4.0.4",
     "react": "^19.1.5",
     "yaml": "^2.6.1"
   },
@@ -87,6 +87,8 @@
   "overrides": {
     "minimatch": "^10.2.3",
     "rollup": "4.59.0",
-    "hono": "^4.12.2"
+    "hono": "^4.12.4",
+    "@hono/node-server": "^1.19.10",
+    "flatted": "^3.4.2"
   }
 }