@agents-at-scale/ark 0.1.49 → 0.1.50

package/dist/arkServices.js

@@ -119,15 +119,18 @@ const defaultArkServices = {
         k8sDeploymentName: 'ark-mcp',
         k8sDevDeploymentName: 'ark-mcp-devspace',
     },
+    // ark-broker replaces ark-cluster-memory (renamed in v0.1.49). The old release
+    // must be uninstalled first to avoid Helm ownership conflicts on shared
+    // resources like the ark-config-streaming ConfigMap.
     'ark-broker': {
         name: 'ark-broker',
         helmReleaseName: 'ark-broker',
         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-broker`,
         installArgs: [],
+        prerequisiteUninstalls: [{ releaseName: 'ark-cluster-memory' }],
         k8sDeploymentName: 'ark-broker',
         k8sDevDeploymentName: 'ark-broker-devspace',
     },

package/dist/commands/install/index.js

@@ -10,7 +10,19 @@ import { printNextSteps } from '../../lib/nextSteps.js';
 import ora from 'ora';
 import { waitForServicesReady, } from '../../lib/waitForReady.js';
 import { parseTimeoutToSeconds } from '../../lib/timeout.js';
+async function uninstallPrerequisites(service, verbose = false) {
+    if (!service.prerequisiteUninstalls?.length)
+        return;
+    for (const prereq of service.prerequisiteUninstalls) {
+        const helmArgs = ['uninstall', prereq.releaseName, '--ignore-not-found'];
+        if (prereq.namespace) {
+            helmArgs.push('--namespace', prereq.namespace);
+        }
+        await execute('helm', helmArgs, { stdio: 'inherit' }, { verbose });
+    }
+}
 async function installService(service, verbose = false) {
+    await uninstallPrerequisites(service, verbose);
     const helmArgs = [
         'upgrade',
         '--install',

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

@@ -11,7 +11,7 @@ export class KubernetesModelManifestBuilder {
                 name: this.modelName,
             },
             spec: {
-                type: config.type,
+                provider: config.type, // Use provider field (required as of v0.50.0)
                 model: {
                     value: config.modelValue,
                 },

package/dist/commands/queries/index.js

@@ -26,8 +26,8 @@ async function getQuery(name, options) {
     try {
         const query = await getResource('queries', name);
         if (options.response) {
-            if (query.status?.responses && query.status.responses.length > 0) {
-                const response = query.status.responses[0];
+            if (query.status?.response) {
+                const response = query.status.response;
                 if (options.output === 'markdown') {
                     console.log(renderMarkdown(response.content || ''));
                 }
@@ -40,8 +40,8 @@ async function getQuery(name, options) {
             }
         }
         else if (options.output === 'markdown') {
-            if (query.status?.responses && query.status.responses.length > 0) {
-                console.log(renderMarkdown(query.status.responses[0].content || ''));
+            if (query.status?.response) {
+                console.log(renderMarkdown(query.status.response.content || ''));
             }
             else {
                 output.warning('No response available');

package/dist/commands/queries/index.spec.d.ts

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

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

@@ -0,0 +1,167 @@
+import { jest } from '@jest/globals';
+import output from '../../lib/output.js';
+const mockExeca = jest.fn();
+jest.unstable_mockModule('execa', () => ({
+    execa: mockExeca,
+}));
+const { createQueriesCommand } = await import('./index.js');
+describe('queries get command', () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+        console.log = jest.fn();
+        jest.spyOn(output, 'warning').mockImplementation(() => { });
+        jest.spyOn(output, 'error').mockImplementation(() => { });
+        jest.spyOn(process, 'exit').mockImplementation(() => undefined);
+    });
+    it('should get query with response in JSON format', async () => {
+        const mockQuery = {
+            metadata: {
+                name: 'test-query',
+            },
+            spec: {
+                input: 'test input',
+                target: { type: 'agent', name: 'test-agent' },
+            },
+            status: {
+                phase: 'done',
+                response: {
+                    content: 'This is the response',
+                },
+            },
+        };
+        mockExeca.mockResolvedValue({
+            stdout: JSON.stringify(mockQuery),
+        });
+        const command = createQueriesCommand({});
+        await command.parseAsync(['node', 'test', 'get', 'test-query']);
+        expect(console.log).toHaveBeenCalledWith(JSON.stringify(mockQuery, null, 2));
+        expect(mockExeca).toHaveBeenCalledWith('kubectl', ['get', 'queries', 'test-query', '-o', 'json'], { stdio: 'pipe' });
+    });
+    it('should get query with response flag in JSON format', async () => {
+        const mockQuery = {
+            metadata: {
+                name: 'test-query',
+            },
+            spec: {
+                input: 'test input',
+                target: { type: 'agent', name: 'test-agent' },
+            },
+            status: {
+                phase: 'done',
+                response: {
+                    content: 'This is the response content',
+                },
+            },
+        };
+        mockExeca.mockResolvedValue({
+            stdout: JSON.stringify(mockQuery),
+        });
+        const command = createQueriesCommand({});
+        await command.parseAsync([
+            'node',
+            'test',
+            'get',
+            'test-query',
+            '--response',
+        ]);
+        expect(console.log).toHaveBeenCalledWith(JSON.stringify(mockQuery.status.response, null, 2));
+        expect(mockExeca).toHaveBeenCalledWith('kubectl', ['get', 'queries', 'test-query', '-o', 'json'], { stdio: 'pipe' });
+    });
+    it('should get query with response flag in markdown format', async () => {
+        const mockQuery = {
+            metadata: {
+                name: 'test-query',
+            },
+            spec: {
+                input: 'test input',
+                target: { type: 'agent', name: 'test-agent' },
+            },
+            status: {
+                phase: 'done',
+                response: {
+                    content: '# Heading\n\nThis is markdown content',
+                },
+            },
+        };
+        mockExeca.mockResolvedValue({
+            stdout: JSON.stringify(mockQuery),
+        });
+        const command = createQueriesCommand({});
+        await command.parseAsync([
+            'node',
+            'test',
+            'get',
+            'test-query',
+            '--response',
+            '--output',
+            'markdown',
+        ]);
+        expect(console.log).toHaveBeenCalled();
+        expect(mockExeca).toHaveBeenCalledWith('kubectl', ['get', 'queries', 'test-query', '-o', 'json'], { stdio: 'pipe' });
+    });
+    it('should get query in markdown format without response flag', async () => {
+        const mockQuery = {
+            metadata: {
+                name: 'test-query',
+            },
+            spec: {
+                input: 'test input',
+                target: { type: 'agent', name: 'test-agent' },
+            },
+            status: {
+                phase: 'done',
+                response: {
+                    content: '# Response\n\nMarkdown response',
+                },
+            },
+        };
+        mockExeca.mockResolvedValue({
+            stdout: JSON.stringify(mockQuery),
+        });
+        const command = createQueriesCommand({});
+        await command.parseAsync([
+            'node',
+            'test',
+            'get',
+            'test-query',
+            '--output',
+            'markdown',
+        ]);
+        expect(console.log).toHaveBeenCalled();
+        expect(mockExeca).toHaveBeenCalledWith('kubectl', ['get', 'queries', 'test-query', '-o', 'json'], { stdio: 'pipe' });
+    });
+    it('should warn when query has no response with response flag', async () => {
+        const mockQuery = {
+            metadata: {
+                name: 'test-query',
+            },
+            spec: {
+                input: 'test input',
+                target: { type: 'agent', name: 'test-agent' },
+            },
+            status: {
+                phase: 'running',
+            },
+        };
+        mockExeca.mockResolvedValue({
+            stdout: JSON.stringify(mockQuery),
+        });
+        const command = createQueriesCommand({});
+        await command.parseAsync([
+            'node',
+            'test',
+            'get',
+            'test-query',
+            '--response',
+        ]);
+        expect(output.warning).toHaveBeenCalledWith('No response available');
+        expect(mockExeca).toHaveBeenCalledWith('kubectl', ['get', 'queries', 'test-query', '-o', 'json'], { stdio: 'pipe' });
+    });
+    it('should handle errors when getting query', async () => {
+        mockExeca.mockRejectedValue(new Error('Query not found'));
+        const command = createQueriesCommand({});
+        await command.parseAsync(['node', 'test', 'get', 'nonexistent-query']);
+        expect(output.error).toHaveBeenCalledWith('fetching query:', 'Query not found');
+        expect(process.exit).toHaveBeenCalled();
+    });
+});

package/dist/components/ChatUI.js

@@ -467,11 +467,11 @@ const ChatUI = ({ initialTargetId, arkApiClient, arkApiProxy, config, }) => {
             }
             // Send message and get response with abort signal
             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) {
+                // 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.responses[0].a2a.contextId;
+                        arkMetadata.completedQuery.status.response.a2a.contextId;
                 }
                 // Update message progressively as chunks arrive
                 setMessages((prev) => {

package/dist/lib/executeQuery.js

@@ -116,12 +116,10 @@ async function executeQueryWithFormat(options) {
             ...((options.conversationId || process.env.ARK_CONVERSATION_ID) && {
                 conversationId: options.conversationId || process.env.ARK_CONVERSATION_ID,
             }),
-            targets: [
-                {
-                    type: options.targetType,
-                    name: options.targetName,
-                },
-            ],
+            target: {
+                type: options.targetType,
+                name: options.targetName,
+            },
         },
     };
     try {

package/dist/lib/types.d.ts

@@ -101,7 +101,7 @@ export interface QueryResponse {
 export interface QueryStatus {
     phase?: 'initializing' | 'running' | 'done' | 'error' | 'canceled';
     conditions?: K8sCondition[];
-    responses?: QueryResponse[];
+    response?: QueryResponse;
     message?: string;
     error?: string;
     tokenUsage?: {
@@ -120,7 +120,7 @@ export interface Query {
     metadata: K8sMetadata;
     spec?: {
         input: string;
-        targets: QueryTarget[];
+        target: QueryTarget;
         sessionId?: string;
         conversationId?: string;
         timeout?: string;

package/dist/types/arkService.d.ts

@@ -1,3 +1,7 @@
+export interface PrerequisiteUninstall {
+    releaseName: string;
+    namespace?: string;
+}
 export interface ArkService {
     name: string;
     helmReleaseName: string;
@@ -7,6 +11,7 @@ export interface ArkService {
     namespace?: string;
     chartPath?: string;
     installArgs?: string[];
+    prerequisiteUninstalls?: PrerequisiteUninstall[];
     k8sServiceName?: string;
     k8sServicePort?: number;
     k8sPortForwardLocalPort?: number;

package/package.json

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