@datalayer/agent-runtimes 1.0.5 → 1.0.6

package/lib/stores/agentRuntimeStore.d.ts

@@ -75,7 +75,7 @@ export interface AgentRuntimeStoreActions {
     setLoadedSkillsForAgent: (agentId: string, skills: LoadedSkillInfo[]) => void;
     getLoadedSkillsForAgent: (agentId: string) => LoadedSkillInfo[];
     clearLoadedSkillsForAgent: (agentId: string) => void;
-    launchAgent: (options: IRuntimeOptions) => Promise<AgentConnection>;
+    launchAgent: (options: LaunchAgentOptions) => Promise<AgentConnection>;
     connectAgent: (connection: {
         podName: string;
         environmentName: string;
@@ -134,6 +134,10 @@ export interface AgentRuntimeStoreActions {
     resetWs: () => void;
 }
 export type AgentRuntimeStore = AgentRuntimeStoreState & AgentRuntimeStoreActions;
+export interface LaunchAgentOptions extends IRuntimeOptions {
+    /** Optional runtimes API base URL override for runtime creation. */
+    runtimesRunUrl?: string;
+}
 export declare const agentRuntimeStore: Omit<Omit<import("zustand").StoreApi<AgentRuntimeStore>, "subscribe"> & {
     subscribe: {
         (listener: (selectedState: AgentRuntimeStore, previousSelectedState: AgentRuntimeStore) => void): () => void;

package/lib/stores/agentRuntimeStore.js

@@ -89,6 +89,7 @@ const initialWsState = {
     monitoringCache: {},
     loadedSkillsByAgentId: {},
 };
+const countPendingApprovals = (approvals) => approvals.filter(approval => approval.status === 'pending').length;
 // ---------------------------------------------------------------------------
 // Store
 // ---------------------------------------------------------------------------
@@ -233,13 +234,20 @@ export const agentRuntimeStore = createStore()(subscribeWithSelector(persist((se
         set({ status: 'launching', error: null, isLaunching: true });
         try {
             const { createRuntime } = await import('@datalayer/core/lib/api');
+            const { runtimesStore } = await import('@datalayer/core/lib/state');
+            if (config.runtimesRunUrl) {
+                runtimesStore.setState({
+                    runtimesRunUrl: config.runtimesRunUrl,
+                });
+            }
+            const { runtimesRunUrl: _runtimesRunUrl, ...runtimeOptions } = config;
             const runtimePod = await createRuntime({
-                environmentName: config.environmentName,
-                creditsLimit: config.creditsLimit,
-                type: config.type || 'notebook',
-                givenName: config.givenName,
-                capabilities: config.capabilities,
-                snapshot: config.snapshot,
+                environmentName: runtimeOptions.environmentName,
+                creditsLimit: runtimeOptions.creditsLimit,
+                type: runtimeOptions.type || 'notebook',
+                givenName: runtimeOptions.givenName,
+                capabilities: runtimeOptions.capabilities,
+                snapshot: runtimeOptions.snapshot,
             });
             set({ status: 'connecting' });
             const jupyterBaseUrl = runtimePod.ingress;
@@ -316,11 +324,17 @@ export const agentRuntimeStore = createStore()(subscribeWithSelector(persist((se
     upsertApproval: approval => set(state => {
         const filtered = state.approvals.filter(a => a.id !== approval.id);
         const approvals = [approval, ...filtered];
-        return { approvals, pendingApprovalCount: approvals.length };
+        return {
+            approvals,
+            pendingApprovalCount: countPendingApprovals(approvals),
+        };
     }),
     removeApproval: approvalId => set(state => {
         const approvals = state.approvals.filter(a => a.id !== approvalId);
-        return { approvals, pendingApprovalCount: approvals.length };
+        return {
+            approvals,
+            pendingApprovalCount: countPendingApprovals(approvals),
+        };
     }),
     sendDecision: (approvalId, approved, note, toolCallId, agentId) => {
         const targetWs = _resolveWs(agentId);

package/lib/stores/conversationStore.js

@@ -8,8 +8,8 @@
  *
  * Key features:
  * - Messages are stored per runtime ID in memory
- * - On page reload, messages are fetched from the server API
- * - No browser storage persistence - server is the source of truth
+ * - On page reload, messages are synchronized from the runtime via websocket
+ * - No browser storage persistence - runtime is the source of truth
  *
  * @module store/conversationStore
  */

package/lib/types/agents-lifecycle.d.ts

@@ -18,6 +18,24 @@ export type CreateAgentRuntimeRequest = {
     agentSpecId?: string;
     /** Full agent spec payload to propagate to backend services */
     agentSpec?: Record<string, any>;
+    /** Account UID (user or organization) charged for runtime costs */
+    billableAccountUid?: string;
+    /** User account handle used for user home mount path. */
+    userAccountHandle?: string;
+    /** Account kind charged for runtime costs. */
+    billableAccountType?: 'user' | 'organization' | 'team';
+    /** Account handle charged for runtime costs. */
+    billableAccountHandle?: string;
+    /** Source organization UID for team-billed runtimes. */
+    billableSourceOrganizationUid?: string;
+    /** Source organization handle for team-billed runtimes. */
+    billableSourceOrganizationHandle?: string;
+    /** Mount account home folder into runtime. */
+    mountHomeFolder?: boolean;
+    /** Optional volume UID to mount into runtime. */
+    volumeUid?: string;
+    /** Optional volume UIDs to mount into runtime. */
+    volumeUids?: string[];
 };
 export type CreateRuntimeApiResponse = {
     success?: boolean;

package/lib/types/agents.d.ts

@@ -53,6 +53,12 @@ export type AgentRuntimeData = {
     token?: string;
     agentSpec?: AgentSpec;
     agent_spec_id?: string;
+    billable_account_uid?: string;
+    billable_account_type?: 'user' | 'organization' | 'team';
+    billable_account_handle?: string;
+    mount_home_folder?: boolean;
+    volume_uid?: string;
+    volume_uids?: string[];
 };
 export interface RunningAgent {
     /** Unique agent ID within the runtime */

package/lib/types/agentspecs.d.ts

@@ -33,6 +33,8 @@ export interface AgentSpec {
     enabled: boolean;
     /** AI model identifier to use for this agent */
     model?: string;
+    /** Inference provider routing strategy */
+    inferenceProvider?: 'local' | 'datalayer';
     /** MCP servers used by this agent */
     mcpServers: MCPServer[];
     /** Skills available to this agent */
@@ -96,6 +98,8 @@ export interface AgentSpec {
     postHooks?: {
         sandbox?: string | string[];
     };
+    /** Per-tool-call hooks (authorization/audit integration). */
+    toolHooks?: Record<string, any>;
     /** JSON schema for launch-time parameter values. */
     parameters?: Record<string, any>;
     /** Subagent delegation configuration. */

package/lib/types/benchmarks.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Evaluation benchmark specification.
+ */
+export interface BenchmarkSpec {
+    /** Unique benchmark identifier */
+    id: string;
+    /** Version */
+    version?: string;
+    /** Display name */
+    name: string;
+    /** Description of the benchmark */
+    description: string;
+    /** Category: Coding, Knowledge, Reasoning, Agentic, or Safety */
+    category: 'Coding' | 'Knowledge' | 'Reasoning' | 'Agentic' | 'Safety';
+    /** Number of tasks in the benchmark */
+    task_count: number;
+    /** Primary metric (e.g., 'pass@1', 'accuracy', 'success_rate') */
+    metric: string;
+    /** Source URL or repository */
+    source: string;
+    /** Difficulty level */
+    difficulty: 'easy' | 'medium' | 'hard' | 'expert';
+    /** Relevant languages */
+    languages: string[];
+    /** Dataset source mode used by this benchmark */
+    dataset_source?: 'hosted' | 'local' | 'hybrid';
+    /** Whether this benchmark can be tracked in live monitoring */
+    supports_live_monitoring?: boolean;
+    /** Whether this benchmark supports side-by-side run comparison */
+    supports_experiment_comparison?: boolean;
+    /** Shapes emitted by evaluators (pass_rate, numeric, categorical, error_only) */
+    evaluator_shapes?: Array<'pass_rate' | 'numeric' | 'categorical' | 'error_only'>;
+    /** Evaluator IDs (optionally versioned) used to score this benchmark */
+    evaluators: string[];
+    /** Suggested time windows for monitoring UIs */
+    recommended_windows?: string[];
+    /** Whether traces include links from results to execution spans */
+    trace_integration?: boolean;
+    /** Whether cases are editable in hosted UI */
+    dataset_editability?: 'read-only' | 'editable';
+    /** SDK maturity level for this benchmark */
+    sdk_support?: 'none' | 'experimental' | 'stable';
+}

package/lib/types/benchmarks.js

@@ -0,0 +1,5 @@
+/*
+ * Copyright (c) 2025-2026 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+export {};

package/lib/types/chat.d.ts

@@ -462,6 +462,22 @@ export interface ChatBaseProps {
     loadingState?: React.ReactNode;
     /** Header actions */
     headerActions?: React.ReactNode;
+    /** Notebook kernel indicator state override for the chat header. */
+    kernelIndicatorState?: import('@datalayer/jupyter-react').ExecutionState;
+    /**
+     * Live notebook kernel connection. When provided, the chat header
+     * renders the same `<KernelIndicator>` as the notebook toolbar so
+     * the colour and tooltip remain in sync with the notebook runtime.
+     */
+    kernel?: import('@jupyterlab/services/lib/kernel/kernel').IKernelConnection | null;
+    /** Optional environment name displayed in kernel indicator details. */
+    kernelEnvironmentName?: string;
+    /** Optional CPU info displayed in kernel indicator details. */
+    kernelCpu?: string;
+    /** Optional memory info displayed in kernel indicator details. */
+    kernelMemory?: string;
+    /** Optional GPU info displayed in kernel indicator details. */
+    kernelGpu?: string;
     /**
      * Current chat view mode.
      * When provided, a segmented view-mode toggle is rendered in the header

package/lib/types/evals.d.ts

@@ -1,5 +1,5 @@
 /**
- * Evaluation benchmark specification.
+ * Built-in evaluator specification.
  */
 export interface EvalSpec {
     /** Unique eval identifier */
@@ -8,20 +8,26 @@ export interface EvalSpec {
     version?: string;
     /** Display name */
     name: string;
-    /** Description of the evaluation */
+    /** Description of the evaluator */
     description: string;
-    /** Category: Coding, Knowledge, Reasoning, Agentic, or Safety */
-    category: 'Coding' | 'Knowledge' | 'Reasoning' | 'Agentic' | 'Safety';
-    /** Number of tasks in the benchmark */
-    task_count: number;
-    /** Primary metric (e.g., 'pass@1', 'accuracy', 'success_rate') */
-    metric: string;
-    /** Source URL or repository */
+    /** Evaluator family */
+    category: 'Comparison' | 'Type Validation' | 'Performance' | 'LLM-as-a-Judge' | 'Span-Based' | 'Report';
+    /** Case-level or report-level evaluator */
+    evaluator_type: 'case' | 'report';
+    /** Pydantic evaluator class name */
+    pydantic_class: string;
+    /** Primary output shape */
+    output_kind: 'boolean' | 'boolean_with_reason' | 'score' | 'score_and_assertion' | 'report_table' | 'report_curve';
+    /** Cost tier for running this evaluator */
+    cost_tier: 'free' | 'llm';
+    /** Expected latency profile */
+    latency: 'instant' | 'fast' | 'slow';
+    /** Runtime requirements (e.g. expected_output, logfire, model) */
+    requires?: string[];
+    /** Source documentation URL */
     source: string;
-    /** Difficulty level */
-    difficulty: 'easy' | 'medium' | 'hard' | 'expert';
-    /** Relevant languages */
-    languages: string[];
+    /** Suggested baseline configuration */
+    default_config?: Record<string, unknown>;
 }
 /**
  * Eval configuration for an agent spec.
@@ -31,11 +37,14 @@ export interface AgentEvalConfig {
     name?: string;
     description?: string;
     category?: string;
-    task_count?: number;
-    metric?: string;
+    evaluator_type?: string;
+    pydantic_class?: string;
+    output_kind?: string;
+    cost_tier?: string;
+    latency?: string;
+    requires?: string[];
     source?: string;
-    difficulty?: string;
-    languages?: string[];
+    default_config?: Record<string, unknown>;
     [key: string]: unknown;
 }
 export interface EvalReport {

package/lib/types/index.d.ts

@@ -4,6 +4,7 @@ export * from './ag-ui';
 export * from './agents';
 export * from './agents-lifecycle';
 export * from './agentspecs';
+export * from './benchmarks';
 export * from './chat';
 export * from './checkpoints';
 export * from './config';

package/lib/types/index.js

@@ -8,6 +8,7 @@ export * from './ag-ui';
 export * from './agents';
 export * from './agents-lifecycle';
 export * from './agentspecs';
+export * from './benchmarks';
 export * from './chat';
 export * from './checkpoints';
 export * from './config';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@datalayer/agent-runtimes",
-  "version": "1.0.5",
+  "version": "1.0.6",
   "type": "module",
   "workspaces": [
     ".",
@@ -68,10 +68,11 @@
     "clean:lib": "rimraf lib tsconfig.tsbuildinfo",
     "create:patches": "bash scripts/create-patches.sh",
     "examples": "run-p server:start server:start:codemode jupyter:start examples:vite",
+    "examples:proxy": "make examples:proxy",
     "examples:fresh": "npm run clean:cache && npm run examples",
     "examples:jupyter": "run-p jupyter:start server:start server:start:codemode examples:vite",
     "examples:nextjs": "npm run dev --workspace=nextjs-notebook-example",
-    "examples:vite": "VITE_APP_TARGET=examples VITE_DATALAYER_RUN_URL=http://localhost:8888 vite",
+    "examples:vite": "VITE_DATALAYER_RUN_URL=${VITE_DATALAYER_RUN_URL:-https://prod1.datalayer.run} VITE_DATALAYER_RUNTIMES_URL=${VITE_DATALAYER_RUNTIMES_URL:-https://r1.datalayer.run} VITE_DATALAYER_AGENT_RUNTIMES_URL=${VITE_DATALAYER_AGENT_RUNTIMES_URL:-https://r1.datalayer.run} VITE_APP_TARGET=examples vite",
     "format": "prettier --write \"src/**/*.{js,jsx,ts,tsx,css,json,md}\" \"examples/**/*.{js,jsx,ts,tsx,css,json,md,mjs}\"",
     "format:all": "npm run format && npm run format --workspaces --if-present",
     "format:check": "prettier --check \"src/**/*.{js,jsx,ts,tsx,css,json,md}\" \"examples/**/*.{js,jsx,ts,tsx,css,json,md,mjs}\"",
@@ -89,8 +90,9 @@
     "preview": "vite preview",
     "rebuild:fresh": "npm run create:patches && npm install && npm run build && npm run clean:cache",
     "server": "python -m agent_runtimes serve",
-    "server:start": "PYTHONIOENCODING=utf-8 AGENT_RUNTIMES_DEBUG=false AGENT_RUNTIMES_LOG_LEVEL=info python -m agent_runtimes serve --port 8765 --log-level info",
-    "server:start:codemode": "PYTHONIOENCODING=utf-8 AGENT_RUNTIMES_DEBUG=false AGENT_RUNTIMES_LOG_LEVEL=info python -m agent_runtimes serve --port 8766 --log-level info",
+    "server:start": "PYTHONIOENCODING=utf-8 AGENT_RUNTIMES_DEBUG=false AGENT_RUNTIMES_LOG_LEVEL=info DATALAYER_EVALS_MODE=interactive DATALAYER_EVALS_EMIT_LIVE_EVENTS=true python -m agent_runtimes serve --port 8765 --log-level info",
+    "server:start:agent-node": "PYTHONIOENCODING=utf-8 AGENT_RUNTIMES_DEBUG=false AGENT_RUNTIMES_LOG_LEVEL=info DATALAYER_EVALS_MODE=interactive DATALAYER_EVALS_EMIT_LIVE_EVENTS=true AGENT_RUNTIMES_INFERENCE_PROVIDER_OVERRIDE=${AGENT_RUNTIMES_INFERENCE_PROVIDER_OVERRIDE:-datalayer} python -m agent_runtimes serve --node --port 8765 --log-level info",
+    "server:start:codemode": "PYTHONIOENCODING=utf-8 AGENT_RUNTIMES_DEBUG=false AGENT_RUNTIMES_LOG_LEVEL=info DATALAYER_EVALS_MODE=interactive DATALAYER_EVALS_EMIT_LIVE_EVENTS=true python -m agent_runtimes serve --port 8766 --log-level info",
     "examples:codemode": "run-p server:start server:start:codemode examples:vite",
     "start": "vite",
     "start:acp": "run-p server:start start:acp:vite",
@@ -98,6 +100,8 @@
     "start:acp:vite": "VITE_ACP_WS_URL=ws://localhost:8765/api/v1/acp/ws vite",
     "start:agent": "run-p server:start start:agent:vite",
     "start:agent:vite": "vite --open /html/agent.html",
+    "start:agent-node": "run-p server:start:agent-node start:agent-node:vite",
+    "start:agent-node:vite": "vite --open /html/agent-node.html",
     "start:agent-notebook": "run-p server:start jupyter:start start:agent-notebook:vite",
     "start:agent-notebook:vite": "vite --open /html/agent-notebook.html",
     "start:agent-lexical": "run-p server:start jupyter:start start:agent-lexical:vite",
@@ -130,7 +134,7 @@
     "@agentclientprotocol/sdk": "^0.8.0",
     "@ai-sdk/react": "^4.0.0-beta.33",
     "@anthropic-ai/sdk": "^0.52.0",
-    "@datalayer/core": "^1.0.20",
+    "@datalayer/core": "^1.0.22",
     "@datalayer/icons-react": "^1.0.7",
     "@datalayer/jupyter-lexical": "^1.0.16",
     "@datalayer/jupyter-react": "^2.0.7",

package/scripts/codegen/generate_agents.py

@@ -11,6 +11,7 @@ Generates Python and TypeScript code from YAML agent specifications.
 import argparse
 import json
 import sys
+from copy import deepcopy
 from pathlib import Path
 from typing import Any, Dict, List
 
@@ -82,6 +83,30 @@ def _normalize_subagents_for_typescript(value: Any) -> Any:
     return normalized
 
 
+def _sanitize_tool_hooks_for_codegen(value: Any) -> Any:
+    """Normalize tool hook paths that would trigger bandit in generated code."""
+    if not isinstance(value, dict):
+        return value
+
+    tool_hooks = deepcopy(value)
+    for key in ("audit_log_path", "auditLogPath"):
+        raw_path = tool_hooks.get(key)
+        if isinstance(raw_path, str):
+            raw_parts = Path(raw_path).parts
+            if len(raw_parts) >= 3 and raw_parts[0] == "/" and raw_parts[1] == "tmp":
+                tool_hooks[key] = Path(raw_path).name
+    return tool_hooks
+
+
+def _sanitize_spec_for_codegen(spec: Dict[str, Any]) -> Dict[str, Any]:
+    """Return a spec copy sanitized for generated Python/TypeScript outputs."""
+    sanitized = deepcopy(spec)
+    sanitized["tool_hooks"] = _sanitize_tool_hooks_for_codegen(
+        sanitized.get("tool_hooks")
+    )
+    return sanitized
+
+
 def load_yaml_specs(specs_dir: Path) -> List[tuple[str, Dict[str, Any]]]:
     """
     Load all YAML agent specifications from directory and subdirectories.
@@ -161,6 +186,7 @@ from agent_runtimes.types import AgentSpec, SubAgentSpecConfig, SubAgentsConfig
             code += f"# {'=' * 76}\n\n"
 
         for spec in folder_specs:
+            spec = _sanitize_spec_for_codegen(spec)
             agent_id = spec["id"]
             version = spec["version"]
             # Prefix agent ID with folder name for uniqueness
@@ -248,6 +274,10 @@ from agent_runtimes.types import AgentSpec, SubAgentSpecConfig, SubAgentsConfig
             # Model field
             model_id = spec.get("model")
             model_str = f'"{model_id}"' if model_id else "None"
+            inference_provider = spec.get("inference_provider")
+            inference_provider_str = (
+                f'"{inference_provider}"' if inference_provider else "None"
+            )
 
             # Sandbox variant field
             sandbox_variant = spec.get("sandbox_variant")
@@ -280,6 +310,7 @@ from agent_runtimes.types import AgentSpec, SubAgentSpecConfig, SubAgentsConfig
             memory_str = f'"{memory_val}"' if memory_val else "None"
             pre_hooks_val = spec.get("pre_hooks")
             post_hooks_val = spec.get("post_hooks")
+            tool_hooks_val = spec.get("tool_hooks")
             parameters_val = spec.get("parameters")
             subagents_val = spec.get("subagents")
 
@@ -329,6 +360,7 @@ from agent_runtimes.types import AgentSpec, SubAgentSpecConfig, SubAgentsConfig
     tags={_fmt_list(spec.get("tags", []))},
     enabled={spec.get("enabled", True)},
     model={model_str},
+    inference_provider={inference_provider_str},
     mcp_servers=[{mcp_servers_str}],
     skills={_fmt_list(skill_refs)},
     tools={_fmt_list(tool_refs)},
@@ -360,6 +392,7 @@ from agent_runtimes.types import AgentSpec, SubAgentSpecConfig, SubAgentsConfig
     memory={memory_str},
     pre_hooks={_fmt_py_literal(pre_hooks_val)},
     post_hooks={_fmt_py_literal(post_hooks_val)},
+    tool_hooks={_fmt_py_literal(tool_hooks_val)},
     parameters={_fmt_py_literal(parameters_val)},
     subagents={subagents_str},
 )
@@ -649,15 +682,15 @@ const SKILL_MAP: Record<string, any> = {
         code += "};\n"
         code += """
 function toAgentSkillSpec(skill: SkillSpec) {
-  return {
-    id: skill.id,
-    name: skill.name,
-    description: skill.description,
+    return {
+        id: skill.id,
+        name: skill.name,
+        description: skill.description,
         version: skill.version ?? '0.0.1',
-    tags: skill.tags,
-    enabled: skill.enabled,
-    requiredEnvVars: skill.requiredEnvVars,
-  };
+        tags: skill.tags,
+        enabled: skill.enabled,
+        requiredEnvVars: skill.requiredEnvVars,
+    };
 }
 """
 
@@ -714,6 +747,7 @@ const FRONTEND_TOOL_MAP: Record<string, any> = {
             code += f"// {'=' * 76}\n\n"
 
         for spec in folder_specs:
+            spec = _sanitize_spec_for_codegen(spec)
             agent_id = spec["id"]
             version = spec["version"]
             # Prefix agent ID with folder name for uniqueness
@@ -748,7 +782,8 @@ const FRONTEND_TOOL_MAP: Record<string, any> = {
             ]
             if has_skills and skill_ids_list:
                 skills_str = ", ".join(
-                    f"toAgentSkillSpec(SKILL_MAP['{sid}'])" for sid in skill_ids_list
+                    f"(SKILL_MAP['{sid}'] ? toAgentSkillSpec(SKILL_MAP['{sid}']) : undefined)"
+                    for sid in skill_ids_list
                 )
             else:
                 skills_str = ""
@@ -816,6 +851,10 @@ const FRONTEND_TOOL_MAP: Record<string, any> = {
             # Model field
             model_id = spec.get("model")
             model_ts = f"'{model_id}'" if model_id else "undefined"
+            inference_provider = spec.get("inference_provider")
+            inference_provider_ts = (
+                f"'{inference_provider}'" if inference_provider else "undefined"
+            )
 
             # Sandbox variant field
             sandbox_variant = spec.get("sandbox_variant")
@@ -851,53 +890,60 @@ const FRONTEND_TOOL_MAP: Record<string, any> = {
             memory_ts = f"'{memory_val}'" if memory_val else "undefined"
             pre_hooks_val = spec.get("pre_hooks")
             post_hooks_val = spec.get("post_hooks")
+            tool_hooks_val = spec.get("tool_hooks")
             parameters_val = spec.get("parameters")
             subagents_val = spec.get("subagents")
             subagents_ts = _fmt_ts_literal(
                 _normalize_subagents_for_typescript(subagents_val)
             )
+            inference_provider_line = (
+                f"    inferenceProvider: {inference_provider_ts},\n"
+                if inference_provider
+                else ""
+            )
 
             code += f"""export const {const_name}: AgentSpec = {{
-  id: '{full_agent_id}',
+    id: '{full_agent_id}',
     version: '{version}',
-  name: '{spec["name"]}',
-  description: `{description}`,
-  tags: {tags_str},
-  enabled: {str(spec.get("enabled", True)).lower()},
-  model: {model_ts},
-  mcpServers: [{mcp_servers_str}],
-  skills: [{skills_str}],
+    name: '{spec["name"]}',
+    description: `{description}`,
+    tags: {tags_str},
+    enabled: {str(spec.get("enabled", True)).lower()},
+    model: {model_ts},
+{inference_provider_line}    mcpServers: [{mcp_servers_str}],
+    skills: [{skills_str}].filter(Boolean) as SkillSpec[],
     tools: [{tools_str}],
     frontendTools: [{frontend_tools_str}],
-  environmentName: '{spec.get("environment_name", "ai-agents-env")}',
-  icon: {icon},
-  emoji: {emoji},
-  color: {color},
-  suggestions: {suggestions_str},
+    environmentName: '{spec.get("environment_name", "ai-agents-env")}',
+    icon: {icon},
+    emoji: {emoji},
+    color: {color},
+    suggestions: {suggestions_str},
     welcomeMessage: {_fmt_ts_literal(welcome_message)},
     welcomeNotebook: {_fmt_ts_literal(welcome_notebook)},
     welcomeDocument: {_fmt_ts_literal(welcome_document)},
-  sandboxVariant: {sandbox_variant_ts},
-  systemPrompt: {f"`{system_prompt}`" if system_prompt else "undefined"},
-  systemPromptCodemodeAddons: {f"`{system_prompt_codemode_addons}`" if system_prompt_codemode_addons else "undefined"},
-  goal: {goal_ts},
-  protocol: {protocol_ts},
-  uiExtension: {ui_ext_ts},
-  trigger: {_fmt_ts_literal(trigger_val)},
-  modelConfig: {_fmt_ts_literal(model_cfg)},
-  mcpServerTools: {_fmt_ts_literal(mcp_srv_tools)},
-  guardrails: {_fmt_ts_literal(guardrails_val)},
-  evals: {_fmt_ts_literal(evals_val)},
-  codemode: {_fmt_ts_literal(codemode_val)},
-  output: {_fmt_ts_literal(output_val)},
-  advanced: {_fmt_ts_literal(advanced_val)},
-  authorizationPolicy: {auth_policy_ts},
-  notifications: {_fmt_ts_literal(notifs)},
-  memory: {memory_ts},
-  preHooks: {_fmt_ts_literal(pre_hooks_val)},
-  postHooks: {_fmt_ts_literal(post_hooks_val)},
-  parameters: {_fmt_ts_literal(parameters_val)},
-  subagents: {subagents_ts},
+    sandboxVariant: {sandbox_variant_ts},
+    systemPrompt: {f"`{system_prompt}`" if system_prompt else "undefined"},
+    systemPromptCodemodeAddons: {f"`{system_prompt_codemode_addons}`" if system_prompt_codemode_addons else "undefined"},
+    goal: {goal_ts},
+    protocol: {protocol_ts},
+    uiExtension: {ui_ext_ts},
+    trigger: {_fmt_ts_literal(trigger_val)},
+    modelConfig: {_fmt_ts_literal(model_cfg)},
+    mcpServerTools: {_fmt_ts_literal(mcp_srv_tools)},
+    guardrails: {_fmt_ts_literal(guardrails_val)},
+    evals: {_fmt_ts_literal(evals_val)},
+    codemode: {_fmt_ts_literal(codemode_val)},
+    output: {_fmt_ts_literal(output_val)},
+    advanced: {_fmt_ts_literal(advanced_val)},
+    authorizationPolicy: {auth_policy_ts},
+    notifications: {_fmt_ts_literal(notifs)},
+    memory: {memory_ts},
+    preHooks: {_fmt_ts_literal(pre_hooks_val)},
+    postHooks: {_fmt_ts_literal(post_hooks_val)},
+    toolHooks: {_fmt_ts_literal(tool_hooks_val)},
+    parameters: {_fmt_ts_literal(parameters_val)},
+    subagents: {subagents_ts},
 }};
 
 """