@agents-at-scale/ark 0.1.42 → 0.1.44

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

@@ -0,0 +1,170 @@
+import { jest } from '@jest/globals';
+import { UNSUPPORTED_OUTPUT_FORMAT_MESSAGE } from './validation.js';
+import output from '../../lib/output.js';
+const mockExeca = jest.fn();
+jest.unstable_mockModule('execa', () => ({
+    execa: mockExeca,
+}));
+const { createQueriesCommand } = await import('./index.js');
+describe('queries list 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 list all queries in text format by default', async () => {
+        const mockQueries = [
+            {
+                metadata: {
+                    name: 'query-1',
+                    creationTimestamp: '2024-01-01T00:00:00Z',
+                },
+                status: {
+                    phase: 'done',
+                },
+            },
+            {
+                metadata: {
+                    name: 'query-2',
+                    creationTimestamp: '2024-01-02T00:00:00Z',
+                },
+                status: {
+                    phase: 'running',
+                },
+            },
+        ];
+        mockExeca.mockResolvedValue({
+            stdout: JSON.stringify({ items: mockQueries }),
+        });
+        const command = createQueriesCommand({});
+        await command.parseAsync(['node', 'test', 'list']);
+        expect(console.log).toHaveBeenCalledWith(expect.stringMatching(/NAME.*STATUS/));
+        expect(console.log).toHaveBeenCalledWith(expect.stringMatching(/query-1/));
+        expect(console.log).toHaveBeenCalledWith(expect.stringMatching(/query-2/));
+        expect(mockExeca).toHaveBeenCalledWith('kubectl', ['get', 'queries', '-o', 'json'], { stdio: 'pipe' });
+    });
+    it('should list all queries in JSON format', async () => {
+        const mockQueries = [
+            {
+                metadata: {
+                    name: 'query-1',
+                    creationTimestamp: '2024-01-01T00:00:00Z',
+                },
+            },
+            {
+                metadata: {
+                    name: 'query-2',
+                    creationTimestamp: '2024-01-02T00:00:00Z',
+                },
+            },
+        ];
+        mockExeca.mockResolvedValue({
+            stdout: JSON.stringify({ items: mockQueries }),
+        });
+        const command = createQueriesCommand({});
+        await command.parseAsync(['node', 'test', '--output', 'json']);
+        expect(console.log).toHaveBeenCalledWith(JSON.stringify(mockQueries, null, 2));
+        expect(mockExeca).toHaveBeenCalledWith('kubectl', ['get', 'queries', '-o', 'json'], { stdio: 'pipe' });
+    });
+    it('should support sorting by creation timestamp', async () => {
+        const mockQueries = [
+            {
+                metadata: {
+                    name: 'query-1',
+                    creationTimestamp: '2024-01-01T00:00:00Z',
+                },
+                status: {
+                    phase: 'done',
+                },
+            },
+            {
+                metadata: {
+                    name: 'query-2',
+                    creationTimestamp: '2024-01-02T00:00:00Z',
+                },
+                status: {
+                    phase: 'running',
+                },
+            },
+        ];
+        mockExeca.mockResolvedValue({
+            stdout: JSON.stringify({ items: mockQueries }),
+        });
+        const command = createQueriesCommand({});
+        await command.parseAsync([
+            'node',
+            'test',
+            '--sort-by',
+            '.metadata.creationTimestamp',
+        ]);
+        expect(console.log).toHaveBeenCalledWith(expect.stringMatching(/NAME.*STATUS/));
+        expect(console.log).toHaveBeenCalledWith(expect.stringMatching(/query-1/));
+        expect(console.log).toHaveBeenCalledWith(expect.stringMatching(/query-2/));
+        expect(mockExeca).toHaveBeenCalledWith('kubectl', ['get', 'queries', '--sort-by=.metadata.creationTimestamp', '-o', 'json'], { stdio: 'pipe' });
+    });
+    it('should display warning when no queries exist', async () => {
+        mockExeca.mockResolvedValue({
+            stdout: JSON.stringify({ items: [] }),
+        });
+        const command = createQueriesCommand({});
+        await command.parseAsync(['node', 'test', 'list']);
+        expect(output.warning).toHaveBeenCalledWith('no queries available');
+        expect(mockExeca).toHaveBeenCalledWith('kubectl', ['get', 'queries', '-o', 'json'], { stdio: 'pipe' });
+    });
+    it('should handle errors when listing queries', async () => {
+        mockExeca.mockRejectedValue(new Error('kubectl connection failed'));
+        const command = createQueriesCommand({});
+        await command.parseAsync(['node', 'test', 'list']);
+        expect(output.error).toHaveBeenCalled();
+        expect(process.exit).toHaveBeenCalled();
+    });
+    it('should handle invalid output format gracefully', async () => {
+        const mockQueries = [
+            {
+                metadata: {
+                    name: 'query-1',
+                    creationTimestamp: '2024-01-01T00:00:00Z',
+                },
+                status: {
+                    phase: 'done',
+                },
+            },
+        ];
+        mockExeca.mockResolvedValue({
+            stdout: JSON.stringify({ items: mockQueries }),
+        });
+        const command = createQueriesCommand({});
+        await command.parseAsync(['node', 'test', '--output', 'xml']);
+        expect(output.error).toHaveBeenCalledWith(expect.anything(), expect.stringMatching(UNSUPPORTED_OUTPUT_FORMAT_MESSAGE));
+        expect(mockExeca).not.toHaveBeenCalled();
+        expect(console.log).not.toHaveBeenCalledWith(expect.stringMatching(/query-1/));
+        expect(process.exit).toHaveBeenCalled();
+    });
+    it('should list many queries without truncation', async () => {
+        // Create 100 mock queries
+        const mockQueries = Array.from({ length: 100 }, (_, i) => ({
+            metadata: {
+                name: `query-${i + 1}`,
+                creationTimestamp: new Date(2024, 0, i + 1).toISOString(),
+            },
+            status: {
+                phase: i % 3 === 0 ? 'done' : i % 2 === 0 ? 'running' : 'initializing',
+            },
+        }));
+        mockExeca.mockResolvedValue({
+            stdout: JSON.stringify({ items: mockQueries }),
+        });
+        const command = createQueriesCommand({});
+        await command.parseAsync(['node', 'test', 'list']);
+        // Check for header and separator
+        expect(console.log).toHaveBeenCalledWith(expect.stringMatching(/NAME.*STATUS/));
+        // Verify all queries are logged
+        for (let i = 1; i <= 100; i++) {
+            expect(console.log).toHaveBeenCalledWith(expect.stringMatching(new RegExp(`query-${i}`)));
+        }
+        // Verify console.log was called: header + 100 queries
+        expect(console.log).toHaveBeenCalledTimes(101);
+    });
+});

package/dist/commands/queries/validation.d.ts

@@ -0,0 +1,2 @@
+export declare const UNSUPPORTED_OUTPUT_FORMAT_MESSAGE = "unsupported \"output\" format";
+export declare function assertSupportedOutputFormat(format: string | undefined): void;

package/dist/commands/queries/validation.js

@@ -0,0 +1,10 @@
+import { InvalidArgumentError } from 'commander';
+const SUPPORTED_OUTPUT_FORMATS = ['json', 'text'];
+export const UNSUPPORTED_OUTPUT_FORMAT_MESSAGE = `unsupported "output" format`;
+const VALID_OUTPUT_FORMATS_MESSAGE = `valid formats are: ${SUPPORTED_OUTPUT_FORMATS.join(', ')}`;
+export function assertSupportedOutputFormat(format) {
+    if (format && !SUPPORTED_OUTPUT_FORMATS.includes(format)) {
+        const message = `${UNSUPPORTED_OUTPUT_FORMAT_MESSAGE}: "${format}". ${VALID_OUTPUT_FORMATS_MESSAGE}`;
+        throw new InvalidArgumentError(message);
+    }
+}

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

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

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

@@ -0,0 +1,27 @@
+import { jest } from '@jest/globals';
+import { InvalidArgumentError } from 'commander';
+import { assertSupportedOutputFormat, UNSUPPORTED_OUTPUT_FORMAT_MESSAGE, } from './validation.js';
+jest.spyOn(console, 'error').mockImplementation(() => { });
+describe('queries validation', () => {
+    describe('assertSupportedOutputFormat', () => {
+        it('should not throw for supported formats', () => {
+            expect(() => assertSupportedOutputFormat('json')).not.toThrow();
+            expect(() => assertSupportedOutputFormat('text')).not.toThrow();
+        });
+        it('should not throw when format is undefined', () => {
+            expect(() => assertSupportedOutputFormat(undefined)).not.toThrow();
+        });
+        it('should throw InvalidArgumentError for unsupported format', () => {
+            expect(() => assertSupportedOutputFormat('xml')).toThrow(InvalidArgumentError);
+        });
+        it('should include format and supported formats in error message', () => {
+            expect(() => assertSupportedOutputFormat('xml')).toThrow(UNSUPPORTED_OUTPUT_FORMAT_MESSAGE);
+        });
+        it('should work with various invalid formats', () => {
+            const invalidFormats = ['yaml', 'csv', 'html', 'pdf'];
+            for (const format of invalidFormats) {
+                expect(() => assertSupportedOutputFormat(format)).toThrow(InvalidArgumentError);
+            }
+        });
+    });
+});

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/commands/uninstall/index.js

@@ -5,6 +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, extractMarketplaceServiceName, getMarketplaceService, getAllMarketplaceServices, } 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
@@ -25,6 +26,32 @@ async function uninstallArk(config, serviceName, options = {}) {
     console.log(); // Add blank line after cluster info
     // If a specific service is requested, uninstall only that service
     if (serviceName) {
+        // Check if it's a marketplace service
+        if (isMarketplaceService(serviceName)) {
+            const marketplaceServiceName = extractMarketplaceServiceName(serviceName);
+            const service = getMarketplaceService(marketplaceServiceName);
+            if (!service) {
+                output.error(`marketplace service '${marketplaceServiceName}' not found`);
+                output.info('available marketplace services:');
+                const marketplaceServices = getAllMarketplaceServices();
+                for (const serviceName of Object.keys(marketplaceServices)) {
+                    output.info(`  marketplace/services/${serviceName}`);
+                }
+                process.exit(1);
+            }
+            output.info(`uninstalling marketplace service ${service.name}...`);
+            try {
+                await uninstallService(service, options.verbose);
+                output.success(`${service.name} uninstalled successfully`);
+            }
+            catch (error) {
+                output.error(`failed to uninstall ${service.name}`);
+                console.error(error);
+                process.exit(1);
+            }
+            return;
+        }
+        // Core ARK service
         const services = getInstallableServices();
         const service = Object.values(services).find((s) => s.name === serviceName);
         if (!service) {

package/dist/components/ChatUI.js

@@ -18,12 +18,12 @@ const generateMessageId = () => {
 // Configure marked with terminal renderer for markdown output
 const configureMarkdown = () => {
     marked.setOptions({
-        // @ts-expect-error - TerminalRenderer types are incomplete
+        // @ts-ignore - TerminalRenderer types are incomplete
         renderer: new TerminalRenderer({
             showSectionPrefix: false,
             width: 80,
             reflowText: true,
-            // @ts-expect-error - preserveNewlines exists but not in types
+            // @ts-ignore - preserveNewlines exists but not in types
             preserveNewlines: true,
         }),
     });
@@ -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/index.js

@@ -16,6 +16,7 @@ import { createDocsCommand } from './commands/docs/index.js';
 import { createEvaluationCommand } from './commands/evaluation/index.js';
 import { createGenerateCommand } from './commands/generate/index.js';
 import { createInstallCommand } from './commands/install/index.js';
+import { createMarketplaceCommand } from './commands/marketplace/index.js';
 import { createMemoryCommand } from './commands/memory/index.js';
 import { createModelsCommand } from './commands/models/index.js';
 import { createQueryCommand } from './commands/query/index.js';
@@ -49,6 +50,7 @@ async function main() {
     program.addCommand(createEvaluationCommand(config));
     program.addCommand(createGenerateCommand(config));
     program.addCommand(createInstallCommand(config));
+    program.addCommand(createMarketplaceCommand(config));
     program.addCommand(createMemoryCommand(config));
     program.addCommand(createModelsCommand(config));
     program.addCommand(createQueryCommand(config));

package/dist/lib/arkApiClient.js

@@ -146,6 +146,8 @@ export class ArkApiClient {
         }));
     }
     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,

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,11 +10,8 @@ export interface QueryOptions {
     watchTimeout?: string;
     verbose?: boolean;
     outputFormat?: string;
+    sessionId?: string;
 }
-/**
- * Execute a query against any ARK target (model, agent, team)
- * This is the shared implementation used by all query commands
- */
 export declare function executeQuery(options: QueryOptions): Promise<void>;
 /**
  * Parse a target string like "model/default" or "agent/weather"