@ax-llm/ax 21.0.7 → 21.0.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ax-llm/ax",
-  "version": "21.0.7",
+  "version": "21.0.8",
   "type": "module",
   "description": "The best library to work with LLMs",
   "repository": {

package/skills/ax-agent-memory-skills.md

@@ -0,0 +1,284 @@
+---
+name: ax-agent-memory-skills
+description: This skill helps an LLM generate correct AxAgent memory retrieval and dynamic skill-loading code using @ax-llm/ax. Use when the user asks about onMemoriesSearch, recall(...), inputs.memories, onLoadedMemories, onUsedMemories, onSkillsSearch, discover({ skills }), onLoadedSkills, onUsedSkills, preloaded skills, loaded memory/skill IDs, or carrying memories across forward() calls.
+version: "21.0.8"
+---
+
+# AxAgent Memory And Skills Rules (@ax-llm/ax)
+
+Use this skill when an agent needs to retrieve task-relevant memories or load skill guides into the executor prompt on demand. For ordinary agent setup use `ax-agent`. For RLM runtime policy use `ax-agent-rlm`. For callbacks and telemetry use `ax-agent-observability`.
+
+## Use These Defaults
+
+- Use `onMemoriesSearch` when the agent should pull relevant context from an external store instead of stuffing everything into the prompt upfront.
+- Use `onSkillsSearch` when the agent should load usage guides, runbooks, or domain conventions into the executor prompt on demand.
+- `recall(...)` is available to distiller and executor stages when `onMemoriesSearch` is set.
+- `discover({ skills })` is available to the executor when `onSkillsSearch` is set.
+- Both `recall(...)` and `discover({ skills })` return `void`. The loaded content appears on the next turn.
+- Use `onLoadedMemories` / `onLoadedSkills` to observe what got loaded.
+- Use `onUsedMemories` / `onUsedSkills` to track what the actor says it actually relied on.
+- Child agents do not inherit memory or skills search callbacks; wire them explicitly on every agent that needs the capability.
+
+## Memory Search
+
+Use `onMemoriesSearch` when the agent needs to pull task-relevant context such as user preferences, prior decisions, project facts, or past conversations from an external store (vector DB, BM25, KV). The actor decides what to load, when, and how much.
+
+When `onMemoriesSearch` is set, the distiller and executor stages gain:
+
+1. An `inputs.memories` field. In JS this is an array of `{ id, content }` entries the actor reads directly. In the prompt, the same entries render as markdown blocks with `ID: \`...\`` lines, matching the Loaded Skills ID style. Each `content` is opaque markdown; frontmatter is not parsed.
+2. A `recall(searches: string[]): void` global the actor `await`s to load more entries. Recalled entries are appended to `inputs.memories` and visible from the next turn onward. `recall()` returns nothing.
+
+The responder stage does not receive memories.
+
+### Enabling
+
+```typescript
+import { agent } from '@ax-llm/ax';
+import type { AxAgentMemoriesSearchFn } from '@ax-llm/ax';
+
+const onMemoriesSearch: AxAgentMemoriesSearchFn = async (
+  searches,
+  alreadyLoaded
+) => {
+  // `searches` is the full array passed to recall(...). Batch your
+  // store lookup in one round-trip.
+  // `alreadyLoaded` is the current inputs.memories snapshot. Filter
+  // against it to skip duplicates.
+  const skip = new Set(alreadyLoaded.map((m) => m.id));
+  const fresh = await myVectorDB.searchBatch(searches, { topK: 3 });
+  return fresh.filter((m) => !skip.has(m.id));
+};
+
+const myAgent = agent('task:string -> answer:string', {
+  contextFields: [],
+  onMemoriesSearch,
+});
+```
+
+Each memory result must be:
+
+```typescript
+type AxAgentMemoryResult = {
+  id: string;
+  content: string;
+};
+```
+
+### Actor usage
+
+```javascript
+// Turn 1: kick off one batched lookup.
+await recall(['user preferences', 'project constraints']);
+
+// Turn 2+: matched entries are now visible on inputs.memories.
+const prefs = inputs.memories.find((m) => m.id === 'user-prefs-v2');
+```
+
+Rules:
+
+- Pass all memory queries in one `await recall([...])` call.
+- Do not loop `recall()` calls or wrap them in `Promise.all(...)`.
+- Read `inputs.memories` on the next turn to see what landed.
+- `recall()` invokes `onMemoriesSearch` with `(searches, alreadyLoaded)` and returns `void`.
+- Results land on `inputs.memories` for subsequent turns and render in the prompt as:
+
+```markdown
+### Memory
+
+ID: `mem:user-prefs-v2`
+
+...
+```
+
+- Entries are deduped by `id` (last-write-wins) and sorted by `id` for prefix-cache stability.
+- Memories loaded by the distiller thread automatically to the executor. No second `recall()` is needed for those entries.
+- `recall()` may be called multiple times across turns; results accumulate for that run.
+- `inputs.memories` lifetime is one `.forward()` call. It resets between calls.
+
+## Carrying Memories Across `.forward()` Calls
+
+To preserve continuity across calls, persist memories in your store and recall them again on the next call. If you want to replay anything loaded on a prior run, observe loads with `onLoadedMemories`.
+
+```typescript
+const carried = new Map<string, string>();
+
+const myAgent = agent('task:string -> answer:string', {
+  contextFields: [],
+  onMemoriesSearch: async (searches) => {
+    const fresh = await myVectorDB.searchBatch(searches, { topK: 3 });
+    const carriedAsResults = [...carried.entries()].map(([id, content]) => ({
+      id,
+      content,
+    }));
+    return [...carriedAsResults, ...fresh];
+  },
+  onLoadedMemories: (results) => {
+    for (const r of results) carried.set(r.id, r.content);
+  },
+});
+```
+
+## Skills Search
+
+Use `onSkillsSearch` when the agent needs to load skill guides such as usage instructions, runbooks, or domain conventions into the executor's system prompt on demand. The actor decides which skills to fetch and when, so you do not pre-render every skill into every prompt.
+
+When `onSkillsSearch` is set, the executor stage gains:
+
+1. A "Loaded Skills" section in the system prompt that renders matched skill bodies with stable `ID:` values sorted by `id`.
+2. A `discover({ skills })` path the actor `await`s to load more skills. Loaded entries appear in the next turn's prompt. `discover(...)` returns nothing.
+
+The distiller and responder do not see skills. Only the executor.
+
+### Enabling
+
+```typescript
+import { agent } from '@ax-llm/ax';
+import type { AxAgentSkillsSearchFn } from '@ax-llm/ax';
+
+// Each result is { id?: string; name: string; content: string }.
+// If id is omitted, Ax falls back to name.
+const onSkillsSearch: AxAgentSkillsSearchFn = async (searches) => {
+  return mySkillStore.searchBatch(searches, { topK: 2 });
+};
+
+const myAgent = agent('task:string -> answer:string', {
+  contextFields: [],
+  onSkillsSearch,
+});
+```
+
+Each skill result is:
+
+```typescript
+type AxAgentSkillResult = {
+  id?: string;
+  name: string;
+  content: string;
+};
+```
+
+### Actor usage
+
+```javascript
+// Pass all skill queries in one call.
+await discover({ skills: ['release-checklist', 'incident-response'] });
+
+// Next turn: loaded skill bodies render under the "Loaded Skills"
+// system-prompt section.
+```
+
+Rules:
+
+- `discover({ skills })` invokes `onSkillsSearch` with the raw search strings and returns `void`.
+- Matched skills land under "Loaded Skills" for the next turn.
+- Entries are deduped by `id` (last-write-wins) and sorted by `id` for prefix-cache stability.
+- If a skill result omits `id`, its trimmed `name` is used as the id for backwards compatibility.
+- Skills persist on the agent's `currentSkillsPromptState` across `.forward()` calls, unlike memories.
+- Use `agent.getState()` / `setState(...)` to serialize/restore loaded skills.
+- `discover({ skills })` may be called multiple times across turns. Within one turn, batch all skill queries in a single call.
+- Child agents do not inherit `onSkillsSearch`; wire it explicitly per agent.
+
+## Preloading Skills
+
+If the caller already knows which skills are relevant, pass them up front instead of round-tripping through `discover({ skills })`.
+
+- Init-time: `skills` on `AxAgentOptions` seeds the executor prompt at agent creation. They survive `setState(...)` resets.
+- Forward-time: `skills` on `forward(ai, values, { skills })` merge in at the start of that call. Distiller and responder ignore forward-time skills.
+
+Both accept the same shape `onSkillsSearch` returns: `readonly AxAgentSkillResult[]`. Forward-time skills override init-time skills by `id`. `onLoadedSkills` is not fired for preset skills; that callback is for runtime `discover({ skills })` analytics.
+
+```typescript
+const releaseAgent = agent('task:string -> answer:string', {
+  contextFields: [],
+  skills: [
+    {
+      id: 'skill:release-checklist',
+      name: 'release-checklist',
+      content: '...',
+    },
+  ],
+});
+
+await releaseAgent.forward(
+  ai,
+  { task: 'Prepare release notes' },
+  {
+    skills: [
+      {
+        id: 'skill:incident-response',
+        name: 'incident-response',
+        content: '...',
+      },
+    ],
+  }
+);
+```
+
+You can use `skills` without setting `onSkillsSearch` at all. That is useful for static guides where the actor never needs to fetch more.
+
+## Loaded And Used Tracking
+
+`onLoadedMemories` reports what `recall(...)` loaded. `onLoadedSkills` reports what `discover({ skills })` loaded. To track what the actor says it actually relied on, use `onUsedMemories` / `onUsedSkills`.
+
+```typescript
+const used: AxAgentUsedMemory[] = [];
+
+await myAgent.forward(
+  ai,
+  { task: 'Make a personal plan' },
+  {
+    onUsedMemories: (items) => used.push(...items),
+  }
+);
+
+used; // [{ id, reason, stage }]
+```
+
+Rules:
+
+- The actor can only report memory IDs already present in `inputs.memories`.
+- The actor can only report skill IDs already present in Loaded Skills.
+- Unknown values are dropped.
+- When tracking is enabled, the actor sees `await used(id, reason?)`; this is the actor-side declaration mechanism.
+- `used(...)` resolves against loaded memory IDs and loaded skill IDs.
+- If memory IDs and skill IDs can collide, namespace them in your application, for example `mem:abc` and `skill:planning`.
+
+Types:
+
+```typescript
+onMemoriesSearch?: AxAgentMemoriesSearchFn;
+onLoadedMemories?: (
+  results: readonly AxAgentMemoryResult[]
+) => void | Promise<void>;
+onUsedMemories?: (
+  usedMemories: readonly AxAgentUsedMemory[]
+) => void | Promise<void>;
+
+onSkillsSearch?: AxAgentSkillsSearchFn;
+onLoadedSkills?: (
+  results: readonly AxAgentSkillResult[]
+) => void | Promise<void>;
+onUsedSkills?: (
+  usedSkills: readonly AxAgentUsedSkill[]
+) => void | Promise<void>;
+
+skills?: readonly AxAgentSkillResult[];
+```
+
+## Examples
+
+Fetch this for full working code:
+
+- [RLM Memories and Skills](https://raw.githubusercontent.com/ax-llm/ax/refs/heads/main/src/examples/rlm-memories-and-skills.ts) - `onMemoriesSearch` + `recall()` and `onSkillsSearch` + `discover({ skills })` with load observability and actual usage tracking via `onUsedMemories` / `onUsedSkills`
+
+## Do Not Generate
+
+- Do not assign the result of `await recall(...)` or `await discover(...)`; both return `void`.
+- Do not call `recall()` from the responder stage.
+- Do not call `discover({ skills })` from the distiller or responder stages.
+- Do not loop `recall()` calls or wrap them in `Promise.all(...)`.
+- Do not loop `discover()` calls or wrap them in `Promise.all(...)`.
+- Do not assume child agents inherit `onMemoriesSearch` or `onSkillsSearch`.
+- Do not pass `onMemoriesSearch` results via shared fields as a workaround; use `recall(...)`.
+- Do not assume `inputs.memories` persists across `.forward()` calls.
+- Do not use `onLoadedMemories` / `onLoadedSkills` as proof that the actor relied on an item; use `onUsedMemories` / `onUsedSkills` for actual-use tracking.

package/skills/ax-agent-observability.md

@@ -0,0 +1,334 @@
+---
+name: ax-agent-observability
+description: This skill helps an LLM generate correct AxAgent observability code using @ax-llm/ax. Use when the user asks about actorTurnCallback, executorTurnCallback, onContextEvent, agentStatusCallback, onFunctionCall, reportSuccess, reportFailure, getChatLog(), getUsage(), resetUsage(), debug traces, progress updates, or telemetry for AxAgent runs.
+version: "21.0.8"
+---
+
+# AxAgent Observability Rules (@ax-llm/ax)
+
+Use this skill when an agent needs runtime visibility, progress reporting, tracing, usage accounting, or chat-log access. For ordinary agent setup use `ax-agent`. For RLM runtime policy use `ax-agent-rlm`. For memories and dynamic skill loading use `ax-agent-memory-skills`.
+
+## Choose The Smallest Hook
+
+- Need a quick prompt/runtime trace during development -> start with `debug: true`.
+- Need structured per-turn code, raw runtime result, formatted output, provider thoughts, or actor stage -> use `actorTurnCallback`.
+- Need context-pressure and compaction telemetry -> use `onContextEvent`.
+- Need real-time task progress emitted by actor code -> use `agentStatusCallback`.
+- Need every runtime function call before execution -> use `onFunctionCall`.
+- Need model prompts/responses after a run -> use `getChatLog()`.
+- Need token usage by actor/responder -> use `getUsage()` and `resetUsage()`.
+- Need usage split by context and task stages -> use `getStagedUsage()`.
+- Need Ax program traces -> use `getTraces()`.
+- Do not add multiple hooks unless the user clearly needs each output stream.
+
+## Actor Turn Callback
+
+Use `actorTurnCallback` when the caller needs structured telemetry for each actor turn. `executorTurnCallback` is still accepted as a deprecated alias for older code.
+
+What it gives you:
+
+- `code`: the normalized JavaScript code the actor produced
+- `stage`: which actor produced the turn (`distiller` or `executor`)
+- `result`: the raw untruncated runtime return value from executing that code
+- `output`: the formatted action-log output string after Ax normalizes and truncates it for prompt replay
+- `thought`: the actor model's `thought` field when `showThoughts` is enabled and the provider returns one
+- `executorResult`: the full actor payload returned by the current actor stage, kept under this historical field name for compatibility
+- `isError`: whether the execution path for that turn was treated as an error
+- `usage`: token usage for this actor turn only
+- `model`: model used for this turn when explicitly set through `executorModelPolicy`
+- `chatLogMessages`: raw ChatML conversation for this turn, populated only when an actor turn callback is set
+
+Use it for:
+
+- debug UIs that want to show code plus raw runtime results
+- tracing and analytics
+- capturing `thought` for internal diagnostics when supported by the provider
+- storing per-turn execution artifacts without scraping the prompt/action log
+
+Important:
+
+- `output` is not raw stdout; it is the formatted replay string used in the action log.
+- `result` is the raw runtime result before Ax applies type-aware serialization and budget-proportional truncation.
+- `thought` is optional and only appears when the underlying `AxGen` call had `showThoughts` enabled and the provider actually returned a thought field.
+- `actionLogEntryCount` and `guidanceLogEntryCount` reflect the live log sizes after the turn is processed, including resumed runs.
+- `actorTurnCallback` fires for the root agent and for recursive child agents that run actor turns.
+
+Good pattern:
+
+```typescript
+const supportAgent = agent('query:string -> answer:string', {
+  contextFields: ['query'],
+  runtime,
+  actorTurnCallback: ({
+    stage,
+    turn,
+    actionLogEntryCount,
+    guidanceLogEntryCount,
+    code,
+    result,
+    output,
+    thought,
+    isError,
+    usage,
+    model,
+  }) => {
+    console.log({
+      turn,
+      stage,
+      model,
+      actionLogEntryCount,
+      guidanceLogEntryCount,
+      isError,
+      code,
+      rawResult: result,
+      replayOutput: output,
+      thought,
+      usage,
+    });
+  },
+  executorOptions: {
+    model: 'gpt-5.4-mini',
+    showThoughts: true,
+  },
+});
+```
+
+Callback type:
+
+```typescript
+actorTurnCallback?: (turn: {
+  stage: 'distiller' | 'executor';
+  turn: number;
+  actionLogEntryCount: number;
+  guidanceLogEntryCount: number;
+  executorResult: Record<string, unknown>;
+  code: string;
+  result: unknown;
+  output: string;
+  isError: boolean;
+  thought?: string;
+  usage?: AxProgramUsage[];
+  model?: string;
+  chatLogMessages?: ReadonlyArray<{ role: string; content: string }>;
+}) => void | Promise<void>;
+
+executorTurnCallback?: (turn: {
+  stage: 'distiller' | 'executor';
+  turn: number;
+  actionLogEntryCount: number;
+  guidanceLogEntryCount: number;
+  executorResult: Record<string, unknown>;
+  code: string;
+  result: unknown;
+  output: string;
+  isError: boolean;
+  thought?: string;
+  usage?: AxProgramUsage[];
+  model?: string;
+  chatLogMessages?: ReadonlyArray<{ role: string; content: string }>;
+}) => void | Promise<void>; // deprecated alias
+```
+
+## Context Event Observability
+
+Use `onContextEvent` when the caller needs structured telemetry about prompt pressure and compaction. It does not change model behavior directly; it is for logs, evals, and dashboards.
+
+Events:
+
+- `budget_check`: character-based prompt pressure before an actor turn, with detailed metrics kept out of the actor prompt
+- `checkpoint_created` / `checkpoint_cleared`: checkpoint lifecycle events with covered turns and reason
+- `tombstone_created`: compact resolved-error summary creation
+
+Rules:
+
+- `contextPressure` in the actor prompt is intentionally compact (`ok`, `watch`, `critical` plus one short instruction).
+- Budget metrics are character-based for provider neutrality and are exposed through `onContextEvent`, not the actor prompt.
+- Callback errors are swallowed so telemetry cannot break the agent run.
+- Do not scrape actor prompts for pressure metrics.
+
+```typescript
+const supportAgent = agent('query:string -> answer:string', {
+  contextFields: ['query'],
+  runtime,
+  contextPolicy: { preset: 'checkpointed', budget: 'balanced' },
+  onContextEvent: (event) => {
+    if (event.kind === 'budget_check') {
+      console.log(event.pressure, event.mutablePromptChars);
+    }
+  },
+});
+```
+
+Type:
+
+```typescript
+onContextEvent?: (event: AxAgentContextEvent) => void | Promise<void>;
+```
+
+## Agent Status Callback
+
+Use `agentStatusCallback` when the caller wants real-time progress updates from the actor. When set, the actor can call `await reportSuccess(message)` and `await reportFailure(message)` in its JavaScript turns.
+
+```typescript
+const supportAgent = agent('query:string -> answer:string', {
+  contextFields: ['query'],
+  runtime,
+  agentStatusCallback: (message, status) => {
+    console.log(`[${status}] ${message}`);
+  },
+});
+```
+
+Rules:
+
+- `agentStatusCallback` receives `(message: string, status: 'success' | 'failed')`.
+- When set, the actor prompt automatically includes `reportSuccess(message)` and `reportFailure(message)` as available runtime functions.
+- The actor is instructed to keep the user updated on task progress.
+- `reportSuccess` and `reportFailure` are reserved runtime names when the callback is configured.
+- Child agents inherit the callback via the RLM config.
+
+Type:
+
+```typescript
+agentStatusCallback?: (
+  message: string,
+  status: 'success' | 'failed'
+) => void | Promise<void>;
+```
+
+## On Function Call
+
+Use `onFunctionCall` when the caller wants to observe every function call the actor makes from the JS runtime. It fires before the underlying function runs.
+
+```typescript
+const supportAgent = agent('query:string -> answer:string', {
+  contextFields: ['query'],
+  runtime,
+  functions: [helperAgent, lookupOrderTool],
+  onFunctionCall: ({ name, qualifiedName, args, kind }) => {
+    console.log(`[${kind}] ${qualifiedName}`, args);
+  },
+});
+```
+
+Rules:
+
+- Receives `{ name, qualifiedName, args, kind }`.
+- `name` is the bare function name, e.g. `'lookupOrder'`.
+- `qualifiedName` is the namespaced name as the actor sees it, e.g. `'tools.lookupOrder'`; for un-namespaced runtime globals it equals `name`.
+- `args` is the resolved positional/named arguments object (`Record<string, unknown>`).
+- `kind` is `'external'` for caller-registered `functions`.
+- `kind` is `'internal'` for agent-injected globals: child agents, `discover`, `recall`, and `used`.
+- Fires once per call, before the function executes.
+- Errors thrown inside the callback are swallowed so they cannot break the actor loop.
+- This is independent from the DSP-layer `onFunctionCall` on `AxProgramForwardOptions`; that hook is for LLM tool-calls and never fires under AxAgent because AxAgent injects functions as runtime globals.
+
+Type:
+
+```typescript
+onFunctionCall?: (call: {
+  name: string;
+  qualifiedName: string;
+  args: Record<string, unknown>;
+  kind: 'internal' | 'external';
+}) => void | Promise<void>;
+```
+
+## Chat Log, Usage, And Traces
+
+`AxAgent` exposes actor and responder sub-programs. `getChatLog()` returns the same flat `AxChatLogEntry[]` shape as `AxGen` and `AxFlow`; use each entry's optional `name` field to distinguish `distiller`, `executor`, and `responder`. `getUsage()` returns token usage split by actor/responder.
+
+### getChatLog()
+
+Returns the full normalized chat history after any `.forward()` call. Each entry is one `ai.chat()` round-trip. Actor stages accumulate one entry per turn; the responder typically has one entry.
+
+```typescript
+const log = myAgent.getChatLog();
+
+for (const entry of log) {
+  console.log(entry.name, entry.model);
+  for (const msg of entry.messages) {
+    console.log(`[${msg.role}]`, msg.content);
+  }
+}
+```
+
+Each `AxChatLogEntry` captures the full prompt sent to the model and its response:
+
+```typescript
+type AxChatLogMessage =
+  | { role: 'system'; content: string }
+  | { role: 'user'; content: string }
+  | { role: 'assistant'; content: string }
+  | { role: 'tool'; name: string; content: string };
+
+type AxChatLogEntry = {
+  name?: string; // e.g. "distiller", "executor", "responder"
+  model: string;
+  messages: AxChatLogMessage[];
+  modelUsage?: AxProgramUsage;
+  stage?: 'ctx' | 'task';
+};
+```
+
+### getUsage()
+
+Returns token usage split by actor/responder. Each sub-array contains one `AxProgramUsage` entry per model/run, merged by `(ai, model)` key.
+
+```typescript
+const usage = myAgent.getUsage();
+// { actor: AxProgramUsage[], responder: AxProgramUsage[] }
+
+console.log('Actor tokens:', usage.actor[0]?.tokens);
+console.log('Responder tokens:', usage.responder[0]?.tokens);
+```
+
+### getStagedUsage()
+
+Returns usage split by pipeline stage. The `ctx` stage has the distiller actor only; the `task` stage has the executor actor plus responder.
+
+```typescript
+const staged = myAgent.getStagedUsage();
+console.log(staged.ctx?.actor);
+console.log(staged.task.actor);
+console.log(staged.task.responder);
+```
+
+### getTraces()
+
+Returns Ax program traces for the agent pipeline. Use it when the caller needs trace data rather than chat messages or token summaries.
+
+```typescript
+const traces = myAgent.getTraces();
+```
+
+### resetUsage()
+
+Resets both actor and responder usage at once:
+
+```typescript
+myAgent.resetUsage();
+```
+
+Type signatures:
+
+```typescript
+// AxAgent
+agent.getChatLog(): readonly AxChatLogEntry[]
+agent.getUsage(): { actor: AxProgramUsage[]; responder: AxProgramUsage[] }
+agent.getStagedUsage(): { ctx?: AxAgentUsage; task: AxAgentUsage }
+agent.getTraces(): AxProgramTrace[]
+agent.resetUsage(): void
+
+// AxGen / AxFlow
+gen.getChatLog(): readonly AxChatLogEntry[]
+gen.getUsage(): AxProgramUsage[]
+```
+
+## Do Not Generate
+
+- Do not add both `debug: true` and `actorTurnCallback` unless the user wants both unstructured prompt/runtime visibility and structured telemetry.
+- Do not scrape actor prompts or action logs when a callback exposes the data directly.
+- Do not let observability callback failures break the agent run; Ax swallows callback errors for telemetry hooks.
+- Do not use DSP-layer `onFunctionCall` when the user wants AxAgent runtime function calls.
+- Do not enable `showThoughts` unless the user needs provider thought diagnostics and the provider supports it.

package/skills/ax-agent-optimize.md

@@ -1,7 +1,7 @@
 ---
 name: ax-agent-optimize
 description: This skill helps an LLM generate correct AxAgent tuning and evaluation code using @ax-llm/ax. Use when the user asks about agent.optimize(...), judgeOptions, eval datasets, optimization targets, saved optimizedProgram artifacts, or recursive optimization guidance.
-version: "21.0.7"
+version: "21.0.8"
 ---
 
 # AxAgent Optimize Codegen Rules (@ax-llm/ax)