@bluefly/openstandardagents 0.4.5 → 0.4.8

package/dist/sdks/kagent/crd-generator.js

@@ -795,6 +795,188 @@ export class KAgentCRDGenerator {
         readme += `**Generated at**: ${new Date().toISOString()}\n`;
         return readme;
     }
+    /**
+     * Generate kagent.dev v1alpha2 Declarative Agent (and optional ModelConfig) for POC / native kagent installs
+     */
+    generateV1Alpha2(manifest, options = {}) {
+        const spec = manifest.spec;
+        const llmConfig = spec.llm;
+        const agentName = manifest.metadata?.name || 'unknown-agent';
+        const namespace = options.namespace || 'kagent';
+        const systemMessage = spec.role || manifest.metadata?.description || '';
+        const tools = this.extractToolsForV1Alpha2(spec.tools, options);
+        const a2aSkills = this.extractA2ASkills(manifest, options);
+        const modelConfigName = options.modelConfigName || 'default-model-config';
+        const extKagent = manifest.extensions
+            ?.kagent;
+        const deployment = extKagent?.kubernetes
+            ?.resourceLimits;
+        const agent = {
+            apiVersion: 'kagent.dev/v1alpha2',
+            kind: 'Agent',
+            metadata: {
+                name: agentName,
+                namespace,
+                labels: {
+                    'ossa.ai/version': manifest.metadata?.version || getVersion(),
+                    'ossa.ai/domain': spec.taxonomy?.domain ||
+                        'agents',
+                    'app.kubernetes.io/name': agentName,
+                    'app.kubernetes.io/managed-by': 'kagent',
+                    ...manifest.metadata?.labels,
+                },
+                annotations: {
+                    'ossa.ai/generated-by': 'kagent-crd-generator',
+                    'ossa.ai/generated-at': new Date().toISOString(),
+                    ...manifest.metadata?.annotations,
+                },
+            },
+            spec: {
+                type: 'Declarative',
+                description: manifest.metadata?.description,
+                declarative: {
+                    modelConfig: modelConfigName,
+                    stream: true,
+                    systemMessage,
+                    ...(tools && tools.length > 0 && { tools }),
+                    ...(a2aSkills &&
+                        a2aSkills.length > 0 && { a2aConfig: { skills: a2aSkills } }),
+                },
+                deployment: {
+                    replicas: options.replicas ?? 1,
+                    ...(deployment || options.resources
+                        ? {
+                            resources: {
+                                requests: options.resources?.requests ?? {
+                                    cpu: '100m',
+                                    memory: '256Mi',
+                                },
+                                limits: (deployment || options.resources?.limits) ?? {
+                                    cpu: '500m',
+                                    memory: '512Mi',
+                                },
+                            },
+                        }
+                        : {}),
+                },
+            },
+        };
+        let modelConfig;
+        if (options.modelConfigName === undefined && llmConfig) {
+            modelConfig = this.buildV1Alpha2ModelConfig(manifest, namespace, agentName);
+            agent.spec.declarative.modelConfig = modelConfig.metadata.name;
+        }
+        return { agent, modelConfig };
+    }
+    /**
+     * Build v1alpha2 ModelConfig from OSSA spec.llm (optional; use when not relying on default-model-config)
+     */
+    buildV1Alpha2ModelConfig(manifest, namespace, agentName) {
+        const spec = manifest.spec;
+        const llm = spec.llm;
+        const name = `ossa-${agentName}-model`;
+        const provider = llm?.provider || 'openai';
+        const model = llm?.model || 'gpt-4';
+        const isAnthropic = provider === 'anthropic';
+        return {
+            apiVersion: 'kagent.dev/v1alpha2',
+            kind: 'ModelConfig',
+            metadata: {
+                name,
+                namespace,
+                labels: { 'ossa.ai/agent': agentName },
+            },
+            spec: {
+                model,
+                provider: isAnthropic ? 'Anthropic' : 'OpenAI',
+                apiKeySecret: isAnthropic ? 'anthropic-api-key' : 'openai-api-key',
+                apiKeySecretKey: 'api-key',
+                ...(isAnthropic && {
+                    anthropic: {
+                        maxTokens: llm?.maxTokens ?? 4096,
+                        temperature: llm?.temperature ?? 0.3,
+                    },
+                }),
+                ...(!isAnthropic && {
+                    openAI: {
+                        maxTokens: llm?.maxTokens ?? 4096,
+                        temperature: llm?.temperature ?? 0.3,
+                    },
+                }),
+            },
+        };
+    }
+    /**
+     * Extract tools in kagent v1alpha2 format (McpServer with toolNames, or Agent ref)
+     */
+    extractToolsForV1Alpha2(tools, options) {
+        if (!tools || !Array.isArray(tools))
+            return undefined;
+        const out = [];
+        for (const t of tools) {
+            if (!t || typeof t !== 'object')
+                continue;
+            const obj = t;
+            if (obj.agent && typeof obj.agent === 'object') {
+                const agentRef = obj.agent;
+                out.push({
+                    type: 'Agent',
+                    agent: {
+                        name: agentRef.name,
+                        ...(agentRef.namespace && { namespace: agentRef.namespace }),
+                    },
+                });
+                continue;
+            }
+            const server = obj.server || obj.name;
+            const toolNames = obj.toolNames ?? obj.capabilities;
+            if (!server || !toolNames?.length)
+                continue;
+            out.push({
+                type: 'McpServer',
+                mcpServer: {
+                    name: server,
+                    kind: 'RemoteMCPServer',
+                    toolNames,
+                    ...(obj.namespace ? { namespace: obj.namespace } : {}),
+                },
+            });
+        }
+        return out.length ? out : undefined;
+    }
+    /**
+     * Extract A2A skills from OSSA manifest (extensions.kagent.a2aConfig.skills or single skill from description)
+     */
+    extractA2ASkills(manifest, _options) {
+        const ext = manifest.extensions?.kagent;
+        const a2a = ext?.a2aConfig;
+        const skills = a2a?.skills;
+        if (skills?.length) {
+            return skills.map((s) => ({
+                id: s.id || s.name?.toLowerCase().replace(/\s+/g, '-') || 'skill',
+                name: s.name || 'Skill',
+                description: s.description || '',
+                inputModes: s.inputModes ?? ['text'],
+                outputModes: s.outputModes ?? ['text'],
+                tags: s.tags ?? [],
+                examples: s.examples ?? [],
+            }));
+        }
+        if (manifest.metadata?.description) {
+            return [
+                {
+                    id: `${(manifest.metadata?.name || 'agent').toLowerCase().replace(/\s+/g, '-')}-skill`,
+                    name: manifest.metadata.name || 'Agent',
+                    description: manifest.metadata.description,
+                    inputModes: ['text'],
+                    outputModes: ['text'],
+                    tags: ['ossa'],
+                    examples: [],
+                },
+            ];
+        }
+        return undefined;
+    }
     /**
      * Extract tools from OSSA spec
      */

package/dist/sdks/kagent/index.d.ts

@@ -6,5 +6,5 @@ export { KAgentCRDGenerator } from './crd-generator.js';
 export { KAgentCRDParser } from './crd-parser.js';
 export { KAgentRuntimeAdapter } from './runtime-adapter.js';
 export { KAgentValidator } from './validator.js';
-export type { KAgentCRD, KAgentDeploymentOptions, KAgentDeploymentResult, KAgentValidationResult, KubernetesManifestBundle, } from './types.js';
+export type { KAgentCRD, KAgentDeploymentOptions, KAgentDeploymentResult, KAgentValidationResult, KubernetesManifestBundle, KAgentV1Alpha2Agent, KAgentV1Alpha2ModelConfig, } from './types.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/sdks/kagent/kubectl-apply.d.ts

@@ -0,0 +1,35 @@
+/**
+ * kubectl apply adapter for kagent v1alpha2 bundles.
+ * Applies CRDs in APPLY_ORDER: ModelConfig → RemoteMCPServer → Agent.
+ */
+import type { KAgentV1Alpha2Bundle } from './types.js';
+interface ApplyItemResult {
+    kind: string;
+    name: string;
+    status: 'created' | 'configured' | 'unchanged' | 'error';
+    message?: string;
+}
+interface ApplyBundleResult {
+    success: boolean;
+    applied: number;
+    results: ApplyItemResult[];
+    error?: string;
+}
+/**
+ * Apply a complete v1alpha2 bundle to Kubernetes in APPLY_ORDER.
+ *
+ * Order: ModelConfig → RemoteMCPServer(s) → Agent
+ * This ensures dependencies exist before the Agent references them.
+ */
+export declare function applyV1Alpha2Bundle(bundle: KAgentV1Alpha2Bundle): Promise<ApplyBundleResult>;
+/**
+ * Flatten a bundle into an ordered array of CRD objects for serialization.
+ * Follows KAGENT_APPLY_ORDER.
+ */
+export declare function flattenBundle(bundle: KAgentV1Alpha2Bundle): Array<{
+    kind: string;
+    name: string;
+    manifest: Record<string, unknown>;
+}>;
+export {};
+//# sourceMappingURL=kubectl-apply.d.ts.map

package/dist/sdks/kagent/kubectl-apply.js

@@ -0,0 +1,127 @@
+/**
+ * kubectl apply adapter for kagent v1alpha2 bundles.
+ * Applies CRDs in APPLY_ORDER: ModelConfig → RemoteMCPServer → Agent.
+ */
+import { spawn } from 'child_process';
+import * as yaml from 'yaml';
+/**
+ * Apply a single YAML manifest via kubectl stdin.
+ */
+async function kubectlApplyManifest(manifestYaml) {
+    return new Promise((resolve, reject) => {
+        const kubectl = spawn('kubectl', ['apply', '-f', '-'], {
+            stdio: ['pipe', 'pipe', 'pipe'],
+        });
+        let stdout = '';
+        let stderr = '';
+        kubectl.stdout.on('data', (data) => {
+            stdout += data.toString();
+        });
+        kubectl.stderr.on('data', (data) => {
+            stderr += data.toString();
+        });
+        kubectl.on('close', (code) => {
+            if (code === 0) {
+                resolve({ stdout, stderr });
+            }
+            else {
+                reject(new Error(`kubectl apply failed (exit ${code}): ${stderr}`));
+            }
+        });
+        kubectl.on('error', (err) => {
+            reject(new Error(`kubectl not found or failed to spawn: ${err.message}`));
+        });
+        kubectl.stdin.write(manifestYaml);
+        kubectl.stdin.end();
+    });
+}
+/**
+ * Parse kubectl apply output to determine status.
+ */
+function parseApplyOutput(stdout) {
+    if (stdout.includes('created'))
+        return 'created';
+    if (stdout.includes('configured'))
+        return 'configured';
+    return 'unchanged';
+}
+/**
+ * Apply a complete v1alpha2 bundle to Kubernetes in APPLY_ORDER.
+ *
+ * Order: ModelConfig → RemoteMCPServer(s) → Agent
+ * This ensures dependencies exist before the Agent references them.
+ */
+export async function applyV1Alpha2Bundle(bundle) {
+    const results = [];
+    let applied = 0;
+    try {
+        // 1. ModelConfig (if present)
+        if (bundle.modelConfig) {
+            const yamlStr = yaml.stringify(bundle.modelConfig);
+            const { stdout } = await kubectlApplyManifest(yamlStr);
+            results.push({
+                kind: 'ModelConfig',
+                name: bundle.modelConfig.metadata.name,
+                status: parseApplyOutput(stdout),
+            });
+            applied++;
+        }
+        // 2. RemoteMCPServer(s)
+        for (const server of bundle.remoteMCPServers) {
+            const yamlStr = yaml.stringify(server);
+            const { stdout } = await kubectlApplyManifest(yamlStr);
+            results.push({
+                kind: 'RemoteMCPServer',
+                name: server.metadata.name,
+                status: parseApplyOutput(stdout),
+            });
+            applied++;
+        }
+        // 3. Agent (last — depends on ModelConfig and RemoteMCPServer)
+        const agentYaml = yaml.stringify(bundle.agent);
+        const { stdout } = await kubectlApplyManifest(agentYaml);
+        results.push({
+            kind: 'Agent',
+            name: bundle.agent.metadata.name,
+            status: parseApplyOutput(stdout),
+        });
+        applied++;
+        return { success: true, applied, results };
+    }
+    catch (error) {
+        return {
+            success: false,
+            applied,
+            results,
+            error: error instanceof Error ? error.message : String(error),
+        };
+    }
+}
+/**
+ * Flatten a bundle into an ordered array of CRD objects for serialization.
+ * Follows KAGENT_APPLY_ORDER.
+ */
+export function flattenBundle(bundle) {
+    const ordered = [];
+    if (bundle.modelConfig) {
+        ordered.push({
+            kind: 'ModelConfig',
+            name: bundle.modelConfig.metadata.name,
+            manifest: bundle.modelConfig,
+        });
+    }
+    for (const server of bundle.remoteMCPServers) {
+        ordered.push({
+            kind: 'RemoteMCPServer',
+            name: server.metadata.name,
+            manifest: server,
+        });
+    }
+    ordered.push({
+        kind: 'Agent',
+        name: bundle.agent.metadata.name,
+        manifest: bundle.agent,
+    });
+    return ordered;
+}
+//# sourceMappingURL=kubectl-apply.js.map

package/dist/sdks/kagent/tool-registry.d.ts

@@ -0,0 +1,25 @@
+/**
+ * kagent.dev built-in tool registry
+ * Canonical mapping of kagent tool categories and toolNames for validation and docs.
+ * @see https://kagent.dev/tools
+ */
+export declare const KAGENT_TOOL_CATEGORIES: readonly ["kubernetes", "prometheus", "istio", "helm", "argo", "grafana", "cilium", "documentation", "other"];
+export type KAgentToolCategory = (typeof KAGENT_TOOL_CATEGORIES)[number];
+/** Built-in kagent tool names by category (snake_case as in kagent MCP) */
+export declare const KAGENT_BUILTIN_TOOL_NAMES: Record<KAgentToolCategory, string[]>;
+/** All known built-in tool names (flat set for validation) */
+export declare const KAGENT_ALL_BUILTIN_TOOL_NAMES: Set<string>;
+/**
+ * Optional: map OSSA capability-style names to kagent toolNames for convenience.
+ * When manifest uses capabilities: [get_pods, get_logs] we can suggest or map to k8s_* names.
+ */
+export declare const OSSA_CAPABILITY_TO_KAGENT_TOOL: Record<string, string>;
+/**
+ * Check if a tool name is a known kagent built-in (may be from custom MCP)
+ */
+export declare function isKnownKagentBuiltinTool(name: string): boolean;
+/**
+ * Resolve OSSA capability to kagent tool name if mapped
+ */
+export declare function resolveCapabilityToKagentTool(capability: string): string | undefined;
+//# sourceMappingURL=tool-registry.d.ts.map

package/dist/sdks/kagent/tool-registry.js

@@ -0,0 +1,148 @@
+/**
+ * kagent.dev built-in tool registry
+ * Canonical mapping of kagent tool categories and toolNames for validation and docs.
+ * @see https://kagent.dev/tools
+ */
+export const KAGENT_TOOL_CATEGORIES = [
+    'kubernetes',
+    'prometheus',
+    'istio',
+    'helm',
+    'argo',
+    'grafana',
+    'cilium',
+    'documentation',
+    'other',
+];
+/** Built-in kagent tool names by category (snake_case as in kagent MCP) */
+export const KAGENT_BUILTIN_TOOL_NAMES = {
+    kubernetes: [
+        'k8s_annotate_resource',
+        'k8s_apply_manifest',
+        'k8s_check_service_connectivity',
+        'k8s_create_resource',
+        'k8s_create_resource_from_url',
+        'k8s_delete_resource',
+        'k8s_describe_resource',
+        'k8s_execute_command',
+        'k8s_get_available_api_resources',
+        'k8s_get_cluster_configuration',
+        'k8s_get_events',
+        'k8s_get_pod_logs',
+        'k8s_get_resources',
+        'k8s_get_resource_yaml',
+        'k8s_label_resource',
+        'k8s_patch_resource',
+        'k8s_remove_annotation',
+        'k8s_remove_label',
+        'k8s_rollout',
+        'k8s_scale',
+        'k8s_generate_resource_tool',
+    ],
+    prometheus: [
+        'alertmanagers_tool',
+        'alerts_tool',
+        'build_info_tool',
+        'clean_tombstones_tool',
+        'create_snapshot_tool',
+        'delete_series_tool',
+        'label_names_tool',
+        'label_values_tool',
+        'metadata_tool',
+        'query_range_tool',
+        'query_tool',
+        'rules_tool',
+        'runtime_info_tool',
+        'series_query_tool',
+        'status_config_tool',
+        'status_flags_tool',
+        'target_metadata_tool',
+        'targets_tool',
+        'tsdb_status_tool',
+        'wal_replay_tool',
+        'generate_promql_tool',
+    ],
+    istio: [
+        'istio_get_workloads',
+        'istio_get_workload_detail',
+        'istio_get_services',
+        'istio_get_virtual_services',
+        'istio_get_destination_rules',
+        'istio_get_gateways',
+        'istio_get_peer_authentication',
+        'istio_get_authorization_policies',
+        'istio_get_sidecars',
+        'istio_analyze',
+        'istio_inject',
+        'istio_remove',
+        'istio_dashboard',
+    ],
+    helm: [
+        'helm_list_releases',
+        'helm_get_release',
+        'helm_get_manifest',
+        'helm_get_values',
+        'helm_get_history',
+        'helm_rollback',
+    ],
+    argo: [
+        'argo_list_workflows',
+        'argo_get_workflow',
+        'argo_submit_workflow',
+        'argo_list_applications',
+        'argo_get_application',
+        'argo_sync_application',
+        'argo_list_projects',
+    ],
+    grafana: [
+        'grafana_list_dashboards',
+        'grafana_get_dashboard',
+        'grafana_list_data_sources',
+        'grafana_query',
+    ],
+    cilium: [
+        'cilium_status',
+        'cilium_get_identity',
+        'cilium_get_endpoints',
+        'cilium_get_services',
+        'cilium_get_policy',
+        'cilium_get_cluster_mesh',
+        // ... many more; subset for reference
+    ],
+    documentation: ['documentation_search', 'documentation_manage'],
+    other: [],
+};
+/** All known built-in tool names (flat set for validation) */
+export const KAGENT_ALL_BUILTIN_TOOL_NAMES = new Set(Object.values(KAGENT_BUILTIN_TOOL_NAMES).flat());
+/**
+ * Optional: map OSSA capability-style names to kagent toolNames for convenience.
+ * When manifest uses capabilities: [get_pods, get_logs] we can suggest or map to k8s_* names.
+ */
+export const OSSA_CAPABILITY_TO_KAGENT_TOOL = {
+    get_pods: 'k8s_get_resources',
+    get_logs: 'k8s_get_pod_logs',
+    get_events: 'k8s_get_events',
+    describe_resource: 'k8s_describe_resource',
+    get_metrics: 'prometheus_query_tool',
+    apply_manifest: 'k8s_apply_manifest',
+    delete_resource: 'k8s_delete_resource',
+    get_available_api_resources: 'k8s_get_available_api_resources',
+    get_resources: 'k8s_get_resources',
+    get_pod_logs: 'k8s_get_pod_logs',
+    execute_command: 'k8s_execute_command',
+    rollout: 'k8s_rollout',
+    scale: 'k8s_scale',
+};
+/**
+ * Check if a tool name is a known kagent built-in (may be from custom MCP)
+ */
+export function isKnownKagentBuiltinTool(name) {
+    return KAGENT_ALL_BUILTIN_TOOL_NAMES.has(name);
+}
+/**
+ * Resolve OSSA capability to kagent tool name if mapped
+ */
+export function resolveCapabilityToKagentTool(capability) {
+    return OSSA_CAPABILITY_TO_KAGENT_TOOL[capability];
+}
+//# sourceMappingURL=tool-registry.js.map

package/dist/sdks/kagent/types.d.ts

@@ -117,12 +117,119 @@ export interface KubernetesManifestBundle {
     networkPolicy: Record<string, unknown>;
     readme: string;
 }
+/**
+ * kagent.dev v1alpha2 Declarative Agent (native kagent CRD shape)
+ */
+export interface KAgentV1Alpha2Agent {
+    apiVersion: 'kagent.dev/v1alpha2';
+    kind: 'Agent';
+    metadata: {
+        name: string;
+        namespace?: string;
+        labels?: Record<string, string>;
+        annotations?: Record<string, string>;
+    };
+    spec: {
+        type: 'Declarative';
+        description?: string;
+        declarative: {
+            modelConfig: string;
+            stream?: boolean;
+            systemMessage: string;
+            systemMessageFrom?: {
+                type: 'ConfigMap' | 'Secret';
+                name: string;
+                key: string;
+            };
+            tools?: ({
+                type: 'McpServer';
+                mcpServer: {
+                    name: string;
+                    namespace?: string;
+                    kind: 'RemoteMCPServer';
+                    toolNames: string[];
+                };
+                headersFrom?: Array<{
+                    name: string;
+                    valueFrom: {
+                        type: 'Secret' | 'ConfigMap';
+                        name: string;
+                        key: string;
+                    };
+                }>;
+            } | {
+                type: 'Agent';
+                agent: {
+                    name: string;
+                    namespace?: string;
+                };
+            })[];
+            a2aConfig?: {
+                skills?: Array<{
+                    id: string;
+                    name: string;
+                    description: string;
+                    inputModes?: string[];
+                    outputModes?: string[];
+                    tags?: string[];
+                    examples?: string[];
+                }>;
+            };
+        };
+        deployment?: {
+            replicas?: number;
+            resources?: {
+                requests?: {
+                    cpu?: string;
+                    memory?: string;
+                };
+                limits?: {
+                    cpu?: string;
+                    memory?: string;
+                };
+            };
+        };
+        skills?: {
+            insecureSkipVerify?: boolean;
+            refs?: string[];
+        };
+    };
+}
+/**
+ * kagent.dev v1alpha2 ModelConfig
+ */
+export interface KAgentV1Alpha2ModelConfig {
+    apiVersion: 'kagent.dev/v1alpha2';
+    kind: 'ModelConfig';
+    metadata: {
+        name: string;
+        namespace?: string;
+        labels?: Record<string, string>;
+    };
+    spec: {
+        model: string;
+        provider: string;
+        apiKeySecret?: string;
+        apiKeySecretKey?: string;
+        openAI?: {
+            maxTokens?: number;
+            temperature?: number;
+        };
+        anthropic?: {
+            maxTokens?: number;
+            temperature?: number;
+        };
+    };
+}
 /**
  * Deployment options for kagent
  */
 export interface KAgentDeploymentOptions {
     namespace?: string;
     replicas?: number;
+    crdVersion?: 'v1alpha1' | 'v1alpha2';
+    /** For v1alpha2: name of ModelConfig to reference (e.g. default-model-config) */
+    modelConfigName?: string;
     resources?: {
         limits?: {
             cpu?: string;
@@ -197,4 +304,24 @@ export interface KAgentValidationResult {
     errors: string[];
     warnings: string[];
 }
+/**
+ * v1alpha2 bundle: ModelConfig (optional), RemoteMCPServers, Agent.
+ * Apply order: ModelConfig -> RemoteMCPServer(s) -> Agent.
+ */
+export interface KAgentV1Alpha2Bundle {
+    modelConfig?: KAgentV1Alpha2ModelConfig;
+    remoteMCPServers: Array<{
+        apiVersion: string;
+        kind: string;
+        metadata: {
+            name: string;
+            namespace?: string;
+            labels?: Record<string, string>;
+        };
+        spec: Record<string, unknown>;
+    }>;
+    agent: KAgentV1Alpha2Agent;
+}
+/** Apply order for v1alpha2 bundle (ModelConfig -> RemoteMCPServer -> Agent). */
+export declare const KAGENT_APPLY_ORDER: readonly ["ModelConfig", "RemoteMCPServer", "Agent"];
 //# sourceMappingURL=types.d.ts.map

package/dist/sdks/kagent/types.js

@@ -1,5 +1,10 @@
 /**
  * kagent.dev SDK Types
  */
-export {};
+/** Apply order for v1alpha2 bundle (ModelConfig -> RemoteMCPServer -> Agent). */
+export const KAGENT_APPLY_ORDER = [
+    'ModelConfig',
+    'RemoteMCPServer',
+    'Agent',
+];
 //# sourceMappingURL=types.js.map