@datalayer/agent-runtimes 1.3.54 → 1.3.55

package/lib/examples/AgentStrategyExample.d.ts

@@ -0,0 +1,12 @@
+import { ServiceManager } from '@jupyterlab/services';
+interface AgentStrategyExampleInnerProps {
+    serviceManager?: ServiceManager.IManager;
+}
+export declare function AgentStrategyExampleInner({ serviceManager, }: AgentStrategyExampleInnerProps): import("react").JSX.Element;
+/**
+ * Main example component with Jupyter provider wrapper.
+ */
+export declare function AgentStrategyExample({ serviceManager, }: {
+    serviceManager?: ServiceManager.IManager;
+}): import("react").JSX.Element;
+export default AgentStrategyExample;

package/lib/examples/{AgentLoopExample.js → AgentStrategyExample.js}

@@ -4,27 +4,27 @@ import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-run
  * Distributed under the terms of the Modified BSD License.
  */
 /**
- * AgentLoopExample - Define and launch an agent execution *loop*.
+ * AgentStrategyExample - Define and launch an agent reasoning *strategy*.
  *
- * This example demonstrates the "loop" paradigm (observe → think → act →
+ * This example demonstrates the control-loop paradigm (observe → think → act →
  * evaluate) instead of one-shot prompting. It is fully driven by the generic
- * loop specifications defined in agentspecs (`src/specs/loops.ts`):
+ * strategy specifications defined in agentspecs (`src/specs/strategies.ts`):
  *
- * - Pick any loop spec (Data Analysis, Plan/Execute/Critic, OODA,
- *   Human-in-the-Loop). The list is read from the loop catalogue, so adding a
- *   new YAML loop spec automatically makes it available here.
- * - The agent's system prompt is composed generically from the selected loop's
+ * - Pick any strategy spec (Data Analysis, Plan/Execute/Critic, OODA,
+ *   Human-in-the-Loop). The list is read from the strategy catalogue, so adding a
+ *   new YAML strategy spec automatically makes it available here.
+ * - The agent's system prompt is composed generically from the selected strategy's
  *   objective, phases, constraints, termination policy and human settings — no
- *   loop-specific code.
- * - The agent then runs the loop against a live Jupyter notebook, where the
- *   loop state (dataframes, charts, intermediate results) lives outside the
+ *   strategy-specific code.
+ * - The agent then runs the strategy against a live Jupyter notebook, where the
+ *   strategy state (dataframes, charts, intermediate results) lives outside the
  *   model so each iteration stays small and focused.
  *
  * To run this example:
  * 1. Start the agent-runtimes server.
  * 2. Select this example from the header dropdown (Agent group).
  *
- * @module examples/AgentLoopExample
+ * @module examples/AgentStrategyExample
  */
 import { useMemo, useState } from 'react';
 import { Box } from '@datalayer/primer-addons';
@@ -32,40 +32,40 @@ import { Notebook } from '@datalayer/jupyter-react';
 import { useNotebookTools } from '../tools/adapters/agent-runtimes/notebookHooks';
 import { ThemedJupyterProvider, ThemedProvider } from './utils/themedProvider';
 import { ChatSidebar } from '../chat';
-import { listLoops, getLoop, DEFAULT_LOOP } from '../specs';
+import { listStrategies, getStrategy, DEFAULT_STRATEGY } from '../specs';
 import { useExampleJupyterAgent } from './hooks/useExampleJupyterAgent';
 import MatplotlibNotebook from './utils/notebooks/Matplotlib.ipynb.json';
 import { ExampleNotebookToolbar } from './utils/notebookToolbarItems';
 // Fixed notebook ID
-const NOTEBOOK_ID = 'agent-loop-example';
-// Use the imported Matplotlib notebook as the working surface for the loop.
+const NOTEBOOK_ID = 'agent-strategy-example';
+// Use the imported Matplotlib notebook as the working surface for the strategy.
 const NOTEBOOK_CONTENT = MatplotlibNotebook;
 // Default configuration
-const DEFAULT_AGENT_ID = import.meta.env.VITE_AGENT_ID || 'loop-agent-runtime-example';
+const DEFAULT_AGENT_ID = import.meta.env.VITE_AGENT_ID || 'strategy-agent-runtime-example';
 /**
- * Compose an agent system prompt generically from a loop specification.
+ * Compose an agent system prompt generically from a strategy specification.
  *
- * This is intentionally spec-driven: every field comes from the loop YAML, so
- * the same code drives any loop (data analysis, plan/execute/critic, OODA, ...).
+ * This is intentionally spec-driven: every field comes from the strategy YAML, so
+ * the same code drives any strategy (data analysis, plan/execute/critic, OODA, ...).
  */
-function buildLoopSystemPrompt(loop) {
+function buildStrategySystemPrompt(strategy) {
     const lines = [];
-    lines.push(`You are an agent that operates as a control LOOP rather than answering in a single prompt.`);
-    lines.push(`Loop: ${loop.name} (${loop.strategy}).`);
-    if (loop.objective) {
-        lines.push(`Objective: ${loop.objective}`);
+    lines.push(`You are an agent that operates as a control loop rather than answering in a single prompt.`);
+    lines.push(`Strategy: ${strategy.name} (${strategy.strategy}).`);
+    if (strategy.objective) {
+        lines.push(`Objective: ${strategy.objective}`);
     }
-    if (loop.phases?.length) {
-        lines.push(`Each iteration, execute these phases in order: ${loop.phases.join(' → ')}. ` +
+    if (strategy.phases?.length) {
+        lines.push(`Each iteration, execute these phases in order: ${strategy.phases.join(' → ')}. ` +
             `Decide the single best next action each iteration; do not try to solve everything at once.`);
     }
-    if (loop.constraints?.length) {
-        lines.push(`Constraints you must respect:\n${loop.constraints
+    if (strategy.constraints?.length) {
+        lines.push(`Constraints you must respect:\n${strategy.constraints
             .map(c => `- ${c}`)
             .join('\n')}`);
     }
-    if (loop.termination) {
-        const t = loop.termination;
+    if (strategy.termination) {
+        const t = strategy.termination;
         lines.push(`Termination: stop after at most ${t.maxIterations} iterations, or when the goal is reached.`);
         if (t.successCriteria?.length) {
             lines.push(`Success criteria:\n${t.successCriteria.map(s => `- ${s}`).join('\n')}`);
@@ -74,13 +74,13 @@ function buildLoopSystemPrompt(loop) {
             lines.push(`If blocked: ${t.onBlocked}.`);
         }
     }
-    if (loop.human && loop.human.mode !== 'none') {
-        lines.push(`Human-in-the-loop: mode "${loop.human.mode}"` +
-            (loop.human.approvalRequired
-                ? `; request explicit approval before: ${loop.human.approvalFor.join(', ') || 'sensitive actions'}.`
+    if (strategy.human && strategy.human.mode !== 'none') {
+        lines.push(`Human-in-the-loop: mode "${strategy.human.mode}"` +
+            (strategy.human.approvalRequired
+                ? `; request explicit approval before: ${strategy.human.approvalFor.join(', ') || 'sensitive actions'}.`
                 : '.'));
     }
-    lines.push(`Keep loop state (dataframes, charts, intermediate results) in the notebook/runtime, not in the prompt. ` +
+    lines.push(`Keep strategy state (dataframes, charts, intermediate results) in the notebook/runtime, not in the prompt. ` +
         `For notebook operations, always use the notebook frontend tools (runCell, readAllCells, readCell, insertCell, updateCell, deleteCells) so actions happen in the live notebook UI. ` +
         `Use executeCodeInNotebook only for temporary inspection code that should not modify notebook cells.`);
     return lines.join('\n\n');
@@ -108,9 +108,9 @@ function NotebookUI({ serviceManager }) {
     return (_jsx(ThemedJupyterProvider, { children: _jsx(Notebook, { nbformat: NOTEBOOK_CONTENT, id: NOTEBOOK_ID, Toolbar: ExampleNotebookToolbar, serviceManager: serviceManager, height: "100%", cellSidebarMargin: 120, startDefaultKernel: true }) }));
 }
 /**
- * A compact, read-only summary of the selected loop specification.
+ * A compact, read-only summary of the selected strategy specification.
  */
-function LoopSummary({ loop }) {
+function StrategySummary({ strategy }) {
     return (_jsxs(Box, { sx: {
             mt: 2,
             p: 2,
@@ -119,7 +119,7 @@ function LoopSummary({ loop }) {
             borderRadius: 2,
             bg: 'canvas.default',
             fontSize: 0,
-        }, children: [_jsx(Box, { sx: { display: 'flex', flexWrap: 'wrap', gap: 2, mb: 1 }, children: loop.phases.map((phase, index) => (_jsxs(Box, { sx: {
+        }, children: [_jsx(Box, { sx: { display: 'flex', flexWrap: 'wrap', gap: 2, mb: 1 }, children: strategy.phases.map((phase, index) => (_jsxs(Box, { sx: {
                         display: 'flex',
                         alignItems: 'center',
                         gap: 1,
@@ -129,21 +129,21 @@ function LoopSummary({ loop }) {
                         bg: 'neutral.muted',
                         color: 'fg.default',
                         fontWeight: 'bold',
-                    }, children: [index + 1, ". ", phase] }, phase))) }), loop.objective && (_jsxs(Box, { sx: { color: 'fg.muted' }, children: [_jsx("strong", { children: "Objective:" }), " ", loop.objective] })), loop.termination && (_jsxs(Box, { sx: { color: 'fg.muted', mt: 1 }, children: [_jsx("strong", { children: "Max iterations:" }), " ", loop.termination.maxIterations, " \u00B7", ' ', _jsx("strong", { children: "On blocked:" }), " ", loop.termination.onBlocked] }))] }));
+                    }, children: [index + 1, ". ", phase] }, phase))) }), strategy.objective && (_jsxs(Box, { sx: { color: 'fg.muted' }, children: [_jsx("strong", { children: "Objective:" }), " ", strategy.objective] })), strategy.termination && (_jsxs(Box, { sx: { color: 'fg.muted', mt: 1 }, children: [_jsx("strong", { children: "Max iterations:" }), " ", strategy.termination.maxIterations, ' ', "\u00B7 ", _jsx("strong", { children: "On blocked:" }), " ", strategy.termination.onBlocked] }))] }));
 }
-export function AgentLoopExampleInner({ serviceManager, }) {
-    // All available loops come from the generated loop catalogue.
-    const loops = useMemo(() => listLoops(), []);
-    const [selectedLoopId, setSelectedLoopId] = useState(DEFAULT_LOOP);
-    const selectedLoop = useMemo(() => getLoop(selectedLoopId) ?? loops[0], [selectedLoopId, loops]);
-    const systemPrompt = useMemo(() => buildLoopSystemPrompt(selectedLoop), [selectedLoop]);
+export function AgentStrategyExampleInner({ serviceManager, }) {
+    // All available strategies come from the generated strategy catalogue.
+    const strategies = useMemo(() => listStrategies(), []);
+    const [selectedStrategyId, setSelectedStrategyId] = useState(DEFAULT_STRATEGY);
+    const selectedStrategy = useMemo(() => getStrategy(selectedStrategyId) ?? strategies[0], [selectedStrategyId, strategies]);
+    const systemPrompt = useMemo(() => buildStrategySystemPrompt(selectedStrategy), [selectedStrategy]);
     // The tools. Which of the chat and the harness runs them depends on
-    // where the loop turns, and the hook decides that.
+    // where the strategy turns, and the hook decides that.
     const tools = useNotebookTools(NOTEBOOK_ID);
     const { agentReady, protocol: protocolConfig, chatFrontendTools, error, unavailableReason, createAttempted, } = useExampleJupyterAgent({
-        exampleId: 'AgentLoopExample',
+        exampleId: 'AgentStrategyExample',
         agentName: DEFAULT_AGENT_ID,
-        description: `Loop agent (${selectedLoop.name}) for AgentLoopExample`,
+        description: `Strategy agent (${selectedStrategy.name}) for AgentStrategyExample`,
         systemPrompt,
         serviceManager,
         frontendTools: tools,
@@ -153,16 +153,16 @@ export function AgentLoopExampleInner({ serviceManager, }) {
     // The example's own agent, not merely the runtime: on the cloud target the
     // runtime is ready before this agent has been registered on it.
     const effectiveReady = agentReady;
-    const isLoopSelectorDisabled = createAttempted;
+    const isStrategySelectorDisabled = createAttempted;
     // Get notebook tools for ChatSidebar
     // Build Vercel AI protocol config
-    // Chat suggestions derived from the selected loop.
+    // Chat suggestions derived from the selected strategy.
     const suggestions = useMemo(() => [
         {
-            title: `${selectedLoop.emoji} Run the loop`,
-            message: selectedLoop.objective
-                ? `Run the ${selectedLoop.name}. ${selectedLoop.objective}`
-                : `Run the ${selectedLoop.name} against the data in this notebook.`,
+            title: `${selectedStrategy.emoji} Run the strategy`,
+            message: selectedStrategy.objective
+                ? `Run the ${selectedStrategy.name}. ${selectedStrategy.objective}`
+                : `Run the ${selectedStrategy.name} against the data in this notebook.`,
         },
         {
             title: '🔁 Next iteration',
@@ -176,7 +176,7 @@ export function AgentLoopExampleInner({ serviceManager, }) {
             title: '📊 Summarize findings',
             message: 'Summarize the key findings and produce a final, decision-oriented report.',
         },
-    ], [selectedLoop]);
+    ], [selectedStrategy]);
     return (_jsx(_Fragment, { children: _jsxs(Box, { sx: {
                 // The wrapper is the viewport, not the window: it sits below the
                 // header and beside the sidebar, so viewport units size this box to
@@ -204,9 +204,9 @@ export function AgentLoopExampleInner({ serviceManager, }) {
                                         justifyContent: 'space-between',
                                         gap: 3,
                                         flexWrap: 'wrap',
-                                    }, children: [_jsxs(Box, { children: [_jsxs("h1", { style: { margin: 0, fontSize: '1.5rem' }, children: [selectedLoop.emoji, " Agent Loop Example"] }), _jsx("p", { style: { margin: '8px 0 0', color: 'var(--fgColor-muted)' }, children: "Define and launch an agent execution loop \u2014 observe, think, act, evaluate \u2014 over a live notebook." })] }), _jsxs(Box, { sx: { display: 'flex', alignItems: 'center', gap: 2 }, title: isLoopSelectorDisabled
-                                                ? 'Loop selector is temporarily disabled while launching the agent'
-                                                : 'Choose a loop', children: [_jsx(Box, { as: "label", sx: { fontSize: 1, fontWeight: 'bold' }, children: "Loop" }), _jsx(Box, { as: "select", value: selectedLoopId, onChange: (e) => setSelectedLoopId(e.target.value), disabled: isLoopSelectorDisabled, "aria-label": "Loop specification", sx: {
+                                    }, children: [_jsxs(Box, { children: [_jsxs("h1", { style: { margin: 0, fontSize: '1.5rem' }, children: [selectedStrategy.emoji, " Agent Strategy Example"] }), _jsx("p", { style: { margin: '8px 0 0', color: 'var(--fgColor-muted)' }, children: "Define and launch an agent reasoning strategy \u2014 observe, think, act, evaluate \u2014 over a live notebook." })] }), _jsxs(Box, { sx: { display: 'flex', alignItems: 'center', gap: 2 }, title: isStrategySelectorDisabled
+                                                ? 'Strategy selector is temporarily disabled while launching the agent'
+                                                : 'Choose a strategy', children: [_jsx(Box, { as: "label", sx: { fontSize: 1, fontWeight: 'bold' }, children: "Strategy" }), _jsx(Box, { as: "select", value: selectedStrategyId, onChange: (e) => setSelectedStrategyId(e.target.value), disabled: isStrategySelectorDisabled, "aria-label": "Strategy specification", sx: {
                                                         px: 2,
                                                         py: '6px',
                                                         fontSize: 1,
@@ -215,7 +215,7 @@ export function AgentLoopExampleInner({ serviceManager, }) {
                                                         borderColor: 'border.default',
                                                         bg: 'canvas.default',
                                                         color: 'fg.default',
-                                                    }, children: loops.map(loop => (_jsxs("option", { value: loop.id, children: [loop.emoji, " ", loop.name] }, loop.id))) })] })] }), _jsx(LoopSummary, { loop: selectedLoop })] }), _jsx(Box, { sx: {
+                                                    }, children: strategies.map(strategy => (_jsxs("option", { value: strategy.id, children: [strategy.emoji, " ", strategy.name] }, strategy.id))) })] })] }), _jsx(StrategySummary, { strategy: selectedStrategy })] }), _jsx(Box, { sx: {
                                 flex: 1,
                                 display: 'flex',
                                 overflow: 'hidden',
@@ -227,7 +227,7 @@ export function AgentLoopExampleInner({ serviceManager, }) {
                                     borderColor: 'border.default',
                                     borderRadius: 2,
                                     overflow: 'hidden',
-                                }, children: _jsx(NotebookUI, { serviceManager: serviceManager }) }) })] }), effectiveReady && (_jsx(ChatSidebar, { title: `${selectedLoop.emoji} ${selectedLoop.name}`, protocol: protocolConfig, position: "right", width: 400, clickOutsideToClose: false, showNewChatButton: true, showClearButton: true, showSettingsButton: true, defaultOpen: true, panelProps: {
+                                }, children: _jsx(NotebookUI, { serviceManager: serviceManager }) }) })] }), effectiveReady && (_jsx(ChatSidebar, { title: `${selectedStrategy.emoji} ${selectedStrategy.name}`, protocol: protocolConfig, position: "right", width: 400, clickOutsideToClose: false, showNewChatButton: true, showClearButton: true, showSettingsButton: true, defaultOpen: true, panelProps: {
                         protocol: protocolConfig,
                         frontendTools: chatFrontendTools,
                         useStore: false,
@@ -250,7 +250,7 @@ export function AgentLoopExampleInner({ serviceManager, }) {
 /**
  * Main example component with Jupyter provider wrapper.
  */
-export function AgentLoopExample({ serviceManager, }) {
-    return (_jsx(ThemedProvider, { children: _jsx(AgentLoopExampleInner, { serviceManager: serviceManager }) }));
+export function AgentStrategyExample({ serviceManager, }) {
+    return (_jsx(ThemedProvider, { children: _jsx(AgentStrategyExampleInner, { serviceManager: serviceManager }) }));
 }
-export default AgentLoopExample;
+export default AgentStrategyExample;

package/lib/examples/example-selector.js

@@ -111,7 +111,7 @@ export const EXAMPLE_ENTRIES = [
     // `owns-sandbox-control`: the shell is pinned to the browser sandbox, so
     // the page's selector would offer three targets it cannot move to.
     ['example', 'loop', 'shell', 'prompt', 'editors', 'owns-sandbox-control']),
-    makeEntry('AgentLoopExample', () => import('./AgentLoopExample'), 'Define and launch an agent execution loop (observe/think/act/evaluate) over a live notebook, driven by generic loop specs.', ['example', 'agent', 'loop', 'notebook', 'agentspecs']),
+    makeEntry('AgentStrategyExample', () => import('./AgentStrategyExample'), 'Define and launch an agent reasoning strategy (a control loop: observe/think/act/evaluate) over a live notebook, driven by generic strategy specs.', ['example', 'agent', 'strategy', 'notebook', 'agentspecs']),
     makeEntry('AgentToolApprovalsExample', () => import('./AgentToolApprovalsExample'), 'Tool approval workflows and manual decisions.'),
     makeEntry('AgentMemoryExample', () => import('./AgentMemoryExample'), 'Memory-aware conversation and retrieval example.'),
     makeEntry('AgentSkillsExample', () => import('./AgentSkillsExample'), 'Skills discovery, execution, and monitoring example.'),

package/lib/examples/index.d.ts

@@ -28,7 +28,7 @@ export { default as AgentEvalsExample } from './AgentEvalsExample';
 export { default as AgentGuardrailsExample } from './AgentGuardrailsExample';
 export { default as AgentHooksExample } from './AgentHooksExample';
 export { default as AgentInferenceProviderExample } from './AgentInferenceProviderExample';
-export { default as AgentLoopExample } from './AgentLoopExample';
+export { default as AgentStrategyExample } from './AgentStrategyExample';
 export { default as AgentToolApprovalsExample } from './AgentToolApprovalsExample';
 export { default as AgentMemoryExample } from './AgentMemoryExample';
 export { default as AgentOtelExample } from './AgentOtelExample';

package/lib/examples/index.js

@@ -34,7 +34,7 @@ export { default as AgentEvalsExample } from './AgentEvalsExample';
 export { default as AgentGuardrailsExample } from './AgentGuardrailsExample';
 export { default as AgentHooksExample } from './AgentHooksExample';
 export { default as AgentInferenceProviderExample } from './AgentInferenceProviderExample';
-export { default as AgentLoopExample } from './AgentLoopExample';
+export { default as AgentStrategyExample } from './AgentStrategyExample';
 export { default as AgentToolApprovalsExample } from './AgentToolApprovalsExample';
 export { default as AgentMemoryExample } from './AgentMemoryExample';
 export { default as AgentOtelExample } from './AgentOtelExample';

package/lib/examples/main.js

@@ -86,7 +86,7 @@ const ANONYMOUS_EXAMPLES = new Set([
 ]);
 const getExampleGroup = (id) => {
     if (id === 'AgentspecsExample' ||
-        id === 'AgentLoopExample' ||
+        id === 'AgentStrategyExample' ||
         id === 'LoopWorkspaceExample' ||
         id === 'LoopShellExample' ||
         id === 'DecksAgent') {
@@ -1068,12 +1068,12 @@ const ExampleAppThemed = ({ selectedExample, isChangingExample, error, ExampleCo
         for (const [groupName, examples] of groups) {
             examples.sort((left, right) => {
                 if (groupName === 'Loop') {
-                    // The shells first, most naked first; then the loop that drives a
+                    // The shells first, most naked first; then the strategy that drives a
                     // notebook; then the library of specs behind them all.
                     const LOOP_ORDER = [
                         'LoopShellExample',
                         'LoopWorkspaceExample',
-                        'AgentLoopExample',
+                        'AgentStrategyExample',
                         'AgentspecsExample',
                     ];
                     const loopOrder = (id) => {

package/lib/specs/index.d.ts

@@ -8,7 +8,7 @@ export * from './teams';
 export * from './envvars';
 export * from './evals';
 export * from './guardrails';
-export * from './loops';
+export * from './strategies';
 export * from './mcpServers';
 export * from './memory';
 export * from './models';

package/lib/specs/index.js

@@ -12,7 +12,7 @@ export * from './teams';
 export * from './envvars';
 export * from './evals';
 export * from './guardrails';
-export * from './loops';
+export * from './strategies';
 export * from './mcpServers';
 export * from './memory';
 export * from './models';

package/lib/specs/strategies.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Strategy Catalog
+ *
+ * Predefined agent reasoning strategies (control loops).
+ *
+ * This file is AUTO-GENERATED from YAML specifications.
+ * DO NOT EDIT MANUALLY - run 'make specs' to regenerate.
+ */
+import type { StrategySpec } from '../types';
+export declare const Strategies: {
+    readonly DATA_ANALYSIS: "data-analysis";
+    readonly HUMAN_IN_THE_LOOP: "human-in-the-loop";
+    readonly OODA: "ooda";
+    readonly PLAN_EXECUTE_CRITIC: "plan-execute-critic";
+};
+export type StrategyId = (typeof Strategies)[keyof typeof Strategies];
+export declare const DATA_ANALYSIS_STRATEGY_0_0_1: StrategySpec;
+export declare const HUMAN_IN_THE_LOOP_STRATEGY_0_0_1: StrategySpec;
+export declare const OODA_STRATEGY_0_0_1: StrategySpec;
+export declare const PLAN_EXECUTE_CRITIC_STRATEGY_0_0_1: StrategySpec;
+export declare const STRATEGY_CATALOGUE: Record<string, StrategySpec>;
+export declare const DEFAULT_STRATEGY: StrategyId;
+/**
+ * Get a strategy specification by ID.
+ */
+export declare function getStrategy(strategyId: string): StrategySpec | undefined;
+/**
+ * Get the default strategy.
+ */
+export declare function getDefaultStrategy(): StrategySpec | undefined;
+/**
+ * List all available strategies.
+ */
+export declare function listStrategies(): StrategySpec[];

package/lib/specs/{loops.js → strategies.js}

@@ -3,18 +3,18 @@
  * Distributed under the terms of the Modified BSD License.
  */
 // ============================================================================
-// Loops Enum
+// Strategies Enum
 // ============================================================================
-export const Loops = {
+export const Strategies = {
     DATA_ANALYSIS: 'data-analysis',
     HUMAN_IN_THE_LOOP: 'human-in-the-loop',
     OODA: 'ooda',
     PLAN_EXECUTE_CRITIC: 'plan-execute-critic',
 };
 // ============================================================================
-// Loop Definitions
+// Strategy Definitions
 // ============================================================================
-export const DATA_ANALYSIS_LOOP_0_0_1 = {
+export const DATA_ANALYSIS_STRATEGY_0_0_1 = {
     id: 'data-analysis',
     version: '0.0.1',
     name: 'Data Analysis Loop',
@@ -47,7 +47,7 @@ export const DATA_ANALYSIS_LOOP_0_0_1 = {
     icon: 'graph',
     emoji: '📊',
 };
-export const HUMAN_IN_THE_LOOP_LOOP_0_0_1 = {
+export const HUMAN_IN_THE_LOOP_STRATEGY_0_0_1 = {
     id: 'human-in-the-loop',
     version: '0.0.1',
     name: 'Human-in-the-Loop',
@@ -83,7 +83,7 @@ export const HUMAN_IN_THE_LOOP_LOOP_0_0_1 = {
     icon: 'person',
     emoji: '🙋',
 };
-export const OODA_LOOP_0_0_1 = {
+export const OODA_STRATEGY_0_0_1 = {
     id: 'ooda',
     version: '0.0.1',
     name: 'OODA Loop',
@@ -112,7 +112,7 @@ export const OODA_LOOP_0_0_1 = {
     icon: 'sync',
     emoji: '🔄',
 };
-export const PLAN_EXECUTE_CRITIC_LOOP_0_0_1 = {
+export const PLAN_EXECUTE_CRITIC_STRATEGY_0_0_1 = {
     id: 'plan-execute-critic',
     version: '0.0.1',
     name: 'Plan / Execute / Critic Loop',
@@ -148,41 +148,41 @@ export const PLAN_EXECUTE_CRITIC_LOOP_0_0_1 = {
     emoji: '✅',
 };
 // ============================================================================
-// Loop Catalog
+// Strategy Catalog
 // ============================================================================
-export const LOOP_CATALOGUE = {
-    'data-analysis': DATA_ANALYSIS_LOOP_0_0_1,
-    'human-in-the-loop': HUMAN_IN_THE_LOOP_LOOP_0_0_1,
-    ooda: OODA_LOOP_0_0_1,
-    'plan-execute-critic': PLAN_EXECUTE_CRITIC_LOOP_0_0_1,
+export const STRATEGY_CATALOGUE = {
+    'data-analysis': DATA_ANALYSIS_STRATEGY_0_0_1,
+    'human-in-the-loop': HUMAN_IN_THE_LOOP_STRATEGY_0_0_1,
+    ooda: OODA_STRATEGY_0_0_1,
+    'plan-execute-critic': PLAN_EXECUTE_CRITIC_STRATEGY_0_0_1,
 };
-export const DEFAULT_LOOP = Loops.DATA_ANALYSIS;
-function resolveLoopId(loopId) {
-    if (loopId in LOOP_CATALOGUE)
-        return loopId;
-    const idx = loopId.lastIndexOf(':');
+export const DEFAULT_STRATEGY = Strategies.DATA_ANALYSIS;
+function resolveStrategyId(strategyId) {
+    if (strategyId in STRATEGY_CATALOGUE)
+        return strategyId;
+    const idx = strategyId.lastIndexOf(':');
     if (idx > 0) {
-        const base = loopId.slice(0, idx);
-        if (base in LOOP_CATALOGUE)
+        const base = strategyId.slice(0, idx);
+        if (base in STRATEGY_CATALOGUE)
             return base;
     }
-    return loopId;
+    return strategyId;
 }
 /**
- * Get a loop specification by ID.
+ * Get a strategy specification by ID.
  */
-export function getLoop(loopId) {
-    return LOOP_CATALOGUE[resolveLoopId(loopId)];
+export function getStrategy(strategyId) {
+    return STRATEGY_CATALOGUE[resolveStrategyId(strategyId)];
 }
 /**
- * Get the default loop.
+ * Get the default strategy.
  */
-export function getDefaultLoop() {
-    return LOOP_CATALOGUE[DEFAULT_LOOP];
+export function getDefaultStrategy() {
+    return STRATEGY_CATALOGUE[DEFAULT_STRATEGY];
 }
 /**
- * List all available loops.
+ * List all available strategies.
  */
-export function listLoops() {
-    return Object.values(LOOP_CATALOGUE);
+export function listStrategies() {
+    return Object.values(STRATEGY_CATALOGUE);
 }

package/lib/types/index.d.ts

@@ -20,7 +20,7 @@ export * from './execution';
 export * from './uiPlugins';
 export * from './guardrails';
 export * from './inference';
-export * from './loops';
+export * from './strategies';
 export * from './mcp';
 export * from './memory';
 export * from './messages';

package/lib/types/index.js

@@ -24,7 +24,7 @@ export * from './execution';
 export * from './uiPlugins';
 export * from './guardrails';
 export * from './inference';
-export * from './loops';
+export * from './strategies';
 export * from './mcp';
 export * from './memory';
 export * from './messages';

package/lib/types/{loops.d.ts → strategies.d.ts}

@@ -1,10 +1,10 @@
 /**
- * How the human participates in (or around) an agent execution loop.
+ * How the human participates in (or around) an agent reasoning strategy.
  */
-export interface LoopHuman {
+export interface StrategyHuman {
     /** Human interaction pattern: none, initiate, approve, feedback, or tool */
     mode: string;
-    /** Whether the loop pauses for human approval before sensitive actions */
+    /** Whether the strategy pauses for human approval before sensitive actions */
     approvalRequired: boolean;
     /** Actions that require explicit human approval */
     approvalFor: string[];
@@ -12,48 +12,48 @@ export interface LoopHuman {
     description: string;
 }
 /**
- * When and how an agent execution loop stops iterating.
+ * When and how an agent reasoning strategy stops iterating.
  */
-export interface LoopTermination {
-    /** Maximum iterations before the loop is stopped */
+export interface StrategyTermination {
+    /** Maximum iterations before the strategy is stopped */
     maxIterations: number;
     /** Conditions that mark the goal as reached */
     successCriteria: string[];
-    /** Conditions that mark the loop as failed */
+    /** Conditions that mark the strategy as failed */
     failureCriteria: string[];
     /** What to do when blocked: ask-human, retry, or abort */
     onBlocked: string;
 }
 /**
- * Specification for an agent execution loop.
+ * Specification for an agent reasoning strategy (a control loop).
  *
  * A framework-agnostic description of how an agent progresses from one
  * decision to the next: the control cycle (observe/think/act/evaluate), the
  * objective, constraints, where state lives, human participation, and the
  * termination policy.
  */
-export interface LoopSpec {
-    /** Unique loop identifier (e.g., 'data-analysis') */
+export interface StrategySpec {
+    /** Unique strategy identifier (e.g., 'data-analysis') */
     id: string;
     /** Version */
     version: string;
-    /** Display name for the loop */
+    /** Display name for the strategy */
     name: string;
-    /** Loop description */
+    /** Strategy description */
     description: string;
-    /** Default goal/objective the loop works toward */
+    /** Default goal/objective the strategy works toward */
     objective: string;
-    /** Loop strategy family */
+    /** Strategy family */
     strategy: string;
     /** Ordered phase names that make up one iteration */
     phases: string[];
     /** Boundaries the agent must respect */
     constraints: string[];
     /** Termination policy */
-    termination?: LoopTermination;
+    termination?: StrategyTermination;
     /** Human-in-the-loop participation settings */
-    human?: LoopHuman;
-    /** Where loop state lives between iterations */
+    human?: StrategyHuman;
+    /** Where strategy state lives between iterations */
     stateBackends: string[];
     /** Categorization tags */
     tags: string[];

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@datalayer/agent-runtimes",
-    "version": "1.3.54",
+    "version": "1.3.55",
     "type": "module",
     "workspaces": [
         ".",

package/scripts/codegen/generate_agents.py

@@ -1616,7 +1616,7 @@ export * from './teams';
 export * from './envvars';
 export * from './evals';
 export * from './guardrails';
-export * from './loops';
+export * from './strategies';
 export * from './mcpServers';
 export * from './memory';
 export * from './models';

package/scripts/codegen/{generate_loops.py → generate_strategies.py}

@@ -3,18 +3,18 @@
 # Distributed under the terms of the Modified BSD License.
 
 """
-Generate Python and TypeScript code from YAML loop specifications.
+Generate Python and TypeScript code from YAML strategy specifications.
 
-A *loop* describes how an agent progresses from one decision to the next: the
-control cycle (observe/think/act/evaluate), the objective it works toward, the
-constraints and success criteria that bound it, where state lives between
-iterations, how the human participates, and when the loop terminates.
+A *strategy* is the control loop an agent reasons with: how it progresses from
+one decision to the next (observe/think/act/evaluate), the objective it works
+toward, the constraints and success criteria that bound it, where state lives
+between iterations, how the human participates, and when it terminates.
 
 Usage:
-    python generate_loops.py \\
-      --specs-dir agentspecs/agentspecs/loops \\
-      --python-output agent_runtimes/specs/loops.py \\
-      --typescript-output src/specs/loops.ts
+    python generate_strategies.py \\
+      --specs-dir agentspecs/agentspecs/strategies \\
+      --python-output agent_runtimes/specs/strategies.py \\
+      --typescript-output src/specs/strategies.ts
 """
 
 import argparse
@@ -26,14 +26,14 @@ import yaml
 from versioning import ensure_spec_version, version_suffix
 
 
-def _make_const_name(loop_id: str) -> str:
-    """Convert a loop ID to a constant name (e.g., 'ooda' -> 'OODA_LOOP')."""
-    return f"{loop_id.upper().replace('-', '_')}_LOOP"
+def _make_const_name(strategy_id: str) -> str:
+    """Convert a strategy ID to a constant name (e.g., 'ooda' -> 'OODA_STRATEGY')."""
+    return f"{strategy_id.upper().replace('-', '_')}_STRATEGY"
 
 
-def _make_enum_name(loop_id: str) -> str:
-    """Convert a loop ID to an enum member name (e.g., 'data-analysis' -> 'DATA_ANALYSIS')."""
-    return loop_id.upper().replace("-", "_")
+def _make_enum_name(strategy_id: str) -> str:
+    """Convert a strategy ID to an enum member name (e.g., 'data-analysis' -> 'DATA_ANALYSIS')."""
+    return strategy_id.upper().replace("-", "_")
 
 
 def _clean(text: str) -> str:
@@ -65,8 +65,8 @@ def _ts_list(items: list) -> str:
     return "[" + ", ".join(_ts_str(item) for item in items) + "]"
 
 
-def load_loop_specs(specs_dir: Path) -> list[dict[str, Any]]:
-    """Load all loop YAML specifications from a directory."""
+def load_strategy_specs(specs_dir: Path) -> list[dict[str, Any]]:
+    """Load all strategy YAML specifications from a directory."""
     specs = []
     for yaml_file in sorted(specs_dir.glob("*.yaml")):
         with open(yaml_file) as f:
@@ -77,14 +77,14 @@ def load_loop_specs(specs_dir: Path) -> list[dict[str, Any]]:
 
 
 def generate_python_code(specs: list[dict[str, Any]]) -> str:
-    """Generate Python code from loop specifications."""
+    """Generate Python code from strategy specifications."""
     lines = [
         "# Copyright (c) 2025-2026 Datalayer, Inc.",
         "# Distributed under the terms of the Modified BSD License.",
         '"""',
-        "Loop Catalog.",
+        "Strategy Catalog.",
         "",
-        "Predefined agent execution-loop specifications that can be used by agents.",
+        "Predefined agent reasoning strategies (control loops) that agents can use.",
         "",
         "This file is AUTO-GENERATED from YAML specifications.",
         "DO NOT EDIT MANUALLY - run 'make specs' to regenerate.",
@@ -93,16 +93,16 @@ def generate_python_code(specs: list[dict[str, Any]]) -> str:
         "from enum import Enum",
         "from typing import Optional",
         "",
-        "from agent_runtimes.types import LoopHuman, LoopSpec, LoopTermination",
+        "from agent_runtimes.types import StrategyHuman, StrategySpec, StrategyTermination",
         "",
         "",
         "# " + "=" * 76,
-        "# Loops Enum",
+        "# Strategies Enum",
         "# " + "=" * 76,
         "",
         "",
-        "class Loops(str, Enum):",
-        '    """Enumeration of available agent execution loops."""',
+        "class Strategies(str, Enum):",
+        '    """Enumeration of available agent reasoning strategies."""',
         "",
     ]
 
@@ -114,7 +114,7 @@ def generate_python_code(specs: list[dict[str, Any]]) -> str:
             "",
             "",
             "# " + "=" * 76,
-            "# Loop Definitions",
+            "# Strategy Definitions",
             "# " + "=" * 76,
             "",
         ]
@@ -124,7 +124,7 @@ def generate_python_code(specs: list[dict[str, Any]]) -> str:
         version = spec["version"]
         const_name = _make_const_name(spec["id"]) + version_suffix(version)
 
-        lines.append(f"{const_name} = LoopSpec(")
+        lines.append(f"{const_name} = StrategySpec(")
         lines.append(f'    id="{spec["id"]}",')
         lines.append(f'    version="{version}",')
         lines.append(f'    name="{spec["name"]}",')
@@ -138,7 +138,7 @@ def generate_python_code(specs: list[dict[str, Any]]) -> str:
 
         term = spec.get("termination")
         if term:
-            lines.append("    termination=LoopTermination(")
+            lines.append("    termination=StrategyTermination(")
             lines.append(
                 f"        max_iterations={int(term.get('max_iterations', 10))},"
             )
@@ -155,7 +155,7 @@ def generate_python_code(specs: list[dict[str, Any]]) -> str:
 
         human = spec.get("human")
         if human:
-            lines.append("    human=LoopHuman(")
+            lines.append("    human=StrategyHuman(")
             lines.append(f"        mode={_py_str(human.get('mode', 'initiate'))},")
             lines.append(
                 f"        approval_required={bool(human.get('approval_required', False))},"
@@ -179,10 +179,10 @@ def generate_python_code(specs: list[dict[str, Any]]) -> str:
         [
             "",
             "# " + "=" * 76,
-            "# Loop Catalog",
+            "# Strategy Catalog",
             "# " + "=" * 76,
             "",
-            "LOOP_CATALOGUE: dict[str, LoopSpec] = {",
+            "STRATEGY_CATALOGUE: dict[str, StrategySpec] = {",
         ]
     )
 
@@ -195,46 +195,46 @@ def generate_python_code(specs: list[dict[str, Any]]) -> str:
             "}",
             "",
             "",
-            'DEFAULT_LOOP: str = "data-analysis"',
+            'DEFAULT_STRATEGY: str = "data-analysis"',
             "",
             "",
-            "def get_loop(loop_id: str) -> Optional[LoopSpec]:",
+            "def get_strategy(strategy_id: str) -> Optional[StrategySpec]:",
             '    """',
-            "    Get a loop specification by ID (accepts both bare and versioned refs).",
+            "    Get a strategy specification by ID (accepts both bare and versioned refs).",
             "",
             "    Args:",
-            "        loop_id: The unique identifier of the loop.",
+            "        strategy_id: The unique identifier of the strategy.",
             "",
             "    Returns:",
-            "        The LoopSpec, or None if not found.",
+            "        The StrategySpec, or None if not found.",
             '    """',
-            "    loop = LOOP_CATALOGUE.get(loop_id)",
-            "    if loop is not None:",
-            "        return loop",
-            "    base, _, ver = loop_id.rpartition(':')",
+            "    strategy = STRATEGY_CATALOGUE.get(strategy_id)",
+            "    if strategy is not None:",
+            "        return strategy",
+            "    base, _, ver = strategy_id.rpartition(':')",
             "    if base and '.' in ver:",
-            "        return LOOP_CATALOGUE.get(base)",
+            "        return STRATEGY_CATALOGUE.get(base)",
             "    return None",
             "",
             "",
-            "def get_default_loop() -> Optional[LoopSpec]:",
+            "def get_default_strategy() -> Optional[StrategySpec]:",
             '    """',
-            "    Get the default loop.",
+            "    Get the default strategy.",
             "",
             "    Returns:",
-            "        The default LoopSpec, or None if no default is set.",
+            "        The default StrategySpec, or None if no default is set.",
             '    """',
-            "    return LOOP_CATALOGUE.get(DEFAULT_LOOP)",
+            "    return STRATEGY_CATALOGUE.get(DEFAULT_STRATEGY)",
             "",
             "",
-            "def list_loops() -> list[LoopSpec]:",
+            "def list_strategies() -> list[StrategySpec]:",
             '    """',
-            "    List all available loops.",
+            "    List all available strategies.",
             "",
             "    Returns:",
-            "        List of all LoopSpec specifications.",
+            "        List of all StrategySpec specifications.",
             '    """',
-            "    return list(LOOP_CATALOGUE.values())",
+            "    return list(STRATEGY_CATALOGUE.values())",
             "",
         ]
     )
@@ -243,7 +243,7 @@ def generate_python_code(specs: list[dict[str, Any]]) -> str:
 
 
 def generate_typescript_code(specs: list[dict[str, Any]]) -> str:
-    """Generate TypeScript code from loop specifications."""
+    """Generate TypeScript code from strategy specifications."""
     lines = [
         "/*",
         " * Copyright (c) 2025-2026 Datalayer, Inc.",
@@ -251,21 +251,21 @@ def generate_typescript_code(specs: list[dict[str, Any]]) -> str:
         " */",
         "",
         "/**",
-        " * Loop Catalog",
+        " * Strategy Catalog",
         " *",
-        " * Predefined agent execution-loop specifications.",
+        " * Predefined agent reasoning strategies (control loops).",
         " *",
         " * This file is AUTO-GENERATED from YAML specifications.",
         " * DO NOT EDIT MANUALLY - run 'make specs' to regenerate.",
         " */",
         "",
-        "import type { LoopSpec } from '../types';",
+        "import type { StrategySpec } from '../types';",
         "",
         "// " + "=" * 76,
-        "// Loops Enum",
+        "// Strategies Enum",
         "// " + "=" * 76,
         "",
-        "export const Loops = {",
+        "export const Strategies = {",
     ]
 
     for spec in specs:
@@ -275,10 +275,10 @@ def generate_typescript_code(specs: list[dict[str, Any]]) -> str:
         [
             "} as const;",
             "",
-            "export type LoopId = (typeof Loops)[keyof typeof Loops];",
+            "export type StrategyId = (typeof Strategies)[keyof typeof Strategies];",
             "",
             "// " + "=" * 76,
-            "// Loop Definitions",
+            "// Strategy Definitions",
             "// " + "=" * 76,
             "",
         ]
@@ -288,7 +288,7 @@ def generate_typescript_code(specs: list[dict[str, Any]]) -> str:
         version = spec["version"]
         const_name = _make_const_name(spec["id"]) + version_suffix(version)
 
-        lines.append(f"export const {const_name}: LoopSpec = {{")
+        lines.append(f"export const {const_name}: StrategySpec = {{")
         lines.append(f"  id: '{spec['id']}',")
         lines.append(f"  version: '{version}',")
         lines.append(f"  name: {_ts_str(spec['name'])},")
@@ -336,10 +336,10 @@ def generate_typescript_code(specs: list[dict[str, Any]]) -> str:
     lines.extend(
         [
             "// " + "=" * 76,
-            "// Loop Catalog",
+            "// Strategy Catalog",
             "// " + "=" * 76,
             "",
-            "export const LOOP_CATALOGUE: Record<string, LoopSpec> = {",
+            "export const STRATEGY_CATALOGUE: Record<string, StrategySpec> = {",
         ]
     )
 
@@ -351,37 +351,37 @@ def generate_typescript_code(specs: list[dict[str, Any]]) -> str:
         [
             "};",
             "",
-            "export const DEFAULT_LOOP: LoopId = Loops.DATA_ANALYSIS;",
+            "export const DEFAULT_STRATEGY: StrategyId = Strategies.DATA_ANALYSIS;",
             "",
-            "function resolveLoopId(loopId: string): string {",
-            "  if (loopId in LOOP_CATALOGUE) return loopId;",
-            "  const idx = loopId.lastIndexOf(':');",
+            "function resolveStrategyId(strategyId: string): string {",
+            "  if (strategyId in STRATEGY_CATALOGUE) return strategyId;",
+            "  const idx = strategyId.lastIndexOf(':');",
             "  if (idx > 0) {",
-            "    const base = loopId.slice(0, idx);",
-            "    if (base in LOOP_CATALOGUE) return base;",
+            "    const base = strategyId.slice(0, idx);",
+            "    if (base in STRATEGY_CATALOGUE) return base;",
             "  }",
-            "  return loopId;",
+            "  return strategyId;",
             "}",
             "",
             "/**",
-            " * Get a loop specification by ID.",
+            " * Get a strategy specification by ID.",
             " */",
-            "export function getLoop(loopId: string): LoopSpec | undefined {",
-            "  return LOOP_CATALOGUE[resolveLoopId(loopId)];",
+            "export function getStrategy(strategyId: string): StrategySpec | undefined {",
+            "  return STRATEGY_CATALOGUE[resolveStrategyId(strategyId)];",
             "}",
             "",
             "/**",
-            " * Get the default loop.",
+            " * Get the default strategy.",
             " */",
-            "export function getDefaultLoop(): LoopSpec | undefined {",
-            "  return LOOP_CATALOGUE[DEFAULT_LOOP];",
+            "export function getDefaultStrategy(): StrategySpec | undefined {",
+            "  return STRATEGY_CATALOGUE[DEFAULT_STRATEGY];",
             "}",
             "",
             "/**",
-            " * List all available loops.",
+            " * List all available strategies.",
             " */",
-            "export function listLoops(): LoopSpec[] {",
-            "  return Object.values(LOOP_CATALOGUE);",
+            "export function listStrategies(): StrategySpec[] {",
+            "  return Object.values(STRATEGY_CATALOGUE);",
             "}",
             "",
         ]
@@ -393,13 +393,13 @@ def generate_typescript_code(specs: list[dict[str, Any]]) -> str:
 def main():
     """Main entry point."""
     parser = argparse.ArgumentParser(
-        description="Generate Python and TypeScript code from YAML loop specifications"
+        description="Generate Python and TypeScript code from YAML strategy specifications"
     )
     parser.add_argument(
         "--specs-dir",
         type=Path,
         required=True,
-        help="Directory containing YAML loop specification files",
+        help="Directory containing YAML strategy specification files",
     )
     parser.add_argument(
         "--python-output",
@@ -420,9 +420,9 @@ def main():
         print(f"Error: Specs directory does not exist: {args.specs_dir}")
         sys.exit(1)
 
-    print(f"Loading loop specs from {args.specs_dir}...")
-    specs = load_loop_specs(args.specs_dir)
-    print(f"Loaded {len(specs)} loop specifications")
+    print(f"Loading strategy specs from {args.specs_dir}...")
+    specs = load_strategy_specs(args.specs_dir)
+    print(f"Loaded {len(specs)} strategy specifications")
 
     print("Generating Python code...")
     python_code = generate_python_code(specs)
@@ -436,7 +436,7 @@ def main():
     args.typescript_output.write_text(typescript_code)
     print(f"✓ Generated {args.typescript_output}")
 
-    print(f"\n✓ Successfully generated code from {len(specs)} loop specs")
+    print(f"\n✓ Successfully generated code from {len(specs)} strategy specs")
 
 
 if __name__ == "__main__":

package/lib/examples/AgentLoopExample.d.ts

@@ -1,12 +0,0 @@
-import { ServiceManager } from '@jupyterlab/services';
-interface AgentLoopExampleInnerProps {
-    serviceManager?: ServiceManager.IManager;
-}
-export declare function AgentLoopExampleInner({ serviceManager, }: AgentLoopExampleInnerProps): import("react").JSX.Element;
-/**
- * Main example component with Jupyter provider wrapper.
- */
-export declare function AgentLoopExample({ serviceManager, }: {
-    serviceManager?: ServiceManager.IManager;
-}): import("react").JSX.Element;
-export default AgentLoopExample;

package/lib/specs/loops.d.ts

@@ -1,34 +0,0 @@
-/**
- * Loop Catalog
- *
- * Predefined agent execution-loop specifications.
- *
- * This file is AUTO-GENERATED from YAML specifications.
- * DO NOT EDIT MANUALLY - run 'make specs' to regenerate.
- */
-import type { LoopSpec } from '../types';
-export declare const Loops: {
-    readonly DATA_ANALYSIS: "data-analysis";
-    readonly HUMAN_IN_THE_LOOP: "human-in-the-loop";
-    readonly OODA: "ooda";
-    readonly PLAN_EXECUTE_CRITIC: "plan-execute-critic";
-};
-export type LoopId = (typeof Loops)[keyof typeof Loops];
-export declare const DATA_ANALYSIS_LOOP_0_0_1: LoopSpec;
-export declare const HUMAN_IN_THE_LOOP_LOOP_0_0_1: LoopSpec;
-export declare const OODA_LOOP_0_0_1: LoopSpec;
-export declare const PLAN_EXECUTE_CRITIC_LOOP_0_0_1: LoopSpec;
-export declare const LOOP_CATALOGUE: Record<string, LoopSpec>;
-export declare const DEFAULT_LOOP: LoopId;
-/**
- * Get a loop specification by ID.
- */
-export declare function getLoop(loopId: string): LoopSpec | undefined;
-/**
- * Get the default loop.
- */
-export declare function getDefaultLoop(): LoopSpec | undefined;
-/**
- * List all available loops.
- */
-export declare function listLoops(): LoopSpec[];