@agents-at-scale/ark 0.1.64 → 0.1.67

package/dist/commands/status/index.js

@@ -5,7 +5,7 @@ import { StatusChecker } from '../../components/statusChecker.js';
 import { StatusFormatter, } from '../../ui/statusFormatter.js';
 import { fetchVersionInfo } from '../../lib/versions.js';
 import { waitForServicesReady, } from '../../lib/waitForReady.js';
-import { runReadinessChecks, detectStorageBackend, } from '../../lib/readinessChecks.js';
+import { runReadinessChecks, describeStorageBackend, } from '../../lib/readinessChecks.js';
 import { arkServices } from '../../arkServices.js';
 import output from '../../lib/output.js';
 import { parseTimeoutToSeconds } from '../../lib/timeout.js';
@@ -49,7 +49,26 @@ function enrichServiceDetails(service) {
         details: details.join(', '),
     };
 }
-function buildStatusSections(data, versionInfo) {
+function backendStatusLine(detection) {
+    const display = {
+        etcd: { color: 'green', details: 'etcd' },
+        postgresql: { color: 'green', details: 'postgresql' },
+        'not-installed': { color: 'yellow', details: 'not installed' },
+        unreachable: { color: 'yellow', details: 'cluster unreachable' },
+        forbidden: { color: 'yellow', details: 'access denied' },
+        undetermined: { color: 'yellow', details: 'undetermined' },
+    };
+    const { color, details } = display[detection.status];
+    return {
+        icon: '●',
+        iconColor: color,
+        status: 'storage backend',
+        statusColor: color,
+        name: '',
+        details,
+    };
+}
+function buildStatusSections(data, versionInfo, backend) {
     const sections = [];
     // Dependencies section
     sections.push({
@@ -251,6 +270,9 @@ function buildStatusSections(data, versionInfo) {
             }
         }
     }
+    if (backend) {
+        arkStatusLines.push(backendStatusLine(backend));
+    }
     sections.push({ title: 'ark status:', lines: arkStatusLines });
     return sections;
 }
@@ -266,12 +288,24 @@ export async function checkStatus(serviceNames, options) {
             statusChecker.checkAll(),
             fetchVersionInfo(),
         ]);
+        // Only probe for the storage backend if the cluster is reachable; probing an
+        // unreachable cluster would just retry to its timeout.
+        const detection = statusData.clusterAccess
+            ? await describeStorageBackend()
+            : {
+                backend: 'unknown',
+                status: 'unreachable',
+                message: 'Cluster is not reachable — cannot determine the storage backend.',
+            };
         spinner.stop();
-        const sections = buildStatusSections(statusData, versionInfo);
+        const sections = buildStatusSections(statusData, versionInfo, detection);
         StatusFormatter.printSections(sections);
         if (options?.waitForReady) {
             const timeoutSeconds = parseTimeoutToSeconds(options.waitForReady);
-            const backend = await detectStorageBackend();
+            const backend = detection.backend;
+            if (backend === 'unknown') {
+                output.warning(`${detection.message} Skipping backend-specific readiness checks.`);
+            }
             let servicesToWait = [];
             if (serviceNames && serviceNames.length > 0) {
                 servicesToWait = serviceNames
@@ -316,7 +350,7 @@ export async function checkStatus(serviceNames, options) {
             waitSpinner.succeed('All services are ready');
             const elapsedSeconds = Math.floor((Date.now() - startTime) / 1000);
             const remainingSeconds = Math.max(1, timeoutSeconds - elapsedSeconds);
-            const deepResults = await runReadinessChecks(remainingSeconds, (r) => {
+            const deepResults = await runReadinessChecks(remainingSeconds, backend, (r) => {
                 const icon = r.passed ? chalk.green('✓') : chalk.red('✗');
                 const dur = `${(r.durationMs / 1000).toFixed(1)}s`;
                 const suffix = r.message ? ` — ${r.message}` : '';

package/dist/lib/arkApiClient.d.ts

@@ -58,6 +58,10 @@ export declare class ArkApiClient {
         sessionId?: string;
         conversationId?: string;
         timeout?: string;
+        parameters?: Array<{
+            name: string;
+            value?: string;
+        }>;
         metadata?: {
             annotations?: Record<string, string>;
         };

package/dist/lib/arkApiClient.js

@@ -159,6 +159,9 @@ export class ArkApiClient {
                 sessionId: params.sessionId,
                 conversationId: params.conversationId,
                 timeout: params.timeout,
+                ...(params.parameters && params.parameters.length > 0
+                    ? { parameters: params.parameters }
+                    : {}),
                 ...(params.metadata ? { metadata: params.metadata } : {}),
             }),
         });

package/dist/lib/chatClient.d.ts

@@ -1,4 +1,5 @@
 import { ArkApiClient, QueryTarget } from './arkApiClient.js';
+import type { QueryParameter } from './types.js';
 export { QueryTarget };
 export interface ChatConfig {
     streamingEnabled: boolean;
@@ -7,6 +8,7 @@ export interface ChatConfig {
     conversationId?: string;
     queryTimeout?: string;
     a2aContextId?: string;
+    parameters?: QueryParameter[];
 }
 export interface ToolCall {
     id: string;

package/dist/lib/chatClient.js

@@ -1,4 +1,19 @@
 import { QUERY_ANNOTATIONS } from './constants.js';
+/** Best-effort human-readable error from a failed query's status. */
+function extractQueryError(status) {
+    if (!status)
+        return 'Query failed';
+    if (status.error)
+        return status.error;
+    if (status.message)
+        return status.message;
+    const condition = status.conditions?.find((c) => c.message);
+    if (condition?.message)
+        return condition.message.trim();
+    if (status.response?.content)
+        return status.response.content;
+    return 'Query failed';
+}
 export class ChatClient {
     arkApiClient;
     constructor(arkApiClient) {
@@ -26,6 +41,7 @@ export class ChatClient {
             sessionId: config.sessionId,
             conversationId: config.conversationId,
             timeout: config.queryTimeout,
+            parameters: config.parameters,
             ...(Object.keys(annotations).length > 0
                 ? { metadata: { annotations } }
                 : {}),
@@ -72,7 +88,7 @@ export class ChatClient {
                     onChunk(content, undefined, undefined);
                 }
                 if (phase === 'error') {
-                    throw new Error(content || 'Query failed');
+                    throw new Error(extractQueryError(query.status));
                 }
                 return content;
             }
@@ -155,6 +171,14 @@ export class ChatClient {
         finally {
             reader.releaseLock();
         }
+        // Empty stream (no content, no tool calls) can mean the query errored — surface it.
+        if (!fullResponse && toolCallsById.size === 0 && !signal?.aborted) {
+            const query = (await this.arkApiClient.getQuery(queryName));
+            const phase = query?.status?.phase;
+            if (phase === 'error' || phase === 'canceled') {
+                throw new Error(extractQueryError(query?.status));
+            }
+        }
         return fullResponse;
     }
 }

package/dist/lib/executeQuery.d.ts

@@ -1,7 +1,7 @@
 /**
  * Shared query execution logic for both universal and resource-specific query commands
  */
-import type { QueryTarget } from './types.js';
+import type { QueryTarget, QueryParameter } from './types.js';
 export interface QueryOptions {
     targetType: string;
     targetName: string;
@@ -12,6 +12,7 @@ export interface QueryOptions {
     outputFormat?: string;
     sessionId?: string;
     conversationId?: string;
+    parameters?: QueryParameter[];
 }
 export declare function executeQuery(options: QueryOptions): Promise<void>;
 /**
@@ -19,3 +20,5 @@ export declare function executeQuery(options: QueryOptions): Promise<void>;
  * Returns QueryTarget or null if invalid
  */
 export declare function parseTarget(target: string): QueryTarget | null;
+/** Parse repeated `name=value` flags into QueryParameters (mirrors the fark CLI). */
+export declare function parseParameters(parameters: string[]): QueryParameter[];

package/dist/lib/executeQuery.js

@@ -37,6 +37,7 @@ export async function executeQuery(options) {
             sessionId,
             conversationId,
             queryTimeout: options.timeout,
+            parameters: options.parameters,
         }, (chunk, toolCalls, arkMetadata) => {
             if (firstOutput) {
                 spinner.stop();
@@ -120,6 +121,9 @@ async function executeQueryWithFormat(options) {
                 type: options.targetType,
                 name: options.targetName,
             },
+            ...(options.parameters && options.parameters.length > 0
+                ? { parameters: options.parameters }
+                : {}),
         },
     };
     try {
@@ -133,6 +137,10 @@ async function executeQueryWithFormat(options) {
             await watchEventsLive(queryName);
             return;
         }
+        if (options.outputFormat === 'events-pretty') {
+            await watchEventsLive(queryName, true);
+            return;
+        }
         const timeoutSeconds = 300;
         await execa('kubectl', [
             'wait',
@@ -149,7 +157,7 @@ async function executeQueryWithFormat(options) {
             console.log(stdout);
         }
         else {
-            console.error(chalk.red(`Invalid output format: ${options.outputFormat}. Use: yaml, json, name, or events`));
+            console.error(chalk.red(`Invalid output format: ${options.outputFormat}. Use: yaml, json, name, events, or events-pretty`));
             process.exit(ExitCodes.CliError);
         }
     }
@@ -172,3 +180,18 @@ export function parseTarget(target) {
         name: parts[1],
     };
 }
+/** Parse repeated `name=value` flags into QueryParameters (mirrors the fark CLI). */
+export function parseParameters(parameters) {
+    return parameters.map((param) => {
+        const idx = param.indexOf('=');
+        if (idx === -1) {
+            throw new Error(`parameter must be in name=value format, got: ${param}`);
+        }
+        const name = param.slice(0, idx).trim();
+        const value = param.slice(idx + 1).trim();
+        if (name === '') {
+            throw new Error(`parameter name cannot be empty in: ${param}`);
+        }
+        return { name, value };
+    });
+}

package/dist/lib/formatEvent.d.ts

@@ -0,0 +1,29 @@
+export interface K8sEvent {
+    type?: string;
+    reason?: string;
+    eventTime?: string;
+    lastTimestamp?: string;
+    firstTimestamp?: string;
+    metadata?: {
+        uid?: string;
+        creationTimestamp?: string;
+        annotations?: Record<string, string>;
+    };
+}
+export declare function pad(value: number, width: number): string;
+/**
+ * Derive an HH:MM:SS.mmm timestamp, preferring the event-data payload timestamp
+ * and falling back through the native Event time fields to wall-clock now.
+ */
+export declare function formatEventTimestamp(event: K8sEvent): string;
+/**
+ * Render the structured event-data payload as `message > key=value ...`.
+ * The message is clipped and colored red for Warning/Error events; trailing
+ * fields keep their full value. Non-object payloads are echoed as-is.
+ */
+export declare function formatEventData(eventData: string, eventType?: string): string;
+/**
+ * Format a Kubernetes Event carrying an ark event-data annotation into a
+ * single human-readable line. Returns null when the event has no payload.
+ */
+export declare function formatEvent(event: K8sEvent): string | null;

package/dist/lib/formatEvent.js

@@ -0,0 +1,138 @@
+import chalk from 'chalk';
+import { EVENT_ANNOTATIONS } from './constants.js';
+/**
+ * Shape of the JSON carried in the `ark.mckinsey.com/event-data` annotation:
+ *
+ *   {
+ *     "durationMs": "7084.30",
+ *     "input": "ok?",
+ *     "message": "Query execution completed",
+ *     "queryId": "0b61250b-...",
+ *     "queryName": "cli-query-1784110137509",
+ *     "queryNamespace": "ark-system",
+ *     "sessionId": "0b61250b-...",
+ *     "targetType": "model",
+ *     "timestamp": "2026-07-15T10:09:04.602422162Z"
+ *   }
+ */
+const NUMERIC = /^-?\d+(\.\d+)?$/;
+const MAX_MESSAGE_LENGTH = 120;
+// Fields rendered first (in this order); everything else is sorted alphabetically.
+const FIELD_PRIORITY = { input: 0, durationMs: 1 };
+// Keys pulled out of the trailing field list because they are rendered elsewhere.
+const RESERVED_KEYS = new Set(['message', 'timestamp']);
+export function pad(value, width) {
+    return value.toString().padStart(width, '0');
+}
+function parseEventData(raw) {
+    if (!raw) {
+        return null;
+    }
+    try {
+        const parsed = JSON.parse(raw);
+        return parsed !== null && typeof parsed === 'object' && !Array.isArray(parsed)
+            ? parsed
+            : null;
+    }
+    catch {
+        return null;
+    }
+}
+function firstValidDate(candidates) {
+    for (const candidate of candidates) {
+        if (!candidate) {
+            continue;
+        }
+        const date = new Date(candidate);
+        if (!Number.isNaN(date.getTime())) {
+            return date;
+        }
+    }
+    return new Date();
+}
+function truncate(value, max = MAX_MESSAGE_LENGTH) {
+    return value.length > max ? `${value.slice(0, max)}…` : value;
+}
+/**
+ * Derive an HH:MM:SS.mmm timestamp, preferring the event-data payload timestamp
+ * and falling back through the native Event time fields to wall-clock now.
+ */
+export function formatEventTimestamp(event) {
+    const data = parseEventData(event.metadata?.annotations?.[EVENT_ANNOTATIONS.EVENT_DATA]);
+    const dataTimestamp = typeof data?.timestamp === 'string' ? data.timestamp : undefined;
+    const date = firstValidDate([
+        dataTimestamp,
+        event.eventTime,
+        event.lastTimestamp,
+        event.firstTimestamp,
+        event.metadata?.creationTimestamp,
+    ]);
+    return `${pad(date.getHours(), 2)}:${pad(date.getMinutes(), 2)}:${pad(date.getSeconds(), 2)}.${pad(date.getMilliseconds(), 3)}`;
+}
+function colorReason(reason, eventType) {
+    if (eventType === 'Warning') {
+        return chalk.yellow(reason);
+    }
+    if (eventType === 'Normal') {
+        return chalk.green(reason);
+    }
+    return chalk.red(reason);
+}
+function isErrorType(eventType) {
+    return eventType === 'Warning' || eventType === 'Error';
+}
+function compareKeys(a, b) {
+    const rank = (key) => FIELD_PRIORITY[key] ?? Number.MAX_SAFE_INTEGER;
+    return rank(a) - rank(b) || a.localeCompare(b);
+}
+function renderFieldValue(key, value) {
+    if (typeof value === 'number') {
+        return chalk.green(String(value));
+    }
+    if (value !== null && typeof value === 'object') {
+        return chalk.white(JSON.stringify(value));
+    }
+    const str = String(value);
+    if (NUMERIC.test(str)) {
+        return chalk.green(str);
+    }
+    return chalk.white(key === 'input' ? `"${str}"` : str);
+}
+/**
+ * Render the structured event-data payload as `message > key=value ...`.
+ * The message is clipped and colored red for Warning/Error events; trailing
+ * fields keep their full value. Non-object payloads are echoed as-is.
+ */
+export function formatEventData(eventData, eventType = 'Normal') {
+    const data = parseEventData(eventData);
+    if (!data) {
+        return ` ${eventData}`;
+    }
+    const messageColor = isErrorType(eventType) ? chalk.red : chalk.white;
+    const messagePart = typeof data.message === 'string'
+        ? ` ${messageColor(truncate(data.message))}`
+        : '';
+    const fields = Object.keys(data)
+        .filter((key) => !RESERVED_KEYS.has(key))
+        .sort(compareKeys)
+        .map((key) => `${chalk.blue(key)}${chalk.dim('=')}${renderFieldValue(key, data[key])}`)
+        .join(' ');
+    if (!fields) {
+        return messagePart;
+    }
+    return `${messagePart} ${chalk.dim('>')} ${fields}`;
+}
+/**
+ * Format a Kubernetes Event carrying an ark event-data annotation into a
+ * single human-readable line. Returns null when the event has no payload.
+ */
+export function formatEvent(event) {
+    const eventData = event.metadata?.annotations?.[EVENT_ANNOTATIONS.EVENT_DATA];
+    if (!eventData) {
+        return null;
+    }
+    const timestamp = formatEventTimestamp(event);
+    const reason = event.reason || 'Unknown';
+    const eventType = event.type || 'Normal';
+    return `${chalk.dim(timestamp)} [${colorReason(reason, eventType)}]${formatEventData(eventData, eventType)}`;
+}

package/dist/lib/kubectl.d.ts

@@ -14,5 +14,5 @@ export declare function deleteResource(resourceType: string, name?: string, opti
     all?: boolean;
 }): Promise<void>;
 export declare function replaceResource<T extends K8sResource>(resource: T): Promise<T>;
-export declare function watchEventsLive(queryName: string): Promise<void>;
+export declare function watchEventsLive(queryName: string, pretty?: boolean): Promise<void>;
 export {};

package/dist/lib/kubectl.js

@@ -1,6 +1,7 @@
 import { execa } from 'execa';
 import chalk from 'chalk';
 import { EVENT_ANNOTATIONS } from './constants.js';
+import { formatEvent } from './formatEvent.js';
 export async function getResource(resourceType, name) {
     if (name === '@latest') {
         const result = await execa('kubectl', [
@@ -53,7 +54,7 @@ export async function replaceResource(resource) {
     });
     return JSON.parse(result.stdout);
 }
-export async function watchEventsLive(queryName) {
+export async function watchEventsLive(queryName, pretty = false) {
     const seenEvents = new Set();
     const pollEvents = async () => {
         try {
@@ -73,16 +74,24 @@ export async function watchEventsLive(queryName) {
                     const annotations = event.metadata?.annotations || {};
                     const eventData = annotations[EVENT_ANNOTATIONS.EVENT_DATA];
                     if (eventData) {
-                        const now = new Date();
-                        const hours = now.getHours().toString().padStart(2, '0');
-                        const minutes = now.getMinutes().toString().padStart(2, '0');
-                        const seconds = now.getSeconds().toString().padStart(2, '0');
-                        const millis = now.getMilliseconds().toString().padStart(3, '0');
-                        const timestamp = `${hours}:${minutes}:${seconds}.${millis}`;
-                        const reason = event.reason || 'Unknown';
-                        const eventType = event.type || 'Normal';
-                        const colorCode = eventType === 'Normal' ? 32 : eventType === 'Warning' ? 33 : 31;
-                        console.log(`${timestamp} \x1b[${colorCode}m${reason}\x1b[0m ${eventData}`);
+                        if (pretty) {
+                            const line = formatEvent(event);
+                            if (line !== null) {
+                                console.log(line);
+                            }
+                        }
+                        else {
+                            const now = new Date();
+                            const hours = now.getHours().toString().padStart(2, '0');
+                            const minutes = now.getMinutes().toString().padStart(2, '0');
+                            const seconds = now.getSeconds().toString().padStart(2, '0');
+                            const millis = now.getMilliseconds().toString().padStart(3, '0');
+                            const timestamp = `${hours}:${minutes}:${seconds}.${millis}`;
+                            const reason = event.reason || 'Unknown';
+                            const eventType = event.type || 'Normal';
+                            const colorCode = eventType === 'Normal' ? 32 : eventType === 'Warning' ? 33 : 31;
+                            console.log(`${timestamp} \x1b[${colorCode}m${reason}\x1b[0m ${eventData}`);
+                        }
                     }
                 }
             }

package/dist/lib/readinessChecks.d.ts

@@ -1,4 +1,11 @@
 export type StorageBackend = 'etcd' | 'postgresql';
+export type DetectedBackend = StorageBackend | 'unknown';
+export type BackendStatus = 'etcd' | 'postgresql' | 'not-installed' | 'unreachable' | 'forbidden' | 'undetermined';
+export interface BackendDetection {
+    backend: DetectedBackend;
+    status: BackendStatus;
+    message: string;
+}
 export interface ReadinessCheckResult {
     name: string;
     passed: boolean;
@@ -6,5 +13,6 @@ export interface ReadinessCheckResult {
     message?: string;
 }
 export type ReadinessProgress = (result: ReadinessCheckResult) => void;
-export declare function detectStorageBackend(): Promise<StorageBackend>;
-export declare function runReadinessChecks(timeoutSeconds: number, onProgress?: ReadinessProgress): Promise<ReadinessCheckResult[]>;
+export declare function describeStorageBackend(): Promise<BackendDetection>;
+export declare function detectStorageBackend(): Promise<DetectedBackend>;
+export declare function runReadinessChecks(timeoutSeconds: number, backend: DetectedBackend, onProgress?: ReadinessProgress): Promise<ReadinessCheckResult[]>;

package/dist/lib/readinessChecks.js

@@ -14,9 +14,89 @@ async function runKubectl(args, timeoutMs) {
         stderr: result.stderr ?? '',
     };
 }
+function classifyFailure(stderr) {
+    if (/not\s*found/i.test(stderr)) {
+        return 'not-found';
+    }
+    if (/forbidden|unauthorized/i.test(stderr)) {
+        return 'forbidden';
+    }
+    if (/connection refused|was refused|no such host|i\/o timeout|timed out|dial tcp|unable to connect|did you specify the right host/i.test(stderr)) {
+        return 'unreachable';
+    }
+    return 'undetermined';
+}
+const DETECT_RETRY_DELAY_MS = 250;
+const DETECT_MAX_RETRIES = 2;
+function isAuthoritativeResult(result) {
+    if (result.exitCode === 0) {
+        return true;
+    }
+    return /not\s*found|forbidden/i.test(result.stderr);
+}
+async function probeKubectl(args, timeoutMs, maxRetries = DETECT_MAX_RETRIES) {
+    let result = await runKubectl(args, timeoutMs);
+    for (let attempt = 0; attempt < maxRetries && !isAuthoritativeResult(result); attempt++) {
+        await sleep(DETECT_RETRY_DELAY_MS);
+        result = await runKubectl(args, timeoutMs);
+    }
+    return result;
+}
+function unknownFrom(reason) {
+    switch (reason) {
+        case 'forbidden':
+            return {
+                backend: 'unknown',
+                status: 'forbidden',
+                message: 'Access denied reading cluster resources (RBAC) — cannot determine the storage backend.',
+            };
+        case 'unreachable':
+            return {
+                backend: 'unknown',
+                status: 'unreachable',
+                message: 'Cluster is not reachable (connection failed or timed out) — cannot determine the storage backend.',
+            };
+        default:
+            return {
+                backend: 'unknown',
+                status: 'undetermined',
+                message: 'Could not determine the storage backend (unrecognized kubectl error).',
+            };
+    }
+}
+export async function describeStorageBackend() {
+    const crd = await probeKubectl(['get', 'crd', 'agents.ark.mckinsey.com'], 10000);
+    if (crd.exitCode === 0) {
+        return {
+            backend: 'etcd',
+            status: 'etcd',
+            message: 'ARK is running the etcd (Kubernetes-native) backend; agents are stored as CRDs.',
+        };
+    }
+    const crdReason = classifyFailure(crd.stderr);
+    if (crdReason !== 'not-found') {
+        return unknownFrom(crdReason);
+    }
+    const api = await probeKubectl(['get', 'apiservice', 'v1alpha1.ark.mckinsey.com', '-o', 'name'], 10000);
+    if (api.exitCode === 0) {
+        return {
+            backend: 'postgresql',
+            status: 'postgresql',
+            message: 'ARK is running the PostgreSQL backend; agents are served by the aggregated API server.',
+        };
+    }
+    const apiReason = classifyFailure(api.stderr);
+    if (apiReason === 'not-found') {
+        return {
+            backend: 'unknown',
+            status: 'not-installed',
+            message: 'ARK is not installed on this cluster (no agents CRD and no aggregated APIService).',
+        };
+    }
+    return unknownFrom(apiReason);
+}
 export async function detectStorageBackend() {
-    const { exitCode } = await runKubectl(['get', 'crd', 'agents.ark.mckinsey.com'], 10000);
-    return exitCode === 0 ? 'etcd' : 'postgresql';
+    return (await describeStorageBackend()).backend;
 }
 async function waitForApiServices(timeoutSeconds) {
     const start = Date.now();
@@ -64,11 +144,20 @@ async function waitForApiGroup(timeoutSeconds) {
         message: 'timed out waiting for ark.mckinsey.com API group',
     };
 }
-export async function runReadinessChecks(timeoutSeconds, onProgress) {
-    const backend = await detectStorageBackend();
+export async function runReadinessChecks(timeoutSeconds, backend, onProgress) {
     if (backend === 'etcd') {
         return [];
     }
+    if (backend === 'unknown') {
+        const result = {
+            name: 'Storage backend',
+            passed: false,
+            durationMs: 0,
+            message: 'could not determine storage backend (ARK not installed, cluster unreachable, or access denied)',
+        };
+        onProgress?.(result);
+        return [result];
+    }
     const overallStart = Date.now();
     const remaining = () => Math.max(1, timeoutSeconds - Math.floor((Date.now() - overallStart) / 1000));
     const checks = [

package/dist/lib/types.d.ts

@@ -92,6 +92,10 @@ export interface QueryTarget {
     type: string;
     name: string;
 }
+export interface QueryParameter {
+    name: string;
+    value?: string;
+}
 export interface QueryResponse {
     content?: string;
     a2a?: {
@@ -124,6 +128,7 @@ export interface Query {
         sessionId?: string;
         conversationId?: string;
         timeout?: string;
+        parameters?: QueryParameter[];
     };
     status?: QueryStatus;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agents-at-scale/ark",
-  "version": "0.1.64",
+  "version": "0.1.67",
   "description": "Ark CLI - Interactive terminal interface for ARK agents",
   "main": "dist/index.js",
   "type": "module",
@@ -85,15 +85,17 @@
     "node": ">=18.0.0"
   },
   "overrides": {
-    "brace-expansion": ">=5.0.6",
+    "brace-expansion": ">=5.0.7",
     "minimatch": "^10.2.3",
     "rollup": "4.59.0",
-    "hono": "^4.12.18",
+    "hono": "^4.12.25",
     "@hono/node-server": "^1.19.13",
     "flatted": "^3.4.2",
     "tar": "^7.5.11",
     "express-rate-limit": "^8.3.0",
-    "fast-uri": "^3.1.1",
-    "ws": "^8.20.1"
+    "fast-uri": "^3.1.4",
+    "ws": "^8.21.0",
+    "esbuild": "^0.28.1",
+    "form-data": "^4.0.6"
   }
 }

package/templates/mcp-server/Dockerfile

@@ -63,7 +63,7 @@ ENTRYPOINT [ "/bin/bash", "-c", "mcp-proxy --debug --port 8080 --host 0.0.0.0 --
 {{- end }}
 
 {{- else if eq .Values.technology "go" }}
-FROM golang:1.26.3-alpine AS go-builder
+FROM golang:1.26.5-alpine AS go-builder
 {{- if .Values.packageSource }}
 {{- if eq .Values.packageSource "go-install" }}
 RUN go install {{ .Values.packageName }}@latest