@agents-at-scale/ark 0.1.43 → 0.1.44

package/dist/arkServices.js

@@ -119,6 +119,18 @@ const defaultArkServices = {
         k8sDeploymentName: 'ark-mcp',
         k8sDevDeploymentName: 'ark-mcp-devspace',
     },
+    'ark-cluster-memory': {
+        name: 'ark-cluster-memory',
+        helmReleaseName: 'ark-cluster-memory',
+        description: 'In-memory storage service with streaming support for Ark queries',
+        enabled: true,
+        category: 'service',
+        // namespace: undefined - uses current context namespace
+        chartPath: `${REGISTRY_BASE}/ark-cluster-memory`,
+        installArgs: [],
+        k8sDeploymentName: 'ark-cluster-memory',
+        k8sDevDeploymentName: 'ark-cluster-memory-devspace',
+    },
     'mcp-filesystem': {
         name: 'mcp-filesystem',
         helmReleaseName: 'mcp-filesystem',
@@ -131,15 +143,6 @@ const defaultArkServices = {
         k8sDeploymentName: 'mcp-filesystem',
         k8sDevDeploymentName: 'mcp-filesystem-devspace',
     },
-    'agents-at-scale': {
-        name: 'agents-at-scale',
-        helmReleaseName: 'agents-at-scale',
-        description: 'Agents @ Scale Platform',
-        enabled: false,
-        category: 'service',
-        chartPath: 'oci://ghcr.io/mck-private/qb-fm-labs-legacyx/charts/legacyx',
-        installArgs: [],
-    },
     'localhost-gateway': {
         name: 'localhost-gateway',
         helmReleaseName: 'localhost-gateway',

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

@@ -727,16 +727,16 @@ Generated with ARK CLI generator`;
             },
         ];
         if (config.projectType === 'empty') {
-            steps.push({ desc: 'Add YAML files to agents/, teams/, queries/ directories' }, { desc: 'Copy model configurations from samples/models/' }, { desc: 'Edit .env file to set your API keys' }, { desc: 'Deploy your project', cmd: 'make quickstart' });
+            steps.push({ desc: 'Add YAML files to agents/, teams/, queries/ directories' }, { desc: 'Copy model configurations from samples/models/' }, { desc: 'Edit .env file to set your API keys' }, { desc: 'Deploy your project', cmd: 'devspace dev' });
         }
         else if (config.selectedModels && config.selectedModels !== 'none') {
-            steps.push({ desc: 'Edit .env file to set your API keys' }, { desc: 'Load environment variables', cmd: 'source .env' }, { desc: 'Deploy your project', cmd: 'make quickstart' }, {
+            steps.push({ desc: 'Edit .env file to set your API keys' }, { desc: 'Load environment variables', cmd: 'source .env' }, { desc: 'Deploy your project', cmd: 'devspace dev' }, {
                 desc: 'Test your deployment',
                 cmd: `kubectl get query sample-team-query -w --namespace ${config.namespace}`,
             });
         }
         else {
-            steps.push({ desc: 'Copy model configurations from samples/models/' }, { desc: 'Edit .env file to set your API keys' }, { desc: 'Deploy your project', cmd: 'make quickstart' });
+            steps.push({ desc: 'Copy model configurations from samples/models/' }, { desc: 'Edit .env file to set your API keys' }, { desc: 'Deploy your project', cmd: 'devspace dev' });
         }
         console.log(chalk.magenta.bold('🚀 NEXT STEPS:\n'));
         let stepNumber = 1;

package/dist/commands/generate/index.js

@@ -56,7 +56,7 @@ ${chalk.cyan('Getting started:')}
   1. ${chalk.yellow('ark generate project my-first-project')}  # Create project
   2. ${chalk.yellow('cd my-first-project')}                   # Enter directory
   3. ${chalk.yellow('source .env')}                          # Set environment
-  4. ${chalk.yellow('make quickstart')}                     # Deploy to cluster
+  4. ${chalk.yellow('devspace dev')}                         # Deploy to cluster
 `);
     // Register generators
     const generators = new Map();
@@ -345,7 +345,7 @@ ${chalk.cyan('Use Cases:')}
         console.log(chalk.cyan('\n📖 Quick Start:'));
         console.log(chalk.gray('  1. ark generate project my-first-project'));
         console.log(chalk.gray('  2. cd my-first-project && source .env'));
-        console.log(chalk.gray('  3. make quickstart'));
+        console.log(chalk.gray('  3. devspace dev'));
         console.log(chalk.cyan('\n🔧 Usage:'));
         console.log(chalk.gray('  ark generate <type> [name] [options]'));
         console.log(chalk.gray('  ark g <type> [name] [options]'));

package/dist/commands/query/index.js

@@ -9,6 +9,7 @@ export function createQueryCommand(_) {
         .argument('<target>', 'Query target (e.g., model/default, agent/my-agent)')
         .argument('<message>', 'Message to send')
         .option('-o, --output <format>', 'Output format: yaml, json, or name (prints only resource name)')
+        .option('--session-id <sessionId>', 'Session ID to associate with the query for conversation continuity')
         .action(async (target, message, options) => {
         const parsed = parseTarget(target);
         if (!parsed) {
@@ -20,6 +21,7 @@ export function createQueryCommand(_) {
             targetName: parsed.name,
             message,
             outputFormat: options.output,
+            sessionId: options.sessionId,
         });
     });
     return queryCommand;

package/dist/commands/query/index.spec.js

@@ -68,6 +68,30 @@ describe('createQueryCommand', () => {
             outputFormat: 'json',
         });
     });
+    it('should pass session-id option to executeQuery', async () => {
+        mockParseTarget.mockReturnValue({
+            type: 'agent',
+            name: 'test-agent',
+        });
+        mockExecuteQuery.mockResolvedValue(undefined);
+        const command = createQueryCommand({});
+        await command.parseAsync([
+            'node',
+            'test',
+            'agent/test-agent',
+            'Hello world',
+            '--session-id',
+            'my-session-123',
+        ]);
+        expect(mockParseTarget).toHaveBeenCalledWith('agent/test-agent');
+        expect(mockExecuteQuery).toHaveBeenCalledWith({
+            targetType: 'agent',
+            targetName: 'test-agent',
+            message: 'Hello world',
+            outputFormat: undefined,
+            sessionId: 'my-session-123',
+        });
+    });
     it('should error on invalid target format', async () => {
         mockParseTarget.mockReturnValue(null);
         const command = createQueryCommand({});

package/dist/components/ChatUI.js

@@ -61,6 +61,8 @@ const ChatUI = ({ initialTargetId, arkApiClient, arkApiProxy, config, }) => {
         streamingEnabled: config?.chat?.streaming ?? true,
         currentTarget: undefined,
     });
+    // Track A2A context ID for conversation continuity using ref
+    const a2aContextIdRef = React.useRef(undefined);
     React.useEffect(() => {
         if (showAgentSelector && agents.length === 0) {
             setSelectorLoading(true);
@@ -330,11 +332,13 @@ const ChatUI = ({ initialTargetId, arkApiClient, arkApiProxy, config, }) => {
         if (value.startsWith('/reset')) {
             // Clear all messages
             setMessages([]);
+            // Clear A2A context ID
+            a2aContextIdRef.current = undefined;
             // Add system message to show the reset
             const systemMessage = {
                 id: generateMessageId(),
                 type: 'system',
-                content: 'Message history cleared',
+                content: 'Message history and A2A context cleared',
                 timestamp: new Date(),
                 command: '/reset',
             };
@@ -462,7 +466,13 @@ const ChatUI = ({ initialTargetId, arkApiClient, arkApiProxy, config, }) => {
                 setMessages((prev) => [...prev, agentMessage]);
             }
             // Send message and get response with abort signal
-            const fullResponse = await chatClientRef.current.sendMessage(target.id, apiMessages, chatConfig, (chunk, toolCalls, arkMetadata) => {
+            const fullResponse = await chatClientRef.current.sendMessage(target.id, apiMessages, { ...chatConfig, a2aContextId: a2aContextIdRef.current }, (chunk, toolCalls, arkMetadata) => {
+                // Extract A2A context ID from first response
+                // Chat TUI always queries a single target, so contextId is in responses[0]
+                if (arkMetadata?.completedQuery?.status?.responses?.[0]?.a2a?.contextId) {
+                    a2aContextIdRef.current =
+                        arkMetadata.completedQuery.status.responses[0].a2a.contextId;
+                }
                 // Update message progressively as chunks arrive
                 setMessages((prev) => {
                     const newMessages = [...prev];

package/dist/lib/chatClient.d.ts

@@ -1,8 +1,11 @@
 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;
 }
 export interface ToolCall {
     id: string;
@@ -18,6 +21,7 @@ export interface ArkMetadata {
     model?: string;
     query?: string;
     target?: string;
+    completedQuery?: Query;
 }
 export declare class ChatClient {
     private arkApiClient;

package/dist/lib/chatClient.js

@@ -1,3 +1,4 @@
+import { QUERY_ANNOTATIONS } from './constants.js';
 export class ChatClient {
     constructor(arkApiClient) {
         this.arkApiClient = arkApiClient;
@@ -15,6 +16,21 @@ export class ChatClient {
             messages: messages,
             signal: signal,
         };
+        // Build metadata object - only add if we have something to include
+        if (config.sessionId || config.a2aContextId) {
+            params.metadata = {};
+            // Add sessionId directly to metadata (goes to spec, not annotations)
+            if (config.sessionId) {
+                params.metadata.sessionId = config.sessionId;
+            }
+            // 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);
+            }
+        }
         if (shouldStream) {
             let fullResponse = '';
             const toolCallsById = new Map();
@@ -23,16 +39,15 @@ export class ChatClient {
                 if (signal?.aborted) {
                     break;
                 }
-                const delta = chunk.choices[0]?.delta;
+                const delta = chunk.choices?.[0]?.delta;
                 // Extract ARK metadata if present
                 const arkMetadata = chunk.ark;
-                // Handle regular content
                 const content = delta?.content || '';
                 if (content) {
                     fullResponse += content;
-                    if (onChunk) {
-                        onChunk(content, undefined, arkMetadata);
-                    }
+                }
+                if (onChunk) {
+                    onChunk(content, undefined, arkMetadata);
                 }
                 // Handle tool calls
                 if (delta?.tool_calls) {
@@ -68,6 +83,7 @@ export class ChatClient {
             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) => ({
@@ -80,12 +96,12 @@ export class ChatClient {
                 }));
                 // Send tool calls first
                 if (onChunk) {
-                    onChunk('', toolCalls);
+                    onChunk('', toolCalls, arkMetadata);
                 }
             }
             // Send content after tool calls
             if (content && onChunk) {
-                onChunk(content);
+                onChunk(content, undefined, arkMetadata);
             }
             return content;
         }

package/dist/lib/chatClient.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/lib/chatClient.spec.js

@@ -0,0 +1,108 @@
+import { jest } from '@jest/globals';
+import { QUERY_ANNOTATIONS } from './constants.js';
+const mockCreateChatCompletion = jest.fn();
+const mockArkApiClient = {
+    createChatCompletion: mockCreateChatCompletion,
+    createChatCompletionStream: jest.fn(),
+    getQueryTargets: jest.fn(),
+};
+const { ChatClient } = await import('./chatClient.js');
+describe('ChatClient', () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+    describe('sendMessage', () => {
+        it('should include sessionId directly in metadata when provided', async () => {
+            const client = new ChatClient(mockArkApiClient);
+            mockCreateChatCompletion.mockResolvedValue({
+                id: 'test-id',
+                object: 'chat.completion',
+                created: 1234567890,
+                model: 'test-model',
+                choices: [
+                    {
+                        index: 0,
+                        message: { role: 'assistant', content: 'Hello' },
+                        finish_reason: 'stop',
+                    },
+                ],
+                usage: {
+                    prompt_tokens: 10,
+                    completion_tokens: 5,
+                    total_tokens: 15,
+                },
+            });
+            await client.sendMessage('agent/test-agent', [{ role: 'user', content: 'Hello' }], { streamingEnabled: false, sessionId: 'test-session-123' });
+            expect(mockCreateChatCompletion).toHaveBeenCalledWith(expect.objectContaining({
+                model: 'agent/test-agent',
+                messages: [{ role: 'user', content: 'Hello' }],
+                metadata: {
+                    sessionId: 'test-session-123',
+                },
+            }));
+        });
+        it('should include both sessionId in metadata and a2aContextId in queryAnnotations when both provided', async () => {
+            const client = new ChatClient(mockArkApiClient);
+            mockCreateChatCompletion.mockResolvedValue({
+                id: 'test-id',
+                object: 'chat.completion',
+                created: 1234567890,
+                model: 'test-model',
+                choices: [
+                    {
+                        index: 0,
+                        message: { role: 'assistant', content: 'Hello' },
+                        finish_reason: 'stop',
+                    },
+                ],
+                usage: {
+                    prompt_tokens: 10,
+                    completion_tokens: 5,
+                    total_tokens: 15,
+                },
+            });
+            await client.sendMessage('agent/test-agent', [{ role: 'user', content: 'Hello' }], {
+                streamingEnabled: false,
+                sessionId: 'test-session-123',
+                a2aContextId: 'a2a-context-456',
+            });
+            expect(mockCreateChatCompletion).toHaveBeenCalled();
+            const callArgs = mockCreateChatCompletion.mock.calls[0][0];
+            expect(callArgs.model).toBe('agent/test-agent');
+            expect(callArgs.messages).toEqual([{ role: 'user', content: 'Hello' }]);
+            expect(callArgs.metadata).toBeDefined();
+            expect(callArgs.metadata.sessionId).toBe('test-session-123');
+            expect(callArgs.metadata.queryAnnotations).toBeDefined();
+            const queryAnnotations = JSON.parse(callArgs.metadata.queryAnnotations);
+            expect(queryAnnotations[QUERY_ANNOTATIONS.A2A_CONTEXT_ID]).toBe('a2a-context-456');
+        });
+        it('should not include metadata when neither sessionId nor a2aContextId is provided', async () => {
+            const client = new ChatClient(mockArkApiClient);
+            mockCreateChatCompletion.mockResolvedValue({
+                id: 'test-id',
+                object: 'chat.completion',
+                created: 1234567890,
+                model: 'test-model',
+                choices: [
+                    {
+                        index: 0,
+                        message: { role: 'assistant', content: 'Hello' },
+                        finish_reason: 'stop',
+                    },
+                ],
+                usage: {
+                    prompt_tokens: 10,
+                    completion_tokens: 5,
+                    total_tokens: 15,
+                },
+            });
+            await client.sendMessage('agent/test-agent', [{ role: 'user', content: 'Hello' }], { streamingEnabled: false });
+            expect(mockCreateChatCompletion).toHaveBeenCalledWith(expect.objectContaining({
+                model: 'agent/test-agent',
+                messages: [{ role: 'user', content: 'Hello' }],
+            }));
+            const callArgs = mockCreateChatCompletion.mock.calls[0];
+            expect(callArgs[0].metadata).toBeUndefined();
+        });
+    });
+});

package/dist/lib/constants.d.ts

@@ -0,0 +1,3 @@
+export declare const QUERY_ANNOTATIONS: {
+    readonly A2A_CONTEXT_ID: "ark.mckinsey.com/a2a-context-id";
+};

package/dist/lib/constants.js

@@ -0,0 +1,8 @@
+// ARK annotation prefix - mirrors ark/internal/annotations/annotations.go
+const ARK_PREFIX = 'ark.mckinsey.com/';
+// Query annotation constants for metadata.queryAnnotations
+// Note: sessionId is passed directly in metadata, not in queryAnnotations
+export const QUERY_ANNOTATIONS = {
+    // A2A context ID annotation (goes to K8s annotations)
+    A2A_CONTEXT_ID: `${ARK_PREFIX}a2a-context-id`,
+};

package/dist/lib/executeQuery.d.ts

@@ -10,6 +10,7 @@ export interface QueryOptions {
     watchTimeout?: string;
     verbose?: boolean;
     outputFormat?: string;
+    sessionId?: string;
 }
 export declare function executeQuery(options: QueryOptions): Promise<void>;
 /**

package/dist/lib/executeQuery.js

@@ -27,7 +27,9 @@ export async function executeQuery(options) {
         let lastAgentName;
         let headerShown = false;
         let firstOutput = true;
-        await chatClient.sendMessage(targetId, messages, { streamingEnabled: true }, (chunk, toolCalls, arkMetadata) => {
+        // Get sessionId from option or environment variable
+        const sessionId = options.sessionId || process.env.ARK_SESSION_ID;
+        await chatClient.sendMessage(targetId, messages, { streamingEnabled: true, sessionId }, (chunk, toolCalls, arkMetadata) => {
             if (firstOutput) {
                 spinner.stop();
                 firstOutput = false;
@@ -100,6 +102,9 @@ async function executeQueryWithFormat(options) {
         spec: {
             input: options.message,
             ...(options.timeout && { timeout: options.timeout }),
+            ...((options.sessionId || process.env.ARK_SESSION_ID) && {
+                sessionId: options.sessionId || process.env.ARK_SESSION_ID,
+            }),
             targets: [
                 {
                     type: options.targetType,

package/dist/lib/executeQuery.spec.js

@@ -94,6 +94,18 @@ describe('executeQuery', () => {
             expect(mockArkApiProxyInstance.start).toHaveBeenCalled();
             expect(mockChatClient).toHaveBeenCalled();
             expect(mockSendMessage).toHaveBeenCalledWith('model/default', [{ role: 'user', content: 'Hello' }], { streamingEnabled: true }, expect.any(Function));
+        });
+        it('should pass sessionId to sendMessage when provided', async () => {
+            mockSendMessage.mockImplementation(async (targetId, messages, options, callback) => {
+                callback('Hello', undefined, { agent: 'test-agent' });
+            });
+            await executeQuery({
+                targetType: 'model',
+                targetName: 'default',
+                message: 'Hello',
+                sessionId: 'test-session-123',
+            });
+            expect(mockSendMessage).toHaveBeenCalledWith('model/default', [{ role: 'user', content: 'Hello' }], { streamingEnabled: true, sessionId: 'test-session-123' }, expect.any(Function));
             expect(mockSpinner.stop).toHaveBeenCalled();
             expect(mockArkApiProxyInstance.stop).toHaveBeenCalled();
             expect(mockStdoutWrite).toHaveBeenCalled();
@@ -193,6 +205,36 @@ describe('executeQuery', () => {
             expect(mockExeca).toHaveBeenCalledWith('kubectl', expect.arrayContaining(['wait', '--for=condition=Completed']), expect.any(Object));
             expect(mockConsoleLog).toHaveBeenCalledWith(expect.stringMatching(/cli-query-\d+/));
         });
+        it('should include sessionId in query manifest when outputFormat is specified', async () => {
+            let appliedManifest = '';
+            mockExeca.mockImplementation(async (command, args) => {
+                if (args.includes('apply') && args.includes('-f') && args.includes('-')) {
+                    // Capture the stdin input
+                    const stdinIndex = args.indexOf('-');
+                    if (stdinIndex >= 0 && args[stdinIndex + 1]) {
+                        appliedManifest = args[stdinIndex + 1];
+                    }
+                    return { stdout: '', stderr: '', exitCode: 0 };
+                }
+                if (args.includes('wait')) {
+                    return { stdout: '', stderr: '', exitCode: 0 };
+                }
+                return { stdout: '', stderr: '', exitCode: 0 };
+            });
+            await executeQuery({
+                targetType: 'model',
+                targetName: 'default',
+                message: 'Hello',
+                outputFormat: 'name',
+                sessionId: 'test-session-456',
+            });
+            // Check that the manifest includes sessionId in spec
+            const applyCall = mockExeca.mock.calls.find((call) => call[1]?.includes('apply'));
+            expect(applyCall).toBeDefined();
+            // The manifest should be passed via stdin, so we need to check the actual call
+            // Since execa handles stdin separately, we verify the call was made
+            expect(mockExeca).toHaveBeenCalledWith('kubectl', expect.arrayContaining(['apply', '-f', '-']), expect.any(Object));
+        });
         it('should output json format', async () => {
             const mockQuery = {
                 apiVersion: 'ark.mckinsey.com/v1alpha1',

package/dist/lib/types.d.ts

@@ -94,6 +94,25 @@ export interface QueryTarget {
 }
 export interface QueryResponse {
     content?: string;
+    a2a?: {
+        contextId?: string;
+    };
+}
+export interface QueryStatus {
+    phase?: 'initializing' | 'running' | 'done' | 'error' | 'canceled';
+    conditions?: K8sCondition[];
+    responses?: QueryResponse[];
+    message?: string;
+    error?: string;
+    tokenUsage?: {
+        promptTokens?: number;
+        completionTokens?: number;
+        totalTokens?: number;
+    };
+    a2a?: {
+        contextId?: string;
+        taskId?: string;
+    };
 }
 export interface Query {
     apiVersion: string;
@@ -102,14 +121,10 @@ export interface Query {
     spec?: {
         input: string;
         targets: QueryTarget[];
+        sessionId?: string;
+        timeout?: string;
     };
-    status?: {
-        phase?: 'initializing' | 'running' | 'done' | 'error' | 'canceled';
-        conditions?: K8sCondition[];
-        responses?: QueryResponse[];
-        message?: string;
-        error?: string;
-    };
+    status?: QueryStatus;
 }
 export interface Tool {
     metadata: K8sMetadata;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agents-at-scale/ark",
-  "version": "0.1.43",
+  "version": "0.1.44",
   "description": "Ark CLI - Interactive terminal interface for ARK agents",
   "main": "dist/index.js",
   "type": "module",

package/templates/models/azure.yaml

@@ -7,7 +7,7 @@ stringData:
   # IMPORTANT: Environment variables must be substituted before applying
   # Use one of these methods:
   #   1. make models-apply (recommended)
-  #   2. make quickstart (full deployment)
+  #   2. devspace dev (full deployment)
   #   3. make fix-models (if you have broken queries)
   # Manual: export AZURE_API_KEY="key" && envsubst < models/{{ .Values.modelName }}.yaml | kubectl apply -f -
   token: ${AZURE_API_KEY}

package/templates/project/Makefile

@@ -29,7 +29,7 @@ DOCKER_BUILD_DIR := $(OUT_DIR)/docker
 .PHONY: help
 help: ## Show this help message
 	@echo "🚀 Quick Commands:"
-	@echo "  make quickstart     # 5-minute setup with proper resource dependency handling"
+	@echo "  devspace dev        # Deploy ARK to cluster"
 	@echo "  make resources-apply # Apply all custom resources in correct order"
 	@echo "  make fix-models     # Fix broken models (if you have query errors)"
 	@echo ""

package/templates/project/README.md

@@ -12,7 +12,7 @@ cd {{ .Values.projectName }}
 source .env  # Edit this file first with your API keys
 
 # 3. Deploy to your ARK cluster
-make quickstart
+devspace dev
 
 # 4. Check your deployment
 kubectl get agents,teams,queries --namespace {{ .Values.namespace }}

package/templates/project/scripts/setup.sh

@@ -104,5 +104,5 @@ echo -e "${BLUE}Next steps:${NC}"
 echo "  make install       # Deploy to Kubernetes"
 echo "  make status        # Check deployment"
 echo ""
-echo "Or use the quick start:"
-echo "  make quickstart   # One-command deploy"
+echo "Or use ARK CLI for deployment:"
+echo "  devspace dev      # Local development"