@rune-kit/rune 2.2.0 → 2.2.2

package/extensions/ai-ml/skills/ai-agents.md

@@ -0,0 +1,172 @@
+---
+name: "ai-agents"
+pack: "@rune/ai-ml"
+description: "Stateful AI agent architecture — persistent state, callable RPC methods, scheduling, multi-agent coordination, MCP server integration, and real-time client communication via WebSocket."
+model: sonnet
+tools: [Read, Edit, Write, Grep, Glob, Bash]
+---
+
+# ai-agents
+
+Stateful AI agent architecture — persistent state, callable RPC methods, scheduling, multi-agent coordination, MCP server integration, and real-time client communication via WebSocket. Covers agent lifecycle, state management patterns, tool registration, human-in-the-loop approval flows, and durable workflow orchestration for long-running agent tasks.
+
+#### Workflow
+
+**Step 1 — Classify agent type**
+Identify what the agent needs to do and map to an architecture:
+
+| Agent Type | Key Characteristics | Platform Options |
+|---|---|---|
+| Stateless tool-caller | Single request → tool calls → response. No memory between requests. | Any LLM API + function calling |
+| Conversational with memory | Multi-turn dialogue. Needs chat history persistence. | Session store (Redis, KV) + LLM |
+| Stateful autonomous | Persistent state, scheduled tasks, reacts to events. Long-lived. | Cloudflare Agents SDK, LangGraph, CrewAI |
+| Multi-agent coordinator | Multiple specialized agents collaborating on a task. | LangGraph, AutoGen, custom orchestrator |
+| MCP server | Exposes tools/resources to any MCP-compatible client. | Cloudflare McpAgent, custom MCP server |
+
+**Step 2 — Design state management**
+For stateful agents, define the state contract:
+
+```typescript
+// State must be serializable (JSON-safe) — no functions, no circular refs
+interface AgentState {
+  // Domain state
+  conversations: ConversationEntry[];
+  preferences: Record<string, string>;
+  taskQueue: ScheduledTask[];
+
+  // Metadata
+  createdAt: string;
+  lastActiveAt: string;
+  version: number;
+}
+
+// State validation — reject invalid transitions
+function validateStateChange(current: AgentState, next: AgentState): void {
+  if (next.version < current.version) {
+    throw new Error('State version cannot decrease — concurrent modification detected');
+  }
+  if (next.conversations.length > 10_000) {
+    throw new Error('Conversation limit exceeded — archive old entries first');
+  }
+}
+```
+
+**Step 3 — Implement tool registration**
+Define agent capabilities as typed, callable methods:
+
+```typescript
+// Tools as typed RPC methods (Cloudflare Agents SDK pattern)
+import { Agent, callable } from 'agents';
+
+export class ResearchAgent extends Agent<Env, ResearchState> {
+  initialState: ResearchState = { findings: [], status: 'idle' };
+
+  @callable()
+  async search(query: string): Promise<SearchResult[]> {
+    this.setState({ ...this.state, status: 'searching' });
+    const results = await this.env.AI.run('@cf/meta/llama-3-8b-instruct', {
+      prompt: `Search for: ${query}`,
+    });
+    const findings = parseResults(results);
+    this.setState({
+      ...this.state,
+      findings: [...this.state.findings, ...findings],
+      status: 'idle',
+    });
+    return findings;
+  }
+
+  @callable()
+  async summarize(): Promise<string> {
+    if (this.state.findings.length === 0) {
+      throw new Error('No findings to summarize — run search first');
+    }
+    return generateSummary(this.state.findings);
+  }
+}
+```
+
+**Step 4 — Add scheduling and durability**
+For agents that need to perform work on a schedule or survive restarts:
+
+```typescript
+// Scheduled tasks — one-time, recurring, and cron
+@callable()
+async scheduleDigest(userId: string) {
+  // Daily digest at 9 AM
+  await this.schedule('0 9 * * *', 'sendDigest', { userId });
+
+  // One-time reminder in 1 hour
+  await this.schedule(3600, 'sendReminder', { userId, message: 'Check results' });
+
+  // Recurring every 30 minutes
+  await this.scheduleEvery(1800, 'pollDataSource');
+}
+
+// Handler runs when scheduled time arrives — even if agent was hibernated
+async onScheduledTask(task: ScheduledTask) {
+  switch (task.type) {
+    case 'sendDigest':
+      await this.compileAndSendDigest(task.payload.userId);
+      break;
+    case 'pollDataSource':
+      const newData = await fetchLatest();
+      if (newData.length > 0) {
+        this.setState({ ...this.state, lastPoll: Date.now(), data: newData });
+      }
+      break;
+  }
+}
+```
+
+**Step 5 — Human-in-the-loop patterns**
+For agents that need approval before taking high-impact actions:
+
+```typescript
+// Approval flow — agent pauses, human approves, agent resumes
+interface PendingApproval {
+  id: string;
+  action: string;
+  params: Record<string, unknown>;
+  requestedAt: string;
+  status: 'pending' | 'approved' | 'rejected';
+}
+
+@callable()
+async requestApproval(action: string, params: Record<string, unknown>): Promise<string> {
+  const approval: PendingApproval = {
+    id: crypto.randomUUID(),
+    action,
+    params,
+    requestedAt: new Date().toISOString(),
+    status: 'pending',
+  };
+  this.setState({
+    ...this.state,
+    pendingApprovals: [...this.state.pendingApprovals, approval],
+  });
+  // Client receives state update via WebSocket → shows approval UI
+  return approval.id;
+}
+
+@callable()
+async resolveApproval(id: string, decision: 'approved' | 'rejected') {
+  const updated = this.state.pendingApprovals.map(a =>
+    a.id === id ? { ...a, status: decision } : a
+  );
+  this.setState({ ...this.state, pendingApprovals: updated });
+  if (decision === 'approved') {
+    const approval = updated.find(a => a.id === id)!;
+    await this.executeAction(approval.action, approval.params);
+  }
+}
+```
+
+#### Sharp Edges
+
+| Failure Mode | Mitigation |
+|---|---|
+| State grows unbounded (conversation history, logs) | Implement max size limits with archival; prune old entries on state update |
+| Concurrent state mutations from multiple clients | Use version counter in state; reject updates with stale version |
+| Agent crashes mid-workflow, loses progress | Use durable workflows (Cloudflare Workflows, Temporal) for multi-step tasks — each step is persisted |
+| Scheduled tasks pile up during agent hibernation | Deduplicate on wake-up; use idempotency keys for task handlers |

package/extensions/ai-ml/skills/code-sandbox.md

@@ -0,0 +1,187 @@
+---
+name: "code-sandbox"
+pack: "@rune/ai-ml"
+description: "Secure code execution for AI agents — sandboxed environments for running LLM-generated code safely with container isolation, resource limits, and timeout enforcement."
+model: sonnet
+tools: [Read, Edit, Write, Grep, Glob, Bash]
+---
+
+# code-sandbox
+
+Secure code execution for AI agents — sandboxed environments for running LLM-generated code safely. Covers container isolation, resource limits, timeout enforcement, file system boundaries, and output capture for code interpreter, CI/CD, and interactive development use cases.
+
+#### Workflow
+
+**Step 1 — Assess execution requirements**
+Determine what kind of code the agent needs to run:
+
+| Use Case | Isolation Level | Runtime |
+|---|---|---|
+| Code interpreter (data analysis, math) | High — untrusted code | Python + pandas/numpy |
+| Build/test pipeline | Medium — project code | Node.js / Python with project deps |
+| Interactive preview (web app) | Medium — expose HTTP port | Node.js + browser preview |
+| Shell commands (file ops, git) | Low — trusted context | System shell with path restrictions |
+
+**Step 2 — Configure sandbox environment**
+Emit sandbox configuration based on use case:
+
+```typescript
+// Sandbox factory — select isolation level by use case
+interface SandboxConfig {
+  language: 'python' | 'javascript' | 'typescript';
+  timeout: number;       // max execution time in ms
+  memoryLimit: number;   // max memory in MB
+  networkAccess: boolean;
+  fileSystemRoot: string;  // restricted working directory
+  allowedModules: string[];
+}
+
+const SANDBOX_PRESETS: Record<string, SandboxConfig> = {
+  'code-interpreter': {
+    language: 'python',
+    timeout: 30_000,
+    memoryLimit: 256,
+    networkAccess: false,
+    fileSystemRoot: '/workspace',
+    allowedModules: ['pandas', 'numpy', 'matplotlib', 'scipy', 'json', 'csv', 'math'],
+  },
+  'build-test': {
+    language: 'typescript',
+    timeout: 120_000,
+    memoryLimit: 512,
+    networkAccess: true,  // needs npm registry
+    fileSystemRoot: '/project',
+    allowedModules: ['*'],  // project dependencies
+  },
+  'preview': {
+    language: 'javascript',
+    timeout: 300_000,
+    memoryLimit: 256,
+    networkAccess: true,
+    fileSystemRoot: '/app',
+    allowedModules: ['*'],
+  },
+};
+```
+
+**Step 3 — Implement execution with resource limits**
+Emit code execution wrapper with safety boundaries:
+
+```typescript
+// Docker-based sandbox execution
+import { spawn } from 'child_process';
+
+interface ExecutionResult {
+  stdout: string;
+  stderr: string;
+  exitCode: number;
+  durationMs: number;
+  timedOut: boolean;
+}
+
+async function executeInSandbox(
+  code: string,
+  config: SandboxConfig
+): Promise<ExecutionResult> {
+  const start = Date.now();
+
+  // Write code to temp file in sandbox root
+  const codePath = `${config.fileSystemRoot}/run.${config.language === 'python' ? 'py' : 'ts'}`;
+  await writeFile(codePath, code);
+
+  const proc = spawn('docker', [
+    'run', '--rm',
+    '--memory', `${config.memoryLimit}m`,
+    '--cpus', '1',
+    '--network', config.networkAccess ? 'bridge' : 'none',
+    '--read-only',
+    '--tmpfs', '/tmp:size=64m',
+    '-v', `${config.fileSystemRoot}:/workspace:ro`,
+    '-w', '/workspace',
+    `sandbox-${config.language}:latest`,
+    config.language === 'python' ? 'python' : 'npx tsx',
+    `/workspace/run.${config.language === 'python' ? 'py' : 'ts'}`,
+  ]);
+
+  let stdout = '';
+  let stderr = '';
+  let timedOut = false;
+
+  proc.stdout.on('data', (d) => { stdout += d.toString(); });
+  proc.stderr.on('data', (d) => { stderr += d.toString(); });
+
+  const timeout = setTimeout(() => {
+    timedOut = true;
+    proc.kill('SIGKILL');
+  }, config.timeout);
+
+  const exitCode = await new Promise<number>((resolve) => {
+    proc.on('close', (code) => {
+      clearTimeout(timeout);
+      resolve(code ?? 1);
+    });
+  });
+
+  return { stdout, stderr, exitCode, durationMs: Date.now() - start, timedOut };
+}
+```
+
+**Step 4 — Code interpreter mode (stateful sessions)**
+For multi-turn code execution where variables persist between runs:
+
+```typescript
+// Stateful code interpreter — variables persist across executions
+interface CodeSession {
+  id: string;
+  language: 'python' | 'javascript';
+  history: { code: string; result: ExecutionResult }[];
+}
+
+async function runInSession(
+  session: CodeSession,
+  code: string
+): Promise<ExecutionResult> {
+  // Python: use exec() with persistent globals dict
+  // JavaScript: use Node.js vm module with persistent context
+  const wrappedCode = session.language === 'python'
+    ? `exec(${JSON.stringify(code)}, _globals)`
+    : code;
+
+  const result = await executeInSandbox(wrappedCode, SANDBOX_PRESETS['code-interpreter']);
+
+  // Append to history (immutable update)
+  session.history = [...session.history, { code, result }];
+
+  return result;
+}
+
+// Rich output capture — not just stdout
+interface RichOutput {
+  text?: string;
+  images?: { data: string; mimeType: string }[];  // base64 encoded
+  tables?: { headers: string[]; rows: string[][] }[];
+  error?: string;
+}
+```
+
+**Step 5 — Security boundaries**
+Enforce isolation guarantees:
+
+| Boundary | Enforcement |
+|---|---|
+| File system | Read-only mount + tmpfs for temp files. No access to host filesystem. |
+| Network | `--network none` for code interpreter. Whitelist for build/test. |
+| Memory | Docker `--memory` limit. OOM killed if exceeded. |
+| CPU | Docker `--cpus` limit. Prevents crypto mining / infinite loops. |
+| Time | Kill process after timeout. Return partial output. |
+| Secrets | Never mount env vars or secrets into sandbox container. |
+| Output size | Cap stdout/stderr at 1MB. Truncate with `[output truncated]` marker. |
+
+#### Sharp Edges
+
+| Failure Mode | Mitigation |
+|---|---|
+| Sandbox escape via Docker vulnerability | Pin Docker version; use rootless Docker; consider gVisor/Firecracker for high-security |
+| Code writes to /tmp exhausting disk | Use `--tmpfs` with size limit (64MB default) |
+| Infinite loop inside sandbox hangs API | Hard timeout with SIGKILL — never rely on SIGTERM alone |
+| Stateful session grows unbounded memory | Limit session history to last 50 executions; reset context on overflow |

package/extensions/ai-ml/skills/deep-research.md

@@ -0,0 +1,146 @@
+---
+name: "deep-research"
+pack: "@rune/ai-ml"
+description: "Iterative AI research loop that converges on comprehensive answers — search, analyze, identify gaps, repeat. Outputs synthesized report with source attribution."
+model: sonnet
+tools: [Read, Edit, Write, Grep, Glob, Bash]
+---
+
+# deep-research
+
+Iterative AI research loop that converges on comprehensive answers. Search → analyze → identify gaps → search again. Bounded by depth, time, and URL limits. Outputs synthesized report with source attribution.
+
+#### Workflow
+
+**Step 1 — Initialize research state**
+```typescript
+interface ResearchState {
+  query: string;
+  findings: Finding[];           // max 50 most recent (memory bound)
+  gaps: string[];                // what we still don't know
+  seenUrls: Set<string>;         // dedup
+  failedQueries: number;         // convergence signal
+  depth: number;                 // current iteration
+  maxDepth: number;              // hard limit (default: 10)
+  maxUrls: number;               // hard limit (default: 100)
+  maxTimeMs: number;             // hard limit (default: 300_000 = 5 min)
+  startedAt: number;
+  activityLog: ActivityEntry[];  // for progress streaming
+}
+
+interface Finding {
+  content: string;
+  sourceUrl: string;
+  relevance: number;    // 0-1
+  extractedAt: number;
+}
+```
+
+**Step 2 — Generate search queries from current state**
+Each iteration, LLM generates 3 search queries based on:
+- Original research question
+- Current findings (what we know)
+- Current gaps (what we don't know)
+
+```typescript
+const queryPrompt = `Given the research question: "${state.query}"
+Current findings: ${summarizeFindings(state.findings)}
+Knowledge gaps: ${state.gaps.join(', ')}
+
+Generate 3 specific search queries that would fill the most important gaps.
+Avoid queries similar to: ${state.seenQueries.join(', ')}`;
+```
+
+**Step 3 — Search and deduplicate**
+Execute queries in parallel → collect URLs → filter against `seenUrls` → scrape new URLs → extract relevant content.
+
+```typescript
+async function searchAndExtract(queries: string[], state: ResearchState): Promise<Finding[]> {
+  // Parallel search
+  const allResults = await Promise.all(queries.map(q => webSearch(q, { limit: 10 })));
+  const urls = deduplicateUrls(allResults.flat(), state.seenUrls);
+
+  // Mark as seen immediately (even before scraping)
+  for (const url of urls) state.seenUrls.add(url);
+
+  // Scrape and extract in parallel (with concurrency limit)
+  const findings = await pMap(urls, async (url) => {
+    const content = await scrapeAndClean(url);
+    const relevance = await scoreRelevance(content, state.query);
+    return { content: summarize(content, 500), sourceUrl: url, relevance, extractedAt: Date.now() };
+  }, { concurrency: 5 });
+
+  return findings.filter(f => f.relevance > 0.3);  // threshold
+}
+```
+
+**Step 4 — Analyze findings and detect gaps**
+LLM analyzes new findings against existing knowledge:
+```typescript
+interface AnalysisResult {
+  newInsights: string[];
+  updatedGaps: string[];
+  shouldContinue: boolean;
+  nextSearchTopic: string | null;
+  confidence: number;  // 0-1: how complete is our understanding?
+}
+```
+
+**Step 5 — Check convergence criteria**
+Stop when ANY of:
+- `depth >= maxDepth`
+- `seenUrls.size >= maxUrls`
+- `Date.now() - startedAt >= maxTimeMs`
+- `gaps.length === 0` (all gaps filled)
+- `failedQueries >= 3` consecutive (no new information available)
+- `confidence >= 0.9` (LLM believes research is comprehensive)
+
+**Step 6 — Synthesize final report**
+```typescript
+interface ResearchReport {
+  question: string;
+  answer: string;              // comprehensive markdown synthesis
+  confidence: number;
+  sources: Array<{
+    url: string;
+    title: string;
+    relevance: number;
+    citedIn: string[];         // which sections cite this source
+  }>;
+  methodology: {
+    totalIterations: number;
+    urlsExamined: number;
+    findingsCount: number;
+    timeElapsed: number;
+    remainingGaps: string[];
+  };
+}
+```
+
+Memory management: keep only 50 most recent findings to avoid context explosion. Summarize older findings into a "background knowledge" string before dropping them.
+
+#### Example
+
+```typescript
+// Usage
+const report = await deepResearch({
+  query: 'What are the best practices for implementing RAG in production in 2026?',
+  maxDepth: 8,
+  maxUrls: 50,
+  maxTimeMs: 180_000,  // 3 minutes
+  onProgress: (entry) => console.log(`[${entry.depth}] ${entry.action}: ${entry.detail}`),
+});
+
+// Output: comprehensive report with 15-30 sources, gap analysis, confidence score
+```
+
+#### Sharp Edges
+
+| Failure Mode | Mitigation |
+|---|---|
+| Research loop runs forever (no convergence) | Hard limits on depth, URLs, and time; monitor `failedQueries` counter |
+| LLM generates duplicate search queries | Track seen queries; include exclusion list in prompt |
+| Memory explosion from accumulating findings | Cap at 50 findings; summarize oldest into background knowledge string |
+| Low-quality sources pollute findings | Relevance threshold (0.3); domain blocklist for known low-quality sites |
+| Rate limiting on search API | Per-provider rate limiter; fallback to alternative search provider |
+| Circular research (keeps finding same information) | Track `confidence` — if stable for 3 iterations, force stop |

package/extensions/ai-ml/skills/embedding-search.md

@@ -0,0 +1,66 @@
+---
+name: "embedding-search"
+pack: "@rune/ai-ml"
+description: "Embedding-based search — semantic search, hybrid search (BM25 + vector), similarity thresholds, index optimization."
+model: sonnet
+tools: [Read, Edit, Write, Grep, Glob, Bash]
+---
+
+# embedding-search
+
+Embedding-based search — semantic search, hybrid search (BM25 + vector), similarity thresholds, index optimization.
+
+#### Workflow
+
+**Step 1 — Detect search implementation**
+Use Grep to find search code: `similarity_search`, `vector_search`, `fts`, `tsvector`, `BM25`. Read search handlers to understand: query flow, ranking strategy, and result formatting.
+
+**Step 2 — Audit search quality**
+Check for: pure vector search without keyword fallback (misses exact matches), no similarity threshold (returns irrelevant results at low scores), missing query embedding cache (repeated queries re-embed), no hybrid scoring (BM25 for exact + vector for semantic), and unoptimized vector index (HNSW parameters not tuned).
+
+**Step 3 — Emit hybrid search**
+Emit: combined BM25 + vector search with reciprocal rank fusion, similarity threshold filtering, query embedding cache, and HNSW index tuning.
+
+#### Example
+
+```typescript
+// Hybrid search — BM25 + vector with reciprocal rank fusion
+async function hybridSearch(query: string, limit = 10) {
+  // Parallel: keyword (BM25) + semantic (vector)
+  const [keywordResults, vectorResults] = await Promise.all([
+    db.execute(sql`
+      SELECT id, content, ts_rank(search_vector, plainto_tsquery(${query})) AS bm25_score
+      FROM documents
+      WHERE search_vector @@ plainto_tsquery(${query})
+      ORDER BY bm25_score DESC LIMIT ${limit * 2}
+    `),
+    db.execute(sql`
+      SELECT id, content, 1 - (embedding <=> ${await getEmbedding(query)}) AS vector_score
+      FROM documents
+      ORDER BY embedding <=> ${await getEmbedding(query)}
+      LIMIT ${limit * 2}
+    `),
+  ]);
+
+  // Reciprocal rank fusion (k=60)
+  const scores = new Map<string, number>();
+  const K = 60;
+  keywordResults.forEach((r, i) => scores.set(r.id, (scores.get(r.id) || 0) + 1 / (K + i + 1)));
+  vectorResults.forEach((r, i) => scores.set(r.id, (scores.get(r.id) || 0) + 1 / (K + i + 1)));
+
+  return [...scores.entries()]
+    .sort((a, b) => b[1] - a[1])
+    .slice(0, limit)
+    .filter(([_, score]) => score > 0.01); // threshold
+}
+
+// Embedding cache (avoid re-embedding repeated queries)
+const embeddingCache = new Map<string, number[]>();
+async function getEmbedding(text: string): Promise<number[]> {
+  const cached = embeddingCache.get(text);
+  if (cached) return cached;
+  const { data } = await openai.embeddings.create({ model: 'text-embedding-3-small', input: text });
+  embeddingCache.set(text, data[0].embedding);
+  return data[0].embedding;
+}
+```

package/extensions/ai-ml/skills/fine-tuning-guide.md

@@ -0,0 +1,74 @@
+---
+name: "fine-tuning-guide"
+pack: "@rune/ai-ml"
+description: "Fine-tuning workflows — dataset preparation, training configuration, evaluation metrics, deployment, A/B testing."
+model: sonnet
+tools: [Read, Edit, Write, Grep, Glob, Bash]
+---
+
+# fine-tuning-guide
+
+Fine-tuning workflows — dataset preparation, training configuration, evaluation metrics, deployment, A/B testing.
+
+#### Workflow
+
+**Step 1 — Audit training data**
+Use Read to examine the dataset files. Check for: data format (JSONL with `messages` array), train/eval split (eval must not overlap with train), sufficient examples (minimum 50, recommended 200+), balanced class distribution, and PII in training data.
+
+**Step 2 — Prepare and validate dataset**
+Emit: JSONL formatter that validates each example, train/eval splitter with stratification, token count estimator (cost preview), and data quality checks (duplicate detection, format validation).
+
+**Step 3 — Execute fine-tuning and evaluate**
+Emit: fine-tune API call with hyperparameters, evaluation script that compares base vs fine-tuned on held-out set, and A/B deployment configuration.
+
+#### Example
+
+```python
+# Fine-tuning workflow — prepare, train, evaluate
+import json
+import openai
+from sklearn.model_selection import train_test_split
+
+# Step 1: Prepare JSONL dataset
+def prepare_dataset(examples: list[dict], output_prefix: str):
+    train, eval_set = train_test_split(examples, test_size=0.2, random_state=42)
+
+    for split_name, split_data in [("train", train), ("eval", eval_set)]:
+        path = f"{output_prefix}_{split_name}.jsonl"
+        with open(path, "w") as f:
+            for ex in split_data:
+                f.write(json.dumps({"messages": [
+                    {"role": "system", "content": ex["system"]},
+                    {"role": "user", "content": ex["input"]},
+                    {"role": "assistant", "content": ex["output"]},
+                ]}) + "\n")
+        print(f"Wrote {len(split_data)} examples to {path}")
+
+# Step 2: Launch fine-tuning
+def start_fine_tune(train_file: str, eval_file: str):
+    train_id = openai.files.create(file=open(train_file, "rb"), purpose="fine-tune").id
+    eval_id = openai.files.create(file=open(eval_file, "rb"), purpose="fine-tune").id
+
+    job = openai.fine_tuning.jobs.create(
+        training_file=train_id,
+        validation_file=eval_id,
+        model="gpt-4o-mini-2024-07-18",
+        hyperparameters={"n_epochs": 3, "batch_size": "auto", "learning_rate_multiplier": "auto"},
+    )
+    print(f"Fine-tuning job: {job.id} — status: {job.status}")
+    return job
+
+# Step 3: Evaluate base vs fine-tuned
+def evaluate(base_model: str, ft_model: str, eval_set: list[dict]) -> dict:
+    results = {"base": {"correct": 0}, "finetuned": {"correct": 0}}
+    for ex in eval_set:
+        for label, model in [("base", base_model), ("finetuned", ft_model)]:
+            response = openai.chat.completions.create(
+                model=model, messages=ex["messages"][:2], max_tokens=500,
+            )
+            if response.choices[0].message.content.strip() == ex["messages"][2]["content"].strip():
+                results[label]["correct"] += 1
+    for label in results:
+        results[label]["accuracy"] = results[label]["correct"] / len(eval_set)
+    return results
+```