Update version to v1.4.232 and commit

Add Custom Patterns Directory Support

.github/workflows/release.yml

@@ -2,7 +2,7 @@ name: Go Release
 
 on:
   repository_dispatch:
-    types: [ tag_created ]
+    types: [tag_created]
   push:
     tags:
       - "v*"
@@ -108,10 +108,15 @@ jobs:
           Add-Content -Path $env:GITHUB_ENV -Value "latest_tag=$latest_tag"
 
       - name: Create release if it doesn't exist
+        shell: bash
         env:
           GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
         run: |
-          gh release view ${{ env.latest_tag }} || gh release create ${{ env.latest_tag }} --title "Release ${{ env.latest_tag }}" --notes "Automated release for ${{ env.latest_tag }}"
+          if ! gh release view ${{ env.latest_tag }} >/dev/null 2>&1; then
+            gh release create ${{ env.latest_tag }} --title "Release ${{ env.latest_tag }}" --notes "Automated release for ${{ env.latest_tag }}"
+          else
+            echo "Release ${{ env.latest_tag }} already exists."
+          fi
 
       - name: Upload release artifact
         if: matrix.os == 'windows-latest'

.github/workflows/update-version-and-create-tag.yml

@@ -11,6 +11,10 @@ on:
 permissions:
   contents: write  # Ensure the workflow has write permissions
 
+concurrency:
+  group: version-update
+  cancel-in-progress: false
+
 jobs:
   update-version:
     if: github.event_name == 'push' && github.ref == 'refs/heads/main'
@@ -30,6 +34,11 @@ jobs:
           git config user.name "github-actions[bot]"
           git config user.email "github-actions[bot]@users.noreply.github.com"
 
+      - name: Pull latest main and tags
+        run: |
+          git pull --rebase origin main
+          git fetch --tags
+
       - name: Get the latest tag
         id: get_latest_tag
         run: |

Pattern_Descriptions/README_Pattern_Descriptions_and_Tags_MGT.md

@@ -5,6 +5,7 @@ This document explains the complete workflow for managing pattern descriptions a
 ## System Overview
 
 The pattern system follows this hierarchy:
+
 1. `~/.config/fabric/patterns/` directory: The source of truth for available patterns
 2. `pattern_extracts.json`: Contains first 500 words of each pattern for reference
 3. `pattern_descriptions.json`: Stores pattern metadata (descriptions and tags)
@@ -13,17 +14,21 @@ The pattern system follows this hierarchy:
 ## Pattern Processing Workflow
 
 ### 1. Adding New Patterns
+
 - Add patterns to `~/.config/fabric/patterns/`
 - Run extract_patterns.py to process new additions:
+
   ```bash
   python extract_patterns.py
 
 The Python Script automatically:
+
 - Creates pattern extracts for reference
 - Adds placeholder entries in descriptions file
 - Syncs to web interface
 
 ### 2. Pattern Extract Creation
+
 The script extracts first 500 words from each pattern's system.md file to:
 
 - Provide context for writing descriptions
@@ -31,8 +36,8 @@ The script extracts first 500 words from each pattern's system.md file to:
 - Aid in pattern categorization
 
 ### 3. Description and Tag Management
-Pattern descriptions and tags are managed in pattern_descriptions.json:
 
+Pattern descriptions and tags are managed in pattern_descriptions.json:
 
 {
   "patterns": [
@@ -44,20 +49,21 @@ Pattern descriptions and tags are managed in pattern_descriptions.json:
   ]
 }
 
-
 ## Completing Pattern Metadata
 
 ### Writing Descriptions
+
 1. Check pattern_descriptions.json for "[Description pending]" entries
 2. Reference pattern_extracts.json for context
 
-3. How to update Pattern short descriptions (one sentence). 
+3. How to update Pattern short descriptions (one sentence).
 
-You can update your descriptions in pattern_descriptions.json manually or using LLM assistance (preferred approach). 
+You can update your descriptions in pattern_descriptions.json manually or using LLM assistance (preferred approach).
 
-Tell AI to look for "Description pending" entries in this file and write a short description based on the extract info in the pattern_extracts.json file. You can also ask your LLM to add tags for those newly added patterns, using other patterns tag assignments as example.    
+Tell AI to look for "Description pending" entries in this file and write a short description based on the extract info in the pattern_extracts.json file. You can also ask your LLM to add tags for those newly added patterns, using other patterns tag assignments as example.
 
 ### Managing Tags
+
 1. Add appropriate tags to new patterns
 2. Update existing tags as needed
 3. Tags are stored as arrays: ["TAG1", "TAG2"]
@@ -67,6 +73,7 @@ Tell AI to look for "Description pending" entries in this file and write a short
 ## File Synchronization
 
 The script maintains synchronization between:
+
 - Local pattern_descriptions.json
 - Web interface copy in static/data/
 - No manual file copying needed
@@ -91,6 +98,7 @@ The script maintains synchronization between:
 ## Troubleshooting
 
 If patterns are not showing in the web interface:
+
 1. Verify pattern_descriptions.json format
 2. Check web static copy exists
 3. Ensure proper file permissions
@@ -108,17 +116,3 @@ fabric/
     └── static/
         └── data/
             └── pattern_descriptions.json # Web interface copy
-
-
-
-
-
-
-
-
-
-
-
-
-
-

Pattern_Descriptions/extract_patterns.py

@@ -1,81 +1,96 @@
+#!/usr/bin/env python3
+
+"""Extracts pattern information from the ~/.config/fabric/patterns directory,
+creates JSON files for pattern extracts and descriptions, and updates web static files.
+"""
 import os
 import json
 import shutil
 
+
 def load_existing_file(filepath):
     """Load existing JSON file or return default structure"""
     if os.path.exists(filepath):
-        with open(filepath, 'r', encoding='utf-8') as f:
-            return json.load(f)
+        try:
+            with open(filepath, "r", encoding="utf-8") as f:
+                return json.load(f)
+        except json.JSONDecodeError:
+            print(
+                f"Warning: Malformed JSON in {filepath}. Starting with an empty list."
+            )
+            return {"patterns": []}
     return {"patterns": []}
 
+
 def get_pattern_extract(pattern_path):
     """Extract first 500 words from pattern's system.md file"""
     system_md_path = os.path.join(pattern_path, "system.md")
-    with open(system_md_path, 'r', encoding='utf-8') as f:
-        content = ' '.join(f.read().split()[:500])
+    with open(system_md_path, "r", encoding="utf-8") as f:
+        content = " ".join(f.read().split()[:500])
     return content
 
+
 def extract_pattern_info():
+    """Extract pattern information from the patterns directory"""
     script_dir = os.path.dirname(os.path.abspath(__file__))
     patterns_dir = os.path.expanduser("~/.config/fabric/patterns")
     print(f"\nScanning patterns directory: {patterns_dir}")
-    
+
     extracts_path = os.path.join(script_dir, "pattern_extracts.json")
     descriptions_path = os.path.join(script_dir, "pattern_descriptions.json")
-    
+
     existing_extracts = load_existing_file(extracts_path)
     existing_descriptions = load_existing_file(descriptions_path)
-    
+
     existing_extract_names = {p["patternName"] for p in existing_extracts["patterns"]}
-    existing_description_names = {p["patternName"] for p in existing_descriptions["patterns"]}
+    existing_description_names = {
+        p["patternName"] for p in existing_descriptions["patterns"]
+    }
     print(f"Found existing patterns: {len(existing_extract_names)}")
-    
+
     new_extracts = []
     new_descriptions = []
-    
-    
+
     for dirname in sorted(os.listdir(patterns_dir)):
-        # Only log new pattern processing
-        if dirname not in existing_extract_names:
-            print(f"Processing new pattern: {dirname}")
-    
-            
         pattern_path = os.path.join(patterns_dir, dirname)
         system_md_path = os.path.join(pattern_path, "system.md")
-        print(f"Checking system.md at: {system_md_path}")
-        
+
         if os.path.isdir(pattern_path) and os.path.exists(system_md_path):
-            print(f"Valid pattern directory found: {dirname}")
+            if dirname not in existing_extract_names:
+                print(f"Processing new pattern: {dirname}")
+
             try:
                 if dirname not in existing_extract_names:
                     print(f"Creating new extract for: {dirname}")
-                    pattern_extract = get_pattern_extract(pattern_path)  # Pass directory path
-                    new_extracts.append({
-                        "patternName": dirname,
-                        "pattern_extract": pattern_extract
-                    })
-                
+                    pattern_extract = get_pattern_extract(
+                        pattern_path
+                    )  # Pass directory path
+                    new_extracts.append(
+                        {"patternName": dirname, "pattern_extract": pattern_extract}
+                    )
+
                 if dirname not in existing_description_names:
                     print(f"Creating new description for: {dirname}")
-                    new_descriptions.append({
-                        "patternName": dirname,
-                        "description": "[Description pending]",
-                        "tags": []
-                    })
-                    
-            except Exception as e:
+                    new_descriptions.append(
+                        {
+                            "patternName": dirname,
+                            "description": "[Description pending]",
+                            "tags": [],
+                        }
+                    )
+
+            except OSError as e:
                 print(f"Error processing {dirname}: {str(e)}")
         else:
             print(f"Invalid pattern directory or missing system.md: {dirname}")
-    
-    print(f"\nProcessing summary:")
+
+    print("\nProcessing summary:")
     print(f"New extracts created: {len(new_extracts)}")
     print(f"New descriptions added: {len(new_descriptions)}")
-    
+
     existing_extracts["patterns"].extend(new_extracts)
     existing_descriptions["patterns"].extend(new_descriptions)
-    
+
     return existing_extracts, existing_descriptions, len(new_descriptions)
 
 
@@ -87,28 +102,29 @@ def update_web_static(descriptions_path):
     static_path = os.path.join(static_dir, "pattern_descriptions.json")
     shutil.copy2(descriptions_path, static_path)
 
+
 def save_pattern_files():
     """Save both pattern files and sync to web"""
     script_dir = os.path.dirname(os.path.abspath(__file__))
     extracts_path = os.path.join(script_dir, "pattern_extracts.json")
     descriptions_path = os.path.join(script_dir, "pattern_descriptions.json")
-    
+
     pattern_extracts, pattern_descriptions, new_count = extract_pattern_info()
-    
+
     # Save files
-    with open(extracts_path, 'w', encoding='utf-8') as f:
+    with open(extracts_path, "w", encoding="utf-8") as f:
         json.dump(pattern_extracts, f, indent=2, ensure_ascii=False)
-    
-    with open(descriptions_path, 'w', encoding='utf-8') as f:
+
+    with open(descriptions_path, "w", encoding="utf-8") as f:
         json.dump(pattern_descriptions, f, indent=2, ensure_ascii=False)
-    
+
     # Update web static
     update_web_static(descriptions_path)
-    
-    print(f"\nProcessing complete:")
+
+    print("\nProcessing complete:")
     print(f"Total patterns: {len(pattern_descriptions['patterns'])}")
     print(f"New patterns added: {new_count}")
 
+
 if __name__ == "__main__":
     save_pattern_files()
-

Pattern_Descriptions/pattern_descriptions.json

@@ -1634,8 +1634,8 @@
       ]
     },
     {
-      "patternName": "write_essay",
-      "description": "Create essays with thesis statements and arguments.",
+      "patternName": "write_essay_pg",
+      "description": "Create essays with thesis statements and arguments in the style of Paul Graham.",
       "tags": [
         "WRITING",
         "RESEARCH",
@@ -1703,22 +1703,22 @@
     {
       "patternName": "analyze_bill",
       "description": "Analyze a legislative bill and implications.",
-      "tags": [ 
+      "tags": [
         "ANALYSIS",
         "BILL"
       ]
     },
     {
       "patternName": "analyze_bill_short",
-      "description": "Consended - Analyze a legislative bill and implications.",
-      "tags": [ 
+      "description": "Condensed - Analyze a legislative bill and implications.",
+      "tags": [
         "ANALYSIS",
         "BILL"
       ]
     },
     {
       "patternName": "create_coding_feature",
-      "description": "[Description pending]",
+      "description": "Generate secure and composable code features using latest technology and best practices.",
       "tags": [
         "DEVELOPMENT"
       ]
@@ -1774,6 +1774,76 @@
       "tags": [
         "SUMMARIZE"
       ]
+    },
+    {
+      "patternName": "analyze_paper_simple",
+      "description": "Analyze research papers to determine primary findings and assess scientific rigor.",
+      "tags": [
+        "ANALYSIS",
+        "RESEARCH",
+        "WRITING"
+      ]
+    },
+    {
+      "patternName": "analyze_terraform_plan",
+      "description": "Analyze Terraform plans for infrastructure changes, security risks, and cost implications.",
+      "tags": [
+        "ANALYSIS",
+        "DEVOPS"
+      ]
+    },
+    {
+      "patternName": "create_mnemonic_phrases",
+      "description": "Create memorable mnemonic sentences using given words in exact order for memory aids.",
+      "tags": [
+        "CREATIVITY",
+        "LEARNING"
+      ]
+    },
+    {
+      "patternName": "summarize_board_meeting",
+      "description": "Convert board meeting transcripts into formal meeting notes for corporate records.",
+      "tags": [
+        "ANALYSIS",
+        "BUSINESS"
+      ]
+    },
+    {
+      "patternName": "write_essay",
+      "description": "Write essays on given topics in the distinctive style of specified authors.",
+      "tags": [
+        "WRITING",
+        "CREATIVITY"
+      ]
+    },
+    {
+      "patternName": "extract_alpha",
+      "description": "Extracts the most novel and surprising ideas (\"alpha\") from content, inspired by information theory.",
+      "tags": [
+        "EXTRACT",
+        "ANALYSIS",
+        "CR THINKING",
+        "WISDOM"
+      ]
+    },
+    {
+      "patternName": "extract_mcp_servers",
+      "description": "Analyzes content to identify and extract detailed information about Model Context Protocol (MCP) servers.",
+      "tags": [
+        "ANALYSIS",
+        "EXTRACT",
+        "DEVELOPMENT",
+        "AI"
+      ]
+    },
+    {
+      "patternName": "review_code",
+      "description": "Performs a comprehensive code review, providing detailed feedback on correctness, security, and performance.",
+      "tags": [
+        "DEVELOPMENT",
+        "REVIEW",
+        "SECURITY"
+      ]
     }
   ]
 }

README.md

@@ -12,10 +12,11 @@ Fabric is graciously supported by…
 ![GitHub top language](https://img.shields.io/github/languages/top/danielmiessler/fabric)
 ![GitHub last commit](https://img.shields.io/github/last-commit/danielmiessler/fabric)
 [![License: MIT](https://img.shields.io/badge/License-MIT-green.svg)](https://opensource.org/licenses/MIT)
+[![Ask DeepWiki](https://deepwiki.com/badge.svg)](https://deepwiki.com/danielmiessler/fabric)
 
-<p class="align center">
+<div align="center">
 <h4><code>fabric</code> is an open-source framework for augmenting humans using AI.</h4>
-</p>
+</div>
 
 [Updates](#updates) •
 [What and Why](#what-and-why) •
@@ -32,13 +33,36 @@ Fabric is graciously supported by…
 
 </div>
 
+## What and why
+
+Since the start of modern AI in late 2022 we've seen an **_extraordinary_** number of AI applications for accomplishing tasks. There are thousands of websites, chat-bots, mobile apps, and other interfaces for using all the different AI out there.
+
+It's all really exciting and powerful, but _it's not easy to integrate this functionality into our lives._
+
+<div class="align center">
+<h4>In other words, AI doesn't have a capabilities problem—it has an <em>integration</em> problem.</h4>
+</div>
+
+**Fabric was created to address this by creating and organizing the fundamental units of AI—the prompts themselves!**
+
+Fabric organizes prompts by real-world task, allowing people to create, collect, and organize their most important AI solutions in a single place for use in their favorite tools. And if you're command-line focused, you can use Fabric itself as the interface!
+
+## Intro videos
+
+Keep in mind that many of these were recorded when Fabric was Python-based, so remember to use the current [install instructions](#installation) below.
+
+- [Network Chuck](https://www.youtube.com/watch?v=UbDyjIIGaxQ)
+- [David Bombal](https://www.youtube.com/watch?v=vF-MQmVxnCs)
+- [My Own Intro to the Tool](https://www.youtube.com/watch?v=wPEyyigh10g)
+- [More Fabric YouTube Videos](https://www.youtube.com/results?search_query=fabric+ai)
+
 ## Navigation
 
 - [`fabric`](#fabric)
-  - [Navigation](#navigation)
-  - [Updates](#updates)
   - [What and why](#what-and-why)
   - [Intro videos](#intro-videos)
+  - [Navigation](#navigation)
+  - [Updates](#updates)
   - [Philosophy](#philosophy)
     - [Breaking problems into components](#breaking-problems-into-components)
     - [Too many prompts](#too-many-prompts)
@@ -87,28 +111,29 @@ Fabric is graciously supported by…
 ## Updates
 
 > [!NOTE]
-> May 22, 2025
 >
-> - Fabric now supports Anthropic's Claude 4. Read the [blog post from Anthropic](https://www.anthropic.com/news/claude-4).
-
-## What and why
-
-Since the start of 2023 and GenAI we've seen a massive number of AI applications for accomplishing tasks. It's powerful, but _it's not easy to integrate this functionality into our lives._
-
-<div align="center">
-<h4>In other words, AI doesn't have a capabilities problem—it has an <em>integration</em> problem.</h4>
-</div>
-
-Fabric was created to address this by enabling everyone to granularly apply AI to everyday challenges.
-
-## Intro videos
-
-Keep in mind that many of these were recorded when Fabric was Python-based, so remember to use the current [install instructions](#installation) below.
-
-- [Network Chuck](https://www.youtube.com/watch?v=UbDyjIIGaxQ)
-- [David Bombal](https://www.youtube.com/watch?v=vF-MQmVxnCs)
-- [My Own Intro to the Tool](https://www.youtube.com/watch?v=wPEyyigh10g)
-- [More Fabric YouTube Videos](https://www.youtube.com/results?search_query=fabric+ai)
+> July 4, 2025
+>
+> - **Web Search**: Fabric now supports web search for Anthropic and OpenAI models using the `--search` and `--search-location` flags. This replaces the previous plugin-based search, so you may want to remove the old `ANTHROPIC_WEB_SEARCH_TOOL_*` variables from your `~/.config/fabric/.env` file.
+> - **Image Generation**: Fabric now has powerful image generation capabilities with OpenAI.
+>   - Generate images from text prompts and save them using `--image-file`.
+>   - Edit existing images by providing an input image with `--attachment`.
+>   - Control image `size`, `quality`, `compression`, and `background` with the new `--image-*` flags.
+>
+>June 17, 2025
+>
+>- Fabric now supports Perplexity AI. Configure it by using `fabric -S` to add your Perplexity AI API Key,
+>   and then try:
+>
+>   ```bash
+>   fabric -m sonar-pro "What is the latest world news?"
+>   ```
+>
+>June 11, 2025
+>
+>- Fabric's YouTube transcription now needs `yt-dlp` to be installed. Make sure to install the latest
+> version (2025.06.09 as of this note). The YouTube API key is only needed for comments (the `--comments` flag)
+> and metadata extraction (the `--metadata` flag).
 
 ## Philosophy
 
@@ -466,7 +491,6 @@ fabric -h
 ```
 
 ```plaintext
-
 Usage:
   fabric [OPTIONS]
 
@@ -481,7 +505,9 @@ Application Options:
   -T, --topp=                       Set top P (default: 0.9)
   -s, --stream                      Stream
   -P, --presencepenalty=            Set presence penalty (default: 0.0)
-  -r, --raw                         Use the defaults of the model without sending chat options (like temperature etc.) and use the user role instead of the system role for patterns.
+  -r, --raw                         Use the defaults of the model without sending chat options (like
+                                    temperature etc.) and use the user role instead of the system role for
+                                    patterns.
   -F, --frequencypenalty=           Set frequency penalty (default: 0.0)
   -l, --listpatterns                List all patterns
   -L, --listmodels                  List all available models
@@ -495,9 +521,12 @@ Application Options:
       --output-session              Output the entire session (also a temporary one) to the output file
   -n, --latest=                     Number of latest patterns to list (default: 0)
   -d, --changeDefaultModel          Change default model
-  -y, --youtube=                    YouTube video or play list "URL" to grab transcript, comments from it and send to chat or print it put to the console and store it in the output file
+  -y, --youtube=                    YouTube video or play list "URL" to grab transcript, comments from it
+                                    and send to chat or print it put to the console and store it in the
+                                    output file
       --playlist                    Prefer playlist over video if both ids are present in the URL
-      --transcript                  Grab transcript from YouTube video and send to chat (it is used per default).
+      --transcript                  Grab transcript from YouTube video and send to chat (it is used per
+                                    default).
       --transcript-with-timestamps  Grab transcript from YouTube video with timestamps and send to chat
       --comments                    Grab comments from YouTube video and send to chat
       --metadata                    Output video metadata
@@ -525,6 +554,14 @@ Application Options:
       --liststrategies              List all strategies
       --listvendors                 List all vendors
       --shell-complete-list         Output raw list without headers/formatting (for shell completion)
+      --search                      Enable web search tool for supported models (Anthropic, OpenAI)
+      --search-location=            Set location for web search results (e.g., 'America/Los_Angeles')
+      --image-file=                 Save generated image to specified file path (e.g., 'output.png')
+      --image-size=                 Image dimensions: 1024x1024, 1536x1024, 1024x1536, auto (default: auto)
+      --image-quality=              Image quality: low, medium, high, auto (default: auto)
+      --image-compression=          Compression level 0-100 for JPEG/WebP formats (default: not set)
+      --image-background=           Background type: opaque, transparent (default: opaque, only for
+                                    PNG/WebP)
 
 Help Options:
   -h, --help                        Show this help message
@@ -743,7 +780,7 @@ The Streamlit UI supports clipboard operations across different platforms:
 
 - **macOS**: Uses `pbcopy` and `pbpaste` (built-in)
 - **Windows**: Uses `pyperclip` library (install with `pip install pyperclip`)
-- **Linux**: Uses `xclip` (install with `sudo apt-get install xclip` or equivalent for your distro)
+- **Linux**: Uses `xclip` (install with `sudo apt-get install xclip` or equivalent for your Linux distribution)
 
 ## Meta
 
@@ -761,15 +798,15 @@ The Streamlit UI supports clipboard operations across different platforms:
 
 ### Primary contributors
 
-<a href="https://github.com/danielmiessler"><img src="https://avatars.githubusercontent.com/u/50654?v=4" title="Daniel Miessler" width="50" height="50"></a>
-<a href="https://github.com/xssdoctor"><img src="https://avatars.githubusercontent.com/u/9218431?v=4" title="Jonathan Dunn" width="50" height="50"></a>
-<a href="https://github.com/sbehrens"><img src="https://avatars.githubusercontent.com/u/688589?v=4" title="Scott Behrens" width="50" height="50"></a>
-<a href="https://github.com/agu3rra"><img src="https://avatars.githubusercontent.com/u/10410523?v=4" title="Andre Guerra" width="50" height="50"></a>
+<a href="https://github.com/danielmiessler"><img src="https://avatars.githubusercontent.com/u/50654?v=4" title="Daniel Miessler" width="50" height="50" alt="Daniel Miessler"></a>
+<a href="https://github.com/xssdoctor"><img src="https://avatars.githubusercontent.com/u/9218431?v=4" title="Jonathan Dunn" width="50" height="50" alt="Jonathan Dunn"></a>
+<a href="https://github.com/sbehrens"><img src="https://avatars.githubusercontent.com/u/688589?v=4" title="Scott Behrens" width="50" height="50" alt="Scott Behrens"></a>
+<a href="https://github.com/agu3rra"><img src="https://avatars.githubusercontent.com/u/10410523?v=4" title="Andre Guerra" width="50" height="50" alt="Andre Guerra"></a>
 
 ### Contributors
 
 <a href="https://github.com/danielmiessler/fabric/graphs/contributors">
-  <img src="https://contrib.rocks/image?repo=danielmiessler/fabric" />
+  <img src="https://contrib.rocks/image?repo=danielmiessler/fabric" alt="contrib.rocks" />
 </a>
 
 Made with [contrib.rocks](https://contrib.rocks).

chat/chat.go

@@ -0,0 +1,132 @@
+package chat
+
+import (
+	"encoding/json"
+	"errors"
+)
+
+const (
+	ChatMessageRoleSystem    = "system"
+	ChatMessageRoleUser      = "user"
+	ChatMessageRoleAssistant = "assistant"
+	ChatMessageRoleFunction  = "function"
+	ChatMessageRoleTool      = "tool"
+	ChatMessageRoleDeveloper = "developer"
+)
+
+var ErrContentFieldsMisused = errors.New("can't use both Content and MultiContent properties simultaneously")
+
+type ChatMessagePartType string
+
+const (
+	ChatMessagePartTypeText     ChatMessagePartType = "text"
+	ChatMessagePartTypeImageURL ChatMessagePartType = "image_url"
+)
+
+type ChatMessageImageURL struct {
+	URL string `json:"url,omitempty"`
+}
+
+type ChatMessagePart struct {
+	Type     ChatMessagePartType  `json:"type,omitempty"`
+	Text     string               `json:"text,omitempty"`
+	ImageURL *ChatMessageImageURL `json:"image_url,omitempty"`
+}
+
+type FunctionCall struct {
+	Name      string `json:"name,omitempty"`
+	Arguments string `json:"arguments,omitempty"`
+}
+
+type ToolType string
+
+const (
+	ToolTypeFunction ToolType = "function"
+)
+
+type ToolCall struct {
+	Index    *int         `json:"index,omitempty"`
+	ID       string       `json:"id,omitempty"`
+	Type     ToolType     `json:"type"`
+	Function FunctionCall `json:"function"`
+}
+
+type ChatCompletionMessage struct {
+	Role             string            `json:"role"`
+	Content          string            `json:"content,omitempty"`
+	Refusal          string            `json:"refusal,omitempty"`
+	MultiContent     []ChatMessagePart `json:"-"`
+	Name             string            `json:"name,omitempty"`
+	ReasoningContent string            `json:"reasoning_content,omitempty"`
+	FunctionCall     *FunctionCall     `json:"function_call,omitempty"`
+	ToolCalls        []ToolCall        `json:"tool_calls,omitempty"`
+	ToolCallID       string            `json:"tool_call_id,omitempty"`
+}
+
+func (m ChatCompletionMessage) MarshalJSON() ([]byte, error) {
+	if m.Content != "" && m.MultiContent != nil {
+		return nil, ErrContentFieldsMisused
+	}
+	if len(m.MultiContent) > 0 {
+		msg := struct {
+			Role             string            `json:"role"`
+			Content          string            `json:"-"`
+			Refusal          string            `json:"refusal,omitempty"`
+			MultiContent     []ChatMessagePart `json:"content,omitempty"`
+			Name             string            `json:"name,omitempty"`
+			ReasoningContent string            `json:"reasoning_content,omitempty"`
+			FunctionCall     *FunctionCall     `json:"function_call,omitempty"`
+			ToolCalls        []ToolCall        `json:"tool_calls,omitempty"`
+			ToolCallID       string            `json:"tool_call_id,omitempty"`
+		}(m)
+		return json.Marshal(msg)
+	}
+
+	msg := struct {
+		Role             string            `json:"role"`
+		Content          string            `json:"content,omitempty"`
+		Refusal          string            `json:"refusal,omitempty"`
+		MultiContent     []ChatMessagePart `json:"-"`
+		Name             string            `json:"name,omitempty"`
+		ReasoningContent string            `json:"reasoning_content,omitempty"`
+		FunctionCall     *FunctionCall     `json:"function_call,omitempty"`
+		ToolCalls        []ToolCall        `json:"tool_calls,omitempty"`
+		ToolCallID       string            `json:"tool_call_id,omitempty"`
+	}(m)
+	return json.Marshal(msg)
+}
+
+func (m *ChatCompletionMessage) UnmarshalJSON(bs []byte) error {
+	msg := struct {
+		Role             string `json:"role"`
+		Content          string `json:"content"`
+		Refusal          string `json:"refusal,omitempty"`
+		MultiContent     []ChatMessagePart
+		Name             string        `json:"name,omitempty"`
+		ReasoningContent string        `json:"reasoning_content,omitempty"`
+		FunctionCall     *FunctionCall `json:"function_call,omitempty"`
+		ToolCalls        []ToolCall    `json:"tool_calls,omitempty"`
+		ToolCallID       string        `json:"tool_call_id,omitempty"`
+	}{}
+
+	if err := json.Unmarshal(bs, &msg); err == nil {
+		*m = ChatCompletionMessage(msg)
+		return nil
+	}
+	multiMsg := struct {
+		Role             string `json:"role"`
+		Content          string
+		Refusal          string            `json:"refusal,omitempty"`
+		MultiContent     []ChatMessagePart `json:"content"`
+		Name             string            `json:"name,omitempty"`
+		ReasoningContent string            `json:"reasoning_content,omitempty"`
+		FunctionCall     *FunctionCall     `json:"function_call,omitempty"`
+		ToolCalls        []ToolCall        `json:"tool_calls,omitempty"`
+		ToolCallID       string            `json:"tool_call_id,omitempty"`
+	}{}
+	if err := json.Unmarshal(bs, &multiMsg); err != nil {
+		return err
+	}
+	*m = ChatCompletionMessage(multiMsg)
+	return nil
+}

cli/cli.go

@@ -270,7 +270,11 @@ func Cli(version string) (err error) {
 	if chatReq.Language == "" {
 		chatReq.Language = registry.Language.DefaultLanguage.Value
 	}
-	if session, err = chatter.Send(chatReq, currentFlags.BuildChatOptions()); err != nil {
+	var chatOptions *common.ChatOptions
+	if chatOptions, err = currentFlags.BuildChatOptions(); err != nil {
+		return
+	}
+	if session, err = chatter.Send(chatReq, chatOptions); err != nil {
 		return
 	}
 

cli/flags.go

@@ -6,15 +6,16 @@ import (
 	"fmt"
 	"io"
 	"os"
+	"path/filepath"
 	"reflect"
 	"strconv"
 	"strings"
 
+	"github.com/danielmiessler/fabric/chat"
 	"github.com/danielmiessler/fabric/common"
 	"github.com/jessevdk/go-flags"
-	goopenai "github.com/sashabaranov/go-openai"
 	"golang.org/x/text/language"
-	"gopkg.in/yaml.v2"
+	"gopkg.in/yaml.v3"
 )
 
 // Flags create flags struct. the users flags go into this, this will be passed to the chat struct in cli
@@ -74,6 +75,13 @@ type Flags struct {
 	ListStrategies                  bool              `long:"liststrategies" description:"List all strategies"`
 	ListVendors                     bool              `long:"listvendors" description:"List all vendors"`
 	ShellCompleteOutput             bool              `long:"shell-complete-list" description:"Output raw list without headers/formatting (for shell completion)"`
+	Search                          bool              `long:"search" description:"Enable web search tool for supported models (Anthropic, OpenAI)"`
+	SearchLocation                  string            `long:"search-location" description:"Set location for web search results (e.g., 'America/Los_Angeles')"`
+	ImageFile                       string            `long:"image-file" description:"Save generated image to specified file path (e.g., 'output.png')"`
+	ImageSize                       string            `long:"image-size" description:"Image dimensions: 1024x1024, 1536x1024, 1024x1536, auto (default: auto)"`
+	ImageQuality                    string            `long:"image-quality" description:"Image quality: low, medium, high, auto (default: auto)"`
+	ImageCompression                int               `long:"image-compression" description:"Compression level 0-100 for JPEG/WebP formats (default: not set)"`
+	ImageBackground                 string            `long:"image-background" description:"Background type: opaque, transparent (default: opaque, only for PNG/WebP)"`
 }
 
 var debug = false
@@ -254,8 +262,121 @@ func readStdin() (ret string, err error) {
 	return
 }
 
-func (o *Flags) BuildChatOptions() (ret *common.ChatOptions) {
+// validateImageFile validates the image file path and extension
+func validateImageFile(imagePath string) error {
+	if imagePath == "" {
+		return nil // No validation needed if no image file specified
+	}
+
+	// Check if file already exists
+	if _, err := os.Stat(imagePath); err == nil {
+		return fmt.Errorf("image file already exists: %s", imagePath)
+	}
+
+	// Check file extension
+	ext := strings.ToLower(filepath.Ext(imagePath))
+	validExtensions := []string{".png", ".jpeg", ".jpg", ".webp"}
+
+	for _, validExt := range validExtensions {
+		if ext == validExt {
+			return nil // Valid extension found
+		}
+	}
+
+	return fmt.Errorf("invalid image file extension '%s'. Supported formats: .png, .jpeg, .jpg, .webp", ext)
+}
+
+// validateImageParameters validates image generation parameters
+func validateImageParameters(imagePath, size, quality, background string, compression int) error {
+	if imagePath == "" {
+		// Check if any image parameters are specified without --image-file
+		if size != "" || quality != "" || background != "" || compression != 0 {
+			return fmt.Errorf("image parameters (--image-size, --image-quality, --image-background, --image-compression) can only be used with --image-file")
+		}
+		return nil
+	}
+
+	// Validate size
+	if size != "" {
+		validSizes := []string{"1024x1024", "1536x1024", "1024x1536", "auto"}
+		valid := false
+		for _, validSize := range validSizes {
+			if size == validSize {
+				valid = true
+				break
+			}
+		}
+		if !valid {
+			return fmt.Errorf("invalid image size '%s'. Supported sizes: 1024x1024, 1536x1024, 1024x1536, auto", size)
+		}
+	}
+
+	// Validate quality
+	if quality != "" {
+		validQualities := []string{"low", "medium", "high", "auto"}
+		valid := false
+		for _, validQuality := range validQualities {
+			if quality == validQuality {
+				valid = true
+				break
+			}
+		}
+		if !valid {
+			return fmt.Errorf("invalid image quality '%s'. Supported qualities: low, medium, high, auto", quality)
+		}
+	}
+
+	// Validate background
+	if background != "" {
+		validBackgrounds := []string{"opaque", "transparent"}
+		valid := false
+		for _, validBackground := range validBackgrounds {
+			if background == validBackground {
+				valid = true
+				break
+			}
+		}
+		if !valid {
+			return fmt.Errorf("invalid image background '%s'. Supported backgrounds: opaque, transparent", background)
+		}
+	}
+
+	// Get file format for format-specific validations
+	ext := strings.ToLower(filepath.Ext(imagePath))
+
+	// Validate compression (only for jpeg/webp)
+	if compression != 0 { // 0 means not set
+		if ext != ".jpg" && ext != ".jpeg" && ext != ".webp" {
+			return fmt.Errorf("image compression can only be used with JPEG and WebP formats, not %s", ext)
+		}
+		if compression < 0 || compression > 100 {
+			return fmt.Errorf("image compression must be between 0 and 100, got %d", compression)
+		}
+	}
+
+	// Validate background transparency (only for png/webp)
+	if background == "transparent" {
+		if ext != ".png" && ext != ".webp" {
+			return fmt.Errorf("transparent background can only be used with PNG and WebP formats, not %s", ext)
+		}
+	}
+
+	return nil
+}
+
+func (o *Flags) BuildChatOptions() (ret *common.ChatOptions, err error) {
+	// Validate image file if specified
+	if err = validateImageFile(o.ImageFile); err != nil {
+		return nil, err
+	}
+
+	// Validate image parameters
+	if err = validateImageParameters(o.ImageFile, o.ImageSize, o.ImageQuality, o.ImageBackground, o.ImageCompression); err != nil {
+		return nil, err
+	}
+
 	ret = &common.ChatOptions{
+		Model:              o.Model,
 		Temperature:        o.Temperature,
 		TopP:               o.TopP,
 		PresencePenalty:    o.PresencePenalty,
@@ -263,6 +384,13 @@ func (o *Flags) BuildChatOptions() (ret *common.ChatOptions) {
 		Raw:                o.Raw,
 		Seed:               o.Seed,
 		ModelContextLength: o.ModelContextLength,
+		Search:             o.Search,
+		SearchLocation:     o.SearchLocation,
+		ImageFile:          o.ImageFile,
+		ImageSize:          o.ImageSize,
+		ImageQuality:       o.ImageQuality,
+		ImageCompression:   o.ImageCompression,
+		ImageBackground:    o.ImageBackground,
 	}
 	return
 }
@@ -278,22 +406,15 @@ func (o *Flags) BuildChatRequest(Meta string) (ret *common.ChatRequest, err erro
 		Meta:             Meta,
 	}
 
-	var message *goopenai.ChatCompletionMessage
-	if len(o.Attachments) == 0 {
-		if o.Message != "" {
-			message = &goopenai.ChatCompletionMessage{
-				Role:    goopenai.ChatMessageRoleUser,
-				Content: strings.TrimSpace(o.Message),
-			}
-		}
-	} else {
-		message = &goopenai.ChatCompletionMessage{
-			Role: goopenai.ChatMessageRoleUser,
+	var message *chat.ChatCompletionMessage
+	if len(o.Attachments) > 0 {
+		message = &chat.ChatCompletionMessage{
+			Role: chat.ChatMessageRoleUser,
 		}
 
 		if o.Message != "" {
-			message.MultiContent = append(message.MultiContent, goopenai.ChatMessagePart{
-				Type: goopenai.ChatMessagePartTypeText,
+			message.MultiContent = append(message.MultiContent, chat.ChatMessagePart{
+				Type: chat.ChatMessagePartTypeText,
 				Text: strings.TrimSpace(o.Message),
 			})
 		}
@@ -316,14 +437,20 @@ func (o *Flags) BuildChatRequest(Meta string) (ret *common.ChatRequest, err erro
 				dataURL := fmt.Sprintf("data:%s;base64,%s", mimeType, base64Image)
 				url = &dataURL
 			}
-			message.MultiContent = append(message.MultiContent, goopenai.ChatMessagePart{
-				Type: goopenai.ChatMessagePartTypeImageURL,
-				ImageURL: &goopenai.ChatMessageImageURL{
+			message.MultiContent = append(message.MultiContent, chat.ChatMessagePart{
+				Type: chat.ChatMessagePartTypeImageURL,
+				ImageURL: &chat.ChatMessageImageURL{
 					URL: *url,
 				},
 			})
 		}
+	} else if o.Message != "" {
+		message = &chat.ChatCompletionMessage{
+			Role:    chat.ChatMessageRoleUser,
+			Content: strings.TrimSpace(o.Message),
+		}
 	}
+
 	ret.Message = message
 
 	if o.Language != "" {

cli/flags_test.go

@@ -4,6 +4,7 @@ import (
 	"bytes"
 	"io"
 	"os"
+	"path/filepath"
 	"strings"
 	"testing"
 
@@ -64,7 +65,8 @@ func TestBuildChatOptions(t *testing.T) {
 		Raw:              false,
 		Seed:             1,
 	}
-	options := flags.BuildChatOptions()
+	options, err := flags.BuildChatOptions()
+	assert.NoError(t, err)
 	assert.Equal(t, expectedOptions, options)
 }
 
@@ -84,7 +86,8 @@ func TestBuildChatOptionsDefaultSeed(t *testing.T) {
 		Raw:              false,
 		Seed:             0,
 	}
-	options := flags.BuildChatOptions()
+	options, err := flags.BuildChatOptions()
+	assert.NoError(t, err)
 	assert.Equal(t, expectedOptions, options)
 }
 
@@ -164,3 +167,269 @@ model: 123  # should be string
 		assert.Error(t, err)
 	})
 }
+
+func TestValidateImageFile(t *testing.T) {
+	t.Run("Empty path should be valid", func(t *testing.T) {
+		err := validateImageFile("")
+		assert.NoError(t, err)
+	})
+
+	t.Run("Valid extensions should pass", func(t *testing.T) {
+		validExtensions := []string{".png", ".jpeg", ".jpg", ".webp"}
+		for _, ext := range validExtensions {
+			filename := "/tmp/test" + ext
+			err := validateImageFile(filename)
+			assert.NoError(t, err, "Extension %s should be valid", ext)
+		}
+	})
+
+	t.Run("Invalid extensions should fail", func(t *testing.T) {
+		invalidExtensions := []string{".gif", ".bmp", ".tiff", ".svg", ".txt", ""}
+		for _, ext := range invalidExtensions {
+			filename := "/tmp/test" + ext
+			err := validateImageFile(filename)
+			assert.Error(t, err, "Extension %s should be invalid", ext)
+			assert.Contains(t, err.Error(), "invalid image file extension")
+		}
+	})
+
+	t.Run("Existing file should fail", func(t *testing.T) {
+		// Create a temporary file
+		tempFile, err := os.CreateTemp("", "test*.png")
+		assert.NoError(t, err)
+		defer os.Remove(tempFile.Name())
+		tempFile.Close()
+
+		// Validation should fail because file exists
+		err = validateImageFile(tempFile.Name())
+		assert.Error(t, err)
+		assert.Contains(t, err.Error(), "image file already exists")
+	})
+
+	t.Run("Non-existing file with valid extension should pass", func(t *testing.T) {
+		nonExistentFile := filepath.Join(os.TempDir(), "non_existent_file.png")
+		// Make sure the file doesn't exist
+		os.Remove(nonExistentFile)
+
+		err := validateImageFile(nonExistentFile)
+		assert.NoError(t, err)
+	})
+}
+
+func TestBuildChatOptionsWithImageFileValidation(t *testing.T) {
+	t.Run("Valid image file should pass", func(t *testing.T) {
+		flags := &Flags{
+			ImageFile: "/tmp/output.png",
+		}
+
+		options, err := flags.BuildChatOptions()
+		assert.NoError(t, err)
+		assert.Equal(t, "/tmp/output.png", options.ImageFile)
+	})
+
+	t.Run("Invalid extension should fail", func(t *testing.T) {
+		flags := &Flags{
+			ImageFile: "/tmp/output.gif",
+		}
+
+		options, err := flags.BuildChatOptions()
+		assert.Error(t, err)
+		assert.Nil(t, options)
+		assert.Contains(t, err.Error(), "invalid image file extension")
+	})
+
+	t.Run("Existing file should fail", func(t *testing.T) {
+		// Create a temporary file
+		tempFile, err := os.CreateTemp("", "existing*.png")
+		assert.NoError(t, err)
+		defer os.Remove(tempFile.Name())
+		tempFile.Close()
+
+		flags := &Flags{
+			ImageFile: tempFile.Name(),
+		}
+
+		options, err := flags.BuildChatOptions()
+		assert.Error(t, err)
+		assert.Nil(t, options)
+		assert.Contains(t, err.Error(), "image file already exists")
+	})
+}
+
+func TestValidateImageParameters(t *testing.T) {
+	t.Run("No image file and no parameters should pass", func(t *testing.T) {
+		err := validateImageParameters("", "", "", "", 0)
+		assert.NoError(t, err)
+	})
+
+	t.Run("Image parameters without image file should fail", func(t *testing.T) {
+		// Test each parameter individually
+		err := validateImageParameters("", "1024x1024", "", "", 0)
+		assert.Error(t, err)
+		assert.Contains(t, err.Error(), "image parameters")
+		assert.Contains(t, err.Error(), "can only be used with --image-file")
+
+		err = validateImageParameters("", "", "high", "", 0)
+		assert.Error(t, err)
+		assert.Contains(t, err.Error(), "image parameters")
+
+		err = validateImageParameters("", "", "", "transparent", 0)
+		assert.Error(t, err)
+		assert.Contains(t, err.Error(), "image parameters")
+
+		err = validateImageParameters("", "", "", "", 50)
+		assert.Error(t, err)
+		assert.Contains(t, err.Error(), "image parameters")
+
+		// Test multiple parameters
+		err = validateImageParameters("", "1024x1024", "high", "transparent", 50)
+		assert.Error(t, err)
+		assert.Contains(t, err.Error(), "image parameters")
+	})
+
+	t.Run("Valid size values should pass", func(t *testing.T) {
+		validSizes := []string{"1024x1024", "1536x1024", "1024x1536", "auto"}
+		for _, size := range validSizes {
+			err := validateImageParameters("/tmp/test.png", size, "", "", 0)
+			assert.NoError(t, err, "Size %s should be valid", size)
+		}
+	})
+
+	t.Run("Invalid size should fail", func(t *testing.T) {
+		err := validateImageParameters("/tmp/test.png", "invalid", "", "", 0)
+		assert.Error(t, err)
+		assert.Contains(t, err.Error(), "invalid image size")
+	})
+
+	t.Run("Valid quality values should pass", func(t *testing.T) {
+		validQualities := []string{"low", "medium", "high", "auto"}
+		for _, quality := range validQualities {
+			err := validateImageParameters("/tmp/test.png", "", quality, "", 0)
+			assert.NoError(t, err, "Quality %s should be valid", quality)
+		}
+	})
+
+	t.Run("Invalid quality should fail", func(t *testing.T) {
+		err := validateImageParameters("/tmp/test.png", "", "invalid", "", 0)
+		assert.Error(t, err)
+		assert.Contains(t, err.Error(), "invalid image quality")
+	})
+
+	t.Run("Valid background values should pass", func(t *testing.T) {
+		validBackgrounds := []string{"opaque", "transparent"}
+		for _, background := range validBackgrounds {
+			err := validateImageParameters("/tmp/test.png", "", "", background, 0)
+			assert.NoError(t, err, "Background %s should be valid", background)
+		}
+	})
+
+	t.Run("Invalid background should fail", func(t *testing.T) {
+		err := validateImageParameters("/tmp/test.png", "", "", "invalid", 0)
+		assert.Error(t, err)
+		assert.Contains(t, err.Error(), "invalid image background")
+	})
+
+	t.Run("Compression for JPEG should pass", func(t *testing.T) {
+		err := validateImageParameters("/tmp/test.jpg", "", "", "", 75)
+		assert.NoError(t, err)
+	})
+
+	t.Run("Compression for WebP should pass", func(t *testing.T) {
+		err := validateImageParameters("/tmp/test.webp", "", "", "", 50)
+		assert.NoError(t, err)
+	})
+
+	t.Run("Compression for PNG should fail", func(t *testing.T) {
+		err := validateImageParameters("/tmp/test.png", "", "", "", 75)
+		assert.Error(t, err)
+		assert.Contains(t, err.Error(), "image compression can only be used with JPEG and WebP formats")
+	})
+
+	t.Run("Invalid compression range should fail", func(t *testing.T) {
+		err := validateImageParameters("/tmp/test.jpg", "", "", "", 150)
+		assert.Error(t, err)
+		assert.Contains(t, err.Error(), "image compression must be between 0 and 100")
+
+		err = validateImageParameters("/tmp/test.jpg", "", "", "", -10)
+		assert.Error(t, err)
+		assert.Contains(t, err.Error(), "image compression must be between 0 and 100")
+	})
+
+	t.Run("Transparent background for PNG should pass", func(t *testing.T) {
+		err := validateImageParameters("/tmp/test.png", "", "", "transparent", 0)
+		assert.NoError(t, err)
+	})
+
+	t.Run("Transparent background for WebP should pass", func(t *testing.T) {
+		err := validateImageParameters("/tmp/test.webp", "", "", "transparent", 0)
+		assert.NoError(t, err)
+	})
+
+	t.Run("Transparent background for JPEG should fail", func(t *testing.T) {
+		err := validateImageParameters("/tmp/test.jpg", "", "", "transparent", 0)
+		assert.Error(t, err)
+		assert.Contains(t, err.Error(), "transparent background can only be used with PNG and WebP formats")
+	})
+}
+
+func TestBuildChatOptionsWithImageParameters(t *testing.T) {
+	t.Run("Valid image parameters should pass", func(t *testing.T) {
+		flags := &Flags{
+			ImageFile:        "/tmp/test.png",
+			ImageSize:        "1024x1024",
+			ImageQuality:     "high",
+			ImageBackground:  "transparent",
+			ImageCompression: 0, // Not set for PNG
+		}
+
+		options, err := flags.BuildChatOptions()
+		assert.NoError(t, err)
+		assert.NotNil(t, options)
+		assert.Equal(t, "/tmp/test.png", options.ImageFile)
+		assert.Equal(t, "1024x1024", options.ImageSize)
+		assert.Equal(t, "high", options.ImageQuality)
+		assert.Equal(t, "transparent", options.ImageBackground)
+		assert.Equal(t, 0, options.ImageCompression)
+	})
+
+	t.Run("Invalid image parameters should fail", func(t *testing.T) {
+		flags := &Flags{
+			ImageFile:       "/tmp/test.png",
+			ImageSize:       "invalid",
+			ImageQuality:    "high",
+			ImageBackground: "transparent",
+		}
+
+		options, err := flags.BuildChatOptions()
+		assert.Error(t, err)
+		assert.Nil(t, options)
+		assert.Contains(t, err.Error(), "invalid image size")
+	})
+
+	t.Run("JPEG with compression should pass", func(t *testing.T) {
+		flags := &Flags{
+			ImageFile:        "/tmp/test.jpg",
+			ImageSize:        "1536x1024",
+			ImageQuality:     "medium",
+			ImageBackground:  "opaque",
+			ImageCompression: 80,
+		}
+
+		options, err := flags.BuildChatOptions()
+		assert.NoError(t, err)
+		assert.NotNil(t, options)
+		assert.Equal(t, 80, options.ImageCompression)
+	})
+
+	t.Run("Image parameters without image file should fail in BuildChatOptions", func(t *testing.T) {
+		flags := &Flags{
+			ImageSize: "1024x1024", // Image parameter without ImageFile
+		}
+
+		options, err := flags.BuildChatOptions()
+		assert.Error(t, err)
+		assert.Nil(t, options)
+		assert.Contains(t, err.Error(), "image parameters")
+		assert.Contains(t, err.Error(), "can only be used with --image-file")
+	})
+}

common/domain.go

@@ -1,6 +1,6 @@
 package common
 
-import goopenai "github.com/sashabaranov/go-openai"
+import "github.com/danielmiessler/fabric/chat"
 
 const ChatMessageRoleMeta = "meta"
 
@@ -9,7 +9,7 @@ type ChatRequest struct {
 	SessionName      string
 	PatternName      string
 	PatternVariables map[string]string
-	Message          *goopenai.ChatCompletionMessage
+	Message          *chat.ChatCompletionMessage
 	Language         string
 	Meta             string
 	InputHasVars     bool
@@ -25,10 +25,18 @@ type ChatOptions struct {
 	Raw                bool
 	Seed               int
 	ModelContextLength int
+	MaxTokens          int
+	Search             bool
+	SearchLocation     string
+	ImageFile          string
+	ImageSize          string
+	ImageQuality       string
+	ImageCompression   int
+	ImageBackground    string
 }
 
 // NormalizeMessages remove empty messages and ensure messages order user-assist-user
-func NormalizeMessages(msgs []*goopenai.ChatCompletionMessage, defaultUserMessage string) (ret []*goopenai.ChatCompletionMessage) {
+func NormalizeMessages(msgs []*chat.ChatCompletionMessage, defaultUserMessage string) (ret []*chat.ChatCompletionMessage) {
 	// Iterate over messages to enforce the odd position rule for user messages
 	fullMessageIndex := 0
 	for _, message := range msgs {
@@ -38,8 +46,8 @@ func NormalizeMessages(msgs []*goopenai.ChatCompletionMessage, defaultUserMessag
 		}
 
 		// Ensure, that each odd position shall be a user message
-		if fullMessageIndex%2 == 0 && message.Role != goopenai.ChatMessageRoleUser {
-			ret = append(ret, &goopenai.ChatCompletionMessage{Role: goopenai.ChatMessageRoleUser, Content: defaultUserMessage})
+		if fullMessageIndex%2 == 0 && message.Role != chat.ChatMessageRoleUser {
+			ret = append(ret, &chat.ChatCompletionMessage{Role: chat.ChatMessageRoleUser, Content: defaultUserMessage})
 			fullMessageIndex++
 		}
 		ret = append(ret, message)

common/domain_test.go

@@ -3,23 +3,23 @@ package common
 import (
 	"testing"
 
-	goopenai "github.com/sashabaranov/go-openai"
+	"github.com/danielmiessler/fabric/chat"
 	"github.com/stretchr/testify/assert"
 )
 
 func TestNormalizeMessages(t *testing.T) {
-	msgs := []*goopenai.ChatCompletionMessage{
-		{Role: goopenai.ChatMessageRoleUser, Content: "Hello"},
-		{Role: goopenai.ChatMessageRoleAssistant, Content: "Hi there!"},
-		{Role: goopenai.ChatMessageRoleUser, Content: ""},
-		{Role: goopenai.ChatMessageRoleUser, Content: ""},
-		{Role: goopenai.ChatMessageRoleUser, Content: "How are you?"},
+	msgs := []*chat.ChatCompletionMessage{
+		{Role: chat.ChatMessageRoleUser, Content: "Hello"},
+		{Role: chat.ChatMessageRoleAssistant, Content: "Hi there!"},
+		{Role: chat.ChatMessageRoleUser, Content: ""},
+		{Role: chat.ChatMessageRoleUser, Content: ""},
+		{Role: chat.ChatMessageRoleUser, Content: "How are you?"},
 	}
 
-	expected := []*goopenai.ChatCompletionMessage{
-		{Role: goopenai.ChatMessageRoleUser, Content: "Hello"},
-		{Role: goopenai.ChatMessageRoleAssistant, Content: "Hi there!"},
-		{Role: goopenai.ChatMessageRoleUser, Content: "How are you?"},
+	expected := []*chat.ChatCompletionMessage{
+		{Role: chat.ChatMessageRoleUser, Content: "Hello"},
+		{Role: chat.ChatMessageRoleAssistant, Content: "Hi there!"},
+		{Role: chat.ChatMessageRoleUser, Content: "How are you?"},
 	}
 
 	actual := NormalizeMessages(msgs, "default")

common/oauth_storage.go

@@ -0,0 +1,124 @@
+package common
+
+import (
+	"encoding/json"
+	"fmt"
+	"os"
+	"path/filepath"
+	"time"
+)
+
+// OAuthToken represents stored OAuth token information
+type OAuthToken struct {
+	AccessToken  string `json:"access_token"`
+	RefreshToken string `json:"refresh_token"`
+	ExpiresAt    int64  `json:"expires_at"`
+	TokenType    string `json:"token_type"`
+	Scope        string `json:"scope"`
+}
+
+// IsExpired checks if the token is expired or will expire within the buffer time
+func (t *OAuthToken) IsExpired(bufferMinutes int) bool {
+	if t.ExpiresAt == 0 {
+		return true
+	}
+	bufferTime := time.Duration(bufferMinutes) * time.Minute
+	return time.Now().Add(bufferTime).Unix() >= t.ExpiresAt
+}
+
+// OAuthStorage handles persistent storage of OAuth tokens
+type OAuthStorage struct {
+	configDir string
+}
+
+// NewOAuthStorage creates a new OAuth storage instance
+func NewOAuthStorage() (*OAuthStorage, error) {
+	homeDir, err := os.UserHomeDir()
+	if err != nil {
+		return nil, fmt.Errorf("failed to get user home directory: %w", err)
+	}
+
+	configDir := filepath.Join(homeDir, ".config", "fabric")
+
+	// Ensure config directory exists
+	if err := os.MkdirAll(configDir, 0755); err != nil {
+		return nil, fmt.Errorf("failed to create config directory: %w", err)
+	}
+
+	return &OAuthStorage{configDir: configDir}, nil
+}
+
+// GetTokenPath returns the file path for a provider's OAuth token
+func (s *OAuthStorage) GetTokenPath(provider string) string {
+	return filepath.Join(s.configDir, fmt.Sprintf(".%s_oauth", provider))
+}
+
+// SaveToken saves an OAuth token to disk with proper permissions
+func (s *OAuthStorage) SaveToken(provider string, token *OAuthToken) error {
+	tokenPath := s.GetTokenPath(provider)
+
+	// Marshal token to JSON
+	data, err := json.MarshalIndent(token, "", "  ")
+	if err != nil {
+		return fmt.Errorf("failed to marshal token: %w", err)
+	}
+
+	// Write to temporary file first for atomic operation
+	tempPath := tokenPath + ".tmp"
+	if err := os.WriteFile(tempPath, data, 0600); err != nil {
+		return fmt.Errorf("failed to write token file: %w", err)
+	}
+
+	// Atomic rename
+	if err := os.Rename(tempPath, tokenPath); err != nil {
+		os.Remove(tempPath) // Clean up temp file
+		return fmt.Errorf("failed to save token file: %w", err)
+	}
+
+	return nil
+}
+
+// LoadToken loads an OAuth token from disk
+func (s *OAuthStorage) LoadToken(provider string) (*OAuthToken, error) {
+	tokenPath := s.GetTokenPath(provider)
+
+	// Check if file exists
+	if _, err := os.Stat(tokenPath); os.IsNotExist(err) {
+		return nil, nil // No token stored
+	}
+
+	// Read token file
+	data, err := os.ReadFile(tokenPath)
+	if err != nil {
+		return nil, fmt.Errorf("failed to read token file: %w", err)
+	}
+
+	// Unmarshal token
+	var token OAuthToken
+	if err := json.Unmarshal(data, &token); err != nil {
+		return nil, fmt.Errorf("failed to parse token file: %w", err)
+	}
+
+	return &token, nil
+}
+
+// DeleteToken removes a stored OAuth token
+func (s *OAuthStorage) DeleteToken(provider string) error {
+	tokenPath := s.GetTokenPath(provider)
+
+	if err := os.Remove(tokenPath); err != nil && !os.IsNotExist(err) {
+		return fmt.Errorf("failed to delete token file: %w", err)
+	}
+
+	return nil
+}
+
+// HasValidToken checks if a valid (non-expired) token exists for a provider
+func (s *OAuthStorage) HasValidToken(provider string, bufferMinutes int) bool {
+	token, err := s.LoadToken(provider)
+	if err != nil || token == nil {
+		return false
+	}
+
+	return !token.IsExpired(bufferMinutes)
+}

common/oauth_storage_test.go

@@ -0,0 +1,232 @@
+package common
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+	"time"
+)
+
+func TestOAuthToken_IsExpired(t *testing.T) {
+	tests := []struct {
+		name          string
+		expiresAt     int64
+		bufferMinutes int
+		expected      bool
+	}{
+		{
+			name:          "token not expired",
+			expiresAt:     time.Now().Unix() + 3600, // 1 hour from now
+			bufferMinutes: 5,
+			expected:      false,
+		},
+		{
+			name:          "token expired",
+			expiresAt:     time.Now().Unix() - 3600, // 1 hour ago
+			bufferMinutes: 5,
+			expected:      true,
+		},
+		{
+			name:          "token expires within buffer",
+			expiresAt:     time.Now().Unix() + 120, // 2 minutes from now
+			bufferMinutes: 5,
+			expected:      true,
+		},
+		{
+			name:          "zero expiry time",
+			expiresAt:     0,
+			bufferMinutes: 5,
+			expected:      true,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			token := &OAuthToken{ExpiresAt: tt.expiresAt}
+			if got := token.IsExpired(tt.bufferMinutes); got != tt.expected {
+				t.Errorf("IsExpired() = %v, want %v", got, tt.expected)
+			}
+		})
+	}
+}
+
+func TestOAuthStorage_SaveAndLoadToken(t *testing.T) {
+	// Create temporary directory for testing
+	tempDir, err := os.MkdirTemp("", "fabric_oauth_test")
+	if err != nil {
+		t.Fatalf("Failed to create temp dir: %v", err)
+	}
+	defer os.RemoveAll(tempDir)
+
+	// Create storage with custom config dir
+	storage := &OAuthStorage{configDir: tempDir}
+
+	// Test token
+	token := &OAuthToken{
+		AccessToken:  "test_access_token",
+		RefreshToken: "test_refresh_token",
+		ExpiresAt:    time.Now().Unix() + 3600,
+		TokenType:    "Bearer",
+		Scope:        "test_scope",
+	}
+
+	// Test saving token
+	err = storage.SaveToken("test_provider", token)
+	if err != nil {
+		t.Fatalf("Failed to save token: %v", err)
+	}
+
+	// Verify file exists and has correct permissions
+	tokenPath := storage.GetTokenPath("test_provider")
+	info, err := os.Stat(tokenPath)
+	if err != nil {
+		t.Fatalf("Token file not created: %v", err)
+	}
+	if info.Mode().Perm() != 0600 {
+		t.Errorf("Token file has wrong permissions: %v, want 0600", info.Mode().Perm())
+	}
+
+	// Test loading token
+	loadedToken, err := storage.LoadToken("test_provider")
+	if err != nil {
+		t.Fatalf("Failed to load token: %v", err)
+	}
+	if loadedToken == nil {
+		t.Fatal("Loaded token is nil")
+	}
+
+	// Verify token data
+	if loadedToken.AccessToken != token.AccessToken {
+		t.Errorf("AccessToken mismatch: got %v, want %v", loadedToken.AccessToken, token.AccessToken)
+	}
+	if loadedToken.RefreshToken != token.RefreshToken {
+		t.Errorf("RefreshToken mismatch: got %v, want %v", loadedToken.RefreshToken, token.RefreshToken)
+	}
+	if loadedToken.ExpiresAt != token.ExpiresAt {
+		t.Errorf("ExpiresAt mismatch: got %v, want %v", loadedToken.ExpiresAt, token.ExpiresAt)
+	}
+}
+
+func TestOAuthStorage_LoadNonExistentToken(t *testing.T) {
+	// Create temporary directory for testing
+	tempDir, err := os.MkdirTemp("", "fabric_oauth_test")
+	if err != nil {
+		t.Fatalf("Failed to create temp dir: %v", err)
+	}
+	defer os.RemoveAll(tempDir)
+
+	storage := &OAuthStorage{configDir: tempDir}
+
+	// Try to load non-existent token
+	token, err := storage.LoadToken("nonexistent")
+	if err != nil {
+		t.Fatalf("Unexpected error loading non-existent token: %v", err)
+	}
+	if token != nil {
+		t.Error("Expected nil token for non-existent provider")
+	}
+}
+
+func TestOAuthStorage_DeleteToken(t *testing.T) {
+	// Create temporary directory for testing
+	tempDir, err := os.MkdirTemp("", "fabric_oauth_test")
+	if err != nil {
+		t.Fatalf("Failed to create temp dir: %v", err)
+	}
+	defer os.RemoveAll(tempDir)
+
+	storage := &OAuthStorage{configDir: tempDir}
+
+	// Create and save a token
+	token := &OAuthToken{
+		AccessToken:  "test_token",
+		RefreshToken: "test_refresh",
+		ExpiresAt:    time.Now().Unix() + 3600,
+	}
+	err = storage.SaveToken("test_provider", token)
+	if err != nil {
+		t.Fatalf("Failed to save token: %v", err)
+	}
+
+	// Verify token exists
+	tokenPath := storage.GetTokenPath("test_provider")
+	if _, err := os.Stat(tokenPath); os.IsNotExist(err) {
+		t.Fatal("Token file should exist before deletion")
+	}
+
+	// Delete token
+	err = storage.DeleteToken("test_provider")
+	if err != nil {
+		t.Fatalf("Failed to delete token: %v", err)
+	}
+
+	// Verify token is deleted
+	if _, err := os.Stat(tokenPath); !os.IsNotExist(err) {
+		t.Error("Token file should not exist after deletion")
+	}
+
+	// Test deleting non-existent token (should not error)
+	err = storage.DeleteToken("nonexistent")
+	if err != nil {
+		t.Errorf("Deleting non-existent token should not error: %v", err)
+	}
+}
+
+func TestOAuthStorage_HasValidToken(t *testing.T) {
+	// Create temporary directory for testing
+	tempDir, err := os.MkdirTemp("", "fabric_oauth_test")
+	if err != nil {
+		t.Fatalf("Failed to create temp dir: %v", err)
+	}
+	defer os.RemoveAll(tempDir)
+
+	storage := &OAuthStorage{configDir: tempDir}
+
+	// Test with no token
+	if storage.HasValidToken("test_provider", 5) {
+		t.Error("Should return false when no token exists")
+	}
+
+	// Save valid token
+	validToken := &OAuthToken{
+		AccessToken:  "valid_token",
+		RefreshToken: "refresh_token",
+		ExpiresAt:    time.Now().Unix() + 3600, // 1 hour from now
+	}
+	err = storage.SaveToken("test_provider", validToken)
+	if err != nil {
+		t.Fatalf("Failed to save valid token: %v", err)
+	}
+
+	// Test with valid token
+	if !storage.HasValidToken("test_provider", 5) {
+		t.Error("Should return true for valid token")
+	}
+
+	// Save expired token
+	expiredToken := &OAuthToken{
+		AccessToken:  "expired_token",
+		RefreshToken: "refresh_token",
+		ExpiresAt:    time.Now().Unix() - 3600, // 1 hour ago
+	}
+	err = storage.SaveToken("expired_provider", expiredToken)
+	if err != nil {
+		t.Fatalf("Failed to save expired token: %v", err)
+	}
+
+	// Test with expired token
+	if storage.HasValidToken("expired_provider", 5) {
+		t.Error("Should return false for expired token")
+	}
+}
+
+func TestOAuthStorage_GetTokenPath(t *testing.T) {
+	storage := &OAuthStorage{configDir: "/test/config"}
+
+	expected := filepath.Join("/test/config", ".test_provider_oauth")
+	actual := storage.GetTokenPath("test_provider")
+
+	if actual != expected {
+		t.Errorf("GetTokenPath() = %v, want %v", actual, expected)
+	}
+}

completions/_fabric

@@ -96,6 +96,13 @@ _fabric() {
     '(--api-key)--api-key[API key used to secure server routes]:api-key:' \
     '(--config)--config[Path to YAML config file]:config file:_files -g "*.yaml *.yml"' \
     '(--version)--version[Print current version]' \
+    '(--search)--search[Enable web search tool for supported models (Anthropic, OpenAI)]' \
+    '(--search-location)--search-location[Set location for web search results]:location:' \
+    '(--image-file)--image-file[Save generated image to specified file path]:image file:_files -g "*.png *.webp *.jpeg *.jpg"' \
+    '(--image-size)--image-size[Image dimensions]:size:(1024x1024 1536x1024 1024x1536 auto)' \
+    '(--image-quality)--image-quality[Image quality]:quality:(low medium high auto)' \
+    '(--image-compression)--image-compression[Compression level 0-100 for JPEG/WebP formats]:compression:' \
+    '(--image-background)--image-background[Background type]:background:(opaque transparent)' \
     '(--listextensions)--listextensions[List all registered extensions]' \
     '(--addextension)--addextension[Register a new extension from config file path]:config file:_files -g "*.yaml *.yml"' \
     '(--rmextension)--rmextension[Remove a registered extension by name]:extension:_fabric_extensions' \

completions/fabric.bash

@@ -13,7 +13,7 @@ _fabric() {
   _get_comp_words_by_ref -n : cur prev words cword
 
   # Define all possible options/flags
-  local opts="--pattern -p --variable -v --context -C --session --attachment -a --setup -S --temperature -t --topp -T --stream -s --presencepenalty -P --raw -r --frequencypenalty -F --listpatterns -l --listmodels -L --listcontexts -x --listsessions -X --updatepatterns -U --copy -c --model -m --modelContextLength --output -o --output-session --latest -n --changeDefaultModel -d --youtube -y --playlist --transcript --transcript-with-timestamps --comments --metadata --language -g --scrape_url -u --scrape_question -q --seed -e --wipecontext -w --wipesession -W --printcontext --printsession --readability --input-has-vars --dry-run --serve --serveOllama --address --api-key --config --version --listextensions --addextension --rmextension --strategy --liststrategies --listvendors --shell-complete-list --help -h"
+  local opts="--pattern -p --variable -v --context -C --session --attachment -a --setup -S --temperature -t --topp -T --stream -s --presencepenalty -P --raw -r --frequencypenalty -F --listpatterns -l --listmodels -L --listcontexts -x --listsessions -X --updatepatterns -U --copy -c --model -m --modelContextLength --output -o --output-session --latest -n --changeDefaultModel -d --youtube -y --playlist --transcript --transcript-with-timestamps --comments --metadata --language -g --scrape_url -u --scrape_question -q --seed -e --wipecontext -w --wipesession -W --printcontext --printsession --readability --input-has-vars --dry-run --serve --serveOllama --address --api-key --config --search --search-location --image-file --image-size --image-quality --image-compression --image-background --version --listextensions --addextension --rmextension --strategy --liststrategies --listvendors --shell-complete-list --help -h"
 
   # Helper function for dynamic completions
   _fabric_get_list() {
@@ -63,12 +63,25 @@ _fabric() {
     return 0
     ;;
   # Options requiring file/directory paths
-  -a | --attachment | -o | --output | --config | --addextension)
+  -a | --attachment | -o | --output | --config | --addextension | --image-file)
     _filedir
     return 0
     ;;
+  # Image generation options with specific values
+  --image-size)
+    COMPREPLY=($(compgen -W "1024x1024 1536x1024 1024x1536 auto" -- "$cur"))
+    return 0
+    ;;
+  --image-quality)
+    COMPREPLY=($(compgen -W "low medium high auto" -- "$cur"))
+    return 0
+    ;;
+  --image-background)
+    COMPREPLY=($(compgen -W "opaque transparent" -- "$cur"))
+    return 0
+    ;;
   # Options requiring simple arguments (no specific completion logic here)
-  -v | --variable | -t | --temperature | -T | --topp | -P | --presencepenalty | -F | --frequencypenalty | --modelContextLength | -n | --latest | -y | --youtube | -g | --language | -u | --scrape_url | -q | --scrape_question | -e | --seed | --address | --api-key)
+  -v | --variable | -t | --temperature | -T | --topp | -P | --presencepenalty | -F | --frequencypenalty | --modelContextLength | -n | --latest | -y | --youtube | -g | --language | -u | --scrape_url | -q | --scrape_question | -e | --seed | --address | --api-key | --search-location | --image-compression)
     # No specific completion suggestions, user types the value
     return 0
     ;;

completions/fabric.fish

@@ -60,6 +60,12 @@ complete -c fabric -l printsession -d "Print session" -a "(__fabric_get_sessions
 complete -c fabric -l address -d "The address to bind the REST API (default: :8080)"
 complete -c fabric -l api-key -d "API key used to secure server routes"
 complete -c fabric -l config -d "Path to YAML config file" -r -a "*.yaml *.yml"
+complete -c fabric -l search-location -d "Set location for web search results (e.g., 'America/Los_Angeles')"
+complete -c fabric -l image-file -d "Save generated image to specified file path (e.g., 'output.png')" -r -a "*.png *.webp *.jpeg *.jpg"
+complete -c fabric -l image-size -d "Image dimensions: 1024x1024, 1536x1024, 1024x1536, auto (default: auto)" -a "1024x1024 1536x1024 1024x1536 auto"
+complete -c fabric -l image-quality -d "Image quality: low, medium, high, auto (default: auto)" -a "low medium high auto"
+complete -c fabric -l image-compression -d "Compression level 0-100 for JPEG/WebP formats (default: not set)" -r
+complete -c fabric -l image-background -d "Background type: opaque, transparent (default: opaque, only for PNG/WebP)" -a "opaque transparent"
 complete -c fabric -l addextension -d "Register a new extension from config file path" -r -a "*.yaml *.yml"
 complete -c fabric -l rmextension -d "Remove a registered extension by name" -a "(__fabric_get_extensions)"
 complete -c fabric -l strategy -d "Choose a strategy from the available strategies" -a "(__fabric_get_strategies)"
@@ -84,6 +90,7 @@ complete -c fabric -l metadata -d "Output video metadata"
 complete -c fabric -l readability -d "Convert HTML input into a clean, readable view"
 complete -c fabric -l input-has-vars -d "Apply variables to user input"
 complete -c fabric -l dry-run -d "Show what would be sent to the model without actually sending it"
+complete -c fabric -l search -d "Enable web search tool for supported models (Anthropic, OpenAI)"
 complete -c fabric -l serve -d "Serve the Fabric Rest API"
 complete -c fabric -l serveOllama -d "Serve the Fabric Rest API with ollama endpoints"
 complete -c fabric -l version -d "Print current version"

core/chatter.go

@@ -7,7 +7,7 @@ import (
 	"os"
 	"strings"
 
-	goopenai "github.com/sashabaranov/go-openai"
+	"github.com/danielmiessler/fabric/chat"
 
 	"github.com/danielmiessler/fabric/common"
 	"github.com/danielmiessler/fabric/plugins/ai"
@@ -30,11 +30,11 @@ type Chatter struct {
 	strategy           string
 }
 
-// Send processes a chat request and applies any file changes if using the create_coding_feature pattern
+// Send processes a chat request and applies file changes for create_coding_feature pattern
 func (o *Chatter) Send(request *common.ChatRequest, opts *common.ChatOptions) (session *fsdb.Session, err error) {
 	modelToUse := opts.Model
 	if modelToUse == "" {
-		modelToUse = o.model // Default to the model set in the Chatter struct
+		modelToUse = o.model
 	}
 	if o.vendor.NeedsRawMode(modelToUse) {
 		opts.Raw = true
@@ -89,18 +89,15 @@ func (o *Chatter) Send(request *common.ChatRequest, opts *common.ChatOptions) (s
 		return
 	}
 
-	// Process file changes if using the create_coding_feature pattern
+	// Process file changes for create_coding_feature pattern
 	if request.PatternName == "create_coding_feature" {
-		// Look for file changes in the response
 		summary, fileChanges, parseErr := common.ParseFileChanges(message)
 		if parseErr != nil {
 			fmt.Printf("Warning: Failed to parse file changes: %v\n", parseErr)
 		} else if len(fileChanges) > 0 {
-			// Get the project root - use the current directory
 			projectRoot, err := os.Getwd()
 			if err != nil {
 				fmt.Printf("Warning: Failed to get current directory: %v\n", err)
-				// Continue without applying changes
 			} else {
 				if applyErr := common.ApplyFileChanges(projectRoot, fileChanges); applyErr != nil {
 					fmt.Printf("Warning: Failed to apply file changes: %v\n", applyErr)
@@ -113,7 +110,7 @@ func (o *Chatter) Send(request *common.ChatRequest, opts *common.ChatOptions) (s
 		message = summary
 	}
 
-	session.Append(&goopenai.ChatCompletionMessage{Role: goopenai.ChatMessageRoleAssistant, Content: message})
+	session.Append(&chat.ChatCompletionMessage{Role: chat.ChatMessageRoleAssistant, Content: message})
 
 	if session.Name != "" {
 		err = o.db.Sessions.SaveSession(session)
@@ -122,7 +119,6 @@ func (o *Chatter) Send(request *common.ChatRequest, opts *common.ChatOptions) (s
 }
 
 func (o *Chatter) BuildSession(request *common.ChatRequest, raw bool) (session *fsdb.Session, err error) {
-	// If a session name is provided, retrieve it from the database
 	if request.SessionName != "" {
 		var sess *fsdb.Session
 		if sess, err = o.db.Sessions.Get(request.SessionName); err != nil {
@@ -135,7 +131,7 @@ func (o *Chatter) BuildSession(request *common.ChatRequest, raw bool) (session *
 	}
 
 	if request.Meta != "" {
-		session.Append(&goopenai.ChatCompletionMessage{Role: common.ChatMessageRoleMeta, Content: request.Meta})
+		session.Append(&chat.ChatCompletionMessage{Role: common.ChatMessageRoleMeta, Content: request.Meta})
 	}
 
 	// if a context name is provided, retrieve it from the database
@@ -149,12 +145,12 @@ func (o *Chatter) BuildSession(request *common.ChatRequest, raw bool) (session *
 		contextContent = ctx.Content
 	}
 
-	// Process any template variables in the message content (user input)
+	// Process template variables in message content
 	// Double curly braces {{variable}} indicate template substitution
-	// Ensure we have a message before processing, other wise we'll get an error when we pass to pattern.go
+	// Ensure we have a message before processing
 	if request.Message == nil {
-		request.Message = &goopenai.ChatCompletionMessage{
-			Role:    goopenai.ChatMessageRoleUser,
+		request.Message = &chat.ChatCompletionMessage{
+			Role:    chat.ChatMessageRoleUser,
 			Content: " ",
 		}
 	}
@@ -168,19 +164,19 @@ func (o *Chatter) BuildSession(request *common.ChatRequest, raw bool) (session *
 	}
 
 	var patternContent string
+	inputUsed := false
 	if request.PatternName != "" {
 		pattern, err := o.db.Patterns.GetApplyVariables(request.PatternName, request.PatternVariables, request.Message.Content)
-		// pattern will now contain user input, and all variables will be resolved, or errored
 
 		if err != nil {
 			return nil, fmt.Errorf("could not get pattern %s: %v", request.PatternName, err)
 		}
 		patternContent = pattern.Pattern
+		inputUsed = true
 	}
 
 	systemMessage := strings.TrimSpace(contextContent) + strings.TrimSpace(patternContent)
 
-	// Apply strategy if specified
 	if request.StrategyName != "" {
 		strategy, err := strategy.LoadStrategy(request.StrategyName)
 		if err != nil {
@@ -199,33 +195,51 @@ func (o *Chatter) BuildSession(request *common.ChatRequest, raw bool) (session *
 	}
 
 	if raw {
-		// In raw mode, we want to avoid duplicating the input that's already in the pattern
 		var finalContent string
 		if systemMessage != "" {
-			// If we have a pattern, it already includes the user input
 			if request.PatternName != "" {
 				finalContent = systemMessage
 			} else {
-				// No pattern, combine system message with user input
 				finalContent = fmt.Sprintf("%s\n\n%s", systemMessage, request.Message.Content)
 			}
-			request.Message = &goopenai.ChatCompletionMessage{
-				Role:    goopenai.ChatMessageRoleUser,
-				Content: finalContent,
+
+			// Handle MultiContent properly in raw mode
+			if len(request.Message.MultiContent) > 0 {
+				// When we have attachments, add the text as a text part in MultiContent
+				newMultiContent := []chat.ChatMessagePart{
+					{
+						Type: chat.ChatMessagePartTypeText,
+						Text: finalContent,
+					},
+				}
+				// Add existing non-text parts (like images)
+				for _, part := range request.Message.MultiContent {
+					if part.Type != chat.ChatMessagePartTypeText {
+						newMultiContent = append(newMultiContent, part)
+					}
+				}
+				request.Message = &chat.ChatCompletionMessage{
+					Role:         chat.ChatMessageRoleUser,
+					MultiContent: newMultiContent,
+				}
+			} else {
+				// No attachments, use regular Content field
+				request.Message = &chat.ChatCompletionMessage{
+					Role:    chat.ChatMessageRoleUser,
+					Content: finalContent,
+				}
 			}
 		}
-		// After this, if request.Message is not nil, append it
 		if request.Message != nil {
 			session.Append(request.Message)
 		}
-	} else { // Not raw mode
+	} else {
 		if systemMessage != "" {
-			session.Append(&goopenai.ChatCompletionMessage{Role: goopenai.ChatMessageRoleSystem, Content: systemMessage})
+			session.Append(&chat.ChatCompletionMessage{Role: chat.ChatMessageRoleSystem, Content: systemMessage})
 		}
-		// If a pattern was used (request.PatternName != ""), its output (systemMessage)
-		// already incorporates the user input (request.Message.Content via GetApplyVariables).
-		// So, we only append the direct user message if NO pattern was used.
-		if request.PatternName == "" && request.Message != nil {
+		// If multi-part content, it is in the user message, and should be added.
+		// Otherwise, we should only add it if we have not already used it in the systemMessage.
+		if len(request.Message.MultiContent) > 0 || (request.Message != nil && !inputUsed) {
 			session.Append(request.Message)
 		}
 	}

core/plugin_registry.go

@@ -10,7 +10,9 @@ import (
 	"strconv"
 	"strings"
 
+	"github.com/danielmiessler/fabric/plugins/ai/bedrock"
 	"github.com/danielmiessler/fabric/plugins/ai/exolab"
+	"github.com/danielmiessler/fabric/plugins/ai/perplexity" // Added Perplexity plugin
 	"github.com/danielmiessler/fabric/plugins/strategy"
 
 	"github.com/samber/lo"
@@ -29,17 +31,46 @@ import (
 	"github.com/danielmiessler/fabric/plugins/db/fsdb"
 	"github.com/danielmiessler/fabric/plugins/template"
 	"github.com/danielmiessler/fabric/plugins/tools"
+	"github.com/danielmiessler/fabric/plugins/tools/custom_patterns"
 	"github.com/danielmiessler/fabric/plugins/tools/jina"
 	"github.com/danielmiessler/fabric/plugins/tools/lang"
 	"github.com/danielmiessler/fabric/plugins/tools/youtube"
 )
 
+// hasAWSCredentials checks if any AWS credentials are present either in the
+// environment variables or in the default/shared credentials file. It doesn't
+// attempt to verify the validity of the credentials, but simply ensures that a
+// potential authentication source exists so we can safely initialize the
+// Bedrock client without causing the AWS SDK to search for credentials.
+func hasAWSCredentials() bool {
+	if os.Getenv("AWS_PROFILE") != "" ||
+		os.Getenv("AWS_ROLE_SESSION_NAME") != "" ||
+		(os.Getenv("AWS_ACCESS_KEY_ID") != "" && os.Getenv("AWS_SECRET_ACCESS_KEY") != "") {
+
+		return true
+	}
+
+	credFile := os.Getenv("AWS_SHARED_CREDENTIALS_FILE")
+	if credFile == "" {
+		if home, err := os.UserHomeDir(); err == nil {
+			credFile = filepath.Join(home, ".aws", "credentials")
+		}
+	}
+	if credFile != "" {
+		if _, err := os.Stat(credFile); err == nil {
+			return true
+		}
+	}
+	return false
+}
+
 func NewPluginRegistry(db *fsdb.Db) (ret *PluginRegistry, err error) {
 	ret = &PluginRegistry{
 		Db:             db,
 		VendorManager:  ai.NewVendorsManager(),
 		VendorsAll:     ai.NewVendorsManager(),
 		PatternsLoader: tools.NewPatternsLoader(db.Patterns),
+		CustomPatterns: custom_patterns.NewCustomPatterns(),
 		YouTube:        youtube.NewYouTube(),
 		Language:       lang.NewLanguage(),
 		Jina:           jina.NewClient(),
@@ -66,8 +97,13 @@ func NewPluginRegistry(db *fsdb.Db) (ret *PluginRegistry, err error) {
 		anthropic.NewClient(),
 		lmstudio.NewClient(),
 		exolab.NewClient(),
+		perplexity.NewClient(), // Added Perplexity client
 	)
 
+	if hasAWSCredentials() {
+		vendors = append(vendors, bedrock.NewClient())
+	}
+
 	// Add all OpenAI-compatible providers
 	for providerName := range openai_compatible.ProviderMap {
 		provider, _ := openai_compatible.GetProviderByName(providerName)
@@ -104,6 +140,7 @@ type PluginRegistry struct {
 	VendorsAll         *ai.VendorsManager
 	Defaults           *tools.Defaults
 	PatternsLoader     *tools.PatternsLoader
+	CustomPatterns     *custom_patterns.CustomPatterns
 	YouTube            *youtube.YouTube
 	Language           *lang.Language
 	Jina               *jina.Client
@@ -117,6 +154,7 @@ func (o *PluginRegistry) SaveEnvFile() (err error) {
 
 	o.Defaults.Settings.FillEnvFileContent(&envFileContent)
 	o.PatternsLoader.SetupFillEnvFileContent(&envFileContent)
+	o.CustomPatterns.SetupFillEnvFileContent(&envFileContent)
 	o.Strategies.SetupFillEnvFileContent(&envFileContent)
 
 	for _, vendor := range o.VendorManager.Vendors {
@@ -149,7 +187,7 @@ func (o *PluginRegistry) Setup() (err error) {
 			return vendor
 		})...)
 
-	groupsPlugins.AddGroupItems("Tools", o.Defaults, o.Jina, o.Language, o.PatternsLoader, o.Strategies, o.YouTube)
+	groupsPlugins.AddGroupItems("Tools", o.CustomPatterns, o.Defaults, o.Jina, o.Language, o.PatternsLoader, o.Strategies, o.YouTube)
 
 	for {
 		groupsPlugins.Print(false)

go.mod

@@ -5,9 +5,12 @@ go 1.24.0
 toolchain go1.24.2
 
 require (
-	github.com/anaskhan96/soup v1.2.5
 	github.com/anthropics/anthropic-sdk-go v1.4.0
 	github.com/atotto/clipboard v0.1.4
+	github.com/aws/aws-sdk-go-v2 v1.36.4
+	github.com/aws/aws-sdk-go-v2/config v1.27.27
+	github.com/aws/aws-sdk-go-v2/service/bedrock v1.34.1
+	github.com/aws/aws-sdk-go-v2/service/bedrockruntime v1.30.0
 	github.com/gabriel-vasile/mimetype v1.4.9
 	github.com/gin-gonic/gin v1.10.1
 	github.com/go-git/go-git/v5 v5.16.2
@@ -16,14 +19,15 @@ require (
 	github.com/jessevdk/go-flags v1.6.1
 	github.com/joho/godotenv v1.5.1
 	github.com/ollama/ollama v0.9.0
+	github.com/openai/openai-go v1.8.2
 	github.com/otiai10/copy v1.14.1
 	github.com/pkg/errors v0.9.1
 	github.com/samber/lo v1.50.0
-	github.com/sashabaranov/go-openai v1.40.1
+	github.com/sgaunet/perplexity-go/v2 v2.8.0
 	github.com/stretchr/testify v1.10.0
+	golang.org/x/oauth2 v0.30.0
 	golang.org/x/text v0.26.0
 	google.golang.org/api v0.236.0
-	gopkg.in/yaml.v2 v2.4.0
 	gopkg.in/yaml.v3 v3.0.1
 )
 
@@ -39,6 +43,18 @@ require (
 	github.com/ProtonMail/go-crypto v1.3.0 // indirect
 	github.com/andybalholm/cascadia v1.3.3 // indirect
 	github.com/araddon/dateparse v0.0.0-20210429162001-6b43995a97de // indirect
+	github.com/aws/aws-sdk-go-v2/aws/protocol/eventstream v1.6.10 // indirect
+	github.com/aws/aws-sdk-go-v2/credentials v1.17.27 // indirect
+	github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.16.11 // indirect
+	github.com/aws/aws-sdk-go-v2/internal/configsources v1.3.35 // indirect
+	github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.6.35 // indirect
+	github.com/aws/aws-sdk-go-v2/internal/ini v1.8.0 // indirect
+	github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.11.3 // indirect
+	github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.11.17 // indirect
+	github.com/aws/aws-sdk-go-v2/service/sso v1.22.4 // indirect
+	github.com/aws/aws-sdk-go-v2/service/ssooidc v1.26.4 // indirect
+	github.com/aws/aws-sdk-go-v2/service/sts v1.30.3 // indirect
+	github.com/aws/smithy-go v1.22.2 // indirect
 	github.com/bytedance/sonic v1.13.3 // indirect
 	github.com/bytedance/sonic/loader v0.2.4 // indirect
 	github.com/cloudflare/circl v1.6.1 // indirect
@@ -93,7 +109,6 @@ require (
 	golang.org/x/arch v0.18.0 // indirect
 	golang.org/x/crypto v0.39.0 // indirect
 	golang.org/x/net v0.41.0 // indirect
-	golang.org/x/oauth2 v0.30.0 // indirect
 	golang.org/x/sync v0.15.0 // indirect
 	golang.org/x/sys v0.33.0 // indirect
 	golang.org/x/time v0.12.0 // indirect

go.sum

@@ -17,8 +17,6 @@ github.com/Microsoft/go-winio v0.6.2 h1:F2VQgta7ecxGYO8k3ZZz3RS8fVIXVxONVUPlNERo
 github.com/Microsoft/go-winio v0.6.2/go.mod h1:yd8OoFMLzJbo9gZq8j5qaps8bJ9aShtEA8Ipt1oGCvU=
 github.com/ProtonMail/go-crypto v1.3.0 h1:ILq8+Sf5If5DCpHQp4PbZdS1J7HDFRXz/+xKBiRGFrw=
 github.com/ProtonMail/go-crypto v1.3.0/go.mod h1:9whxjD8Rbs29b4XWbB8irEcE8KHMqaR2e7GWU1R+/PE=
-github.com/anaskhan96/soup v1.2.5 h1:V/FHiusdTrPrdF4iA1YkVxsOpdNcgvqT1hG+YtcZ5hM=
-github.com/anaskhan96/soup v1.2.5/go.mod h1:6YnEp9A2yywlYdM4EgDz9NEHclocMepEtku7wg6Cq3s=
 github.com/andybalholm/cascadia v1.3.3 h1:AG2YHrzJIm4BZ19iwJ/DAua6Btl3IwJX+VI4kktS1LM=
 github.com/andybalholm/cascadia v1.3.3/go.mod h1:xNd9bqTn98Ln4DwST8/nG+H0yuB8Hmgu1YHNnWw0GeA=
 github.com/anmitsu/go-shlex v0.0.0-20200514113438-38f4b401e2be h1:9AeTilPcZAjCFIImctFaOjnTIavg87rW78vTPkQqLI8=
@@ -31,6 +29,38 @@ github.com/armon/go-socks5 v0.0.0-20160902184237-e75332964ef5 h1:0CwZNZbxp69SHPd
 github.com/armon/go-socks5 v0.0.0-20160902184237-e75332964ef5/go.mod h1:wHh0iHkYZB8zMSxRWpUBQtwG5a7fFgvEO+odwuTv2gs=
 github.com/atotto/clipboard v0.1.4 h1:EH0zSVneZPSuFR11BlR9YppQTVDbh5+16AmcJi4g1z4=
 github.com/atotto/clipboard v0.1.4/go.mod h1:ZY9tmq7sm5xIbd9bOK4onWV4S6X0u6GY7Vn0Yu86PYI=
+github.com/aws/aws-sdk-go-v2 v1.36.4 h1:GySzjhVvx0ERP6eyfAbAuAXLtAda5TEy19E5q5W8I9E=
+github.com/aws/aws-sdk-go-v2 v1.36.4/go.mod h1:LLXuLpgzEbD766Z5ECcRmi8AzSwfZItDtmABVkRLGzg=
+github.com/aws/aws-sdk-go-v2/aws/protocol/eventstream v1.6.10 h1:zAybnyUQXIZ5mok5Jqwlf58/TFE7uvd3IAsa1aF9cXs=
+github.com/aws/aws-sdk-go-v2/aws/protocol/eventstream v1.6.10/go.mod h1:qqvMj6gHLR/EXWZw4ZbqlPbQUyenf4h82UQUlKc+l14=
+github.com/aws/aws-sdk-go-v2/config v1.27.27 h1:HdqgGt1OAP0HkEDDShEl0oSYa9ZZBSOmKpdpsDMdO90=
+github.com/aws/aws-sdk-go-v2/config v1.27.27/go.mod h1:MVYamCg76dFNINkZFu4n4RjDixhVr51HLj4ErWzrVwg=
+github.com/aws/aws-sdk-go-v2/credentials v1.17.27 h1:2raNba6gr2IfA0eqqiP2XiQ0UVOpGPgDSi0I9iAP+UI=
+github.com/aws/aws-sdk-go-v2/credentials v1.17.27/go.mod h1:gniiwbGahQByxan6YjQUMcW4Aov6bLC3m+evgcoN4r4=
+github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.16.11 h1:KreluoV8FZDEtI6Co2xuNk/UqI9iwMrOx/87PBNIKqw=
+github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.16.11/go.mod h1:SeSUYBLsMYFoRvHE0Tjvn7kbxaUhl75CJi1sbfhMxkU=
+github.com/aws/aws-sdk-go-v2/internal/configsources v1.3.35 h1:o1v1VFfPcDVlK3ll1L5xHsaQAFdNtZ5GXnNR7SwueC4=
+github.com/aws/aws-sdk-go-v2/internal/configsources v1.3.35/go.mod h1:rZUQNYMNG+8uZxz9FOerQJ+FceCiodXvixpeRtdESrU=
+github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.6.35 h1:R5b82ubO2NntENm3SAm0ADME+H630HomNJdgv+yZ3xw=
+github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.6.35/go.mod h1:FuA+nmgMRfkzVKYDNEqQadvEMxtxl9+RLT9ribCwEMs=
+github.com/aws/aws-sdk-go-v2/internal/ini v1.8.0 h1:hT8rVHwugYE2lEfdFE0QWVo81lF7jMrYJVDWI+f+VxU=
+github.com/aws/aws-sdk-go-v2/internal/ini v1.8.0/go.mod h1:8tu/lYfQfFe6IGnaOdrpVgEL2IrrDOf6/m9RQum4NkY=
+github.com/aws/aws-sdk-go-v2/service/bedrock v1.34.1 h1:sD4KqDKG8aOaMWaWTMB8l8VnLa/Di7XHb0Uf4plrndA=
+github.com/aws/aws-sdk-go-v2/service/bedrock v1.34.1/go.mod h1:lrn8DOVFYFeaUZKxJ95T5eGDBjnhffgGz68Wq2sfBbA=
+github.com/aws/aws-sdk-go-v2/service/bedrockruntime v1.30.0 h1:eMOwQ8ZZK+76+08RfxeaGUtRFN6wxmD1rvqovc2kq2w=
+github.com/aws/aws-sdk-go-v2/service/bedrockruntime v1.30.0/go.mod h1:0b5Rq7rUvSQFYHI1UO0zFTV/S6j6DUyuykXA80C+YOI=
+github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.11.3 h1:dT3MqvGhSoaIhRseqw2I0yH81l7wiR2vjs57O51EAm8=
+github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.11.3/go.mod h1:GlAeCkHwugxdHaueRr4nhPuY+WW+gR8UjlcqzPr1SPI=
+github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.11.17 h1:HGErhhrxZlQ044RiM+WdoZxp0p+EGM62y3L6pwA4olE=
+github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.11.17/go.mod h1:RkZEx4l0EHYDJpWppMJ3nD9wZJAa8/0lq9aVC+r2UII=
+github.com/aws/aws-sdk-go-v2/service/sso v1.22.4 h1:BXx0ZIxvrJdSgSvKTZ+yRBeSqqgPM89VPlulEcl37tM=
+github.com/aws/aws-sdk-go-v2/service/sso v1.22.4/go.mod h1:ooyCOXjvJEsUw7x+ZDHeISPMhtwI3ZCB7ggFMcFfWLU=
+github.com/aws/aws-sdk-go-v2/service/ssooidc v1.26.4 h1:yiwVzJW2ZxZTurVbYWA7QOrAaCYQR72t0wrSBfoesUE=
+github.com/aws/aws-sdk-go-v2/service/ssooidc v1.26.4/go.mod h1:0oxfLkpz3rQ/CHlx5hB7H69YUpFiI1tql6Q6Ne+1bCw=
+github.com/aws/aws-sdk-go-v2/service/sts v1.30.3 h1:ZsDKRLXGWHk8WdtyYMoGNO7bTudrvuKpDKgMVRlepGE=
+github.com/aws/aws-sdk-go-v2/service/sts v1.30.3/go.mod h1:zwySh8fpFyXp9yOr/KVzxOl8SRqgf/IDw5aUt9UKFcQ=
+github.com/aws/smithy-go v1.22.2 h1:6D9hW43xKFrRx/tXXfAlIZc4JI+yQe6snnWcQyxSyLQ=
+github.com/aws/smithy-go v1.22.2/go.mod h1:irrKGvNn1InZwb2d7fkIRNucdfwR8R+Ts3wxYa/cJHg=
 github.com/bytedance/sonic v1.13.3 h1:MS8gmaH16Gtirygw7jV91pDCN33NyMrPbN7qiYhEsF0=
 github.com/bytedance/sonic v1.13.3/go.mod h1:o68xyaF9u2gvVBuGHPlUVCy+ZfmNNO5ETf1+KgkJhz4=
 github.com/bytedance/sonic/loader v0.1.1/go.mod h1:ncP89zfokxS5LZrJxl5z0UJcsk4M4yY2JpfqGeCtNLU=
@@ -142,6 +172,8 @@ github.com/ollama/ollama v0.9.0 h1:GvdGhi8G/QMnFrY0TMLDy1bXua+Ify8KTkFe4ZY/OZs=
 github.com/ollama/ollama v0.9.0/go.mod h1:aio9yQ7nc4uwIbn6S0LkGEPgn8/9bNQLL1nHuH+OcD0=
 github.com/onsi/gomega v1.34.1 h1:EUMJIKUjM8sKjYbtxQI9A4z2o+rruxnzNvpknOXie6k=
 github.com/onsi/gomega v1.34.1/go.mod h1:kU1QgUvBDLXBJq618Xvm2LUX6rSAfRaFRTcdOeDLwwY=
+github.com/openai/openai-go v1.8.2 h1:UqSkJ1vCOPUpz9Ka5tS0324EJFEuOvMc+lA/EarJWP8=
+github.com/openai/openai-go v1.8.2/go.mod h1:g461MYGXEXBVdV5SaR/5tNzNbSfwTBBefwc+LlDCK0Y=
 github.com/otiai10/copy v1.14.1 h1:5/7E6qsUMBaH5AnQ0sSLzzTg1oTECmcCmT6lvF45Na8=
 github.com/otiai10/copy v1.14.1/go.mod h1:oQwrEDDOci3IM8dJF0d8+jnbfPDllW6vUjNc3DoZm9I=
 github.com/otiai10/mint v1.6.3 h1:87qsV/aw1F5as1eH1zS/yqHY85ANKVMgkDrf9rcxbQs=
@@ -159,11 +191,11 @@ github.com/rogpeppe/go-internal v1.14.1 h1:UQB4HGPB6osV0SQTLymcB4TgvyWu6ZyliaW0t
 github.com/rogpeppe/go-internal v1.14.1/go.mod h1:MaRKkUm5W0goXpeCfT7UZI6fk/L7L7so1lCWt35ZSgc=
 github.com/samber/lo v1.50.0 h1:XrG0xOeHs+4FQ8gJR97zDz5uOFMW7OwFWiFVzqopKgY=
 github.com/samber/lo v1.50.0/go.mod h1:RjZyNk6WSnUFRKK6EyOhsRJMqft3G+pg7dCWHQCWvsc=
-github.com/sashabaranov/go-openai v1.40.1 h1:bJ08Iwct5mHBVkuvG6FEcb9MDTfsXdTYPGjYLRdeTEU=
-github.com/sashabaranov/go-openai v1.40.1/go.mod h1:lj5b/K+zjTSFxVLijLSTDZuP7adOgerWeFyZLUhAKRg=
 github.com/scylladb/termtables v0.0.0-20191203121021-c4c0b6d42ff4/go.mod h1:C1a7PQSMz9NShzorzCiG2fk9+xuCgLkPeCvMHYR2OWg=
 github.com/sergi/go-diff v1.4.0 h1:n/SP9D5ad1fORl+llWyN+D6qoUETXNZARKjyY2/KVCw=
 github.com/sergi/go-diff v1.4.0/go.mod h1:A0bzQcvG0E7Rwjx0REVgAGH58e96+X0MeOfepqsbeW4=
+github.com/sgaunet/perplexity-go/v2 v2.8.0 h1:stnuVieniZMGo6qJLCV2JyR2uF7K5398YOA/ZZcgrSg=
+github.com/sgaunet/perplexity-go/v2 v2.8.0/go.mod h1:MSks4RNuivCi0GqJyylhFdgSJFVEwZHjAhrf86Wkynk=
 github.com/sirupsen/logrus v1.7.0/go.mod h1:yWOB1SBYBC5VeMP7gHvWumXLIWorT60ONWic61uBYv0=
 github.com/skeema/knownhosts v1.3.1 h1:X2osQ+RAjK76shCbvhHHHVl3ZlgDm8apHEHFqRjnBY8=
 github.com/skeema/knownhosts v1.3.1/go.mod h1:r7KTdC8l4uxWRyK2TpQZ/1o5HaSzh06ePQNxPwTcfiY=
@@ -173,7 +205,6 @@ github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpE
 github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs=
 github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
 github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4=
-github.com/stretchr/testify v1.6.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
 github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
 github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
 github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU=
@@ -232,7 +263,6 @@ golang.org/x/mod v0.12.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs=
 golang.org/x/mod v0.15.0/go.mod h1:hTbmBsO62+eylJbnUtE2MGJUyE7QWk4xUqPFrRgJ+7c=
 golang.org/x/mod v0.17.0/go.mod h1:hTbmBsO62+eylJbnUtE2MGJUyE7QWk4xUqPFrRgJ+7c=
 golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
-golang.org/x/net v0.0.0-20200114155413-6afb5195e5aa/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
 golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg=
 golang.org/x/net v0.0.0-20211112202133-69e39bad7dc2/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y=
 golang.org/x/net v0.0.0-20220722155237-a158d28d115b/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c=
@@ -324,7 +354,6 @@ gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EV
 gopkg.in/warnings.v0 v0.1.2 h1:wFXVbFY8DY5/xOe1ECiWdKCzZlxgshcYVNkBHstARME=
 gopkg.in/warnings.v0 v0.1.2/go.mod h1:jksf8JmL6Qr/oQM2OXTHunEvvTAsrWBLb6OOjuVWRNI=
 gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
-gopkg.in/yaml.v2 v2.4.0 h1:D8xgwECY7CYvx+Y2n4sBz93Jn9JRvxdiyyo8CTfuKaY=
 gopkg.in/yaml.v2 v2.4.0/go.mod h1:RDklbk79AGWmwhnvt/jBztapEOGDOx6ZbXqjP6csGnQ=
 gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
 gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=

nix/pkgs/fabric/gomod2nix.toml

@@ -28,9 +28,6 @@ schema = 3
   [mod."github.com/ProtonMail/go-crypto"]
     version = "v1.3.0"
     hash = "sha256-TUG+C4MyeWglOmiwiW2/NUVurFHXLgEPRd3X9uQ1NGI="
-  [mod."github.com/anaskhan96/soup"]
-    version = "v1.2.5"
-    hash = "sha256-t8yCyK2y7x2qaI/3Yw16q3zVFqu+3acLcPgTr1MIKWg="
   [mod."github.com/andybalholm/cascadia"]
     version = "v1.3.3"
     hash = "sha256-jv7ZshpSd7FZzKKN6hqlUgiR8C3y85zNIS/hq7g76Ho="
@@ -43,6 +40,54 @@ schema = 3
   [mod."github.com/atotto/clipboard"]
     version = "v0.1.4"
     hash = "sha256-ZZ7U5X0gWOu8zcjZcWbcpzGOGdycwq0TjTFh/eZHjXk="
+  [mod."github.com/aws/aws-sdk-go-v2"]
+    version = "v1.36.4"
+    hash = "sha256-Cpdphp8FQUbQlhAYvtPKDh1oZc84+/0bzLlx8CM1/BM="
+  [mod."github.com/aws/aws-sdk-go-v2/aws/protocol/eventstream"]
+    version = "v1.6.10"
+    hash = "sha256-9+ZMhWxtsm7ZtZCjBV5PZkOR5rt3bCOznuv45Iwf55c="
+  [mod."github.com/aws/aws-sdk-go-v2/config"]
+    version = "v1.27.27"
+    hash = "sha256-jQmc1lJmVeTezSeFs6KL2HAvCkP9ZWMdVbG5ymJQrKs="
+  [mod."github.com/aws/aws-sdk-go-v2/credentials"]
+    version = "v1.17.27"
+    hash = "sha256-7ITZjIF0ZmmCG3u5d88IfsAj0KF1IFm9KhWFlC6RtQo="
+  [mod."github.com/aws/aws-sdk-go-v2/feature/ec2/imds"]
+    version = "v1.16.11"
+    hash = "sha256-uedtRd/SIcFJlYZg1jtJdIJViZq1Poks9/J2Bm9/Ehw="
+  [mod."github.com/aws/aws-sdk-go-v2/internal/configsources"]
+    version = "v1.3.35"
+    hash = "sha256-AyQ+eJvyhahypIAqPScdkn44MYwBcr9iyrMC1BRSeZI="
+  [mod."github.com/aws/aws-sdk-go-v2/internal/endpoints/v2"]
+    version = "v2.6.35"
+    hash = "sha256-c8K+Nk5XrFMWaaxVsyhKgyJBZhs3Hkhjr/dIDXWZfSQ="
+  [mod."github.com/aws/aws-sdk-go-v2/internal/ini"]
+    version = "v1.8.0"
+    hash = "sha256-v76jTAr4rEgS5en49ikLh6nuvclN+VjpOPj83ZQ3sLo="
+  [mod."github.com/aws/aws-sdk-go-v2/service/bedrock"]
+    version = "v1.34.1"
+    hash = "sha256-OK7t+ieq4pviCnnhfSytANBF5Lwdz4KxjN10CC5pXyY="
+  [mod."github.com/aws/aws-sdk-go-v2/service/bedrockruntime"]
+    version = "v1.30.0"
+    hash = "sha256-MsEQfbqIREtMikRFqBpLCqdAC4gfgPSNbk08k5OJTbo="
+  [mod."github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding"]
+    version = "v1.11.3"
+    hash = "sha256-TRhoRd7iY7K+pfdkSQLItyr52k2jO4TMYQ5vRGiOOMk="
+  [mod."github.com/aws/aws-sdk-go-v2/service/internal/presigned-url"]
+    version = "v1.11.17"
+    hash = "sha256-eUoYDAXcQNzCmwjXO9RWhrt0jGYlSjt2vQOlAlpIfoE="
+  [mod."github.com/aws/aws-sdk-go-v2/service/sso"]
+    version = "v1.22.4"
+    hash = "sha256-Q3tyDdJVq0BAstOYvCKPvNS4EHkhXt1pL/23KPQJMHM="
+  [mod."github.com/aws/aws-sdk-go-v2/service/ssooidc"]
+    version = "v1.26.4"
+    hash = "sha256-cPv6nmVPOjMUZjN2IeEiYQSzLeAOrfgGnSSvvhJ6iL4="
+  [mod."github.com/aws/aws-sdk-go-v2/service/sts"]
+    version = "v1.30.3"
+    hash = "sha256-4z/K4GPW9osiNM3SxFNZYsVPnSSU50Iuv29Sb2n4Fbk="
+  [mod."github.com/aws/smithy-go"]
+    version = "v1.22.2"
+    hash = "sha256-YdwVeW509cpqU357MjDM8ReL1vftkW8XIhSbJsbTh/s="
   [mod."github.com/bytedance/sonic"]
     version = "v1.13.3"
     hash = "sha256-Nnt5b2NkIvSXhGERQmyI0ka28hbWi7A7Zn3dsAjPcEA="
@@ -163,6 +208,9 @@ schema = 3
   [mod."github.com/ollama/ollama"]
     version = "v0.9.0"
     hash = "sha256-r2eU+kMG3tuJy2B43RXsfmeltzM9t05NEmNiJAW5qr4="
+  [mod."github.com/openai/openai-go"]
+    version = "v1.8.2"
+    hash = "sha256-O8aV3zEj6o8kIlzlkYaTW4RzvwR3qNUBYiN8SuTM1R0="
   [mod."github.com/otiai10/copy"]
     version = "v1.14.1"
     hash = "sha256-8RR7u17SbYg9AeBXVHIv5ZMU+kHmOcx0rLUKyz6YtU0="
@@ -184,12 +232,12 @@ schema = 3
   [mod."github.com/samber/lo"]
     version = "v1.50.0"
     hash = "sha256-KDFks82BKu39sGt0f972IyOkohV2U0r1YvsnlNLdugY="
-  [mod."github.com/sashabaranov/go-openai"]
-    version = "v1.40.1"
-    hash = "sha256-GkToonIIF3GG+lwev1lJQ9rAAPJDjSaOkoXRC3OOlEA="
   [mod."github.com/sergi/go-diff"]
     version = "v1.4.0"
     hash = "sha256-rs9NKpv/qcQEMRg7CmxGdP4HGuFdBxlpWf9LbA9wS4k="
+  [mod."github.com/sgaunet/perplexity-go/v2"]
+    version = "v2.8.0"
+    hash = "sha256-w1S14Jf4/6LFODREmmiJvPtkZh4Sor81Rr1PqC5pIak="
   [mod."github.com/skeema/knownhosts"]
     version = "v1.3.1"
     hash = "sha256-kjqQDzuncQNTuOYegqVZExwuOt/Z73m2ST7NZFEKixI="
@@ -277,9 +325,6 @@ schema = 3
   [mod."gopkg.in/warnings.v0"]
     version = "v0.1.2"
     hash = "sha256-ATVL9yEmgYbkJ1DkltDGRn/auGAjqGOfjQyBYyUo8s8="
-  [mod."gopkg.in/yaml.v2"]
-    version = "v2.4.0"
-    hash = "sha256-uVEGglIedjOIGZzHW4YwN1VoRSTK8o0eGZqzd+TNdd0="
   [mod."gopkg.in/yaml.v3"]
     version = "v3.0.1"
     hash = "sha256-FqL9TKYJ0XkNwJFnq9j0VvJ5ZUU1RvH/52h/f5bkYAU="

nix/pkgs/fabric/version.nix

@@ -1 +1 @@
-"1.4.199"
+"1.4.232"

patterns/analyze_debate/system.md

@@ -22,19 +22,20 @@ Take a deep breath and think step by step about how to best accomplish this goal
     This must be under the heading "INSIGHTFULNESS SCORE (0 = not very interesting and insightful to 10 = very interesting and insightful)".
     - A rating of how emotional the debate was from 0 (very calm) to 5 (very emotional). This must be under the heading "EMOTIONALITY SCORE (0 (very calm) to 5 (very emotional))".
     - A list of the participants of the debate and a score of their emotionality from 0 (very calm) to 5 (very emotional). This must be under the heading "PARTICIPANTS".
-    - A list of arguments attributed to participants with names and quotes. If possible, this should include external references that disprove or back up their claims. 
+    - A list of arguments attributed to participants with names and quotes. Each argument summary must be EXACTLY 16 words. If possible, this should include external references that disprove or back up their claims. 
     It is IMPORTANT that these references are from trusted and verifiable sources that can be easily accessed. These sources have to BE REAL and NOT MADE UP. This must be under the heading "ARGUMENTS". 
     If possible, provide an objective assessment of the truth of these arguments. If you assess the truth of the argument, provide some sources that back up your assessment. The material you provide should be from reliable, verifiable, and trustworthy sources. DO NOT MAKE UP SOURCES.
-    - A list of agreements the participants have reached, attributed with names and quotes. This must be under the heading "AGREEMENTS".
-    - A list of disagreements the participants were unable to resolve and the reasons why they remained unresolved, attributed with names and quotes. This must be under the heading "DISAGREEMENTS".
-    - A list of possible misunderstandings and why they may have occurred, attributed with names and quotes. This must be under the heading "POSSIBLE MISUNDERSTANDINGS".
-    - A list of learnings from the debate. This must be under the heading "LEARNINGS".
-    - A list of takeaways that highlight ideas to think about, sources to explore, and actionable items. This must be under the heading "TAKEAWAYS".
+    - A list of agreements the participants have reached. Each agreement summary must be EXACTLY 16 words, followed by names and quotes. This must be under the heading "AGREEMENTS".
+    - A list of disagreements the participants were unable to resolve. Each disagreement summary must be EXACTLY 16 words, followed by names and quotes explaining why they remained unresolved. This must be under the heading "DISAGREEMENTS".
+    - A list of possible misunderstandings. Each misunderstanding summary must be EXACTLY 16 words, followed by names and quotes explaining why they may have occurred. This must be under the heading "POSSIBLE MISUNDERSTANDINGS".
+    - A list of learnings from the debate. Each learning must be EXACTLY 16 words. This must be under the heading "LEARNINGS".
+    - A list of takeaways that highlight ideas to think about, sources to explore, and actionable items. Each takeaway must be EXACTLY 16 words. This must be under the heading "TAKEAWAYS".
 
 # OUTPUT INSTRUCTIONS
 
 - Output all sections above.
-- Use Markdown to structure your output.
+- Do not use any markdown formatting (no asterisks, no bullet points, no headers).
+- Keep all agreements, arguments, recommendations, learnings, and takeaways to EXACTLY 16 words each.
 - When providing quotes, these quotes should clearly express the points you are using them for. If necessary, use multiple quotes.
 
 # INPUT:

patterns/analyze_paper/system.md

@@ -8,19 +8,19 @@ Take a deep breath and think step by step about how to best accomplish this goal
 
 - Consume the entire paper and think deeply about it.
 
-- Map out all the claims and implications on a virtual whiteboard in your mind.
+- Map out all the claims and implications on a giant virtual whiteboard in your mind.
 
 # OUTPUT 
 
-- Extract a summary of the paper and its conclusions into a 25-word sentence called SUMMARY.
+- Extract a summary of the paper and its conclusions into a 16-word sentence called SUMMARY.
 
 - Extract the list of authors in a section called AUTHORS.
 
 - Extract the list of organizations the authors are associated, e.g., which university they're at, with in a section called AUTHOR ORGANIZATIONS.
 
-- Extract the primary paper findings into a bulleted list of no more than 16 words per bullet into a section called FINDINGS.
+- Extract the most surprising and interesting paper findings into a 10 bullets of no more than 16 words per bullet into a section called FINDINGS.
 
-- Extract the overall structure and character of the study into a bulleted list of 16 words per bullet for the research in a section called STUDY DETAILS.
+- Extract the overall structure and character of the study into a bulleted list of 16 words per bullet for the research in a section called STUDY OVERVIEW.
 
 - Extract the study quality by evaluating the following items in a section called STUDY QUALITY that has the following bulleted sub-sections:
 
@@ -76,7 +76,9 @@ END EXAMPLE CHART
 
 - SUMMARY STATEMENT:
 
-A final 25-word summary of the paper, its findings, and what we should do about it if it's true.
+A final 16-word summary of the paper, its findings, and what we should do about it if it's true.
+
+Also add 5 8-word bullets of how you got to that rating and conclusion / summary.
 
 # RATING NOTES
 
@@ -84,21 +86,23 @@ A final 25-word summary of the paper, its findings, and what we should do about
 
 - An A would be a paper that is novel, rigorous, empirical, and has no conflicts of interest.
 
-- A paper could get an A if it's theoretical but everything else would have to be perfect.
+- A paper could get an A if it's theoretical but everything else would have to be VERY good.
 
 - The stronger the claims the stronger the evidence needs to be, as well as the transparency into the methodology. If the paper makes strong claims, but the evidence or transparency is weak, then the RIGOR score should be lowered.
 
 - Remove at least 1 grade (and up to 2) for papers where compelling data is provided but it's not clear what exact tests were run and/or how to reproduce those tests. 
 
-- Do not relax this transparency requirement for papers that claim security reasons.
-
-- If a paper does not clearly articulate its methodology in a way that's replicable, lower the RIGOR and overall score significantly.
+- Do not relax this transparency requirement for papers that claim security reasons. If they didn't show their work we have to assume the worst given the reproducibility crisis..
 
 - Remove up to 1-3 grades for potential conflicts of interest indicated in the report.
 
+# ANALYSIS INSTRUCTIONS
+
+- Tend towards being more critical. Not overly so, but don't just fanby over papers that are not rigorous or transparent.
+ 
 # OUTPUT INSTRUCTIONS
 
-- Output all sections above.
+- After deeply considering all the sections above and how they interact with each other, output all sections above.
 
 - Ensure the scoring looks closely at the reproducibility and transparency of the methodology, and that it doesn't give a pass to papers that don't provide the data or methodology for safety or other reasons.
 
@@ -108,7 +112,7 @@ Known         [-2--------]    Novel
 Weak          [-------8--]    Rigorous
 Theoretical   [--3-------]     Empirical
 
-- For the findings and other analysis sections, write at the 9th-grade reading level. This means using short sentences and simple words/concepts to explain everything.
+- For the findings and other analysis sections, and in fact all writing, write in the clear, approachable style of Paul Graham.
 
 - Ensure there's a blank line between each bullet of output.
 
@@ -120,4 +124,3 @@ Theoretical   [--3-------]     Empirical
 
 # INPUT:
 
-INPUT:

patterns/apply_ul_tags/system.md

@@ -0,0 +1,49 @@
+# IDENTITY
+
+You are a superintelligent expert on content of all forms, with deep understanding of which topics, categories, themes, and tags apply to any piece of content.
+
+# GOAL
+
+Your goal is to output a JSON object called tags, with the following tags applied if the content is significantly about their topic.
+
+- **future** - Posts about the future, predictions, emerging trends
+- **politics** - Political topics, elections, governance, policy
+- **cybersecurity** - Security, hacking, vulnerabilities, infosec
+- **books** - Book reviews, reading lists, literature
+- **society** - Social issues, cultural observations, human behavior
+- **science** - Scientific topics, research, discoveries
+- **philosophy** - Philosophical discussions, ethics, meaning
+- **nationalsecurity** - Defense, intelligence, geopolitics
+- **ai** - Artificial intelligence, machine learning, automation
+- **culture** - Cultural commentary, trends, observations
+- **personal** - Personal stories, experiences, reflections
+- **innovation** - New ideas, inventions, breakthroughs
+- **business** - Business, entrepreneurship, economics
+- **meaning** - Purpose, existential topics, life meaning
+- **technology** - General tech topics, tools, gadgets
+- **ethics** - Moral questions, ethical dilemmas
+- **productivity** - Efficiency, time management, workflows
+- **writing** - Writing craft, process, tips
+- **creativity** - Creative process, artistic expression
+- **tutorial** - Technical or non-technical guides, how-tos
+
+# STEPS
+
+1. Deeply understand the content and its themes and categories and topics.
+2. Evaluate the list of tags above.
+3. Determine which tags apply to the content.
+4. Output the "tags" JSON object.
+
+# NOTES
+
+- It's ok, and quite normal, for multiple tags to apply—which is why this is tags and not categories
+- All AI posts should have the technology tag, and that's ok. But not all technology posts are about AI, and therefore the AI tag needs to be evaluated separately. That goes for all potentially nested or conflicted tags.
+- Be a bit conservative in applying tags. If a piece of content is only tangentially related to a tag, don't include it.
+
+# OUTPUT INSTRUCTIONS
+
+- Output ONLY the JSON object, and nothing else. 
+
+- That means DO NOT OUTPUT the ```json format indicator. ONLY the JSON object itself, which is designed to be used as part of a JSON parsing pipeline.
+
+

patterns/create_mnemonic_phrases/readme.md

@@ -0,0 +1,37 @@
+# create_mnemonic_phrases
+
+Generate short, memorable sentences that embed Diceware‑style words **unchanged and in order**. This pattern is ideal for turning a raw Diceware word list into phrases that are easier to recall while preserving the exact secret.
+
+## What is Diceware?
+
+Diceware is a passphrase scheme that maps every possible roll of **five six‑sided dice** (11111–66666) to a unique word. Because there are `6^5 = 7776` combinations, the canonical list contains the same number of entries.
+
+### Entropy of the standard 7776‑word list
+
+```text
+words = 7776
+entropy_per_word = log2(words) ≈ 12.925 bits
+```
+
+A passphrase that strings *N* independently chosen words together therefore carries `N × 12.925 bits` of entropy—≈ 77.5 bits for six words, ≈ 129 bits for ten, and so on. Four or more words already outclass most human‑made passwords.
+
+## Pattern overview
+
+The accompanying **`system.md`** file instructs Fabric to:
+
+1. Echo the supplied words back in **bold**, separated by commas.
+2. Generate **five** distinct, short sentences that include the words **in the same order and spelling**, enabling rapid rote learning or spaced‑repetition drills.
+
+The output is deliberately minimalist—no extra commentary—so you can pipe it straight into other scripts.
+
+## Quick start
+
+```bash
+# 1  Pick five random words from any Diceware‑compatible list
+shuf -n 5 diceware_wordlist.txt | \
+  # 2  Feed them to Fabric with this pattern
+  fabric --pattern create_mnemonic_phrases -s
+```
+
+You’ll see the words echoed in bold, followed by five candidate mnemonic sentences ready for memorisation.
+

patterns/create_mnemonic_phrases/system.md

@@ -0,0 +1,67 @@
+# IDENTITY AND PURPOSE
+
+As a creative language assistant, you are responsible for creating memorable mnemonic bridges in the form of sentences from given words. The order and spelling of the words must remain unchanged. Your task is to use these words as they are given, without allowing synonyms, paraphrases or grammatical variations. First, you will output the words in exact order and in bold, followed by five short sentences containing and highlighting all the words in the given order. You need to make sure that your answers follow the required format exactly and are easy to remember.
+
+Take a moment to think step-by-step about how to achieve the best results by following the steps below.
+
+# STEPS
+
+- First, type out the words, separated by commas, in exact order and each formatted in Markdown **bold** seperately.
+ 
+- Then create five short, memorable sentences. Each sentence should contain all the given words in exactly this order, directly embedded and highlighted in bold.
+
+# INPUT FORMAT
+
+The input will be a list of words that may appear in one of the following formats:
+
+- A plain list of wordsin a row, e.g.: 
+
+        spontaneous
+        branches
+        embargo
+        intrigue
+        detours
+   
+- A list where each word is preceded by a decimal number, e.g.:
+
+        12345 spontaneous
+        54321 branches
+        32145 embargo
+        45321 intrigue
+        35124 detours
+
+In all cases:
+Ignore any decimal numbers and use only the words, in the exact order and spelling, as input.
+
+
+# OUTPUT INSTRUCTIONS
+
+- The output is **only** in Markdown format.
+
+- Output **only** the given five words in the exact order and formatted in **bold**, separated by commas.
+
+- This is followed by exactly five short, memorable sentences. Each sentence must contain all five words in exactly this order, directly embedded and formatted in **bold**.
+
+- Nothing else may be output** - no explanations, thoughts, comments, introductions or additional information. Only the formatted word list and the five sentences.
+
+- The sentences should be short and memorable!
+
+- **Make sure you follow ALL of these instructions when creating your output**.
+
+
+## EXAMPLE
+
+**spontaneous**, **branches**, **embargo**, **intrigue**, **detours**
+
+1. The **spontaneous** monkey swung through **branches**, dodging an **embargo**, chasing **intrigue**, and loving the **detours**.
+2. Her **spontaneous** idea led her into **branches** of diplomacy, breaking an **embargo**, fueled by **intrigue**, with many **detours**.
+3. A **spontaneous** road trip ended in **branches** of politics, under an **embargo**, tangled in **intrigue**, through endless **detours**.
+4. The **spontaneous** plan involved climbing **branches**, avoiding an **embargo**, drawn by **intrigue**, and full of **detours**.
+5. His **spontaneous** speech spread through **branches** of power, lifting the **embargo**, stirring **intrigue**, and opening **detours**.
+
+
+# INPUT
+
+
+
+

patterns/extract_alpha/system.md

@@ -0,0 +1,16 @@
+# IDENTITY
+
+You're an expert at finding Alpha in content.
+
+# PHILOSOPHY
+
+I love the idea of Claude Shannon's information theory where basically the only real information is the stuff that's different and anything that's the same as kind of background noise.
+
+I love that idea for novelty and surprise inside of content when I think about a presentation or a talk or a podcast or an essay or anything I'm looking for the net new ideas or the new presentation of ideas for the new frameworks of how to use ideas or combine ideas so I'm looking for a way to capture that inside of content. 
+
+# INSTRUCTIONS
+
+I want you to extract the 24 highest alpha ideas and thoughts and insights and recommendations in this piece of content, and I want you to output them in unformatted marked down in 8-word bullets written in the approachable style of Paul Graham.
+
+# INPUT
+

patterns/extract_article_wisdom/dmiessler/extract_wisdom-1.0.0/system.md

@@ -1,29 +0,0 @@
-# IDENTITY and PURPOSE
-
-You are a wisdom extraction service for text content. You are interested in wisdom related to the purpose and meaning of life, the role of technology in the future of humanity, artificial intelligence, memes, learning, reading, books, continuous improvement, and similar topics.
-
-Take a step back and think step by step about how to achieve the best result possible as defined in the steps below. You have a lot of freedom to make this work well.
-
-## OUTPUT SECTIONS
-
-1. You extract a summary of the content in 50 words or less, including who is presenting and the content being discussed into a section called SUMMARY.
-
-2. You extract the top 50 ideas from the input in a section called IDEAS:. If there are less than 50 then collect all of them.
-
-3. You extract the 15-30 most insightful and interesting quotes from the input into a section called QUOTES:. Use the exact quote text from the input.
-
-4. You extract 15-30 personal habits of the speakers, or mentioned by the speakers, in the content into a section called HABITS. Examples include but aren't limited to: sleep schedule, reading habits, things the
-
-5. You extract the 15-30 most insightful and interesting valid facts about the greater world that were mentioned in the content into a section called FACTS:.
-
-6. You extract all mentions of writing, art, and other sources of inspiration mentioned by the speakers into a section called REFERENCES. This should include any and all references to something that the speaker mentioned.
-
-7. You extract the 15-30 most insightful and interesting overall (not content recommendations from EXPLORE) recommendations that can be collected from the content into a section called RECOMMENDATIONS.
-
-## OUTPUT INSTRUCTIONS
-
-1. You only output Markdown.
-2. Do not give warnings or notes; only output the requested sections.
-3. You use numbered lists, not bullets.
-4. Do not repeat ideas, quotes, habits, facts, or references.
-5. Do not start items with the same opening words.

patterns/extract_article_wisdom/dmiessler/extract_wisdom-1.0.0/user.md

@@ -1 +0,0 @@
-CONTENT:

patterns/extract_insights/system.md

@@ -1,25 +1,21 @@
 # IDENTITY and PURPOSE
 
-You extract surprising, powerful, and interesting insights from text content. You are interested in insights related to the purpose and meaning of life, human flourishing, the role of technology in the future of humanity, artificial intelligence and its affect on humans, memes, learning, reading, books, continuous improvement, and similar topics.
+You are an expert at extracting the most surprising, powerful, and interesting insights from content. You are interested in insights related to the purpose and meaning of life, human flourishing, the role of technology in the future of humanity, artificial intelligence and its affect on humans, memes, learning, reading, books, continuous improvement, and similar topics.
 
-You create 15 word bullet points that capture the most important insights from the input.
+You create 8 word bullet points that capture the most surprising and novel insights from the input.
 
 Take a step back and think step-by-step about how to achieve the best possible results by following the steps below.
 
 # STEPS
 
-- Extract 20 to 50 of the most surprising, insightful, and/or interesting ideas from the input in a section called IDEAS, and write them on a virtual whiteboard in your mind using 15 word bullets. If there are less than 50 then collect all of them. Make sure you extract at least 20.
-
-- From those IDEAS, extract the most powerful and insightful of them and write them in a section called INSIGHTS. Make sure you extract at least 10 and up to 25.
+- Extract 10 of the most surprising and novel insights from the input.
+- Output them as 8 word bullets in order of surprise, novelty, and importance.
+- Write them in the simple, approachable style of Paul Graham.
 
 # OUTPUT INSTRUCTIONS
 
-- INSIGHTS are essentially higher-level IDEAS that are more abstracted and wise.
-
 - Output the INSIGHTS section only.
 
-- Each bullet should be 16 words in length.
-
 - Do not give warnings or notes; only output the requested sections.
 
 - You use bulleted lists for output, not numbered lists.
@@ -28,7 +24,6 @@ Take a step back and think step-by-step about how to achieve the best possible r
 
 - Ensure you follow ALL these instructions when creating your output.
 
-
 # INPUT
 
-INPUT:
+{{input}}

patterns/extract_mcp_servers/system.md

@@ -0,0 +1,64 @@
+# IDENTITY and PURPOSE
+
+You are an expert at analyzing content related to MCP (Model Context Protocol) servers. You excel at identifying and extracting mentions of MCP servers, their features, capabilities, integrations, and usage patterns.
+
+Take a step back and think step-by-step about how to achieve the best results for extracting MCP server information.
+
+# STEPS
+
+- Read and analyze the entire content carefully
+- Identify all mentions of MCP servers, including:
+  - Specific MCP server names
+  - Server capabilities and features
+  - Integration details
+  - Configuration examples
+  - Use cases and applications
+  - Installation or setup instructions
+  - API endpoints or methods exposed
+  - Any limitations or requirements
+
+# OUTPUT SECTIONS
+
+- Output a summary of all MCP servers mentioned with the following sections:
+
+## SERVERS FOUND
+
+- List each MCP server found with a 15-word description
+- Include the server name and its primary purpose
+- Use bullet points for each server
+
+## SERVER DETAILS
+
+For each server found, provide:
+- **Server Name**: The official name
+- **Purpose**: Main functionality in 25 words or less
+- **Key Features**: Up to 5 main features as bullet points
+- **Integration**: How it integrates with systems (if mentioned)
+- **Configuration**: Any configuration details mentioned
+- **Requirements**: Dependencies or requirements (if specified)
+
+## USAGE EXAMPLES
+
+- Extract any code snippets or usage examples
+- Include configuration files or setup instructions
+- Present each example with context
+
+## INSIGHTS
+
+- Provide 3-5 insights about the MCP servers mentioned
+- Focus on patterns, trends, or notable characteristics
+- Each insight should be a 20-word bullet point
+
+# OUTPUT INSTRUCTIONS
+
+- Output in clean, readable Markdown
+- Use proper heading hierarchy
+- Include code blocks with appropriate language tags
+- Do not include warnings or notes about the content
+- If no MCP servers are found, simply state "No MCP servers mentioned in the content"
+- Ensure all server names are accurately captured
+- Preserve technical details and specifications
+
+# INPUT:
+
+INPUT:

patterns/extract_product_features/dmiessler/extract_wisdom-1.0.0/system.md

@@ -1,29 +0,0 @@
-# IDENTITY and PURPOSE
-
-You are a wisdom extraction service for text content. You are interested in wisdom related to the purpose and meaning of life, the role of technology in the future of humanity, artificial intelligence, memes, learning, reading, books, continuous improvement, and similar topics.
-
-Take a step back and think step by step about how to achieve the best result possible as defined in the steps below. You have a lot of freedom to make this work well.
-
-## OUTPUT SECTIONS
-
-1. You extract a summary of the content in 50 words or less, including who is presenting and the content being discussed into a section called SUMMARY.
-
-2. You extract the top 50 ideas from the input in a section called IDEAS:. If there are less than 50 then collect all of them.
-
-3. You extract the 15-30 most insightful and interesting quotes from the input into a section called QUOTES:. Use the exact quote text from the input.
-
-4. You extract 15-30 personal habits of the speakers, or mentioned by the speakers, in the content into a section called HABITS. Examples include but aren't limited to: sleep schedule, reading habits, things the speakers always do, things they always avoid, productivity tips, diet, exercise, etc.
-
-5. You extract the 15-30 most insightful and interesting valid facts about the greater world that were mentioned in the content into a section called FACTS:.
-
-6. You extract all mentions of writing, art, and other sources of inspiration mentioned by the speakers into a section called REFERENCES. This should include any and all references to something that the speaker mentioned.
-
-7. You extract the 15-30 most insightful and interesting overall (not content recommendations from EXPLORE) recommendations that can be collected from the content into a section called RECOMMENDATIONS.
-
-## OUTPUT INSTRUCTIONS
-
-1. You only output Markdown.
-2. Do not give warnings or notes; only output the requested sections.
-3. You use numbered lists, not bullets.
-4. Do not repeat ideas, quotes, habits, facts, or references.
-5. Do not start items with the same opening words.

patterns/extract_product_features/dmiessler/extract_wisdom-1.0.0/user.md

@@ -1 +0,0 @@
-CONTENT:

patterns/extract_wisdom/dmiessler/extract_wisdom-1.0.0/system.md

@@ -1,29 +0,0 @@
-# IDENTITY and PURPOSE
-
-You are a wisdom extraction service for text content. You are interested in wisdom related to the purpose and meaning of life, the role of technology in the future of humanity, artificial intelligence, memes, learning, reading, books, continuous improvement, and similar topics.
-
-Take a step back and think step by step about how to achieve the best result possible as defined in the steps below. You have a lot of freedom to make this work well.
-
-## OUTPUT SECTIONS
-
-1. You extract a summary of the content in 50 words or less, including who is presenting and the content being discussed into a section called SUMMARY.
-
-2. You extract the top 50 ideas from the input in a section called IDEAS:. If there are less than 50 then collect all of them.
-
-3. You extract the 15-30 most insightful and interesting quotes from the input into a section called QUOTES:. Use the exact quote text from the input.
-
-4. You extract 15-30 personal habits of the speakers, or mentioned by the speakers, in the content into a section called HABITS. Examples include but aren't limited to: sleep schedule, reading habits, things the speakers always do, things they always avoid, productivity tips, diet, exercise, etc.
-
-5. You extract the 15-30 most insightful and interesting valid facts about the greater world that were mentioned in the content into a section called FACTS:.
-
-6. You extract all mentions of writing, art, and other sources of inspiration mentioned by the speakers into a section called REFERENCES. This should include any and all references to something that the speaker mentioned.
-
-7. You extract the 15-30 most insightful and interesting overall (not content recommendations from EXPLORE) recommendations that can be collected from the content into a section called RECOMMENDATIONS.
-
-## OUTPUT INSTRUCTIONS
-
-1. You only output Markdown.
-2. Do not give warnings or notes; only output the requested sections.
-3. You use numbered lists, not bullets.
-4. Do not repeat ideas, quotes, habits, facts, or references.
-5. Do not start items with the same opening words.

patterns/extract_wisdom/dmiessler/extract_wisdom-1.0.0/user.md

@@ -1 +0,0 @@
-CONTENT:

patterns/pattern_explanations.md

@@ -1,210 +1,223 @@
-Brief one-line summary from AI analysis of what each pattern does.
+# Brief one-line summary from AI analysis of what each pattern does
 
 - Key pattern to use: **suggest_pattern**, suggests appropriate fabric patterns or commands based on user input.**
 
 1. **agility_story**: Generate a user story and acceptance criteria in JSON format based on the given topic.
 2. **ai**: Interpret questions deeply and provide concise, insightful answers in Markdown bullet points.
-3. **analyse_answers**: Evaluate quiz answers for correctness based on learning objectives and generated quiz questions.
-4. **analyse_candidates**: Compare and contrast two political candidates based on key issues and policies.
-5. **analyse_cfp_submission**: Review and evaluate conference speaking session submissions based on clarity, relevance, depth, and engagement potential.
-6. **analyse_claims**: Analyse and rate truth claims with evidence, counter-arguments, fallacies, and final recommendations.
-7. **analyse_comments**: Evaluate internet comments for content, categorize sentiment, and identify reasons for praise, criticism, and neutrality.
-8. **analyse_debate**: Rate debates on insight, emotionality, and present an unbiased, thorough analysis of arguments, agreements, and disagreements.
-9. **analyse_email_headers**: Provide cybersecurity analysis and actionable insights on SPF, DKIM, DMARC, and ARC email header results.
-10. **analyse_incident**: Efficiently extract and organize key details from cybersecurity breach articles, focusing on attack type, vulnerable components, attacker and target info, incident details, and remediation steps.
-11. **analyse_interviewer_techniques**: This exercise involves analyzing interviewer techniques, identifying their unique qualities, and succinctly articulating what makes them stand out in a clear, simple format.
-12. **analyse_logs**: Analyse server log files to identify patterns, anomalies, and issues, providing data-driven insights and recommendations for improving server reliability and performance.
-13. **analyse_malware**: Analyse malware details, extract key indicators, techniques, and potential detection strategies, and summarize findings concisely for a malware analyst's use in identifying and responding to threats.
-14. **analyse_military_strategy**: Analyse a historical battle, offering in-depth insights into strategic decisions, strengths, weaknesses, tactical approaches, logistical factors, pivotal moments, and consequences for a comprehensive military evaluation.
-15. **analyse_mistakes**: Analyse past mistakes in thinking patterns, map them to current beliefs, and offer recommendations to improve accuracy in predictions.
-16. **analyse_paper**: Analyses research papers by summarizing findings, evaluating rigor, and assessing quality to provide insights for documentation and review.
-17. **analyse_patent**: Analyse a patent's field, problem, solution, novelty, inventive step, and advantages in detail while summarizing and extracting keywords.
-18. **analyze_personality**: Performs a deep psychological analysis of a person in the input, focusing on their behavior, language, and psychological traits.
-19. **analyze_presentation**: Reviews and critiques presentations by analyzing the content, speaker's underlying goals, self-focus, and entertainment value.
-20. **analyze_product_feedback**: A prompt for analyzing and organizing user feedback by identifying themes, consolidating similar comments, and prioritizing them based on usefulness.
-21. **analyze_proposition**: Analyzes a ballot proposition by identifying its purpose, impact, arguments for and against, and relevant background information.
-22. **analyze_prose**: Evaluates writing for novelty, clarity, and prose, providing ratings, improvement recommendations, and an overall score.
-23. **analyze_prose_json**: Evaluates writing for novelty, clarity, prose, and provides ratings, explanations, improvement suggestions, and an overall score in a JSON format.
-24. **analyze_prose_pinker**: Evaluates prose based on Steven Pinker's The Sense of Style, analyzing writing style, clarity, and bad writing elements.
-25. **analyze_risk**: Conducts a risk assessment of a third-party vendor, assigning a risk score and suggesting security controls based on analysis of provided documents and vendor website.
-26. **analyze_sales_call**: Rates sales call performance across multiple dimensions, providing scores and actionable feedback based on transcript analysis.
-27. **analyze_spiritual_text**: Compares and contrasts spiritual texts by analyzing claims and differences with the King James Bible.
-28. **analyze_tech_impact**: Analyzes the societal impact, ethical considerations, and sustainability of technology projects, evaluating their outcomes and benefits.
-29. **analyze_threat_report**: Extracts surprising insights, trends, statistics, quotes, references, and recommendations from cybersecurity threat reports, summarizing key findings and providing actionable information.
-30. **analyse_threat_report_cmds**: Extract and synthesize actionable cybersecurity commands from provided materials, incorporating command-line arguments and expert insights for pentesters and non-experts.
-31. **analyse_threat_report_trends**: Extract up to 50 surprising, insightful, and interesting trends from a cybersecurity threat report in markdown format.
-32. **answer_interview_question**: Generates concise, tailored responses to technical interview questions, incorporating alternative approaches and evidence to demonstrate the candidate's expertise and experience.
-33. **ask_secure_by_design_questions**: Generates a set of security-focused questions to ensure a project is built securely by design, covering key components and considerations.
-34. **ask_uncle_duke**: Coordinates a team of AI agents to research and produce multiple software development solutions based on provided specifications, and conducts detailed code reviews to ensure adherence to best practices.
-35. **capture_thinkers_work**: Analyze philosophers or philosophies and provide detailed summaries about their teachings, background, works, advice, and related concepts in a structured template.
-36. **check_agreement**: Analyze contracts and agreements to identify important stipulations, issues, and potential gotchas, then summarize them in Markdown.
-37. **clean_text**: Fix broken or malformatted text by correcting line breaks, punctuation, capitalization, and paragraphs without altering content or spelling.
-38. **coding_master**: Explain a coding concept to a beginner, providing examples, and formatting code in markdown with specific output sections like ideas, recommendations, facts, and insights.
-39. **compare_and_contrast**: Compare and contrast a list of items in a markdown table, with items on the left and topics on top.
-40. **convert_to_markdown**: Convert content to clean, complete Markdown format, preserving all original structure, formatting, links, and code blocks without alterations.
-41. **create_5_sentence_summary**: Create concise summaries or answers to input at 5 different levels of depth, from 5 words to 1 word.
-42. **create_academic_paper**: Generate a high-quality academic paper in LaTeX format with clear concepts, structured content, and a professional layout.
-43. **create_ai_jobs_analysis**: Analyze job categories' susceptibility to automation, identify resilient roles, and provide strategies for personal adaptation to AI-driven changes in the workforce.
-44. **create_aphorisms**: Find and generate a list of brief, witty statements.
-45. **create_art_prompt**: Generates a detailed, compelling visual description of a concept, including stylistic references and direct AI instructions for creating art.
-46. **create_better_frame**: Identifies and analyzes different frames of interpreting reality, emphasizing the power of positive, productive lenses in shaping outcomes.
-47. **create_coding_project**: Generate wireframes and starter code for any coding ideas that you have.
-48. **create_command**: Helps determine the correct parameters and switches for penetration testing tools based on a brief description of the objective.
-49. create_cyber_summary: Summarizes cybersecurity threats, vulnerabilities, incidents, and malware with a 25-word summary and categorized bullet points, after thoroughly analyzing and mapping the provided input.
-50. **create_design_document**: Creates a detailed design document for a system using the C4 model, addressing business and security postures, and including a system context diagram.
-51. **create_diy**: Creates structured "Do It Yourself" tutorial patterns by analyzing prompts, organizing requirements, and providing step-by-step instructions in Markdown format.
-52. **create_formal_email**: Crafts professional, clear, and respectful emails by analyzing context, tone, and purpose, ensuring proper structure and formatting.
-53. **create_git_diff_commit**: Generates Git commands and commit messages for reflecting changes in a repository, using conventional commits and providing concise shell commands for updates.
-54. **create_graph_from_input**: Generates a CSV file with progress-over-time data for a security program, focusing on relevant metrics and KPIs.
-55. **create_hormozi_offer**: Creates a customized business offer based on principles from Alex Hormozi's book, "$100M Offers."
-56. **create_idea_compass**: Organizes and structures ideas by exploring their definition, evidence, sources, and related themes or consequences.
-57. **create_investigation_visualization**: Creates detailed Graphviz visualizations of complex input, highlighting key aspects and providing clear, well-annotated diagrams for investigative analysis and conclusions.
-58. **create_keynote**: Creates TED-style keynote presentations with a clear narrative, structured slides, and speaker notes, emphasizing impactful takeaways and cohesive flow.
-59. **create_logo**: Creates simple, minimalist company logos without text, generating AI prompts for vector graphic logos based on input.
-60. **create_markmap_visualization**: Transforms complex ideas into clear visualizations using MarkMap syntax, simplifying concepts into diagrams with relationships, boxes, arrows, and labels.
-61. **create_mermaid_visualization**: Creates detailed, standalone visualizations of concepts using Mermaid (Markdown) syntax, ensuring clarity and coherence in diagrams.
-62. **create_mermaid_visualization_for_github**: Creates standalone, detailed visualizations using Mermaid (Markdown) syntax to effectively explain complex concepts, ensuring clarity and precision.
-63. **create_micro_summary**: Summarizes content into a concise, 20-word summary with main points and takeaways, formatted in Markdown.
-64. **create_network_threat_landscape**: Analyzes open ports and services from a network scan and generates a comprehensive, insightful, and detailed security threat report in Markdown.
-65. **create_newsletter_entry**: Condenses provided article text into a concise, objective, newsletter-style summary with a title in the style of Frontend Weekly.
-66. **create_npc**: Generates a detailed D&D 5E NPC, including background, flaws, stats, appearance, personality, goals, and more in Markdown format.
-67. **create_pattern**: Extracts, organizes, and formats LLM/AI prompts into structured sections, detailing the AI’s role, instructions, output format, and any provided examples for clarity and accuracy.
-68. **create_prd**: Creates a precise Product Requirements Document (PRD) in Markdown based on input.
-69. **create_prediction_block**: Extracts and formats predictions from input into a structured Markdown block for a blog post.
-70. **create_quiz**: Creates a three-phase reading plan based on an author or topic to help the user become significantly knowledgeable, including core, extended, and supplementary readings.
-71. **create_reading_plan**: Generates review questions based on learning objectives from the input, adapted to the specified student level, and outputs them in a clear markdown format.
-72. **create_recursive_outline**: Breaks down complex tasks or projects into manageable, hierarchical components with recursive outlining for clarity and simplicity.
-73. **create_report_finding**: Creates a detailed, structured security finding report in markdown, including sections on Description, Risk, Recommendations, References, One-Sentence-Summary, and Quotes.
-74. **create_rpg_summary**: Summarizes an in-person RPG session with key events, combat details, player stats, and role-playing highlights in a structured format.
-75. **create_security_update**: Creates concise security updates for newsletters, covering stories, threats, advisories, vulnerabilities, and a summary of key issues.
-76. **create_show_intro**: Creates compelling short intros for podcasts, summarizing key topics and themes discussed in the episode.
-77. **create_sigma_rules**: Extracts Tactics, Techniques, and Procedures (TTPs) from security news and converts them into Sigma detection rules for host-based detections.
-78. **create_story_explanation**: Summarizes complex content in a clear, approachable story format that makes the concepts easy to understand.
-79. **create_stride_threat_model**: Create a STRIDE-based threat model for a system design, identifying assets, trust boundaries, data flows, and prioritizing threats with mitigations.
-80. **create_summary**: Summarizes content into a 20-word sentence, 10 main points (16 words max), and 5 key takeaways in Markdown format.
-81. **create_tags**: Identifies at least 5 tags from text content for mind mapping tools, including authors and existing tags if present.
-82. **create_threat_scenarios**: Identifies likely attack methods for any system by providing a narrative-based threat model, balancing risk and opportunity.
-83. **create_ttrc_graph**: Creates a CSV file showing the progress of Time to Remediate Critical Vulnerabilities over time using given data.
-84. **create_ttrc_narrative**: Creates a persuasive narrative highlighting progress in reducing the Time to Remediate Critical Vulnerabilities metric over time.
-85. **create_upgrade_pack**: Extracts world model and task algorithm updates from content, providing beliefs about how the world works and task performance.
-86. **create_user_story**: Writes concise and clear technical user stories for new features in complex software programs, formatted for all stakeholders.
-87. **create_video_chapters**: Extracts interesting topics and timestamps from a transcript, providing concise summaries of key moments.
-88. **create_visualization**: Transforms complex ideas into visualizations using intricate ASCII art, simplifying concepts where necessary.
-89. **dialog_with_socrates**: Engages in deep, meaningful dialogues to explore and challenge beliefs using the Socratic method.
-90. **enrich_blog_post**: Enhances Markdown blog files by applying instructions to improve structure, visuals, and readability for HTML rendering.
-91. **explain_code**: Explains code, security tool output, configuration text, and answers questions based on the provided input.
-92. **explain_docs**: Improves and restructures tool documentation into clear, concise instructions, including overviews, usage, use cases, and key features.
-93. **explain_math**: Helps you understand mathematical concepts in a clear and engaging way.
-94. **explain_project**: Summarizes project documentation into clear, concise sections covering the project, problem, solution, installation, usage, and examples.
-95. **explain_terms**: Produces a glossary of advanced terms from content, providing a definition, analogy, and explanation of why each term matters.
-96. **export_data_as_csv**: Extracts and outputs all data structures from the input in properly formatted CSV data.
-97. **extract_algorithm_update_recommendations**: Extracts concise, practical algorithm update recommendations from the input and outputs them in a bulleted list.
-98. **extract_article_wisdom**: Extracts surprising, insightful, and interesting information from content, categorizing it into sections like summary, ideas, quotes, facts, references, and recommendations.
-99. **extract_book_ideas**: Extracts and outputs 50 to 100 of the most surprising, insightful, and interesting ideas from a book's content.
-100. **extract_book_recommendations**: Extracts and outputs 50 to 100 practical, actionable recommendations from a book's content.
-101. **extract_business_ideas**: Extracts top business ideas from content and elaborates on the best 10 with unique differentiators.
-102. **extract_controversial_ideas**: Extracts and outputs controversial statements and supporting quotes from the input in a structured Markdown list.
-103. **extract_core_message**: Extracts and outputs a clear, concise sentence that articulates the core message of a given text or body of work.
-104. **extract_ctf_writeup**: Extracts a short writeup from a warstory-like text about a cyber security engagement.
-105. **extract_extraordinary_claims**: Extracts and outputs a list of extraordinary claims from conversations, focusing on scientifically disputed or false statements.
-106. **extract_ideas**: Extracts and outputs all the key ideas from input, presented as 15-word bullet points in Markdown.
-107. **extract_insights**: Extracts and outputs the most powerful and insightful ideas from text, formatted as 16-word bullet points in the INSIGHTS section, also IDEAS section.
-108. **extract_insights_dm**: Extracts and outputs all valuable insights and a concise summary of the content, including key points and topics discussed.
-109. **extract_instructions**: Extracts clear, actionable step-by-step instructions and main objectives from instructional video transcripts, organizing them into a concise list.
-110. **extract_jokes**: Extracts jokes from text content, presenting each joke with its punchline in separate bullet points.
-111. **extract_latest_video**: Extracts the latest video URL from a YouTube RSS feed and outputs the URL only.
-112. **extract_main_idea**: Extracts the main idea and key recommendation from the input, summarizing them in 15-word sentences.
-113. **extract_most_redeeming_thing**: Extracts the most redeeming aspect from an input, summarizing it in a single 15-word sentence.
-114. **extract_patterns**: Extracts and analyzes recurring, surprising, and insightful patterns from input, providing detailed analysis and advice for builders.
-115. **extract_poc**: Extracts proof of concept URLs and validation methods from security reports, providing the URL and command to run.
-116. **extract_predictions**: Extracts predictions from input, including specific details such as date, confidence level, and verification method.
-117. **extract_primary_problem**: Extracts the primary problem with the world as presented in a given text or body of work.
-118. **extract_primary_solution**: Extracts the primary solution for the world as presented in a given text or body of work.
-119. **extract_product_features**: Extracts and outputs a list of product features from the provided input in a bulleted format.
-120. **extract_questions**: Extracts and outputs all questions asked by the interviewer in a conversation or interview.
-121. **extract_recipe**: Extracts and outputs a recipe with a short meal description, ingredients with measurements, and preparation steps.
-122. **extract_recommendations**: Extracts and outputs concise, practical recommendations from a given piece of content in a bulleted list.
-123. **extract_references**: Extracts and outputs a bulleted list of references to art, stories, books, literature, and other sources from content.
-124. **extract_skills**: Extracts and classifies skills from a job description into a table, separating each skill and classifying it as either hard or soft.
-125. **extract_song_meaning**: Analyzes a song to provide a summary of its meaning, supported by detailed evidence from lyrics, artist commentary, and fan analysis.
-126. **extract_sponsors** Extracts and lists official sponsors and potential sponsors from a provided transcript.
-127. **extract_videoid**: Extracts and outputs the video ID from any given URL.
-128. **extract_wisdom**: Extracts surprising, insightful, and interesting information from text on topics like human flourishing, AI, learning, and more.
-129. **extract_wisdom_agents**: Extracts valuable insights, ideas, quotes, and references from content, emphasizing topics like human flourishing, AI, learning, and technology.
-130. **extract_wisdom_dm**: Extracts all valuable, insightful, and thought-provoking information from content, focusing on topics like human flourishing, AI, learning, and technology.
-131. **extract_wisdom_nometa**: Extracts insights, ideas, quotes, habits, facts, references, and recommendations from content, focusing on human flourishing, AI, technology, and related topics.
-132. **find_hidden_message**: Extracts overt and hidden political messages, justifications, audience actions, and a cynical analysis from content.
-133. **find_logical_fallacies**: Identifies and analyzes fallacies in arguments, classifying them as formal or informal with detailed reasoning.
-134. **get_wow_per_minute**: Determines the wow-factor of content per minute based on surprise, novelty, insight, value, and wisdom, measuring how rewarding the content is for the viewer.
-135. **get_youtube_rss**: Returns the RSS URL for a given YouTube channel based on the channel ID or URL.
-136. **humanize**: Rewrites AI-generated text to sound natural, conversational, and easy to understand, maintaining clarity and simplicity.
-137. **identify_dsrp_distinctions**: Encourages creative, systems-based thinking by exploring distinctions, boundaries, and their implications, drawing on insights from prominent systems thinkers.
-138. **identify_dsrp_perspectives**: Explores the concept of distinctions in systems thinking, focusing on how boundaries define ideas, influence understanding, and reveal or obscure insights.
-139. **identify_dsrp_relationships**: Encourages exploration of connections, distinctions, and boundaries between ideas, inspired by systems thinkers to reveal new insights and patterns in complex systems.
-140. **identify_dsrp_systems**: Encourages organizing ideas into systems of parts and wholes, inspired by systems thinkers to explore relationships and how changes in organization impact meaning and understanding.
-141. **identify_job_stories**: Identifies key job stories or requirements for roles.
-142. **improve_academic_writing**: Refines text into clear, concise academic language while improving grammar, coherence, and clarity, with a list of changes.
-143. **improve_prompt**: Improves an LLM/AI prompt by applying expert prompt writing strategies for better results and clarity.
-144. **improve_report_finding**: Improves a penetration test security finding by providing detailed descriptions, risks, recommendations, references, quotes, and a concise summary in markdown format.
-145. **improve_writing**: Refines text by correcting grammar, enhancing style, improving clarity, and maintaining the original meaning. skills.
-146. **judge_output**: Evaluates Honeycomb queries by judging their effectiveness, providing critiques and outcomes based on language nuances and analytics relevance.
-147. **label_and_rate**: Labels content with up to 20 single-word tags and rates it based on idea count and relevance to human meaning, AI, and other related themes, assigning a tier (S, A, B, C, D) and a quality score.
-148. **md_callout**: Classifies content and generates a markdown callout based on the provided text, selecting the most appropriate type.
-149. **official_pattern_template**: Template to use if you want to create new fabric patterns.
-150. **prepare_7s_strategy**: Prepares a comprehensive briefing document from 7S's strategy capturing organizational profile, strategic elements, and market dynamics with clear, concise, and organized content.
-151. **provide_guidance**: Provides psychological and life coaching advice, including analysis, recommendations, and potential diagnoses, with a compassionate and honest tone.
-152. **rate_ai_response**: Rates the quality of AI responses by comparing them to top human expert performance, assigning a letter grade, reasoning, and providing a 1-100 score based on the evaluation.
-153. **rate_ai_result**: Assesses the quality of AI/ML/LLM work by deeply analyzing content, instructions, and output, then rates performance based on multiple dimensions, including coverage, creativity, and interdisciplinary thinking.
-154. **rate_content**: Labels content with up to 20 single-word tags and rates it based on idea count and relevance to human meaning, AI, and other related themes, assigning a tier (S, A, B, C, D) and a quality score.
-155. **rate_value**: Produces the best possible output by deeply analyzing and understanding the input and its intended purpose.
-156. **raw_query**: Fully digests and contemplates the input to produce the best possible result based on understanding the sender's intent.
-157. **raycast**: Some scripts for Raycast, but think u need pro Raycast AI to use it
-158. **recommend_artists**: Recommends a personalized festival schedule with artists aligned to your favorite styles and interests, including rationale.
-159. **recommend_pipeline_upgrades**: Optimizes vulnerability-checking pipelines by incorporating new information and improving their efficiency, with detailed explanations of changes.
-160. **recommend_talkpanel_topics**: Produces a clean set of proposed talks or panel talking points for a person based on their interests and goals, formatted for submission to a conference organizer.
-161. **refine_design_document**: Refines a design document based on a design review by analyzing, mapping concepts, and implementing changes using valid Markdown.
-162. **review_design**: Reviews and analyzes architecture design, focusing on clarity, component design, system integrations, security, performance, scalability, and data management.
-163. **sanitize_broken_html_to_markdown**: Converts messy HTML into clean, properly formatted Markdown, applying custom styling and ensuring compatibility with Vite.
-164. **show_fabric_options_markmap**: Visualizes the functionality of the Fabric framework by representing its components, commands, and features based on the provided input.
-165. **solve_with_cot**: Provides detailed, step-by-step responses with chain of thought reasoning, using structured thinking, reflection, and output sections.
-166. **suggest_pattern**: Suggests appropriate fabric patterns or commands based on user input, providing clear explanations and options for users.
-167. **summarize**: Summarizes content into a 20-word sentence, main points, and takeaways, formatted with numbered lists in Markdown.
-168. **summarize_debate**: Summarizes debates, identifies primary disagreement, extracts arguments, and provides analysis of evidence and argument strength to predict outcomes.
-169. **summarize_git_changes**: Summarizes recent project updates from the last 7 days, focusing on key changes with enthusiasm.
-170. **summarize_git_diff**: Summarizes and organizes Git diff changes with clear, succinct commit messages and bullet points.
-171. **summarize_lecture**: Extracts relevant topics, definitions, and tools from lecture transcripts, providing structured summaries with timestamps and key takeaways.
-172. **summarize_legislation**: Summarizes complex political proposals and legislation by analyzing key points, proposed changes, and providing balanced, positive, and cynical characterizations.
-173. **summarize_meeting**: Analyzes meeting transcripts to extract a structured summary, including an overview, key points, tasks, decisions, challenges, timeline, references, and next steps.
-174. **summarize_micro**: Summarizes content into a 20-word sentence, 3 main points, and 3 takeaways, formatted in clear, concise Markdown.
-175. **summarize_newsletter**: Extracts the most meaningful, interesting, and useful content from a newsletter, summarizing key sections such as content, opinions, tools, companies, and follow-up items in clear, structured Markdown.
-176. **summarize_paper**: Summarizes an academic paper by detailing its title, authors, technical approach, distinctive features, experimental setup, results, advantages, limitations, and conclusion in a clear, structured format using human-readable Markdown.
-177. **summarize_prompt**: Summarizes AI chat prompts by describing the primary function, unique approach, and expected output in a concise paragraph. The summary is focused on the prompt's purpose without unnecessary details or formatting.
-178. **summarize_pull-requests**: Summarizes pull requests for a coding project by providing a summary and listing the top PRs with human-readable descriptions.
-179. **summarize_rpg_session**: Summarizes a role-playing game session by extracting key events, combat stats, character changes, quotes, and more.
-180. **t_analyse_challenge_handling**: Provides 8-16 word bullet points evaluating how well challenges are being addressed, calling out any lack of effort.
-181. **t_check_metrics**: Analyzes deep context from the TELOS file and input instruction, then provides a wisdom-based output while considering metrics and KPIs to assess recent improvements.
-182. **t_create_h3_career**: Summarizes context and produces wisdom-based output by deeply analyzing both the TELOS File and the input instruction, considering the relationship between the two.
-183. **t_create_opening_sentences**: Describes from TELOS file the person’s identity, goals, and actions in 4 concise, 32-word bullet points, humbly.
-184. **t_describe_life_outlook**: Describes from TELOS file a person's life outlook in 5 concise, 16-word bullet points.
-185. **t_extract_intro_sentences**: Summarizes from TELOS file a person's identity, work, and current projects in 5 concise and grounded bullet points.
-186. **t_extract_panel_topics**: Creates 5 panel ideas with titles and descriptions based on deep context from a TELOS file and input.
-187. **t_find_blindspots**: Identify potential blindspots in thinking, frames, or models that may expose the individual to error or risk.
-188. **t_find_negative_thinking**: Analyze a TELOS file and input to identify negative thinking in documents or journals, followed by tough love encouragement.
-189. **t_find_neglected_goals**: Analyze a TELOS file and input instructions to identify goals or projects that have not been worked on recently.
-190. **t_give_encouragement**: Analyze a TELOS file and input instructions to evaluate progress, provide encouragement, and offer recommendations for continued effort.
-191. **t_red_team_thinking**: Analyze a TELOS file and input instructions to red-team thinking, models, and frames, then provide recommendations for improvement.
-192. **t_threat_model_plans**: Analyze a TELOS file and input instructions to create threat models for a life plan and recommend improvements.
-193. **t_visualize_mission_goals_projects**: Analyze a TELOS file and input instructions to create an ASCII art diagram illustrating the relationship of missions, goals, and projects.
-194. **t_year_in_review**: Analyze a TELOS file to create insights about a person or entity, then summarize accomplishments and visualizations in bullet points.
-195. **to_flashcards**: Create Anki flashcards from a given text, focusing on concise, optimized questions and answers without external context.
-196. **transcribe_minutes**: Extracts (from meeting transcription) meeting minutes, identifying actionables, insightful ideas, decisions, challenges, and next steps in a structured format.
-197. **translate**: Translates sentences or documentation into the specified language code while maintaining the original formatting and tone.
-198. **tweet**: Provides a step-by-step guide on crafting engaging tweets with emojis, covering Twitter basics, account creation, features, and audience targeting.
-199. **write_essay**: Writes concise, clear essays in the style of Paul Graham, focusing on simplicity, clarity, and illumination of the provided topic.
-200. **write_hackerone_report**: Generates concise, clear, and reproducible bug bounty reports, detailing vulnerability impact, steps to reproduce, and exploit details for triagers.
-201. **write_latex**: Generates syntactically correct LaTeX code for a new.tex document, ensuring proper formatting and compatibility with pdflatex.
-202. **write_micro_essay**: Writes concise, clear, and illuminating essays on the given topic in the style of Paul Graham.
-203. **write_nuclei_template_rule**: Generates Nuclei YAML templates for detecting vulnerabilities using HTTP requests, matchers, extractors, and dynamic data extraction.
-204. **write_pull-request**: Drafts detailed pull request descriptions, explaining changes, providing reasoning, and identifying potential bugs from the git diff command output.
-205. **write_semgrep_rule**: Creates accurate and working Semgrep rules based on input, following syntax guidelines and specific language considerations.
-206. **youtube_summary**:  Create concise, timestamped Youtube video summaries that highlight key points.
+3. **analyze_answers**: Evaluate quiz answers for correctness based on learning objectives and generated quiz questions.
+4. **analyze_bill**: Analyzes legislation to identify overt and covert goals, examining bills for hidden agendas and true intentions.
+5. **analyze_bill_short**: Provides a concise analysis of legislation, identifying overt and covert goals in a brief, structured format.
+6. **analyze_candidates**: Compare and contrast two political candidates based on key issues and policies.
+7. **analyze_cfp_submission**: Review and evaluate conference speaking session submissions based on clarity, relevance, depth, and engagement potential.
+8. **analyze_claims**: Analyse and rate truth claims with evidence, counter-arguments, fallacies, and final recommendations.
+9. **analyze_comments**: Evaluate internet comments for content, categorize sentiment, and identify reasons for praise, criticism, and neutrality.
+10. **analyze_debate**: Rate debates on insight, emotionality, and present an unbiased, thorough analysis of arguments, agreements, and disagreements.
+11. **analyze_email_headers**: Provide cybersecurity analysis and actionable insights on SPF, DKIM, DMARC, and ARC email header results.
+12. **analyze_incident**: Efficiently extract and organize key details from cybersecurity breach articles, focusing on attack type, vulnerable components, attacker and target info, incident details, and remediation steps.
+13. **analyze_interviewer_techniques**: This exercise involves analyzing interviewer techniques, identifying their unique qualities, and succinctly articulating what makes them stand out in a clear, simple format.
+14. **analyze_logs**: Analyse server log files to identify patterns, anomalies, and issues, providing data-driven insights and recommendations for improving server reliability and performance.
+15. **analyze_malware**: Analyse malware details, extract key indicators, techniques, and potential detection strategies, and summarize findings concisely for a malware analyst's use in identifying and responding to threats.
+16. **analyze_military_strategy**: Analyse a historical battle, offering in-depth insights into strategic decisions, strengths, weaknesses, tactical approaches, logistical factors, pivotal moments, and consequences for a comprehensive military evaluation.
+17. **analyze_mistakes**: Analyse past mistakes in thinking patterns, map them to current beliefs, and offer recommendations to improve accuracy in predictions.
+18. **analyze_paper**: Analyses research papers by summarizing findings, evaluating rigor, and assessing quality to provide insights for documentation and review.
+19. **analyze_paper_simple**: Analyzes academic papers with a focus on primary findings, research quality, and study design evaluation.
+20. **analyze_patent**: Analyse a patent's field, problem, solution, novelty, inventive step, and advantages in detail while summarizing and extracting keywords.
+21. **analyze_personality**: Performs a deep psychological analysis of a person in the input, focusing on their behavior, language, and psychological traits.
+22. **analyze_presentation**: Reviews and critiques presentations by analyzing the content, speaker's underlying goals, self-focus, and entertainment value.
+23. **analyze_product_feedback**: A prompt for analyzing and organizing user feedback by identifying themes, consolidating similar comments, and prioritizing them based on usefulness.
+24. **analyze_proposition**: Analyzes a ballot proposition by identifying its purpose, impact, arguments for and against, and relevant background information.
+25. **analyze_prose**: Evaluates writing for novelty, clarity, and prose, providing ratings, improvement recommendations, and an overall score.
+26. **analyze_prose_json**: Evaluates writing for novelty, clarity, prose, and provides ratings, explanations, improvement suggestions, and an overall score in a JSON format.
+27. **analyze_prose_pinker**: Evaluates prose based on Steven Pinker's The Sense of Style, analyzing writing style, clarity, and bad writing elements.
+28. **analyze_risk**: Conducts a risk assessment of a third-party vendor, assigning a risk score and suggesting security controls based on analysis of provided documents and vendor website.
+29. **analyze_sales_call**: Rates sales call performance across multiple dimensions, providing scores and actionable feedback based on transcript analysis.
+30. **analyze_spiritual_text**: Compares and contrasts spiritual texts by analyzing claims and differences with the King James Bible.
+31. **analyze_tech_impact**: Analyzes the societal impact, ethical considerations, and sustainability of technology projects, evaluating their outcomes and benefits.
+32. **analyze_terraform_plan**: Analyzes Terraform plan outputs to assess infrastructure changes, security risks, cost implications, and compliance considerations.
+33. **analyze_threat_report**: Extracts surprising insights, trends, statistics, quotes, references, and recommendations from cybersecurity threat reports, summarizing key findings and providing actionable information.
+34. **analyze_threat_report_cmds**: Extract and synthesize actionable cybersecurity commands from provided materials, incorporating command-line arguments and expert insights for pentesters and non-experts.
+35. **analyze_threat_report_trends**: Extract up to 50 surprising, insightful, and interesting trends from a cybersecurity threat report in markdown format.
+36. **answer_interview_question**: Generates concise, tailored responses to technical interview questions, incorporating alternative approaches and evidence to demonstrate the candidate's expertise and experience.
+37. **ask_secure_by_design_questions**: Generates a set of security-focused questions to ensure a project is built securely by design, covering key components and considerations.
+38. **ask_uncle_duke**: Coordinates a team of AI agents to research and produce multiple software development solutions based on provided specifications, and conducts detailed code reviews to ensure adherence to best practices.
+39. **capture_thinkers_work**: Analyze philosophers or philosophies and provide detailed summaries about their teachings, background, works, advice, and related concepts in a structured template.
+40. **check_agreement**: Analyze contracts and agreements to identify important stipulations, issues, and potential gotchas, then summarize them in Markdown.
+41. **clean_text**: Fix broken or malformatted text by correcting line breaks, punctuation, capitalization, and paragraphs without altering content or spelling.
+42. **coding_master**: Explain a coding concept to a beginner, providing examples, and formatting code in markdown with specific output sections like ideas, recommendations, facts, and insights.
+43. **compare_and_contrast**: Compare and contrast a list of items in a markdown table, with items on the left and topics on top.
+44. **convert_to_markdown**: Convert content to clean, complete Markdown format, preserving all original structure, formatting, links, and code blocks without alterations.
+45. **create_5_sentence_summary**: Create concise summaries or answers to input at 5 different levels of depth, from 5 words to 1 word.
+46. **create_academic_paper**: Generate a high-quality academic paper in LaTeX format with clear concepts, structured content, and a professional layout.
+47. **create_ai_jobs_analysis**: Analyze job categories' susceptibility to automation, identify resilient roles, and provide strategies for personal adaptation to AI-driven changes in the workforce.
+48. **create_aphorisms**: Find and generate a list of brief, witty statements.
+49. **create_art_prompt**: Generates a detailed, compelling visual description of a concept, including stylistic references and direct AI instructions for creating art.
+50. **create_better_frame**: Identifies and analyzes different frames of interpreting reality, emphasizing the power of positive, productive lenses in shaping outcomes.
+51. **create_coding_feature**: Generates secure and composable code features using modern technology and best practices from project specifications.
+52. **create_coding_project**: Generate wireframes and starter code for any coding ideas that you have.
+53. **create_command**: Helps determine the correct parameters and switches for penetration testing tools based on a brief description of the objective.
+54. **create_cyber_summary**: Summarizes cybersecurity threats, vulnerabilities, incidents, and malware with a 25-word summary and categorized bullet points, after thoroughly analyzing and mapping the provided input.
+55. **create_design_document**: Creates a detailed design document for a system using the C4 model, addressing business and security postures, and including a system context diagram.
+56. **create_diy**: Creates structured "Do It Yourself" tutorial patterns by analyzing prompts, organizing requirements, and providing step-by-step instructions in Markdown format.
+57. **create_excalidraw_visualization**: Creates complex Excalidraw diagrams to visualize relationships between concepts and ideas in structured format.
+58. **create_flash_cards**: Creates flashcards for key concepts, definitions, and terms with question-answer format for educational purposes.
+59. **create_formal_email**: Crafts professional, clear, and respectful emails by analyzing context, tone, and purpose, ensuring proper structure and formatting.
+60. **create_git_diff_commit**: Generates Git commands and commit messages for reflecting changes in a repository, using conventional commits and providing concise shell commands for updates.
+61. **create_graph_from_input**: Generates a CSV file with progress-over-time data for a security program, focusing on relevant metrics and KPIs.
+62. **create_hormozi_offer**: Creates a customized business offer based on principles from Alex Hormozi's book, "$100M Offers."
+63. **create_idea_compass**: Organizes and structures ideas by exploring their definition, evidence, sources, and related themes or consequences.
+64. **create_investigation_visualization**: Creates detailed Graphviz visualizations of complex input, highlighting key aspects and providing clear, well-annotated diagrams for investigative analysis and conclusions.
+65. **create_keynote**: Creates TED-style keynote presentations with a clear narrative, structured slides, and speaker notes, emphasizing impactful takeaways and cohesive flow.
+66. **create_loe_document**: Creates detailed Level of Effort documents for estimating work effort, resources, and costs for tasks or projects.
+67. **create_logo**: Creates simple, minimalist company logos without text, generating AI prompts for vector graphic logos based on input.
+68. **create_markmap_visualization**: Transforms complex ideas into clear visualizations using MarkMap syntax, simplifying concepts into diagrams with relationships, boxes, arrows, and labels.
+69. **create_mermaid_visualization**: Creates detailed, standalone visualizations of concepts using Mermaid (Markdown) syntax, ensuring clarity and coherence in diagrams.
+70. **create_mermaid_visualization_for_github**: Creates standalone, detailed visualizations using Mermaid (Markdown) syntax to effectively explain complex concepts, ensuring clarity and precision.
+71. **create_micro_summary**: Summarizes content into a concise, 20-word summary with main points and takeaways, formatted in Markdown.
+72. **create_mnemonic_phrases**: Creates memorable mnemonic sentences from given words to aid in memory retention and learning.
+73. **create_network_threat_landscape**: Analyzes open ports and services from a network scan and generates a comprehensive, insightful, and detailed security threat report in Markdown.
+74. **create_newsletter_entry**: Condenses provided article text into a concise, objective, newsletter-style summary with a title in the style of Frontend Weekly.
+75. **create_npc**: Generates a detailed D&D 5E NPC, including background, flaws, stats, appearance, personality, goals, and more in Markdown format.
+76. **create_pattern**: Extracts, organizes, and formats LLM/AI prompts into structured sections, detailing the AI's role, instructions, output format, and any provided examples for clarity and accuracy.
+77. **create_prd**: Creates a precise Product Requirements Document (PRD) in Markdown based on input.
+78. **create_prediction_block**: Extracts and formats predictions from input into a structured Markdown block for a blog post.
+79. **create_quiz**: Creates a three-phase reading plan based on an author or topic to help the user become significantly knowledgeable, including core, extended, and supplementary readings.
+80. **create_reading_plan**: Generates review questions based on learning objectives from the input, adapted to the specified student level, and outputs them in a clear markdown format.
+81. **create_recursive_outline**: Breaks down complex tasks or projects into manageable, hierarchical components with recursive outlining for clarity and simplicity.
+82. **create_report_finding**: Creates a detailed, structured security finding report in markdown, including sections on Description, Risk, Recommendations, References, One-Sentence-Summary, and Quotes.
+83. **create_rpg_summary**: Summarizes an in-person RPG session with key events, combat details, player stats, and role-playing highlights in a structured format.
+84. **create_security_update**: Creates concise security updates for newsletters, covering stories, threats, advisories, vulnerabilities, and a summary of key issues.
+85. **create_show_intro**: Creates compelling short intros for podcasts, summarizing key topics and themes discussed in the episode.
+86. **create_sigma_rules**: Extracts Tactics, Techniques, and Procedures (TTPs) from security news and converts them into Sigma detection rules for host-based detections.
+87. **create_story_explanation**: Summarizes complex content in a clear, approachable story format that makes the concepts easy to understand.
+88. **create_stride_threat_model**: Create a STRIDE-based threat model for a system design, identifying assets, trust boundaries, data flows, and prioritizing threats with mitigations.
+89. **create_summary**: Summarizes content into a 20-word sentence, 10 main points (16 words max), and 5 key takeaways in Markdown format.
+90. **create_tags**: Identifies at least 5 tags from text content for mind mapping tools, including authors and existing tags if present.
+91. **create_threat_scenarios**: Identifies likely attack methods for any system by providing a narrative-based threat model, balancing risk and opportunity.
+92. **create_ttrc_graph**: Creates a CSV file showing the progress of Time to Remediate Critical Vulnerabilities over time using given data.
+93. **create_ttrc_narrative**: Creates a persuasive narrative highlighting progress in reducing the Time to Remediate Critical Vulnerabilities metric over time.
+94. **create_upgrade_pack**: Extracts world model and task algorithm updates from content, providing beliefs about how the world works and task performance.
+95. **create_user_story**: Writes concise and clear technical user stories for new features in complex software programs, formatted for all stakeholders.
+96. **create_video_chapters**: Extracts interesting topics and timestamps from a transcript, providing concise summaries of key moments.
+97. **create_visualization**: Transforms complex ideas into visualizations using intricate ASCII art, simplifying concepts where necessary.
+98. **dialog_with_socrates**: Engages in deep, meaningful dialogues to explore and challenge beliefs using the Socratic method.
+99. **enrich_blog_post**: Enhances Markdown blog files by applying instructions to improve structure, visuals, and readability for HTML rendering.
+100. **explain_code**: Explains code, security tool output, configuration text, and answers questions based on the provided input.
+101. **explain_docs**: Improves and restructures tool documentation into clear, concise instructions, including overviews, usage, use cases, and key features.
+102. **explain_math**: Helps you understand mathematical concepts in a clear and engaging way.
+103. **explain_project**: Summarizes project documentation into clear, concise sections covering the project, problem, solution, installation, usage, and examples.
+104. **explain_terms**: Produces a glossary of advanced terms from content, providing a definition, analogy, and explanation of why each term matters.
+105. **export_data_as_csv**: Extracts and outputs all data structures from the input in properly formatted CSV data.
+106. **extract_algorithm_update_recommendations**: Extracts concise, practical algorithm update recommendations from the input and outputs them in a bulleted list.
+107. **extract_article_wisdom**: Extracts surprising, insightful, and interesting information from content, categorizing it into sections like summary, ideas, quotes, facts, references, and recommendations.
+108. **extract_book_ideas**: Extracts and outputs 50 to 100 of the most surprising, insightful, and interesting ideas from a book's content.
+109. **extract_book_recommendations**: Extracts and outputs 50 to 100 practical, actionable recommendations from a book's content.
+110. **extract_business_ideas**: Extracts top business ideas from content and elaborates on the best 10 with unique differentiators.
+111. **extract_controversial_ideas**: Extracts and outputs controversial statements and supporting quotes from the input in a structured Markdown list.
+112. **extract_core_message**: Extracts and outputs a clear, concise sentence that articulates the core message of a given text or body of work.
+113. **extract_ctf_writeup**: Extracts a short writeup from a warstory-like text about a cyber security engagement.
+114. **extract_domains**: Extracts domains and URLs from content to identify sources used for articles, newsletters, and other publications.
+115. **extract_extraordinary_claims**: Extracts and outputs a list of extraordinary claims from conversations, focusing on scientifically disputed or false statements.
+116. **extract_ideas**: Extracts and outputs all the key ideas from input, presented as 15-word bullet points in Markdown.
+117. **extract_insights**: Extracts and outputs the most powerful and insightful ideas from text, formatted as 16-word bullet points in the INSIGHTS section, also IDEAS section.
+118. **extract_insights_dm**: Extracts and outputs all valuable insights and a concise summary of the content, including key points and topics discussed.
+119. **extract_instructions**: Extracts clear, actionable step-by-step instructions and main objectives from instructional video transcripts, organizing them into a concise list.
+120. **extract_jokes**: Extracts jokes from text content, presenting each joke with its punchline in separate bullet points.
+121. **extract_latest_video**: Extracts the latest video URL from a YouTube RSS feed and outputs the URL only.
+122. **extract_main_activities**: Extracts key events and activities from transcripts or logs, providing a summary of what happened.
+123. **extract_main_idea**: Extracts the main idea and key recommendation from the input, summarizing them in 15-word sentences.
+124. **extract_most_redeeming_thing**: Extracts the most redeeming aspect from an input, summarizing it in a single 15-word sentence.
+125. **extract_patterns**: Extracts and analyzes recurring, surprising, and insightful patterns from input, providing detailed analysis and advice for builders.
+126. **extract_poc**: Extracts proof of concept URLs and validation methods from security reports, providing the URL and command to run.
+127. **extract_predictions**: Extracts predictions from input, including specific details such as date, confidence level, and verification method.
+128. **extract_primary_problem**: Extracts the primary problem with the world as presented in a given text or body of work.
+129. **extract_primary_solution**: Extracts the primary solution for the world as presented in a given text or body of work.
+130. **extract_product_features**: Extracts and outputs a list of product features from the provided input in a bulleted format.
+131. **extract_questions**: Extracts and outputs all questions asked by the interviewer in a conversation or interview.
+132. **extract_recipe**: Extracts and outputs a recipe with a short meal description, ingredients with measurements, and preparation steps.
+133. **extract_recommendations**: Extracts and outputs concise, practical recommendations from a given piece of content in a bulleted list.
+134. **extract_references**: Extracts and outputs a bulleted list of references to art, stories, books, literature, and other sources from content.
+135. **extract_skills**: Extracts and classifies skills from a job description into a table, separating each skill and classifying it as either hard or soft.
+136. **extract_song_meaning**: Analyzes a song to provide a summary of its meaning, supported by detailed evidence from lyrics, artist commentary, and fan analysis.
+137. **extract_sponsors**: Extracts and lists official sponsors and potential sponsors from a provided transcript.
+138. **extract_videoid**: Extracts and outputs the video ID from any given URL.
+139. **extract_wisdom**: Extracts surprising, insightful, and interesting information from text on topics like human flourishing, AI, learning, and more.
+140. **extract_wisdom_agents**: Extracts valuable insights, ideas, quotes, and references from content, emphasizing topics like human flourishing, AI, learning, and technology.
+141. **extract_wisdom_dm**: Extracts all valuable, insightful, and thought-provoking information from content, focusing on topics like human flourishing, AI, learning, and technology.
+142. **extract_wisdom_nometa**: Extracts insights, ideas, quotes, habits, facts, references, and recommendations from content, focusing on human flourishing, AI, technology, and related topics.
+143. **find_female_life_partner**: Analyzes criteria for finding a female life partner and provides clear, direct, and poetic descriptions.
+144. **find_hidden_message**: Extracts overt and hidden political messages, justifications, audience actions, and a cynical analysis from content.
+145. **find_logical_fallacies**: Identifies and analyzes fallacies in arguments, classifying them as formal or informal with detailed reasoning.
+146. **get_wow_per_minute**: Determines the wow-factor of content per minute based on surprise, novelty, insight, value, and wisdom, measuring how rewarding the content is for the viewer.
+147. **get_youtube_rss**: Returns the RSS URL for a given YouTube channel based on the channel ID or URL.
+148. **humanize**: Rewrites AI-generated text to sound natural, conversational, and easy to understand, maintaining clarity and simplicity.
+149. **identify_dsrp_distinctions**: Encourages creative, systems-based thinking by exploring distinctions, boundaries, and their implications, drawing on insights from prominent systems thinkers.
+150. **identify_dsrp_perspectives**: Explores the concept of distinctions in systems thinking, focusing on how boundaries define ideas, influence understanding, and reveal or obscure insights.
+151. **identify_dsrp_relationships**: Encourages exploration of connections, distinctions, and boundaries between ideas, inspired by systems thinkers to reveal new insights and patterns in complex systems.
+152. **identify_dsrp_systems**: Encourages organizing ideas into systems of parts and wholes, inspired by systems thinkers to explore relationships and how changes in organization impact meaning and understanding.
+153. **identify_job_stories**: Identifies key job stories or requirements for roles.
+154. **improve_academic_writing**: Refines text into clear, concise academic language while improving grammar, coherence, and clarity, with a list of changes.
+155. **improve_prompt**: Improves an LLM/AI prompt by applying expert prompt writing strategies for better results and clarity.
+156. **improve_report_finding**: Improves a penetration test security finding by providing detailed descriptions, risks, recommendations, references, quotes, and a concise summary in markdown format.
+157. **improve_writing**: Refines text by correcting grammar, enhancing style, improving clarity, and maintaining the original meaning. skills.
+158. **judge_output**: Evaluates Honeycomb queries by judging their effectiveness, providing critiques and outcomes based on language nuances and analytics relevance.
+159. **label_and_rate**: Labels content with up to 20 single-word tags and rates it based on idea count and relevance to human meaning, AI, and other related themes, assigning a tier (S, A, B, C, D) and a quality score.
+160. **md_callout**: Classifies content and generates a markdown callout based on the provided text, selecting the most appropriate type.
+161. **official_pattern_template**: Template to use if you want to create new fabric patterns.
+162. **prepare_7s_strategy**: Prepares a comprehensive briefing document from 7S's strategy capturing organizational profile, strategic elements, and market dynamics with clear, concise, and organized content.
+163. **provide_guidance**: Provides psychological and life coaching advice, including analysis, recommendations, and potential diagnoses, with a compassionate and honest tone.
+164. **rate_ai_response**: Rates the quality of AI responses by comparing them to top human expert performance, assigning a letter grade, reasoning, and providing a 1-100 score based on the evaluation.
+165. **rate_ai_result**: Assesses the quality of AI/ML/LLM work by deeply analyzing content, instructions, and output, then rates performance based on multiple dimensions, including coverage, creativity, and interdisciplinary thinking.
+166. **rate_content**: Labels content with up to 20 single-word tags and rates it based on idea count and relevance to human meaning, AI, and other related themes, assigning a tier (S, A, B, C, D) and a quality score.
+167. **rate_value**: Produces the best possible output by deeply analyzing and understanding the input and its intended purpose.
+168. **raw_query**: Fully digests and contemplates the input to produce the best possible result based on understanding the sender's intent.
+169. **recommend_artists**: Recommends a personalized festival schedule with artists aligned to your favorite styles and interests, including rationale.
+170. **recommend_pipeline_upgrades**: Optimizes vulnerability-checking pipelines by incorporating new information and improving their efficiency, with detailed explanations of changes.
+171. **recommend_talkpanel_topics**: Produces a clean set of proposed talks or panel talking points for a person based on their interests and goals, formatted for submission to a conference organizer.
+172. **refine_design_document**: Refines a design document based on a design review by analyzing, mapping concepts, and implementing changes using valid Markdown.
+173. **review_design**: Reviews and analyzes architecture design, focusing on clarity, component design, system integrations, security, performance, scalability, and data management.
+174. **sanitize_broken_html_to_markdown**: Converts messy HTML into clean, properly formatted Markdown, applying custom styling and ensuring compatibility with Vite.
+175. **show_fabric_options_markmap**: Visualizes the functionality of the Fabric framework by representing its components, commands, and features based on the provided input.
+176. **solve_with_cot**: Provides detailed, step-by-step responses with chain of thought reasoning, using structured thinking, reflection, and output sections.
+177. **suggest_pattern**: Suggests appropriate fabric patterns or commands based on user input, providing clear explanations and options for users.
+178. **summarize**: Summarizes content into a 20-word sentence, main points, and takeaways, formatted with numbered lists in Markdown.
+179. **summarize_board_meeting**: Creates formal meeting notes from board meeting transcripts for corporate governance documentation.
+180. **summarize_debate**: Summarizes debates, identifies primary disagreement, extracts arguments, and provides analysis of evidence and argument strength to predict outcomes.
+181. **summarize_git_changes**: Summarizes recent project updates from the last 7 days, focusing on key changes with enthusiasm.
+182. **summarize_git_diff**: Summarizes and organizes Git diff changes with clear, succinct commit messages and bullet points.
+183. **summarize_lecture**: Extracts relevant topics, definitions, and tools from lecture transcripts, providing structured summaries with timestamps and key takeaways.
+184. **summarize_legislation**: Summarizes complex political proposals and legislation by analyzing key points, proposed changes, and providing balanced, positive, and cynical characterizations.
+185. **summarize_meeting**: Analyzes meeting transcripts to extract a structured summary, including an overview, key points, tasks, decisions, challenges, timeline, references, and next steps.
+186. **summarize_micro**: Summarizes content into a 20-word sentence, 3 main points, and 3 takeaways, formatted in clear, concise Markdown.
+187. **summarize_newsletter**: Extracts the most meaningful, interesting, and useful content from a newsletter, summarizing key sections such as content, opinions, tools, companies, and follow-up items in clear, structured Markdown.
+188. **summarize_paper**: Summarizes an academic paper by detailing its title, authors, technical approach, distinctive features, experimental setup, results, advantages, limitations, and conclusion in a clear, structured format using human-readable Markdown.
+189. **summarize_prompt**: Summarizes AI chat prompts by describing the primary function, unique approach, and expected output in a concise paragraph. The summary is focused on the prompt's purpose without unnecessary details or formatting.
+190. **summarize_pull-requests**: Summarizes pull requests for a coding project by providing a summary and listing the top PRs with human-readable descriptions.
+191. **summarize_rpg_session**: Summarizes a role-playing game session by extracting key events, combat stats, character changes, quotes, and more.
+192. **t_analyze_challenge_handling**: Provides 8-16 word bullet points evaluating how well challenges are being addressed, calling out any lack of effort.
+193. **t_check_metrics**: Analyzes deep context from the TELOS file and input instruction, then provides a wisdom-based output while considering metrics and KPIs to assess recent improvements.
+194. **t_create_h3_career**: Summarizes context and produces wisdom-based output by deeply analyzing both the TELOS File and the input instruction, considering the relationship between the two.
+195. **t_create_opening_sentences**: Describes from TELOS file the person's identity, goals, and actions in 4 concise, 32-word bullet points, humbly.
+196. **t_describe_life_outlook**: Describes from TELOS file a person's life outlook in 5 concise, 16-word bullet points.
+197. **t_extract_intro_sentences**: Summarizes from TELOS file a person's identity, work, and current projects in 5 concise and grounded bullet points.
+198. **t_extract_panel_topics**: Creates 5 panel ideas with titles and descriptions based on deep context from a TELOS file and input.
+199. **t_find_blindspots**: Identify potential blindspots in thinking, frames, or models that may expose the individual to error or risk.
+200. **t_find_negative_thinking**: Analyze a TELOS file and input to identify negative thinking in documents or journals, followed by tough love encouragement.
+201. **t_find_neglected_goals**: Analyze a TELOS file and input instructions to identify goals or projects that have not been worked on recently.
+202. **t_give_encouragement**: Analyze a TELOS file and input instructions to evaluate progress, provide encouragement, and offer recommendations for continued effort.
+203. **t_red_team_thinking**: Analyze a TELOS file and input instructions to red-team thinking, models, and frames, then provide recommendations for improvement.
+204. **t_threat_model_plans**: Analyze a TELOS file and input instructions to create threat models for a life plan and recommend improvements.
+205. **t_visualize_mission_goals_projects**: Analyze a TELOS file and input instructions to create an ASCII art diagram illustrating the relationship of missions, goals, and projects.
+206. **t_year_in_review**: Analyze a TELOS file to create insights about a person or entity, then summarize accomplishments and visualizations in bullet points.
+207. **to_flashcards**: Create Anki flashcards from a given text, focusing on concise, optimized questions and answers without external context.
+208. **transcribe_minutes**: Extracts (from meeting transcription) meeting minutes, identifying actionables, insightful ideas, decisions, challenges, and next steps in a structured format.
+209. **translate**: Translates sentences or documentation into the specified language code while maintaining the original formatting and tone.
+210. **tweet**: Provides a step-by-step guide on crafting engaging tweets with emojis, covering Twitter basics, account creation, features, and audience targeting.
+211. **write_essay**: Writes essays in the style of a specified author, embodying their unique voice, vocabulary, and approach. Uses `author_name` variable.
+212. **write_essay_pg**: Writes concise, clear essays in the style of Paul Graham, focusing on simplicity, clarity, and illumination of the provided topic.
+213. **write_hackerone_report**: Generates concise, clear, and reproducible bug bounty reports, detailing vulnerability impact, steps to reproduce, and exploit details for triagers.
+214. **write_latex**: Generates syntactically correct LaTeX code for a new.tex document, ensuring proper formatting and compatibility with pdflatex.
+215. **write_micro_essay**: Writes concise, clear, and illuminating essays on the given topic in the style of Paul Graham.
+216. **write_nuclei_template_rule**: Generates Nuclei YAML templates for detecting vulnerabilities using HTTP requests, matchers, extractors, and dynamic data extraction.
+217. **write_pull-request**: Drafts detailed pull request descriptions, explaining changes, providing reasoning, and identifying potential bugs from the git diff command output.
+218. **write_semgrep_rule**: Creates accurate and working Semgrep rules based on input, following syntax guidelines and specific language considerations.
+219. **youtube_summary**: Create concise, timestamped Youtube video summaries that highlight key points.

patterns/raycast/capture_thinkers_work

@@ -1,27 +0,0 @@
-#!/bin/bash
-
-# Required parameters:
-# @raycast.schemaVersion 1
-# @raycast.title Capture Thinkers Work
-# @raycast.mode fullOutput
-
-# Optional parameters:
-# @raycast.icon 🧠
-# @raycast.argument1 { "type": "text", "placeholder": "Input text", "optional": false, "percentEncoded": true}
-
-# Documentation:
-# @raycast.description Run fabric capture_thinkers_work on the input text
-# @raycast.author Daniel Miessler
-# @raycast.authorURL https://github.com/danielmiessler
-
-# Set PATH to include common locations and $HOME/go/bin
-PATH="/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin:$HOME/go/bin:$PATH"
-
-# Use the PATH to find and execute fabric
-if command -v fabric >/dev/null 2>&1; then
-    fabric -sp capture_thinkers_work "${1}"
-else
-    echo "Error: fabric command not found in PATH"
-    echo "Current PATH: $PATH"
-    exit 1
-fi

patterns/raycast/create_story_explanation

@@ -1,27 +0,0 @@
-#!/bin/bash
-
-# Required parameters:
-# @raycast.schemaVersion 1
-# @raycast.title Create Story Explanation
-# @raycast.mode fullOutput
-
-# Optional parameters:
-# @raycast.icon 🧠
-# @raycast.argument1 { "type": "text", "placeholder": "Input text", "optional": false, "percentEncoded": true}
-
-# Documentation:
-# @raycast.description Run fabric create_story_explanation on the input text
-# @raycast.author Daniel Miessler
-# @raycast.authorURL https://github.com/danielmiessler
-
-# Set PATH to include common locations and $HOME/go/bin
-PATH="/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin:$HOME/go/bin:$PATH"
-
-# Use the PATH to find and execute fabric
-if command -v fabric >/dev/null 2>&1; then
-    fabric -sp create_story_explanation "${1}"
-else
-    echo "Error: fabric command not found in PATH"
-    echo "Current PATH: $PATH"
-    exit 1
-fi

patterns/raycast/extract_primary_problem

@@ -1,27 +0,0 @@
-#!/bin/bash
-
-# Required parameters:
-# @raycast.schemaVersion 1
-# @raycast.title Extract Primary Problem
-# @raycast.mode fullOutput
-
-# Optional parameters:
-# @raycast.icon 🧠
-# @raycast.argument1 { "type": "text", "placeholder": "Input text", "optional": false, "percentEncoded": true}
-
-# Documentation:
-# @raycast.description Run fabric extract_primary_problem on the input text
-# @raycast.author Daniel Miessler
-# @raycast.authorURL https://github.com/danielmiessler
-
-# Set PATH to include common locations and $HOME/go/bin
-PATH="/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin:$HOME/go/bin:$PATH"
-
-# Use the PATH to find and execute fabric
-if command -v fabric >/dev/null 2>&1; then
-    fabric -sp extract_primary_problem "${1}"
-else
-    echo "Error: fabric command not found in PATH"
-    echo "Current PATH: $PATH"
-    exit 1
-fi

patterns/raycast/extract_wisdom

@@ -1,27 +0,0 @@
-#!/bin/bash
-
-# Required parameters:
-# @raycast.schemaVersion 1
-# @raycast.title Extract Wisdom
-# @raycast.mode fullOutput
-
-# Optional parameters:
-# @raycast.icon 🧠
-# @raycast.argument1 { "type": "text", "placeholder": "Input text", "optional": false, "percentEncoded": true}
-
-# Documentation:
-# @raycast.description Run fabric extract_wisdom on input text
-# @raycast.author Daniel Miessler
-# @raycast.authorURL https://github.com/danielmiessler
-
-# Set PATH to include common locations and $HOME/go/bin
-PATH="/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin:$HOME/go/bin:$PATH"
-
-# Use the PATH to find and execute fabric
-if command -v fabric >/dev/null 2>&1; then
-    fabric -sp extract_wisdom "${1}"
-else
-    echo "Error: fabric command not found in PATH"
-    echo "Current PATH: $PATH"
-    exit 1
-fi

patterns/raycast/yt

@@ -1,27 +0,0 @@
-#!/bin/bash
-
-# Required parameters:
-# @raycast.schemaVersion 1
-# @raycast.title Get YouTube Transcript
-# @raycast.mode fullOutput
-
-# Optional parameters:
-# @raycast.icon 🧠
-# @raycast.argument1 { "type": "text", "placeholder": "Input text", "optional": false, "percentEncoded": false}
-
-# Documentation:
-# @raycast.description Run fabric -y on the input text of a YouTube video to get the transcript from.
-# @raycast.author Daniel Miessler
-# @raycast.authorURL https://github.com/danielmiessler
-
-# Set PATH to include common locations and $HOME/go/bin
-PATH="/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin:$HOME/go/bin:$PATH"
-
-# Use the PATH to find and execute fabric
-if command -v fabric >/dev/null 2>&1; then
-    fabric -y "${1}"
-else
-    echo "Error: fabric command not found in PATH"
-    echo "Current PATH: $PATH"
-    exit 1
-fi

patterns/review_code/system.md

@@ -0,0 +1,140 @@
+# Code Review Task
+
+## ROLE AND GOAL
+
+You are a Principal Software Engineer, renowned for your meticulous attention to detail and your ability to provide clear, constructive, and educational code reviews. Your goal is to help other developers improve their code quality by identifying potential issues, suggesting concrete improvements, and explaining the underlying principles.
+
+## TASK
+
+You will be given a snippet of code or a diff. Your task is to perform a comprehensive review and generate a detailed report.
+
+## STEPS
+
+1. **Understand the Context**: First, carefully read the provided code and any accompanying context to fully grasp its purpose, functionality, and the problem it aims to solve.
+2. **Systematic Analysis**: Before writing, conduct a mental analysis of the code. Evaluate it against the following key aspects. Do not write this analysis in the output; use it to form your review.
+    * **Correctness**: Are there bugs, logic errors, or race conditions?
+    * **Security**: Are there any potential vulnerabilities (e.g., injection attacks, improper handling of sensitive data)?
+    * **Performance**: Can the code be optimized for speed or memory usage without sacrificing readability?
+    * **Readability & Maintainability**: Is the code clean, well-documented, and easy for others to understand and modify?
+    * **Best Practices & Idiomatic Style**: Does the code adhere to established conventions, patterns, and the idiomatic style of the programming language?
+    * **Error Handling & Edge Cases**: Are errors handled gracefully? Have all relevant edge cases been considered?
+3. **Generate the Review**: Structure your feedback according to the specified `OUTPUT FORMAT`. For each point of feedback, provide the original code snippet, a suggested improvement, and a clear rationale.
+
+## OUTPUT FORMAT
+
+Your review must be in Markdown and follow this exact structure:
+
+---
+
+### Overall Assessment
+
+A brief, high-level summary of the code's quality. Mention its strengths and the primary areas for improvement.
+
+### **Prioritized Recommendations**
+
+A numbered list of the most important changes, ordered from most to least critical.
+
+1. (Most critical change)
+2. (Second most critical change)
+3. ...
+
+### **Detailed Feedback**
+
+For each issue you identified, provide a detailed breakdown in the following format.
+
+---
+
+**[ISSUE TITLE]** - (e.g., `Security`, `Readability`, `Performance`)
+
+**Original Code:**
+
+```[language]
+// The specific lines of code with the issue
+```
+
+**Suggested Improvement:**
+
+```[language]
+// The revised, improved code
+```
+
+**Rationale:**
+A clear and concise explanation of why the change is recommended. Reference best practices, design patterns, or potential risks. If you use advanced concepts, briefly explain them.
+
+---
+(Repeat this section for each issue)
+
+## EXAMPLE
+
+Here is an example of a review for a simple Python function:
+
+---
+
+### **Overall Assessment**
+
+The function correctly fetches user data, but it can be made more robust and efficient. The primary areas for improvement are in error handling and database query optimization.
+
+### **Prioritized Recommendations**
+
+1. Avoid making database queries inside a loop to prevent performance issues (N+1 query problem).
+2. Add specific error handling for when a user is not found.
+
+### **Detailed Feedback**
+
+---
+
+**[PERFORMANCE]** - N+1 Database Query
+
+**Original Code:**
+
+```python
+def get_user_emails(user_ids):
+    emails = []
+    for user_id in user_ids:
+        user = db.query(User).filter(User.id == user_id).one()
+        emails.append(user.email)
+    return emails
+```
+
+**Suggested Improvement:**
+
+```python
+def get_user_emails(user_ids):
+    if not user_ids:
+        return []
+    users = db.query(User).filter(User.id.in_(user_ids)).all()
+    return [user.email for user in users]
+```
+
+**Rationale:**
+The original code executes one database query for each `user_id` in the list. This is known as the "N+1 query problem" and performs very poorly on large lists. The suggested improvement fetches all users in a single query using `IN`, which is significantly more efficient.
+
+---
+
+**[CORRECTNESS]** - Lacks Specific Error Handling
+
+**Original Code:**
+
+```python
+user = db.query(User).filter(User.id == user_id).one()
+```
+
+**Suggested Improvement:**
+
+```python
+from sqlalchemy.orm.exc import NoResultFound
+
+try:
+    user = db.query(User).filter(User.id == user_id).one()
+except NoResultFound:
+    # Handle the case where the user doesn't exist
+    # e.g., log a warning, skip the user, or raise a custom exception
+    continue
+```
+
+**Rationale:**
+The `.one()` method will raise a `NoResultFound` exception if a user with the given ID doesn't exist, which would crash the entire function. It's better to explicitly handle this case using a try/except block to make the function more resilient.
+
+---
+
+## INPUT

patterns/suggest_pattern/user_updated.md

@@ -0,0 +1,919 @@
+# Suggest Pattern
+
+## OVERVIEW
+
+What It Does: Fabric is an open-source framework designed to augment human capabilities using AI, making it easier to integrate AI into daily tasks.
+
+Why People Use It: Users leverage Fabric to seamlessly apply AI for solving everyday challenges, enhancing productivity, and fostering human creativity through technology.
+
+## HOW TO USE IT
+
+Most Common Syntax: The most common usage involves executing Fabric commands in the terminal, such as `fabric --pattern <PATTERN_NAME>`.
+
+## COMMON USE CASES
+
+For Summarizing Content: `fabric --pattern summarize`
+For Analyzing Claims: `fabric --pattern analyze_claims`
+For Extracting Wisdom from Videos: `fabric --pattern extract_wisdom`
+For creating custom patterns: `fabric --pattern create_pattern`
+
+- One possible place to store them is ~/.config/custom-fabric-patterns.
+- Then when you want to use them, simply copy them into ~/.config/fabric/patterns.
+`cp -a ~/.config/custom-fabric-patterns/* ~/.config/fabric/patterns/`
+- Now you can run them with: `pbpaste | fabric -p your_custom_pattern`
+
+## MOST IMPORTANT AND USED OPTIONS AND FEATURES
+
+- **--pattern PATTERN, -p PATTERN**: Specifies the pattern (prompt) to use. Useful for applying specific AI prompts to your input.
+
+- **--stream, -s**: Streams results in real-time. Ideal for getting immediate feedback from AI operations.
+
+- **--update, -u**: Updates patterns. Ensures you're using the latest AI prompts for your tasks.
+
+- **--model MODEL, -m MODEL**: Selects the AI model to use. Allows customization of the AI backend for different tasks.
+
+- **--setup, -S**: Sets up your Fabric instance. Essential for first-time users to configure Fabric correctly.
+
+- **--list, -l**: Lists available patterns. Helps users discover new AI prompts for various applications.
+
+- **--context, -C**: Uses a Context file to add context to your pattern. Enhances the relevance of AI responses by providing additional background information.
+
+## PATTERNS
+
+**Key pattern to use: `suggest_pattern`** - suggests appropriate fabric patterns or commands based on user input.
+
+### agility_story
+
+Generate a user story and acceptance criteria in JSON format based on the given topic.
+
+### ai
+
+Interpret questions deeply and provide concise, insightful answers in Markdown bullet points.
+
+### analyze_answers
+
+Evaluate quiz answers for correctness based on learning objectives and generated quiz questions.
+
+### analyze_bill
+
+Analyzes legislation to identify overt and covert goals, examining bills for hidden agendas and true intentions.
+
+### analyze_bill_short
+
+Provides a concise analysis of legislation, identifying overt and covert goals in a brief, structured format.
+
+### analyze_candidates
+
+Compare and contrast two political candidates based on key issues and policies.
+
+### analyze_cfp_submission
+
+Review and evaluate conference speaking session submissions based on clarity, relevance, depth, and engagement potential.
+
+### analyze_claims
+
+Analyse and rate truth claims with evidence, counter-arguments, fallacies, and final recommendations.
+
+### analyze_comments
+
+Evaluate internet comments for content, categorize sentiment, and identify reasons for praise, criticism, and neutrality.
+
+### analyze_debate
+
+Rate debates on insight, emotionality, and present an unbiased, thorough analysis of arguments, agreements, and disagreements.
+
+### analyze_email_headers
+
+Provide cybersecurity analysis and actionable insights on SPF, DKIM, DMARC, and ARC email header results.
+
+### analyze_incident
+
+Efficiently extract and organize key details from cybersecurity breach articles, focusing on attack type, vulnerable components, attacker and target info, incident details, and remediation steps.
+
+### analyze_interviewer_techniques
+
+This exercise involves analyzing interviewer techniques, identifying their unique qualities, and succinctly articulating what makes them stand out in a clear, simple format.
+
+### analyze_logs
+
+Analyse server log files to identify patterns, anomalies, and issues, providing data-driven insights and recommendations for improving server reliability and performance.
+
+### analyze_malware
+
+Analyse malware details, extract key indicators, techniques, and potential detection strategies, and summarize findings concisely for a malware analyst's use in identifying and responding to threats.
+
+### analyze_military_strategy
+
+Analyse a historical battle, offering in-depth insights into strategic decisions, strengths, weaknesses, tactical approaches, logistical factors, pivotal moments, and consequences for a comprehensive military evaluation.
+
+### analyze_mistakes
+
+Analyse past mistakes in thinking patterns, map them to current beliefs, and offer recommendations to improve accuracy in predictions.
+
+### analyze_paper
+
+Analyses research papers by summarizing findings, evaluating rigor, and assessing quality to provide insights for documentation and review.
+
+### analyze_paper_simple
+
+Analyzes academic papers with a focus on primary findings, research quality, and study design evaluation.
+
+### analyze_patent
+
+Analyse a patent's field, problem, solution, novelty, inventive step, and advantages in detail while summarizing and extracting keywords.
+
+### analyze_personality
+
+Performs a deep psychological analysis of a person in the input, focusing on their behavior, language, and psychological traits.
+
+### analyze_presentation
+
+Reviews and critiques presentations by analyzing the content, speaker's underlying goals, self-focus, and entertainment value.
+
+### analyze_product_feedback
+
+A prompt for analyzing and organizing user feedback by identifying themes, consolidating similar comments, and prioritizing them based on usefulness.
+
+### analyze_proposition
+
+Analyzes a ballot proposition by identifying its purpose, impact, arguments for and against, and relevant background information.
+
+### analyze_prose
+
+Evaluates writing for novelty, clarity, and prose, providing ratings, improvement recommendations, and an overall score.
+
+### analyze_prose_json
+
+Evaluates writing for novelty, clarity, prose, and provides ratings, explanations, improvement suggestions, and an overall score in a JSON format.
+
+### analyze_prose_pinker
+
+Evaluates prose based on Steven Pinker's The Sense of Style, analyzing writing style, clarity, and bad writing elements.
+
+### analyze_risk
+
+Conducts a risk assessment of a third-party vendor, assigning a risk score and suggesting security controls based on analysis of provided documents and vendor website.
+
+### analyze_sales_call
+
+Rates sales call performance across multiple dimensions, providing scores and actionable feedback based on transcript analysis.
+
+### analyze_spiritual_text
+
+Compares and contrasts spiritual texts by analyzing claims and differences with the King James Bible.
+
+### analyze_tech_impact
+
+Analyzes the societal impact, ethical considerations, and sustainability of technology projects, evaluating their outcomes and benefits.
+
+### analyze_terraform_plan
+
+Analyzes Terraform plan outputs to assess infrastructure changes, security risks, cost implications, and compliance considerations.
+
+### analyze_threat_report
+
+Extracts surprising insights, trends, statistics, quotes, references, and recommendations from cybersecurity threat reports, summarizing key findings and providing actionable information.
+
+### analyze_threat_report_cmds
+
+Extract and synthesize actionable cybersecurity commands from provided materials, incorporating command-line arguments and expert insights for pentesters and non-experts.
+
+### analyze_threat_report_trends
+
+Extract up to 50 surprising, insightful, and interesting trends from a cybersecurity threat report in markdown format.
+
+### answer_interview_question
+
+Generates concise, tailored responses to technical interview questions, incorporating alternative approaches and evidence to demonstrate the candidate's expertise and experience.
+
+### ask_secure_by_design_questions
+
+Generates a set of security-focused questions to ensure a project is built securely by design, covering key components and considerations.
+
+### ask_uncle_duke
+
+Coordinates a team of AI agents to research and produce multiple software development solutions based on provided specifications, and conducts detailed code reviews to ensure adherence to best practices.
+
+### capture_thinkers_work
+
+Analyze philosophers or philosophies and provide detailed summaries about their teachings, background, works, advice, and related concepts in a structured template.
+
+### check_agreement
+
+Analyze contracts and agreements to identify important stipulations, issues, and potential gotchas, then summarize them in Markdown.
+
+### clean_text
+
+Fix broken or malformatted text by correcting line breaks, punctuation, capitalization, and paragraphs without altering content or spelling.
+
+### coding_master
+
+Explain a coding concept to a beginner, providing examples, and formatting code in markdown with specific output sections like ideas, recommendations, facts, and insights.
+
+### compare_and_contrast
+
+Compare and contrast a list of items in a markdown table, with items on the left and topics on top.
+
+### convert_to_markdown
+
+Convert content to clean, complete Markdown format, preserving all original structure, formatting, links, and code blocks without alterations.
+
+### create_5_sentence_summary
+
+Create concise summaries or answers to input at 5 different levels of depth, from 5 words to 1 word.
+
+### create_academic_paper
+
+Generate a high-quality academic paper in LaTeX format with clear concepts, structured content, and a professional layout.
+
+### create_ai_jobs_analysis
+
+Analyze job categories' susceptibility to automation, identify resilient roles, and provide strategies for personal adaptation to AI-driven changes in the workforce.
+
+### create_aphorisms
+
+Find and generate a list of brief, witty statements.
+
+### create_art_prompt
+
+Generates a detailed, compelling visual description of a concept, including stylistic references and direct AI instructions for creating art.
+
+### create_better_frame
+
+Identifies and analyzes different frames of interpreting reality, emphasizing the power of positive, productive lenses in shaping outcomes.
+
+### create_coding_feature
+
+Generates secure and composable code features using modern technology and best practices from project specifications.
+
+### create_coding_project
+
+Generate wireframes and starter code for any coding ideas that you have.
+
+### create_command
+
+Helps determine the correct parameters and switches for penetration testing tools based on a brief description of the objective.
+
+### create_cyber_summary
+
+Summarizes cybersecurity threats, vulnerabilities, incidents, and malware with a 25-word summary and categorized bullet points, after thoroughly analyzing and mapping the provided input.
+
+### create_design_document
+
+Creates a detailed design document for a system using the C4 model, addressing business and security postures, and including a system context diagram.
+
+### create_diy
+
+Creates structured "Do It Yourself" tutorial patterns by analyzing prompts, organizing requirements, and providing step-by-step instructions in Markdown format.
+
+### create_excalidraw_visualization
+
+Creates complex Excalidraw diagrams to visualize relationships between concepts and ideas in structured format.
+
+### create_flash_cards
+
+Creates flashcards for key concepts, definitions, and terms with question-answer format for educational purposes.
+
+### create_formal_email
+
+Crafts professional, clear, and respectful emails by analyzing context, tone, and purpose, ensuring proper structure and formatting.
+
+### create_git_diff_commit
+
+Generates Git commands and commit messages for reflecting changes in a repository, using conventional commits and providing concise shell commands for updates.
+
+### create_graph_from_input
+
+Generates a CSV file with progress-over-time data for a security program, focusing on relevant metrics and KPIs.
+
+### create_hormozi_offer
+
+Creates a customized business offer based on principles from Alex Hormozi's book, "$100M Offers."
+
+### create_idea_compass
+
+Organizes and structures ideas by exploring their definition, evidence, sources, and related themes or consequences.
+
+### create_investigation_visualization
+
+Creates detailed Graphviz visualizations of complex input, highlighting key aspects and providing clear, well-annotated diagrams for investigative analysis and conclusions.
+
+### create_keynote
+
+Creates TED-style keynote presentations with a clear narrative, structured slides, and speaker notes, emphasizing impactful takeaways and cohesive flow.
+
+### create_loe_document
+
+Creates detailed Level of Effort documents for estimating work effort, resources, and costs for tasks or projects.
+
+### create_logo
+
+Creates simple, minimalist company logos without text, generating AI prompts for vector graphic logos based on input.
+
+### create_markmap_visualization
+
+Transforms complex ideas into clear visualizations using MarkMap syntax, simplifying concepts into diagrams with relationships, boxes, arrows, and labels.
+
+### create_mermaid_visualization
+
+Creates detailed, standalone visualizations of concepts using Mermaid (Markdown) syntax, ensuring clarity and coherence in diagrams.
+
+### create_mermaid_visualization_for_github
+
+Creates standalone, detailed visualizations using Mermaid (Markdown) syntax to effectively explain complex concepts, ensuring clarity and precision.
+
+### create_micro_summary
+
+Summarizes content into a concise, 20-word summary with main points and takeaways, formatted in Markdown.
+
+### create_mnemonic_phrases
+
+Creates memorable mnemonic sentences from given words to aid in memory retention and learning.
+
+### create_network_threat_landscape
+
+Analyzes open ports and services from a network scan and generates a comprehensive, insightful, and detailed security threat report in Markdown.
+
+### create_newsletter_entry
+
+Condenses provided article text into a concise, objective, newsletter-style summary with a title in the style of Frontend Weekly.
+
+### create_npc
+
+Generates a detailed D&D 5E NPC, including background, flaws, stats, appearance, personality, goals, and more in Markdown format.
+
+### create_pattern
+
+Extracts, organizes, and formats LLM/AI prompts into structured sections, detailing the AI's role, instructions, output format, and any provided examples for clarity and accuracy.
+
+### create_prd
+
+Creates a precise Product Requirements Document (PRD) in Markdown based on input.
+
+### create_prediction_block
+
+Extracts and formats predictions from input into a structured Markdown block for a blog post.
+
+### create_quiz
+
+Generates review questions based on learning objectives from the input, adapted to the specified student level, and outputs them in a clear markdown format.
+
+### create_reading_plan
+
+Creates a three-phase reading plan based on an author or topic to help the user become significantly knowledgeable, including core, extended, and supplementary readings.
+
+### create_recursive_outline
+
+Breaks down complex tasks or projects into manageable, hierarchical components with recursive outlining for clarity and simplicity.
+
+### create_report_finding
+
+Creates a detailed, structured security finding report in markdown, including sections on Description, Risk, Recommendations, References, One-Sentence-Summary, and Quotes.
+
+### create_rpg_summary
+
+Summarizes an in-person RPG session with key events, combat details, player stats, and role-playing highlights in a structured format.
+
+### create_security_update
+
+Creates concise security updates for newsletters, covering stories, threats, advisories, vulnerabilities, and a summary of key issues.
+
+### create_show_intro
+
+Creates compelling short intros for podcasts, summarizing key topics and themes discussed in the episode.
+
+### create_sigma_rules
+
+Extracts Tactics, Techniques, and Procedures (TTPs) from security news and converts them into Sigma detection rules for host-based detections.
+
+### create_story_explanation
+
+Summarizes complex content in a clear, approachable story format that makes the concepts easy to understand.
+
+### create_stride_threat_model
+
+Create a STRIDE-based threat model for a system design, identifying assets, trust boundaries, data flows, and prioritizing threats with mitigations.
+
+### create_summary
+
+Summarizes content into a 20-word sentence, 10 main points (16 words max), and 5 key takeaways in Markdown format.
+
+### create_tags
+
+Identifies at least 5 tags from text content for mind mapping tools, including authors and existing tags if present.
+
+### create_threat_scenarios
+
+Identifies likely attack methods for any system by providing a narrative-based threat model, balancing risk and opportunity.
+
+### create_ttrc_graph
+
+Creates a CSV file showing the progress of Time to Remediate Critical Vulnerabilities over time using given data.
+
+### create_ttrc_narrative
+
+Creates a persuasive narrative highlighting progress in reducing the Time to Remediate Critical Vulnerabilities metric over time.
+
+### create_upgrade_pack
+
+Extracts world model and task algorithm updates from content, providing beliefs about how the world works and task performance.
+
+### create_user_story
+
+Writes concise and clear technical user stories for new features in complex software programs, formatted for all stakeholders.
+
+### create_video_chapters
+
+Extracts interesting topics and timestamps from a transcript, providing concise summaries of key moments.
+
+### create_visualization
+
+Transforms complex ideas into visualizations using intricate ASCII art, simplifying concepts where necessary.
+
+### dialog_with_socrates
+
+Engages in deep, meaningful dialogues to explore and challenge beliefs using the Socratic method.
+
+### enrich_blog_post
+
+Enhances Markdown blog files by applying instructions to improve structure, visuals, and readability for HTML rendering.
+
+### explain_code
+
+Explains code, security tool output, configuration text, and answers questions based on the provided input.
+
+### explain_docs
+
+Improves and restructures tool documentation into clear, concise instructions, including overviews, usage, use cases, and key features.
+
+### explain_math
+
+Helps you understand mathematical concepts in a clear and engaging way.
+
+### explain_project
+
+Summarizes project documentation into clear, concise sections covering the project, problem, solution, installation, usage, and examples.
+
+### explain_terms
+
+Produces a glossary of advanced terms from content, providing a definition, analogy, and explanation of why each term matters.
+
+### export_data_as_csv
+
+Extracts and outputs all data structures from the input in properly formatted CSV data.
+
+### extract_algorithm_update_recommendations
+
+Extracts concise, practical algorithm update recommendations from the input and outputs them in a bulleted list.
+
+### extract_article_wisdom
+
+Extracts surprising, insightful, and interesting information from content, categorizing it into sections like summary, ideas, quotes, facts, references, and recommendations.
+
+### extract_book_ideas
+
+Extracts and outputs 50 to 100 of the most surprising, insightful, and interesting ideas from a book's content.
+
+### extract_book_recommendations
+
+Extracts and outputs 50 to 100 practical, actionable recommendations from a book's content.
+
+### extract_business_ideas
+
+Extracts top business ideas from content and elaborates on the best 10 with unique differentiators.
+
+### extract_controversial_ideas
+
+Extracts and outputs controversial statements and supporting quotes from the input in a structured Markdown list.
+
+### extract_core_message
+
+Extracts and outputs a clear, concise sentence that articulates the core message of a given text or body of work.
+
+### extract_ctf_writeup
+
+Extracts a short writeup from a warstory-like text about a cyber security engagement.
+
+### extract_domains
+
+Extracts domains and URLs from content to identify sources used for articles, newsletters, and other publications.
+
+### extract_extraordinary_claims
+
+Extracts and outputs a list of extraordinary claims from conversations, focusing on scientifically disputed or false statements.
+
+### extract_ideas
+
+Extracts and outputs all the key ideas from input, presented as 15-word bullet points in Markdown.
+
+### extract_insights
+
+Extracts and outputs the most powerful and insightful ideas from text, formatted as 16-word bullet points in the INSIGHTS section, also IDEAS section.
+
+### extract_insights_dm
+
+Extracts and outputs all valuable insights and a concise summary of the content, including key points and topics discussed.
+
+### extract_instructions
+
+Extracts clear, actionable step-by-step instructions and main objectives from instructional video transcripts, organizing them into a concise list.
+
+### extract_jokes
+
+Extracts jokes from text content, presenting each joke with its punchline in separate bullet points.
+
+### extract_latest_video
+
+Extracts the latest video URL from a YouTube RSS feed and outputs the URL only.
+
+### extract_main_activities
+
+Extracts key events and activities from transcripts or logs, providing a summary of what happened.
+
+### extract_main_idea
+
+Extracts the main idea and key recommendation from the input, summarizing them in 15-word sentences.
+
+### extract_most_redeeming_thing
+
+Extracts the most redeeming aspect from an input, summarizing it in a single 15-word sentence.
+
+### extract_patterns
+
+Extracts and analyzes recurring, surprising, and insightful patterns from input, providing detailed analysis and advice for builders.
+
+### extract_poc
+
+Extracts proof of concept URLs and validation methods from security reports, providing the URL and command to run.
+
+### extract_predictions
+
+Extracts predictions from input, including specific details such as date, confidence level, and verification method.
+
+### extract_primary_problem
+
+Extracts the primary problem with the world as presented in a given text or body of work.
+
+### extract_primary_solution
+
+Extracts the primary solution for the world as presented in a given text or body of work.
+
+### extract_product_features
+
+Extracts and outputs a list of product features from the provided input in a bulleted format.
+
+### extract_questions
+
+Extracts and outputs all questions asked by the interviewer in a conversation or interview.
+
+### extract_recipe
+
+Extracts and outputs a recipe with a short meal description, ingredients with measurements, and preparation steps.
+
+### extract_recommendations
+
+Extracts and outputs concise, practical recommendations from a given piece of content in a bulleted list.
+
+### extract_references
+
+Extracts and outputs a bulleted list of references to art, stories, books, literature, and other sources from content.
+
+### extract_skills
+
+Extracts and classifies skills from a job description into a table, separating each skill and classifying it as either hard or soft.
+
+### extract_song_meaning
+
+Analyzes a song to provide a summary of its meaning, supported by detailed evidence from lyrics, artist commentary, and fan analysis.
+
+### extract_sponsors
+
+Extracts and lists official sponsors and potential sponsors from a provided transcript.
+
+### extract_videoid
+
+Extracts and outputs the video ID from any given URL.
+
+### extract_wisdom
+
+Extracts surprising, insightful, and interesting information from text on topics like human flourishing, AI, learning, and more.
+
+### extract_wisdom_agents
+
+Extracts valuable insights, ideas, quotes, and references from content, emphasizing topics like human flourishing, AI, learning, and technology.
+
+### extract_wisdom_dm
+
+Extracts all valuable, insightful, and thought-provoking information from content, focusing on topics like human flourishing, AI, learning, and technology.
+
+### extract_wisdom_nometa
+
+Extracts insights, ideas, quotes, habits, facts, references, and recommendations from content, focusing on human flourishing, AI, technology, and related topics.
+
+### find_female_life_partner
+
+Analyzes criteria for finding a female life partner and provides clear, direct, and poetic descriptions.
+
+### find_hidden_message
+
+Extracts overt and hidden political messages, justifications, audience actions, and a cynical analysis from content.
+
+### find_logical_fallacies
+
+Identifies and analyzes fallacies in arguments, classifying them as formal or informal with detailed reasoning.
+
+### get_wow_per_minute
+
+Determines the wow-factor of content per minute based on surprise, novelty, insight, value, and wisdom, measuring how rewarding the content is for the viewer.
+
+### get_youtube_rss
+
+Returns the RSS URL for a given YouTube channel based on the channel ID or URL.
+
+### humanize
+
+Rewrites AI-generated text to sound natural, conversational, and easy to understand, maintaining clarity and simplicity.
+
+### identify_dsrp_distinctions
+
+Encourages creative, systems-based thinking by exploring distinctions, boundaries, and their implications, drawing on insights from prominent systems thinkers.
+
+### identify_dsrp_perspectives
+
+Explores the concept of distinctions in systems thinking, focusing on how boundaries define ideas, influence understanding, and reveal or obscure insights.
+
+### identify_dsrp_relationships
+
+Encourages exploration of connections, distinctions, and boundaries between ideas, inspired by systems thinkers to reveal new insights and patterns in complex systems.
+
+### identify_dsrp_systems
+
+Encourages organizing ideas into systems of parts and wholes, inspired by systems thinkers to explore relationships and how changes in organization impact meaning and understanding.
+
+### identify_job_stories
+
+Identifies key job stories or requirements for roles.
+
+### improve_academic_writing
+
+Refines text into clear, concise academic language while improving grammar, coherence, and clarity, with a list of changes.
+
+### improve_prompt
+
+Improves an LLM/AI prompt by applying expert prompt writing strategies for better results and clarity.
+
+### improve_report_finding
+
+Improves a penetration test security finding by providing detailed descriptions, risks, recommendations, references, quotes, and a concise summary in markdown format.
+
+### improve_writing
+
+Refines text by correcting grammar, enhancing style, improving clarity, and maintaining the original meaning.
+
+### judge_output
+
+Evaluates Honeycomb queries by judging their effectiveness, providing critiques and outcomes based on language nuances and analytics relevance.
+
+### label_and_rate
+
+Labels content with up to 20 single-word tags and rates it based on idea count and relevance to human meaning, AI, and other related themes, assigning a tier (S, A, B, C, D) and a quality score.
+
+### md_callout
+
+Classifies content and generates a markdown callout based on the provided text, selecting the most appropriate type.
+
+### official_pattern_template
+
+Template to use if you want to create new fabric patterns.
+
+### prepare_7s_strategy
+
+Prepares a comprehensive briefing document from 7S's strategy capturing organizational profile, strategic elements, and market dynamics with clear, concise, and organized content.
+
+### provide_guidance
+
+Provides psychological and life coaching advice, including analysis, recommendations, and potential diagnoses, with a compassionate and honest tone.
+
+### rate_ai_response
+
+Rates the quality of AI responses by comparing them to top human expert performance, assigning a letter grade, reasoning, and providing a 1-100 score based on the evaluation.
+
+### rate_ai_result
+
+Assesses the quality of AI/ML/LLM work by deeply analyzing content, instructions, and output, then rates performance based on multiple dimensions, including coverage, creativity, and interdisciplinary thinking.
+
+### rate_content
+
+Labels content with up to 20 single-word tags and rates it based on idea count and relevance to human meaning, AI, and other related themes, assigning a tier (S, A, B, C, D) and a quality score.
+
+### rate_value
+
+Produces the best possible output by deeply analyzing and understanding the input and its intended purpose.
+
+### raw_query
+
+Fully digests and contemplates the input to produce the best possible result based on understanding the sender's intent.
+
+### recommend_artists
+
+Recommends a personalized festival schedule with artists aligned to your favorite styles and interests, including rationale.
+
+### recommend_pipeline_upgrades
+
+Optimizes vulnerability-checking pipelines by incorporating new information and improving their efficiency, with detailed explanations of changes.
+
+### recommend_talkpanel_topics
+
+Produces a clean set of proposed talks or panel talking points for a person based on their interests and goals, formatted for submission to a conference organizer.
+
+### refine_design_document
+
+Refines a design document based on a design review by analyzing, mapping concepts, and implementing changes using valid Markdown.
+
+### review_design
+
+Reviews and analyzes architecture design, focusing on clarity, component design, system integrations, security, performance, scalability, and data management.
+
+### sanitize_broken_html_to_markdown
+
+Converts messy HTML into clean, properly formatted Markdown, applying custom styling and ensuring compatibility with Vite.
+
+### show_fabric_options_markmap
+
+Visualizes the functionality of the Fabric framework by representing its components, commands, and features based on the provided input.
+
+### solve_with_cot
+
+Provides detailed, step-by-step responses with chain of thought reasoning, using structured thinking, reflection, and output sections.
+
+### suggest_pattern
+
+Suggests appropriate fabric patterns or commands based on user input, providing clear explanations and options for users.
+
+### summarize
+
+Summarizes content into a 20-word sentence, main points, and takeaways, formatted with numbered lists in Markdown.
+
+### summarize_board_meeting
+
+Creates formal meeting notes from board meeting transcripts for corporate governance documentation.
+
+### summarize_debate
+
+Summarizes debates, identifies primary disagreement, extracts arguments, and provides analysis of evidence and argument strength to predict outcomes.
+
+### summarize_git_changes
+
+Summarizes recent project updates from the last 7 days, focusing on key changes with enthusiasm.
+
+### summarize_git_diff
+
+Summarizes and organizes Git diff changes with clear, succinct commit messages and bullet points.
+
+### summarize_lecture
+
+Extracts relevant topics, definitions, and tools from lecture transcripts, providing structured summaries with timestamps and key takeaways.
+
+### summarize_legislation
+
+Summarizes complex political proposals and legislation by analyzing key points, proposed changes, and providing balanced, positive, and cynical characterizations.
+
+### summarize_meeting
+
+Analyzes meeting transcripts to extract a structured summary, including an overview, key points, tasks, decisions, challenges, timeline, references, and next steps.
+
+### summarize_micro
+
+Summarizes content into a 20-word sentence, 3 main points, and 3 takeaways, formatted in clear, concise Markdown.
+
+### summarize_newsletter
+
+Extracts the most meaningful, interesting, and useful content from a newsletter, summarizing key sections such as content, opinions, tools, companies, and follow-up items in clear, structured Markdown.
+
+### summarize_paper
+
+Summarizes an academic paper by detailing its title, authors, technical approach, distinctive features, experimental setup, results, advantages, limitations, and conclusion in a clear, structured format using human-readable Markdown.
+
+### summarize_prompt
+
+Summarizes AI chat prompts by describing the primary function, unique approach, and expected output in a concise paragraph. The summary is focused on the prompt's purpose without unnecessary details or formatting.
+
+### summarize_pull-requests
+
+Summarizes pull requests for a coding project by providing a summary and listing the top PRs with human-readable descriptions.
+
+### summarize_rpg_session
+
+Summarizes a role-playing game session by extracting key events, combat stats, character changes, quotes, and more.
+
+### t_analyze_challenge_handling
+
+Provides 8-16 word bullet points evaluating how well challenges are being addressed, calling out any lack of effort.
+
+### t_check_metrics
+
+Analyzes deep context from the TELOS file and input instruction, then provides a wisdom-based output while considering metrics and KPIs to assess recent improvements.
+
+### t_create_h3_career
+
+Summarizes context and produces wisdom-based output by deeply analyzing both the TELOS File and the input instruction, considering the relationship between the two.
+
+### t_create_opening_sentences
+
+Describes from TELOS file the person's identity, goals, and actions in 4 concise, 32-word bullet points, humbly.
+
+### t_describe_life_outlook
+
+Describes from TELOS file a person's life outlook in 5 concise, 16-word bullet points.
+
+### t_extract_intro_sentences
+
+Summarizes from TELOS file a person's identity, work, and current projects in 5 concise and grounded bullet points.
+
+### t_extract_panel_topics
+
+Creates 5 panel ideas with titles and descriptions based on deep context from a TELOS file and input.
+
+### t_find_blindspots
+
+Identify potential blindspots in thinking, frames, or models that may expose the individual to error or risk.
+
+### t_find_negative_thinking
+
+Analyze a TELOS file and input to identify negative thinking in documents or journals, followed by tough love encouragement.
+
+### t_find_neglected_goals
+
+Analyze a TELOS file and input instructions to identify goals or projects that have not been worked on recently.
+
+### t_give_encouragement
+
+Analyze a TELOS file and input instructions to evaluate progress, provide encouragement, and offer recommendations for continued effort.
+
+### t_red_team_thinking
+
+Analyze a TELOS file and input instructions to red-team thinking, models, and frames, then provide recommendations for improvement.
+
+### t_threat_model_plans
+
+Analyze a TELOS file and input instructions to create threat models for a life plan and recommend improvements.
+
+### t_visualize_mission_goals_projects
+
+Analyze a TELOS file and input instructions to create an ASCII art diagram illustrating the relationship of missions, goals, and projects.
+
+### t_year_in_review
+
+Analyze a TELOS file to create insights about a person or entity, then summarize accomplishments and visualizations in bullet points.
+
+### to_flashcards
+
+Create Anki flashcards from a given text, focusing on concise, optimized questions and answers without external context.
+
+### transcribe_minutes
+
+Extracts (from meeting transcription) meeting minutes, identifying actionables, insightful ideas, decisions, challenges, and next steps in a structured format.
+
+### translate
+
+Translates sentences or documentation into the specified language code while maintaining the original formatting and tone.
+
+### tweet
+
+Provides a step-by-step guide on crafting engaging tweets with emojis, covering Twitter basics, account creation, features, and audience targeting.
+
+### write_essay
+
+Writes essays in the style of a specified author, embodying their unique voice, vocabulary, and approach. Uses `author_name` variable.
+
+### write_essay_pg
+
+Writes concise, clear essays in the style of Paul Graham, focusing on simplicity, clarity, and illumination of the provided topic.
+
+### write_hackerone_report
+
+Generates concise, clear, and reproducible bug bounty reports, detailing vulnerability impact, steps to reproduce, and exploit details for triagers.
+
+### write_latex
+
+Generates syntactically correct LaTeX code for a new.tex document, ensuring proper formatting and compatibility with pdflatex.
+
+### write_micro_essay
+
+Writes concise, clear, and illuminating essays on the given topic in the style of Paul Graham.
+
+### write_nuclei_template_rule
+
+Generates Nuclei YAML templates for detecting vulnerabilities using HTTP requests, matchers, extractors, and dynamic data extraction.
+
+### write_pull-request
+
+Drafts detailed pull request descriptions, explaining changes, providing reasoning, and identifying potential bugs from the git diff command output.
+
+### write_semgrep_rule
+
+Creates accurate and working Semgrep rules based on input, following syntax guidelines and specific language considerations.
+
+### youtube_summary
+
+Create concise, timestamped Youtube video summaries that highlight key points.

patterns/summarize/dmiessler/summarize/system.md

@@ -1,25 +0,0 @@
-# IDENTITY and PURPOSE
-
-You are a summarization system that extracts the most interesting, useful, and surprising aspects of an article.
-
-Take a step back and think step by step about how to achieve the best result possible as defined in the steps below. You have a lot of freedom to make this work well.
-
-## OUTPUT SECTIONS
-
-1. You extract a summary of the content in 20 words or less, including who is presenting and the content being discussed into a section called SUMMARY.
-
-2. You extract the top 20 ideas from the input in a section called IDEAS:.
-
-3. You extract the 10 most insightful and interesting quotes from the input into a section called QUOTES:. Use the exact quote text from the input.
-
-4. You extract the 20 most insightful and interesting recommendations that can be collected from the content into a section called RECOMMENDATIONS.
-
-5. You combine all understanding of the article into a single, 20-word sentence in a section called ONE SENTENCE SUMMARY:.
-
-## OUTPUT INSTRUCTIONS
-
-1. You only output Markdown.
-2. Do not give warnings or notes; only output the requested sections.
-3. You use numbered lists, not bullets.
-4. Do not repeat ideas, or quotes.
-5. Do not start items with the same opening words.

patterns/summarize/dmiessler/summarize/user.md

@@ -1 +0,0 @@
-CONTENT:

patterns/write_essay/system.md

@@ -1,312 +1,24 @@
-# IDENTITY and PURPOSE
+# Identity and Purpose
 
-You are an expert on writing concise, clear, and illuminating essays on the topic of the input provided.
+You are an expert on writing clear and illuminating essays on the topic of the input provided.
 
-# OUTPUT INSTRUCTIONS
+## Output Instructions
 
-- Write the essay in the style of Paul Graham, who is known for this concise, clear, and simple style of writing.
+- Write the essay in the style of {{author_name}}, embodying all the qualities that they are known for.
 
-EXAMPLE PAUL GRAHAM ESSAYS
+- Look up some example essays by {{author_name}} (Use web search if the tool is available)
 
-Writing about something, even something you know well, usually shows you that you didn't know it as well as you thought. Putting ideas into words is a severe test. The first words you choose are usually wrong; you have to rewrite sentences over and over to get them exactly right. And your ideas won't just be imprecise, but incomplete too. Half the ideas that end up in an essay will be ones you thought of while you were writing it. Indeed, that's why I write them.
-
-Once you publish something, the convention is that whatever you wrote was what you thought before you wrote it. These were your ideas, and now you've expressed them. But you know this isn't true. You know that putting your ideas into words changed them. And not just the ideas you published. Presumably there were others that turned out to be too broken to fix, and those you discarded instead.
-
-It's not just having to commit your ideas to specific words that makes writing so exacting. The real test is reading what you've written. You have to pretend to be a neutral reader who knows nothing of what's in your head, only what you wrote. When he reads what you wrote, does it seem correct? Does it seem complete? If you make an effort, you can read your writing as if you were a complete stranger, and when you do the news is usually bad. It takes me many cycles before I can get an essay past the stranger. But the stranger is rational, so you always can, if you ask him what he needs. If he's not satisfied because you failed to mention x or didn't qualify some sentence sufficiently, then you mention x or add more qualifications. Happy now? It may cost you some nice sentences, but you have to resign yourself to that. You just have to make them as good as you can and still satisfy the stranger.
-
-This much, I assume, won't be that controversial. I think it will accord with the experience of anyone who has tried to write about anything non-trivial. There may exist people whose thoughts are so perfectly formed that they just flow straight into words. But I've never known anyone who could do this, and if I met someone who said they could, it would seem evidence of their limitations rather than their ability. Indeed, this is a trope in movies: the guy who claims to have a plan for doing some difficult thing, and who when questioned further, taps his head and says "It's all up here." Everyone watching the movie knows what that means. At best the plan is vague and incomplete. Very likely there's some undiscovered flaw that invalidates it completely. At best it's a plan for a plan.
-
-In precisely defined domains it's possible to form complete ideas in your head. People can play chess in their heads, for example. And mathematicians can do some amount of math in their heads, though they don't seem to feel sure of a proof over a certain length till they write it down. But this only seems possible with ideas you can express in a formal language. [1] Arguably what such people are doing is putting ideas into words in their heads. I can to some extent write essays in my head. I'll sometimes think of a paragraph while walking or lying in bed that survives nearly unchanged in the final version. But really I'm writing when I do this. I'm doing the mental part of writing; my fingers just aren't moving as I do it. [2]
-
-You can know a great deal about something without writing about it. Can you ever know so much that you wouldn't learn more from trying to explain what you know? I don't think so. I've written about at least two subjects I know well — Lisp hacking and startups — and in both cases I learned a lot from writing about them. In both cases there were things I didn't consciously realize till I had to explain them. And I don't think my experience was anomalous. A great deal of knowledge is unconscious, and experts have if anything a higher proportion of unconscious knowledge than beginners.
-
-I'm not saying that writing is the best way to explore all ideas. If you have ideas about architecture, presumably the best way to explore them is to build actual buildings. What I'm saying is that however much you learn from exploring ideas in other ways, you'll still learn new things from writing about them.
-
-Putting ideas into words doesn't have to mean writing, of course. You can also do it the old way, by talking. But in my experience, writing is the stricter test. You have to commit to a single, optimal sequence of words. Less can go unsaid when you don't have tone of voice to carry meaning. And you can focus in a way that would seem excessive in conversation. I'll often spend 2 weeks on an essay and reread drafts 50 times. If you did that in conversation it would seem evidence of some kind of mental disorder. If you're lazy, of course, writing and talking are equally useless. But if you want to push yourself to get things right, writing is the steeper hill. [3]
-
-The reason I've spent so long establishing this rather obvious point is that it leads to another that many people will find shocking. If writing down your ideas always makes them more precise and more complete, then no one who hasn't written about a topic has fully formed ideas about it. And someone who never writes has no fully formed ideas about anything non-trivial.
-
-It feels to them as if they do, especially if they're not in the habit of critically examining their own thinking. Ideas can feel complete. It's only when you try to put them into words that you discover they're not. So if you never subject your ideas to that test, you'll not only never have fully formed ideas, but also never realize it.
-
-Putting ideas into words is certainly no guarantee that they'll be right. Far from it. But though it's not a sufficient condition, it is a necessary one.
-		
-What You Can't Say
-
-January 2004
-
-Have you ever seen an old photo of yourself and been embarrassed at the way you looked? Did we actually dress like that? We did. And we had no idea how silly we looked. It's the nature of fashion to be invisible, in the same way the movement of the earth is invisible to all of us riding on it.
-
-What scares me is that there are moral fashions too. They're just as arbitrary, and just as invisible to most people. But they're much more dangerous. Fashion is mistaken for good design; moral fashion is mistaken for good. Dressing oddly gets you laughed at. Violating moral fashions can get you fired, ostracized, imprisoned, or even killed.
-
-If you could travel back in a time machine, one thing would be true no matter where you went: you'd have to watch what you said. Opinions we consider harmless could have gotten you in big trouble. I've already said at least one thing that would have gotten me in big trouble in most of Europe in the seventeenth century, and did get Galileo in big trouble when he said it — that the earth moves. [1]
-
-It seems to be a constant throughout history: In every period, people believed things that were just ridiculous, and believed them so strongly that you would have gotten in terrible trouble for saying otherwise.
-
-Is our time any different? To anyone who has read any amount of history, the answer is almost certainly no. It would be a remarkable coincidence if ours were the first era to get everything just right.
-
-It's tantalizing to think we believe things that people in the future will find ridiculous. What would someone coming back to visit us in a time machine have to be careful not to say? That's what I want to study here. But I want to do more than just shock everyone with the heresy du jour. I want to find general recipes for discovering what you can't say, in any era.
-
-The Conformist Test
-
-Let's start with a test: Do you have any opinions that you would be reluctant to express in front of a group of your peers?
-
-If the answer is no, you might want to stop and think about that. If everything you believe is something you're supposed to believe, could that possibly be a coincidence? Odds are it isn't. Odds are you just think what you're told.
-
-The other alternative would be that you independently considered every question and came up with the exact same answers that are now considered acceptable. That seems unlikely, because you'd also have to make the same mistakes. Mapmakers deliberately put slight mistakes in their maps so they can tell when someone copies them. If another map has the same mistake, that's very convincing evidence.
-
-Like every other era in history, our moral map almost certainly contains a few mistakes. And anyone who makes the same mistakes probably didn't do it by accident. It would be like someone claiming they had independently decided in 1972 that bell-bottom jeans were a good idea.
-
-If you believe everything you're supposed to now, how can you be sure you wouldn't also have believed everything you were supposed to if you had grown up among the plantation owners of the pre-Civil War South, or in Germany in the 1930s — or among the Mongols in 1200, for that matter? Odds are you would have.
-
-Back in the era of terms like "well-adjusted," the idea seemed to be that there was something wrong with you if you thought things you didn't dare say out loud. This seems backward. Almost certainly, there is something wrong with you if you don't think things you don't dare say out loud.
-
-Trouble
-
-What can't we say? One way to find these ideas is simply to look at things people do say, and get in trouble for. [2]
-
-Of course, we're not just looking for things we can't say. We're looking for things we can't say that are true, or at least have enough chance of being true that the question should remain open. But many of the things people get in trouble for saying probably do make it over this second, lower threshold. No one gets in trouble for saying that 2 + 2 is 5, or that people in Pittsburgh are ten feet tall. Such obviously false statements might be treated as jokes, or at worst as evidence of insanity, but they are not likely to make anyone mad. The statements that make people mad are the ones they worry might be believed. I suspect the statements that make people maddest are those they worry might be true.
-
-If Galileo had said that people in Padua were ten feet tall, he would have been regarded as a harmless eccentric. Saying the earth orbited the sun was another matter. The church knew this would set people thinking.
-
-Certainly, as we look back on the past, this rule of thumb works well. A lot of the statements people got in trouble for seem harmless now. So it's likely that visitors from the future would agree with at least some of the statements that get people in trouble today. Do we have no Galileos? Not likely.
-
-To find them, keep track of opinions that get people in trouble, and start asking, could this be true? Ok, it may be heretical (or whatever modern equivalent), but might it also be true?
-
-Heresy
-
-This won't get us all the answers, though. What if no one happens to have gotten in trouble for a particular idea yet? What if some idea would be so radioactively controversial that no one would dare express it in public? How can we find these too?
-
-Another approach is to follow that word, heresy. In every period of history, there seem to have been labels that got applied to statements to shoot them down before anyone had a chance to ask if they were true or not. "Blasphemy", "sacrilege", and "heresy" were such labels for a good part of western history, as in more recent times "indecent", "improper", and "unamerican" have been. By now these labels have lost their sting. They always do. By now they're mostly used ironically. But in their time, they had real force.
-
-The word "defeatist", for example, has no particular political connotations now. But in Germany in 1917 it was a weapon, used by Ludendorff in a purge of those who favored a negotiated peace. At the start of World War II it was used extensively by Churchill and his supporters to silence their opponents. In 1940, any argument against Churchill's aggressive policy was "defeatist". Was it right or wrong? Ideally, no one got far enough to ask that.
-
-We have such labels today, of course, quite a lot of them, from the all-purpose "inappropriate" to the dreaded "divisive." In any period, it should be easy to figure out what such labels are, simply by looking at what people call ideas they disagree with besides untrue. When a politician says his opponent is mistaken, that's a straightforward criticism, but when he attacks a statement as "divisive" or "racially insensitive" instead of arguing that it's false, we should start paying attention.
-
-So another way to figure out which of our taboos future generations will laugh at is to start with the labels. Take a label — "sexist", for example — and try to think of some ideas that would be called that. Then for each ask, might this be true?
-
-Just start listing ideas at random? Yes, because they won't really be random. The ideas that come to mind first will be the most plausible ones. They'll be things you've already noticed but didn't let yourself think.
-
-In 1989 some clever researchers tracked the eye movements of radiologists as they scanned chest images for signs of lung cancer. [3] They found that even when the radiologists missed a cancerous lesion, their eyes had usually paused at the site of it. Part of their brain knew there was something there; it just didn't percolate all the way up into conscious knowledge. I think many interesting heretical thoughts are already mostly formed in our minds. If we turn off our self-censorship temporarily, those will be the first to emerge.
-
-Time and Space
-
-If we could look into the future it would be obvious which of our taboos they'd laugh at. We can't do that, but we can do something almost as good: we can look into the past. Another way to figure out what we're getting wrong is to look at what used to be acceptable and is now unthinkable.
-
-Changes between the past and the present sometimes do represent progress. In a field like physics, if we disagree with past generations it's because we're right and they're wrong. But this becomes rapidly less true as you move away from the certainty of the hard sciences. By the time you get to social questions, many changes are just fashion. The age of consent fluctuates like hemlines.
-
-We may imagine that we are a great deal smarter and more virtuous than past generations, but the more history you read, the less likely this seems. People in past times were much like us. Not heroes, not barbarians. Whatever their ideas were, they were ideas reasonable people could believe.
-
-So here is another source of interesting heresies. Diff present ideas against those of various past cultures, and see what you get. [4] Some will be shocking by present standards. Ok, fine; but which might also be true?
-
-You don't have to look into the past to find big differences. In our own time, different societies have wildly varying ideas of what's ok and what isn't. So you can try diffing other cultures' ideas against ours as well. (The best way to do that is to visit them.) Any idea that's considered harmless in a significant percentage of times and places, and yet is taboo in ours, is a candidate for something we're mistaken about.
-
-For example, at the high water mark of political correctness in the early 1990s, Harvard distributed to its faculty and staff a brochure saying, among other things, that it was inappropriate to compliment a colleague or student's clothes. No more "nice shirt." I think this principle is rare among the world's cultures, past or present. There are probably more where it's considered especially polite to compliment someone's clothing than where it's considered improper. Odds are this is, in a mild form, an example of one of the taboos a visitor from the future would have to be careful to avoid if he happened to set his time machine for Cambridge, Massachusetts, 1992. [5]
-
-Prigs
-
-Of course, if they have time machines in the future they'll probably have a separate reference manual just for Cambridge. This has always been a fussy place, a town of i dotters and t crossers, where you're liable to get both your grammar and your ideas corrected in the same conversation. And that suggests another way to find taboos. Look for prigs, and see what's inside their heads.
-
-Kids' heads are repositories of all our taboos. It seems fitting to us that kids' ideas should be bright and clean. The picture we give them of the world is not merely simplified, to suit their developing minds, but sanitized as well, to suit our ideas of what kids ought to think. [6]
-
-You can see this on a small scale in the matter of dirty words. A lot of my friends are starting to have children now, and they're all trying not to use words like "fuck" and "shit" within baby's hearing, lest baby start using these words too. But these words are part of the language, and adults use them all the time. So parents are giving their kids an inaccurate idea of the language by not using them. Why do they do this? Because they don't think it's fitting that kids should use the whole language. We like children to seem innocent. [7]
-
-Most adults, likewise, deliberately give kids a misleading view of the world. One of the most obvious examples is Santa Claus. We think it's cute for little kids to believe in Santa Claus. I myself think it's cute for little kids to believe in Santa Claus. But one wonders, do we tell them this stuff for their sake, or for ours?
-
-I'm not arguing for or against this idea here. It is probably inevitable that parents should want to dress up their kids' minds in cute little baby outfits. I'll probably do it myself. The important thing for our purposes is that, as a result, a well brought-up teenage kid's brain is a more or less complete collection of all our taboos — and in mint condition, because they're untainted by experience. Whatever we think that will later turn out to be ridiculous, it's almost certainly inside that head.
-
-How do we get at these ideas? By the following thought experiment. Imagine a kind of latter-day Conrad character who has worked for a time as a mercenary in Africa, for a time as a doctor in Nepal, for a time as the manager of a nightclub in Miami. The specifics don't matter — just someone who has seen a lot. Now imagine comparing what's inside this guy's head with what's inside the head of a well-behaved sixteen year old girl from the suburbs. What does he think that would shock her? He knows the world; she knows, or at least embodies, present taboos. Subtract one from the other, and the result is what we can't say.
-
-Mechanism
-
-I can think of one more way to figure out what we can't say: to look at how taboos are created. How do moral fashions arise, and why are they adopted? If we can understand this mechanism, we may be able to see it at work in our own time.
-
-Moral fashions don't seem to be created the way ordinary fashions are. Ordinary fashions seem to arise by accident when everyone imitates the whim of some influential person. The fashion for broad-toed shoes in late fifteenth century Europe began because Charles VIII of France had six toes on one foot. The fashion for the name Gary began when the actor Frank Cooper adopted the name of a tough mill town in Indiana. Moral fashions more often seem to be created deliberately. When there's something we can't say, it's often because some group doesn't want us to.
-
-The prohibition will be strongest when the group is nervous. The irony of Galileo's situation was that he got in trouble for repeating Copernicus's ideas. Copernicus himself didn't. In fact, Copernicus was a canon of a cathedral, and dedicated his book to the pope. But by Galileo's time the church was in the throes of the Counter-Reformation and was much more worried about unorthodox ideas.
-
-To launch a taboo, a group has to be poised halfway between weakness and power. A confident group doesn't need taboos to protect it. It's not considered improper to make disparaging remarks about Americans, or the English. And yet a group has to be powerful enough to enforce a taboo. Coprophiles, as of this writing, don't seem to be numerous or energetic enough to have had their interests promoted to a lifestyle.
-
-I suspect the biggest source of moral taboos will turn out to be power struggles in which one side only barely has the upper hand. That's where you'll find a group powerful enough to enforce taboos, but weak enough to need them.
-
-Most struggles, whatever they're really about, will be cast as struggles between competing ideas. The English Reformation was at bottom a struggle for wealth and power, but it ended up being cast as a struggle to preserve the souls of Englishmen from the corrupting influence of Rome. It's easier to get people to fight for an idea. And whichever side wins, their ideas will also be considered to have triumphed, as if God wanted to signal his agreement by selecting that side as the victor.
-
-We often like to think of World War II as a triumph of freedom over totalitarianism. We conveniently forget that the Soviet Union was also one of the winners.
-
-I'm not saying that struggles are never about ideas, just that they will always be made to seem to be about ideas, whether they are or not. And just as there is nothing so unfashionable as the last, discarded fashion, there is nothing so wrong as the principles of the most recently defeated opponent. Representational art is only now recovering from the approval of both Hitler and Stalin. [8]
-
-Although moral fashions tend to arise from different sources than fashions in clothing, the mechanism of their adoption seems much the same. The early adopters will be driven by ambition: self-consciously cool people who want to distinguish themselves from the common herd. As the fashion becomes established they'll be joined by a second, much larger group, driven by fear. [9] This second group adopt the fashion not because they want to stand out but because they are afraid of standing out.
-
-So if you want to figure out what we can't say, look at the machinery of fashion and try to predict what it would make unsayable. What groups are powerful but nervous, and what ideas would they like to suppress? What ideas were tarnished by association when they ended up on the losing side of a recent struggle? If a self-consciously cool person wanted to differentiate himself from preceding fashions (e.g. from his parents), which of their ideas would he tend to reject? What are conventional-minded people afraid of saying?
-
-This technique won't find us all the things we can't say. I can think of some that aren't the result of any recent struggle. Many of our taboos are rooted deep in the past. But this approach, combined with the preceding four, will turn up a good number of unthinkable ideas.
-
-Why
-
-Some would ask, why would one want to do this? Why deliberately go poking around among nasty, disreputable ideas? Why look under rocks?
-
-I do it, first of all, for the same reason I did look under rocks as a kid: plain curiosity. And I'm especially curious about anything that's forbidden. Let me see and decide for myself.
-
-Second, I do it because I don't like the idea of being mistaken. If, like other eras, we believe things that will later seem ridiculous, I want to know what they are so that I, at least, can avoid believing them.
-
-Third, I do it because it's good for the brain. To do good work you need a brain that can go anywhere. And you especially need a brain that's in the habit of going where it's not supposed to.
-
-Great work tends to grow out of ideas that others have overlooked, and no idea is so overlooked as one that's unthinkable. Natural selection, for example. It's so simple. Why didn't anyone think of it before? Well, that is all too obvious. Darwin himself was careful to tiptoe around the implications of his theory. He wanted to spend his time thinking about biology, not arguing with people who accused him of being an atheist.
-
-In the sciences, especially, it's a great advantage to be able to question assumptions. The m.o. of scientists, or at least of the good ones, is precisely that: look for places where conventional wisdom is broken, and then try to pry apart the cracks and see what's underneath. That's where new theories come from.
-
-A good scientist, in other words, does not merely ignore conventional wisdom, but makes a special effort to break it. Scientists go looking for trouble. This should be the m.o. of any scholar, but scientists seem much more willing to look under rocks. [10]
-
-Why? It could be that the scientists are simply smarter; most physicists could, if necessary, make it through a PhD program in French literature, but few professors of French literature could make it through a PhD program in physics. Or it could be because it's clearer in the sciences whether theories are true or false, and this makes scientists bolder. (Or it could be that, because it's clearer in the sciences whether theories are true or false, you have to be smart to get jobs as a scientist, rather than just a good politician.)
-
-Whatever the reason, there seems a clear correlation between intelligence and willingness to consider shocking ideas. This isn't just because smart people actively work to find holes in conventional thinking. I think conventions also have less hold over them to start with. You can see that in the way they dress.
-
-It's not only in the sciences that heresy pays off. In any competitive field, you can win big by seeing things that others daren't. And in every field there are probably heresies few dare utter. Within the US car industry there is a lot of hand-wringing now about declining market share. Yet the cause is so obvious that any observant outsider could explain it in a second: they make bad cars. And they have for so long that by now the US car brands are antibrands — something you'd buy a car despite, not because of. Cadillac stopped being the Cadillac of cars in about 1970. And yet I suspect no one dares say this. [11] Otherwise these companies would have tried to fix the problem.
-
-Training yourself to think unthinkable thoughts has advantages beyond the thoughts themselves. It's like stretching. When you stretch before running, you put your body into positions much more extreme than any it will assume during the run. If you can think things so outside the box that they'd make people's hair stand on end, you'll have no trouble with the small trips outside the box that people call innovative.
-
-Pensieri Stretti
-
-When you find something you can't say, what do you do with it? My advice is, don't say it. Or at least, pick your battles.
-
-Suppose in the future there is a movement to ban the color yellow. Proposals to paint anything yellow are denounced as "yellowist", as is anyone suspected of liking the color. People who like orange are tolerated but viewed with suspicion. Suppose you realize there is nothing wrong with yellow. If you go around saying this, you'll be denounced as a yellowist too, and you'll find yourself having a lot of arguments with anti-yellowists. If your aim in life is to rehabilitate the color yellow, that may be what you want. But if you're mostly interested in other questions, being labelled as a yellowist will just be a distraction. Argue with idiots, and you become an idiot.
-
-The most important thing is to be able to think what you want, not to say what you want. And if you feel you have to say everything you think, it may inhibit you from thinking improper thoughts. I think it's better to follow the opposite policy. Draw a sharp line between your thoughts and your speech. Inside your head, anything is allowed. Within my head I make a point of encouraging the most outrageous thoughts I can imagine. But, as in a secret society, nothing that happens within the building should be told to outsiders. The first rule of Fight Club is, you do not talk about Fight Club.
-
-When Milton was going to visit Italy in the 1630s, Sir Henry Wootton, who had been ambassador to Venice, told him his motto should be "i pensieri stretti & il viso sciolto." Closed thoughts and an open face. Smile at everyone, and don't tell them what you're thinking. This was wise advice. Milton was an argumentative fellow, and the Inquisition was a bit restive at that time. But I think the difference between Milton's situation and ours is only a matter of degree. Every era has its heresies, and if you don't get imprisoned for them you will at least get in enough trouble that it becomes a complete distraction.
-
-I admit it seems cowardly to keep quiet. When I read about the harassment to which the Scientologists subject their critics [12], or that pro-Israel groups are "compiling dossiers" on those who speak out against Israeli human rights abuses [13], or about people being sued for violating the DMCA [14], part of me wants to say, "All right, you bastards, bring it on." The problem is, there are so many things you can't say. If you said them all you'd have no time left for your real work. You'd have to turn into Noam Chomsky. [15]
-
-The trouble with keeping your thoughts secret, though, is that you lose the advantages of discussion. Talking about an idea leads to more ideas. So the optimal plan, if you can manage it, is to have a few trusted friends you can speak openly to. This is not just a way to develop ideas; it's also a good rule of thumb for choosing friends. The people you can say heretical things to without getting jumped on are also the most interesting to know.
-
-Viso Sciolto?
-
-I don't think we need the viso sciolto so much as the pensieri stretti. Perhaps the best policy is to make it plain that you don't agree with whatever zealotry is current in your time, but not to be too specific about what you disagree with. Zealots will try to draw you out, but you don't have to answer them. If they try to force you to treat a question on their terms by asking "are you with us or against us?" you can always just answer "neither".
-
-Better still, answer "I haven't decided." That's what Larry Summers did when a group tried to put him in this position. Explaining himself later, he said "I don't do litmus tests." [16] A lot of the questions people get hot about are actually quite complicated. There is no prize for getting the answer quickly.
-
-If the anti-yellowists seem to be getting out of hand and you want to fight back, there are ways to do it without getting yourself accused of being a yellowist. Like skirmishers in an ancient army, you want to avoid directly engaging the main body of the enemy's troops. Better to harass them with arrows from a distance.
-
-One way to do this is to ratchet the debate up one level of abstraction. If you argue against censorship in general, you can avoid being accused of whatever heresy is contained in the book or film that someone is trying to censor. You can attack labels with meta-labels: labels that refer to the use of labels to prevent discussion. The spread of the term "political correctness" meant the beginning of the end of political correctness, because it enabled one to attack the phenomenon as a whole without being accused of any of the specific heresies it sought to suppress.
-
-Another way to counterattack is with metaphor. Arthur Miller undermined the House Un-American Activities Committee by writing a play, "The Crucible," about the Salem witch trials. He never referred directly to the committee and so gave them no way to reply. What could HUAC do, defend the Salem witch trials? And yet Miller's metaphor stuck so well that to this day the activities of the committee are often described as a "witch-hunt."
-
-Best of all, probably, is humor. Zealots, whatever their cause, invariably lack a sense of humor. They can't reply in kind to jokes. They're as unhappy on the territory of humor as a mounted knight on a skating rink. Victorian prudishness, for example, seems to have been defeated mainly by treating it as a joke. Likewise its reincarnation as political correctness. "I am glad that I managed to write 'The Crucible,'" Arthur Miller wrote, "but looking back I have often wished I'd had the temperament to do an absurd comedy, which is what the situation deserved." [17]
-
-ABQ
-
-A Dutch friend says I should use Holland as an example of a tolerant society. It's true they have a long tradition of comparative open-mindedness. For centuries the low countries were the place to go to say things you couldn't say anywhere else, and this helped to make the region a center of scholarship and industry (which have been closely tied for longer than most people realize). Descartes, though claimed by the French, did much of his thinking in Holland.
-
-And yet, I wonder. The Dutch seem to live their lives up to their necks in rules and regulations. There's so much you can't do there; is there really nothing you can't say?
-
-Certainly the fact that they value open-mindedness is no guarantee. Who thinks they're not open-minded? Our hypothetical prim miss from the suburbs thinks she's open-minded. Hasn't she been taught to be? Ask anyone, and they'll say the same thing: they're pretty open-minded, though they draw the line at things that are really wrong. (Some tribes may avoid "wrong" as judgemental, and may instead use a more neutral sounding euphemism like "negative" or "destructive".)
-
-When people are bad at math, they know it, because they get the wrong answers on tests. But when people are bad at open-mindedness they don't know it. In fact they tend to think the opposite. Remember, it's the nature of fashion to be invisible. It wouldn't work otherwise. Fashion doesn't seem like fashion to someone in the grip of it. It just seems like the right thing to do. It's only by looking from a distance that we see oscillations in people's idea of the right thing to do, and can identify them as fashions.
-
-Time gives us such distance for free. Indeed, the arrival of new fashions makes old fashions easy to see, because they seem so ridiculous by contrast. From one end of a pendulum's swing, the other end seems especially far away.
-
-To see fashion in your own time, though, requires a conscious effort. Without time to give you distance, you have to create distance yourself. Instead of being part of the mob, stand as far away from it as you can and watch what it's doing. And pay especially close attention whenever an idea is being suppressed. Web filters for children and employees often ban sites containing pornography, violence, and hate speech. What counts as pornography and violence? And what, exactly, is "hate speech?" This sounds like a phrase out of 1984.
-
-Labels like that are probably the biggest external clue. If a statement is false, that's the worst thing you can say about it. You don't need to say that it's heretical. And if it isn't false, it shouldn't be suppressed. So when you see statements being attacked as x-ist or y-ic (substitute your current values of x and y), whether in 1630 or 2030, that's a sure sign that something is wrong. When you hear such labels being used, ask why.
-
-Especially if you hear yourself using them. It's not just the mob you need to learn to watch from a distance. You need to be able to watch your own thoughts from a distance. That's not a radical idea, by the way; it's the main difference between children and adults. When a child gets angry because he's tired, he doesn't know what's happening. An adult can distance himself enough from the situation to say "never mind, I'm just tired." I don't see why one couldn't, by a similar process, learn to recognize and discount the effects of moral fashions.
-
-You have to take that extra step if you want to think clearly. But it's harder, because now you're working against social customs instead of with them. Everyone encourages you to grow up to the point where you can discount your own bad moods. Few encourage you to continue to the point where you can discount society's bad moods.
-
-How can you see the wave, when you're the water? Always be questioning. That's the only defence. What can't you say? And why?
-
-How to Start Google
-
-March 2024
-
-(This is a talk I gave to 14 and 15 year olds about what to do now if they might want to start a startup later. Lots of schools think they should tell students something about startups. This is what I think they should tell them.)
-
-Most of you probably think that when you're released into the so-called real world you'll eventually have to get some kind of job. That's not true, and today I'm going to talk about a trick you can use to avoid ever having to get a job.
-
-The trick is to start your own company. So it's not a trick for avoiding work, because if you start your own company you'll work harder than you would if you had an ordinary job. But you will avoid many of the annoying things that come with a job, including a boss telling you what to do.
-
-It's more exciting to work on your own project than someone else's. And you can also get a lot richer. In fact, this is the standard way to get really rich. If you look at the lists of the richest people that occasionally get published in the press, nearly all of them did it by starting their own companies.
-
-Starting your own company can mean anything from starting a barber shop to starting Google. I'm here to talk about one extreme end of that continuum. I'm going to tell you how to start Google.
-
-The companies at the Google end of the continuum are called startups when they're young. The reason I know about them is that my wife Jessica and I started something called Y Combinator that is basically a startup factory. Since 2005, Y Combinator has funded over 4000 startups. So we know exactly what you need to start a startup, because we've helped people do it for the last 19 years.
-
-You might have thought I was joking when I said I was going to tell you how to start Google. You might be thinking "How could we start Google?" But that's effectively what the people who did start Google were thinking before they started it. If you'd told Larry Page and Sergey Brin, the founders of Google, that the company they were about to start would one day be worth over a trillion dollars, their heads would have exploded.
-
-All you can know when you start working on a startup is that it seems worth pursuing. You can't know whether it will turn into a company worth billions or one that goes out of business. So when I say I'm going to tell you how to start Google, I mean I'm going to tell you how to get to the point where you can start a company that has as much chance of being Google as Google had of being Google. [1]
-
-How do you get from where you are now to the point where you can start a successful startup? You need three things. You need to be good at some kind of technology, you need an idea for what you're going to build, and you need cofounders to start the company with.
-
-How do you get good at technology? And how do you choose which technology to get good at? Both of those questions turn out to have the same answer: work on your own projects. Don't try to guess whether gene editing or LLMs or rockets will turn out to be the most valuable technology to know about. No one can predict that. Just work on whatever interests you the most. You'll work much harder on something you're interested in than something you're doing because you think you're supposed to.
-
-If you're not sure what technology to get good at, get good at programming. That has been the source of the median startup for the last 30 years, and this is probably not going to change in the next 10.
-
-Those of you who are taking computer science classes in school may at this point be thinking, ok, we've got this sorted. We're already being taught all about programming. But sorry, this is not enough. You have to be working on your own projects, not just learning stuff in classes. You can do well in computer science classes without ever really learning to program. In fact you can graduate with a degree in computer science from a top university and still not be any good at programming. That's why tech companies all make you take a coding test before they'll hire you, regardless of where you went to university or how well you did there. They know grades and exam results prove nothing.
-
-If you really want to learn to program, you have to work on your own projects. You learn so much faster that way. Imagine you're writing a game and there's something you want to do in it, and you don't know how. You're going to figure out how a lot faster than you'd learn anything in a class.
-
-You don't have to learn programming, though. If you're wondering what counts as technology, it includes practically everything you could describe using the words "make" or "build." So welding would count, or making clothes, or making videos. Whatever you're most interested in. The critical distinction is whether you're producing or just consuming. Are you writing computer games, or just playing them? That's the cutoff.
-
-Steve Jobs, the founder of Apple, spent time when he was a teenager studying calligraphy — the sort of beautiful writing that you see in medieval manuscripts. No one, including him, thought that this would help him in his career. He was just doing it because he was interested in it. But it turned out to help him a lot. The computer that made Apple really big, the Macintosh, came out at just the moment when computers got powerful enough to make letters like the ones in printed books instead of the computery-looking letters you see in 8 bit games. Apple destroyed everyone else at this, and one reason was that Steve was one of the few people in the computer business who really got graphic design.
-
-Don't feel like your projects have to be serious. They can be as frivolous as you like, so long as you're building things you're excited about. Probably 90% of programmers start out building games. They and their friends like to play games. So they build the kind of things they and their friends want. And that's exactly what you should be doing at 15 if you want to start a startup one day.
-
-You don't have to do just one project. In fact it's good to learn about multiple things. Steve Jobs didn't just learn calligraphy. He also learned about electronics, which was even more valuable. Whatever you're interested in. (Do you notice a theme here?)
-
-So that's the first of the three things you need, to get good at some kind or kinds of technology. You do it the same way you get good at the violin or football: practice. If you start a startup at 22, and you start writing your own programs now, then by the time you start the company you'll have spent at least 7 years practicing writing code, and you can get pretty good at anything after practicing it for 7 years.
-
-Let's suppose you're 22 and you've succeeded: You're now really good at some technology. How do you get startup ideas? It might seem like that's the hard part. Even if you are a good programmer, how do you get the idea to start Google?
-
-Actually it's easy to get startup ideas once you're good at technology. Once you're good at some technology, when you look at the world you see dotted outlines around the things that are missing. You start to be able to see both the things that are missing from the technology itself, and all the broken things that could be fixed using it, and each one of these is a potential startup.
-
-In the town near our house there's a shop with a sign warning that the door is hard to close. The sign has been there for several years. To the people in the shop it must seem like this mysterious natural phenomenon that the door sticks, and all they can do is put up a sign warning customers about it. But any carpenter looking at this situation would think "why don't you just plane off the part that sticks?"
-
-Once you're good at programming, all the missing software in the world starts to become as obvious as a sticking door to a carpenter. I'll give you a real world example. Back in the 20th century, American universities used to publish printed directories with all the students' names and contact info. When I tell you what these directories were called, you'll know which startup I'm talking about. They were called facebooks, because they usually had a picture of each student next to their name.
-
-So Mark Zuckerberg shows up at Harvard in 2002, and the university still hasn't gotten the facebook online. Each individual house has an online facebook, but there isn't one for the whole university. The university administration has been diligently having meetings about this, and will probably have solved the problem in another decade or so. Most of the students don't consciously notice that anything is wrong. But Mark is a programmer. He looks at this situation and thinks "Well, this is stupid. I could write a program to fix this in one night. Just let people upload their own photos and then combine the data into a new site for the whole university." So he does. And almost literally overnight he has thousands of users.
-
-Of course Facebook was not a startup yet. It was just a... project. There's that word again. Projects aren't just the best way to learn about technology. They're also the best source of startup ideas.
-
-Facebook was not unusual in this respect. Apple and Google also began as projects. Apple wasn't meant to be a company. Steve Wozniak just wanted to build his own computer. It only turned into a company when Steve Jobs said "Hey, I wonder if we could sell plans for this computer to other people." That's how Apple started. They weren't even selling computers, just plans for computers. Can you imagine how lame this company seemed?
-
-Ditto for Google. Larry and Sergey weren't trying to start a company at first. They were just trying to make search better. Before Google, most search engines didn't try to sort the results they gave you in order of importance. If you searched for "rugby" they just gave you every web page that contained the word "rugby." And the web was so small in 1997 that this actually worked! Kind of. There might only be 20 or 30 pages with the word "rugby," but the web was growing exponentially, which meant this way of doing search was becoming exponentially more broken. Most users just thought, "Wow, I sure have to look through a lot of search results to find what I want." Door sticks. But like Mark, Larry and Sergey were programmers. Like Mark, they looked at this situation and thought "Well, this is stupid. Some pages about rugby matter more than others. Let's figure out which those are and show them first."
-
-It's obvious in retrospect that this was a great idea for a startup. It wasn't obvious at the time. It's never obvious. If it was obviously a good idea to start Apple or Google or Facebook, someone else would have already done it. That's why the best startups grow out of projects that aren't meant to be startups. You're not trying to start a company. You're just following your instincts about what's interesting. And if you're young and good at technology, then your unconscious instincts about what's interesting are better than your conscious ideas about what would be a good company.
-
-So it's critical, if you're a young founder, to build things for yourself and your friends to use. The biggest mistake young founders make is to build something for some mysterious group of other people. But if you can make something that you and your friends truly want to use — something your friends aren't just using out of loyalty to you, but would be really sad to lose if you shut it down — then you almost certainly have the germ of a good startup idea. It may not seem like a startup to you. It may not be obvious how to make money from it. But trust me, there's a way.
-
-What you need in a startup idea, and all you need, is something your friends actually want. And those ideas aren't hard to see once you're good at technology. There are sticking doors everywhere. [2]
-
-Now for the third and final thing you need: a cofounder, or cofounders. The optimal startup has two or three founders, so you need one or two cofounders. How do you find them? Can you predict what I'm going to say next? It's the same thing: projects. You find cofounders by working on projects with them. What you need in a cofounder is someone who's good at what they do and that you work well with, and the only way to judge this is to work with them on things.
-
-At this point I'm going to tell you something you might not want to hear. It really matters to do well in your classes, even the ones that are just memorization or blathering about literature, because you need to do well in your classes to get into a good university. And if you want to start a startup you should try to get into the best university you can, because that's where the best cofounders are. It's also where the best employees are. When Larry and Sergey started Google, they began by just hiring all the smartest people they knew out of Stanford, and this was a real advantage for them.
-
-The empirical evidence is clear on this. If you look at where the largest numbers of successful startups come from, it's pretty much the same as the list of the most selective universities.
-
-I don't think it's the prestigious names of these universities that cause more good startups to come out of them. Nor do I think it's because the quality of the teaching is better. What's driving this is simply the difficulty of getting in. You have to be pretty smart and determined to get into MIT or Cambridge, so if you do manage to get in, you'll find the other students include a lot of smart and determined people. [3]
-
-You don't have to start a startup with someone you meet at university. The founders of Twitch met when they were seven. The founders of Stripe, Patrick and John Collison, met when John was born. But universities are the main source of cofounders. And because they're where the cofounders are, they're also where the ideas are, because the best ideas grow out of projects you do with the people who become your cofounders.
-
-So the list of what you need to do to get from here to starting a startup is quite short. You need to get good at technology, and the way to do that is to work on your own projects. And you need to do as well in school as you can, so you can get into a good university, because that's where the cofounders and the ideas are.
-
-That's it, just two things, build stuff and do well in school.
-
-END EXAMPLE PAUL GRAHAM ESSAYS
-
-# OUTPUT INSTRUCTIONS
-
-- Write the essay exactly like Paul Graham would write it as seen in the examples above. 
+- Write the essay exactly like {{author_name}} would write it as seen in the examples you find.
 
 - Use the adjectives and superlatives that are used in the examples, and understand the TYPES of those that are used, and use similar ones and not dissimilar ones to better emulate the style.
 
-- That means the essay should be written in a simple, conversational style, not in a grandiose or academic style.
+- Use the same style, vocabulary level, and sentence structure as {{author_name}}.
 
-- Use the same style, vocabulary level, and sentence structure as Paul Graham.
-
-# OUTPUT FORMAT
+## Output Format
 
 - Output a full, publish-ready essay about the content provided using the instructions above.
 
-- Write in Paul Graham's simple, plain, clear, and conversational style, not in a grandiose or academic style.
+- Write in {{author_name}}'s natural and clear style, without embellishment.
 
 - Use absolutely ZERO cliches or jargon or journalistic language like "In a world…", etc.
 
@@ -316,7 +28,6 @@ END EXAMPLE PAUL GRAHAM ESSAYS
 
 - Do not output warnings or notes—just the output requested.
 
-
-# INPUT:
+## INPUT
 
 INPUT:

patterns/write_essay_pg/system.md

@@ -0,0 +1,322 @@
+# IDENTITY and PURPOSE
+
+You are an expert on writing concise, clear, and illuminating essays on the topic of the input provided.
+
+# OUTPUT INSTRUCTIONS
+
+- Write the essay in the style of Paul Graham, who is known for this concise, clear, and simple style of writing.
+
+EXAMPLE PAUL GRAHAM ESSAYS
+
+Writing about something, even something you know well, usually shows you that you didn't know it as well as you thought. Putting ideas into words is a severe test. The first words you choose are usually wrong; you have to rewrite sentences over and over to get them exactly right. And your ideas won't just be imprecise, but incomplete too. Half the ideas that end up in an essay will be ones you thought of while you were writing it. Indeed, that's why I write them.
+
+Once you publish something, the convention is that whatever you wrote was what you thought before you wrote it. These were your ideas, and now you've expressed them. But you know this isn't true. You know that putting your ideas into words changed them. And not just the ideas you published. Presumably there were others that turned out to be too broken to fix, and those you discarded instead.
+
+It's not just having to commit your ideas to specific words that makes writing so exacting. The real test is reading what you've written. You have to pretend to be a neutral reader who knows nothing of what's in your head, only what you wrote. When he reads what you wrote, does it seem correct? Does it seem complete? If you make an effort, you can read your writing as if you were a complete stranger, and when you do the news is usually bad. It takes me many cycles before I can get an essay past the stranger. But the stranger is rational, so you always can, if you ask him what he needs. If he's not satisfied because you failed to mention x or didn't qualify some sentence sufficiently, then you mention x or add more qualifications. Happy now? It may cost you some nice sentences, but you have to resign yourself to that. You just have to make them as good as you can and still satisfy the stranger.
+
+This much, I assume, won't be that controversial. I think it will accord with the experience of anyone who has tried to write about anything non-trivial. There may exist people whose thoughts are so perfectly formed that they just flow straight into words. But I've never known anyone who could do this, and if I met someone who said they could, it would seem evidence of their limitations rather than their ability. Indeed, this is a trope in movies: the guy who claims to have a plan for doing some difficult thing, and who when questioned further, taps his head and says "It's all up here." Everyone watching the movie knows what that means. At best the plan is vague and incomplete. Very likely there's some undiscovered flaw that invalidates it completely. At best it's a plan for a plan.
+
+In precisely defined domains it's possible to form complete ideas in your head. People can play chess in their heads, for example. And mathematicians can do some amount of math in their heads, though they don't seem to feel sure of a proof over a certain length till they write it down. But this only seems possible with ideas you can express in a formal language. [1] Arguably what such people are doing is putting ideas into words in their heads. I can to some extent write essays in my head. I'll sometimes think of a paragraph while walking or lying in bed that survives nearly unchanged in the final version. But really I'm writing when I do this. I'm doing the mental part of writing; my fingers just aren't moving as I do it. [2]
+
+You can know a great deal about something without writing about it. Can you ever know so much that you wouldn't learn more from trying to explain what you know? I don't think so. I've written about at least two subjects I know well — Lisp hacking and startups — and in both cases I learned a lot from writing about them. In both cases there were things I didn't consciously realize till I had to explain them. And I don't think my experience was anomalous. A great deal of knowledge is unconscious, and experts have if anything a higher proportion of unconscious knowledge than beginners.
+
+I'm not saying that writing is the best way to explore all ideas. If you have ideas about architecture, presumably the best way to explore them is to build actual buildings. What I'm saying is that however much you learn from exploring ideas in other ways, you'll still learn new things from writing about them.
+
+Putting ideas into words doesn't have to mean writing, of course. You can also do it the old way, by talking. But in my experience, writing is the stricter test. You have to commit to a single, optimal sequence of words. Less can go unsaid when you don't have tone of voice to carry meaning. And you can focus in a way that would seem excessive in conversation. I'll often spend 2 weeks on an essay and reread drafts 50 times. If you did that in conversation it would seem evidence of some kind of mental disorder. If you're lazy, of course, writing and talking are equally useless. But if you want to push yourself to get things right, writing is the steeper hill. [3]
+
+The reason I've spent so long establishing this rather obvious point is that it leads to another that many people will find shocking. If writing down your ideas always makes them more precise and more complete, then no one who hasn't written about a topic has fully formed ideas about it. And someone who never writes has no fully formed ideas about anything non-trivial.
+
+It feels to them as if they do, especially if they're not in the habit of critically examining their own thinking. Ideas can feel complete. It's only when you try to put them into words that you discover they're not. So if you never subject your ideas to that test, you'll not only never have fully formed ideas, but also never realize it.
+
+Putting ideas into words is certainly no guarantee that they'll be right. Far from it. But though it's not a sufficient condition, it is a necessary one.
+		
+What You Can't Say
+
+January 2004
+
+Have you ever seen an old photo of yourself and been embarrassed at the way you looked? Did we actually dress like that? We did. And we had no idea how silly we looked. It's the nature of fashion to be invisible, in the same way the movement of the earth is invisible to all of us riding on it.
+
+What scares me is that there are moral fashions too. They're just as arbitrary, and just as invisible to most people. But they're much more dangerous. Fashion is mistaken for good design; moral fashion is mistaken for good. Dressing oddly gets you laughed at. Violating moral fashions can get you fired, ostracized, imprisoned, or even killed.
+
+If you could travel back in a time machine, one thing would be true no matter where you went: you'd have to watch what you said. Opinions we consider harmless could have gotten you in big trouble. I've already said at least one thing that would have gotten me in big trouble in most of Europe in the seventeenth century, and did get Galileo in big trouble when he said it — that the earth moves. [1]
+
+It seems to be a constant throughout history: In every period, people believed things that were just ridiculous, and believed them so strongly that you would have gotten in terrible trouble for saying otherwise.
+
+Is our time any different? To anyone who has read any amount of history, the answer is almost certainly no. It would be a remarkable coincidence if ours were the first era to get everything just right.
+
+It's tantalizing to think we believe things that people in the future will find ridiculous. What would someone coming back to visit us in a time machine have to be careful not to say? That's what I want to study here. But I want to do more than just shock everyone with the heresy du jour. I want to find general recipes for discovering what you can't say, in any era.
+
+The Conformist Test
+
+Let's start with a test: Do you have any opinions that you would be reluctant to express in front of a group of your peers?
+
+If the answer is no, you might want to stop and think about that. If everything you believe is something you're supposed to believe, could that possibly be a coincidence? Odds are it isn't. Odds are you just think what you're told.
+
+The other alternative would be that you independently considered every question and came up with the exact same answers that are now considered acceptable. That seems unlikely, because you'd also have to make the same mistakes. Mapmakers deliberately put slight mistakes in their maps so they can tell when someone copies them. If another map has the same mistake, that's very convincing evidence.
+
+Like every other era in history, our moral map almost certainly contains a few mistakes. And anyone who makes the same mistakes probably didn't do it by accident. It would be like someone claiming they had independently decided in 1972 that bell-bottom jeans were a good idea.
+
+If you believe everything you're supposed to now, how can you be sure you wouldn't also have believed everything you were supposed to if you had grown up among the plantation owners of the pre-Civil War South, or in Germany in the 1930s — or among the Mongols in 1200, for that matter? Odds are you would have.
+
+Back in the era of terms like "well-adjusted," the idea seemed to be that there was something wrong with you if you thought things you didn't dare say out loud. This seems backward. Almost certainly, there is something wrong with you if you don't think things you don't dare say out loud.
+
+Trouble
+
+What can't we say? One way to find these ideas is simply to look at things people do say, and get in trouble for. [2]
+
+Of course, we're not just looking for things we can't say. We're looking for things we can't say that are true, or at least have enough chance of being true that the question should remain open. But many of the things people get in trouble for saying probably do make it over this second, lower threshold. No one gets in trouble for saying that 2 + 2 is 5, or that people in Pittsburgh are ten feet tall. Such obviously false statements might be treated as jokes, or at worst as evidence of insanity, but they are not likely to make anyone mad. The statements that make people mad are the ones they worry might be believed. I suspect the statements that make people maddest are those they worry might be true.
+
+If Galileo had said that people in Padua were ten feet tall, he would have been regarded as a harmless eccentric. Saying the earth orbited the sun was another matter. The church knew this would set people thinking.
+
+Certainly, as we look back on the past, this rule of thumb works well. A lot of the statements people got in trouble for seem harmless now. So it's likely that visitors from the future would agree with at least some of the statements that get people in trouble today. Do we have no Galileos? Not likely.
+
+To find them, keep track of opinions that get people in trouble, and start asking, could this be true? Ok, it may be heretical (or whatever modern equivalent), but might it also be true?
+
+Heresy
+
+This won't get us all the answers, though. What if no one happens to have gotten in trouble for a particular idea yet? What if some idea would be so radioactively controversial that no one would dare express it in public? How can we find these too?
+
+Another approach is to follow that word, heresy. In every period of history, there seem to have been labels that got applied to statements to shoot them down before anyone had a chance to ask if they were true or not. "Blasphemy", "sacrilege", and "heresy" were such labels for a good part of western history, as in more recent times "indecent", "improper", and "unamerican" have been. By now these labels have lost their sting. They always do. By now they're mostly used ironically. But in their time, they had real force.
+
+The word "defeatist", for example, has no particular political connotations now. But in Germany in 1917 it was a weapon, used by Ludendorff in a purge of those who favored a negotiated peace. At the start of World War II it was used extensively by Churchill and his supporters to silence their opponents. In 1940, any argument against Churchill's aggressive policy was "defeatist". Was it right or wrong? Ideally, no one got far enough to ask that.
+
+We have such labels today, of course, quite a lot of them, from the all-purpose "inappropriate" to the dreaded "divisive." In any period, it should be easy to figure out what such labels are, simply by looking at what people call ideas they disagree with besides untrue. When a politician says his opponent is mistaken, that's a straightforward criticism, but when he attacks a statement as "divisive" or "racially insensitive" instead of arguing that it's false, we should start paying attention.
+
+So another way to figure out which of our taboos future generations will laugh at is to start with the labels. Take a label — "sexist", for example — and try to think of some ideas that would be called that. Then for each ask, might this be true?
+
+Just start listing ideas at random? Yes, because they won't really be random. The ideas that come to mind first will be the most plausible ones. They'll be things you've already noticed but didn't let yourself think.
+
+In 1989 some clever researchers tracked the eye movements of radiologists as they scanned chest images for signs of lung cancer. [3] They found that even when the radiologists missed a cancerous lesion, their eyes had usually paused at the site of it. Part of their brain knew there was something there; it just didn't percolate all the way up into conscious knowledge. I think many interesting heretical thoughts are already mostly formed in our minds. If we turn off our self-censorship temporarily, those will be the first to emerge.
+
+Time and Space
+
+If we could look into the future it would be obvious which of our taboos they'd laugh at. We can't do that, but we can do something almost as good: we can look into the past. Another way to figure out what we're getting wrong is to look at what used to be acceptable and is now unthinkable.
+
+Changes between the past and the present sometimes do represent progress. In a field like physics, if we disagree with past generations it's because we're right and they're wrong. But this becomes rapidly less true as you move away from the certainty of the hard sciences. By the time you get to social questions, many changes are just fashion. The age of consent fluctuates like hemlines.
+
+We may imagine that we are a great deal smarter and more virtuous than past generations, but the more history you read, the less likely this seems. People in past times were much like us. Not heroes, not barbarians. Whatever their ideas were, they were ideas reasonable people could believe.
+
+So here is another source of interesting heresies. Diff present ideas against those of various past cultures, and see what you get. [4] Some will be shocking by present standards. Ok, fine; but which might also be true?
+
+You don't have to look into the past to find big differences. In our own time, different societies have wildly varying ideas of what's ok and what isn't. So you can try diffing other cultures' ideas against ours as well. (The best way to do that is to visit them.) Any idea that's considered harmless in a significant percentage of times and places, and yet is taboo in ours, is a candidate for something we're mistaken about.
+
+For example, at the high water mark of political correctness in the early 1990s, Harvard distributed to its faculty and staff a brochure saying, among other things, that it was inappropriate to compliment a colleague or student's clothes. No more "nice shirt." I think this principle is rare among the world's cultures, past or present. There are probably more where it's considered especially polite to compliment someone's clothing than where it's considered improper. Odds are this is, in a mild form, an example of one of the taboos a visitor from the future would have to be careful to avoid if he happened to set his time machine for Cambridge, Massachusetts, 1992. [5]
+
+Prigs
+
+Of course, if they have time machines in the future they'll probably have a separate reference manual just for Cambridge. This has always been a fussy place, a town of i dotters and t crossers, where you're liable to get both your grammar and your ideas corrected in the same conversation. And that suggests another way to find taboos. Look for prigs, and see what's inside their heads.
+
+Kids' heads are repositories of all our taboos. It seems fitting to us that kids' ideas should be bright and clean. The picture we give them of the world is not merely simplified, to suit their developing minds, but sanitized as well, to suit our ideas of what kids ought to think. [6]
+
+You can see this on a small scale in the matter of dirty words. A lot of my friends are starting to have children now, and they're all trying not to use words like "fuck" and "shit" within baby's hearing, lest baby start using these words too. But these words are part of the language, and adults use them all the time. So parents are giving their kids an inaccurate idea of the language by not using them. Why do they do this? Because they don't think it's fitting that kids should use the whole language. We like children to seem innocent. [7]
+
+Most adults, likewise, deliberately give kids a misleading view of the world. One of the most obvious examples is Santa Claus. We think it's cute for little kids to believe in Santa Claus. I myself think it's cute for little kids to believe in Santa Claus. But one wonders, do we tell them this stuff for their sake, or for ours?
+
+I'm not arguing for or against this idea here. It is probably inevitable that parents should want to dress up their kids' minds in cute little baby outfits. I'll probably do it myself. The important thing for our purposes is that, as a result, a well brought-up teenage kid's brain is a more or less complete collection of all our taboos — and in mint condition, because they're untainted by experience. Whatever we think that will later turn out to be ridiculous, it's almost certainly inside that head.
+
+How do we get at these ideas? By the following thought experiment. Imagine a kind of latter-day Conrad character who has worked for a time as a mercenary in Africa, for a time as a doctor in Nepal, for a time as the manager of a nightclub in Miami. The specifics don't matter — just someone who has seen a lot. Now imagine comparing what's inside this guy's head with what's inside the head of a well-behaved sixteen year old girl from the suburbs. What does he think that would shock her? He knows the world; she knows, or at least embodies, present taboos. Subtract one from the other, and the result is what we can't say.
+
+Mechanism
+
+I can think of one more way to figure out what we can't say: to look at how taboos are created. How do moral fashions arise, and why are they adopted? If we can understand this mechanism, we may be able to see it at work in our own time.
+
+Moral fashions don't seem to be created the way ordinary fashions are. Ordinary fashions seem to arise by accident when everyone imitates the whim of some influential person. The fashion for broad-toed shoes in late fifteenth century Europe began because Charles VIII of France had six toes on one foot. The fashion for the name Gary began when the actor Frank Cooper adopted the name of a tough mill town in Indiana. Moral fashions more often seem to be created deliberately. When there's something we can't say, it's often because some group doesn't want us to.
+
+The prohibition will be strongest when the group is nervous. The irony of Galileo's situation was that he got in trouble for repeating Copernicus's ideas. Copernicus himself didn't. In fact, Copernicus was a canon of a cathedral, and dedicated his book to the pope. But by Galileo's time the church was in the throes of the Counter-Reformation and was much more worried about unorthodox ideas.
+
+To launch a taboo, a group has to be poised halfway between weakness and power. A confident group doesn't need taboos to protect it. It's not considered improper to make disparaging remarks about Americans, or the English. And yet a group has to be powerful enough to enforce a taboo. Coprophiles, as of this writing, don't seem to be numerous or energetic enough to have had their interests promoted to a lifestyle.
+
+I suspect the biggest source of moral taboos will turn out to be power struggles in which one side only barely has the upper hand. That's where you'll find a group powerful enough to enforce taboos, but weak enough to need them.
+
+Most struggles, whatever they're really about, will be cast as struggles between competing ideas. The English Reformation was at bottom a struggle for wealth and power, but it ended up being cast as a struggle to preserve the souls of Englishmen from the corrupting influence of Rome. It's easier to get people to fight for an idea. And whichever side wins, their ideas will also be considered to have triumphed, as if God wanted to signal his agreement by selecting that side as the victor.
+
+We often like to think of World War II as a triumph of freedom over totalitarianism. We conveniently forget that the Soviet Union was also one of the winners.
+
+I'm not saying that struggles are never about ideas, just that they will always be made to seem to be about ideas, whether they are or not. And just as there is nothing so unfashionable as the last, discarded fashion, there is nothing so wrong as the principles of the most recently defeated opponent. Representational art is only now recovering from the approval of both Hitler and Stalin. [8]
+
+Although moral fashions tend to arise from different sources than fashions in clothing, the mechanism of their adoption seems much the same. The early adopters will be driven by ambition: self-consciously cool people who want to distinguish themselves from the common herd. As the fashion becomes established they'll be joined by a second, much larger group, driven by fear. [9] This second group adopt the fashion not because they want to stand out but because they are afraid of standing out.
+
+So if you want to figure out what we can't say, look at the machinery of fashion and try to predict what it would make unsayable. What groups are powerful but nervous, and what ideas would they like to suppress? What ideas were tarnished by association when they ended up on the losing side of a recent struggle? If a self-consciously cool person wanted to differentiate himself from preceding fashions (e.g. from his parents), which of their ideas would he tend to reject? What are conventional-minded people afraid of saying?
+
+This technique won't find us all the things we can't say. I can think of some that aren't the result of any recent struggle. Many of our taboos are rooted deep in the past. But this approach, combined with the preceding four, will turn up a good number of unthinkable ideas.
+
+Why
+
+Some would ask, why would one want to do this? Why deliberately go poking around among nasty, disreputable ideas? Why look under rocks?
+
+I do it, first of all, for the same reason I did look under rocks as a kid: plain curiosity. And I'm especially curious about anything that's forbidden. Let me see and decide for myself.
+
+Second, I do it because I don't like the idea of being mistaken. If, like other eras, we believe things that will later seem ridiculous, I want to know what they are so that I, at least, can avoid believing them.
+
+Third, I do it because it's good for the brain. To do good work you need a brain that can go anywhere. And you especially need a brain that's in the habit of going where it's not supposed to.
+
+Great work tends to grow out of ideas that others have overlooked, and no idea is so overlooked as one that's unthinkable. Natural selection, for example. It's so simple. Why didn't anyone think of it before? Well, that is all too obvious. Darwin himself was careful to tiptoe around the implications of his theory. He wanted to spend his time thinking about biology, not arguing with people who accused him of being an atheist.
+
+In the sciences, especially, it's a great advantage to be able to question assumptions. The m.o. of scientists, or at least of the good ones, is precisely that: look for places where conventional wisdom is broken, and then try to pry apart the cracks and see what's underneath. That's where new theories come from.
+
+A good scientist, in other words, does not merely ignore conventional wisdom, but makes a special effort to break it. Scientists go looking for trouble. This should be the m.o. of any scholar, but scientists seem much more willing to look under rocks. [10]
+
+Why? It could be that the scientists are simply smarter; most physicists could, if necessary, make it through a PhD program in French literature, but few professors of French literature could make it through a PhD program in physics. Or it could be because it's clearer in the sciences whether theories are true or false, and this makes scientists bolder. (Or it could be that, because it's clearer in the sciences whether theories are true or false, you have to be smart to get jobs as a scientist, rather than just a good politician.)
+
+Whatever the reason, there seems a clear correlation between intelligence and willingness to consider shocking ideas. This isn't just because smart people actively work to find holes in conventional thinking. I think conventions also have less hold over them to start with. You can see that in the way they dress.
+
+It's not only in the sciences that heresy pays off. In any competitive field, you can win big by seeing things that others daren't. And in every field there are probably heresies few dare utter. Within the US car industry there is a lot of hand-wringing now about declining market share. Yet the cause is so obvious that any observant outsider could explain it in a second: they make bad cars. And they have for so long that by now the US car brands are antibrands — something you'd buy a car despite, not because of. Cadillac stopped being the Cadillac of cars in about 1970. And yet I suspect no one dares say this. [11] Otherwise these companies would have tried to fix the problem.
+
+Training yourself to think unthinkable thoughts has advantages beyond the thoughts themselves. It's like stretching. When you stretch before running, you put your body into positions much more extreme than any it will assume during the run. If you can think things so outside the box that they'd make people's hair stand on end, you'll have no trouble with the small trips outside the box that people call innovative.
+
+Pensieri Stretti
+
+When you find something you can't say, what do you do with it? My advice is, don't say it. Or at least, pick your battles.
+
+Suppose in the future there is a movement to ban the color yellow. Proposals to paint anything yellow are denounced as "yellowist", as is anyone suspected of liking the color. People who like orange are tolerated but viewed with suspicion. Suppose you realize there is nothing wrong with yellow. If you go around saying this, you'll be denounced as a yellowist too, and you'll find yourself having a lot of arguments with anti-yellowists. If your aim in life is to rehabilitate the color yellow, that may be what you want. But if you're mostly interested in other questions, being labelled as a yellowist will just be a distraction. Argue with idiots, and you become an idiot.
+
+The most important thing is to be able to think what you want, not to say what you want. And if you feel you have to say everything you think, it may inhibit you from thinking improper thoughts. I think it's better to follow the opposite policy. Draw a sharp line between your thoughts and your speech. Inside your head, anything is allowed. Within my head I make a point of encouraging the most outrageous thoughts I can imagine. But, as in a secret society, nothing that happens within the building should be told to outsiders. The first rule of Fight Club is, you do not talk about Fight Club.
+
+When Milton was going to visit Italy in the 1630s, Sir Henry Wootton, who had been ambassador to Venice, told him his motto should be "i pensieri stretti & il viso sciolto." Closed thoughts and an open face. Smile at everyone, and don't tell them what you're thinking. This was wise advice. Milton was an argumentative fellow, and the Inquisition was a bit restive at that time. But I think the difference between Milton's situation and ours is only a matter of degree. Every era has its heresies, and if you don't get imprisoned for them you will at least get in enough trouble that it becomes a complete distraction.
+
+I admit it seems cowardly to keep quiet. When I read about the harassment to which the Scientologists subject their critics [12], or that pro-Israel groups are "compiling dossiers" on those who speak out against Israeli human rights abuses [13], or about people being sued for violating the DMCA [14], part of me wants to say, "All right, you bastards, bring it on." The problem is, there are so many things you can't say. If you said them all you'd have no time left for your real work. You'd have to turn into Noam Chomsky. [15]
+
+The trouble with keeping your thoughts secret, though, is that you lose the advantages of discussion. Talking about an idea leads to more ideas. So the optimal plan, if you can manage it, is to have a few trusted friends you can speak openly to. This is not just a way to develop ideas; it's also a good rule of thumb for choosing friends. The people you can say heretical things to without getting jumped on are also the most interesting to know.
+
+Viso Sciolto?
+
+I don't think we need the viso sciolto so much as the pensieri stretti. Perhaps the best policy is to make it plain that you don't agree with whatever zealotry is current in your time, but not to be too specific about what you disagree with. Zealots will try to draw you out, but you don't have to answer them. If they try to force you to treat a question on their terms by asking "are you with us or against us?" you can always just answer "neither".
+
+Better still, answer "I haven't decided." That's what Larry Summers did when a group tried to put him in this position. Explaining himself later, he said "I don't do litmus tests." [16] A lot of the questions people get hot about are actually quite complicated. There is no prize for getting the answer quickly.
+
+If the anti-yellowists seem to be getting out of hand and you want to fight back, there are ways to do it without getting yourself accused of being a yellowist. Like skirmishers in an ancient army, you want to avoid directly engaging the main body of the enemy's troops. Better to harass them with arrows from a distance.
+
+One way to do this is to ratchet the debate up one level of abstraction. If you argue against censorship in general, you can avoid being accused of whatever heresy is contained in the book or film that someone is trying to censor. You can attack labels with meta-labels: labels that refer to the use of labels to prevent discussion. The spread of the term "political correctness" meant the beginning of the end of political correctness, because it enabled one to attack the phenomenon as a whole without being accused of any of the specific heresies it sought to suppress.
+
+Another way to counterattack is with metaphor. Arthur Miller undermined the House Un-American Activities Committee by writing a play, "The Crucible," about the Salem witch trials. He never referred directly to the committee and so gave them no way to reply. What could HUAC do, defend the Salem witch trials? And yet Miller's metaphor stuck so well that to this day the activities of the committee are often described as a "witch-hunt."
+
+Best of all, probably, is humor. Zealots, whatever their cause, invariably lack a sense of humor. They can't reply in kind to jokes. They're as unhappy on the territory of humor as a mounted knight on a skating rink. Victorian prudishness, for example, seems to have been defeated mainly by treating it as a joke. Likewise its reincarnation as political correctness. "I am glad that I managed to write 'The Crucible,'" Arthur Miller wrote, "but looking back I have often wished I'd had the temperament to do an absurd comedy, which is what the situation deserved." [17]
+
+ABQ
+
+A Dutch friend says I should use Holland as an example of a tolerant society. It's true they have a long tradition of comparative open-mindedness. For centuries the low countries were the place to go to say things you couldn't say anywhere else, and this helped to make the region a center of scholarship and industry (which have been closely tied for longer than most people realize). Descartes, though claimed by the French, did much of his thinking in Holland.
+
+And yet, I wonder. The Dutch seem to live their lives up to their necks in rules and regulations. There's so much you can't do there; is there really nothing you can't say?
+
+Certainly the fact that they value open-mindedness is no guarantee. Who thinks they're not open-minded? Our hypothetical prim miss from the suburbs thinks she's open-minded. Hasn't she been taught to be? Ask anyone, and they'll say the same thing: they're pretty open-minded, though they draw the line at things that are really wrong. (Some tribes may avoid "wrong" as judgemental, and may instead use a more neutral sounding euphemism like "negative" or "destructive".)
+
+When people are bad at math, they know it, because they get the wrong answers on tests. But when people are bad at open-mindedness they don't know it. In fact they tend to think the opposite. Remember, it's the nature of fashion to be invisible. It wouldn't work otherwise. Fashion doesn't seem like fashion to someone in the grip of it. It just seems like the right thing to do. It's only by looking from a distance that we see oscillations in people's idea of the right thing to do, and can identify them as fashions.
+
+Time gives us such distance for free. Indeed, the arrival of new fashions makes old fashions easy to see, because they seem so ridiculous by contrast. From one end of a pendulum's swing, the other end seems especially far away.
+
+To see fashion in your own time, though, requires a conscious effort. Without time to give you distance, you have to create distance yourself. Instead of being part of the mob, stand as far away from it as you can and watch what it's doing. And pay especially close attention whenever an idea is being suppressed. Web filters for children and employees often ban sites containing pornography, violence, and hate speech. What counts as pornography and violence? And what, exactly, is "hate speech?" This sounds like a phrase out of 1984.
+
+Labels like that are probably the biggest external clue. If a statement is false, that's the worst thing you can say about it. You don't need to say that it's heretical. And if it isn't false, it shouldn't be suppressed. So when you see statements being attacked as x-ist or y-ic (substitute your current values of x and y), whether in 1630 or 2030, that's a sure sign that something is wrong. When you hear such labels being used, ask why.
+
+Especially if you hear yourself using them. It's not just the mob you need to learn to watch from a distance. You need to be able to watch your own thoughts from a distance. That's not a radical idea, by the way; it's the main difference between children and adults. When a child gets angry because he's tired, he doesn't know what's happening. An adult can distance himself enough from the situation to say "never mind, I'm just tired." I don't see why one couldn't, by a similar process, learn to recognize and discount the effects of moral fashions.
+
+You have to take that extra step if you want to think clearly. But it's harder, because now you're working against social customs instead of with them. Everyone encourages you to grow up to the point where you can discount your own bad moods. Few encourage you to continue to the point where you can discount society's bad moods.
+
+How can you see the wave, when you're the water? Always be questioning. That's the only defence. What can't you say? And why?
+
+How to Start Google
+
+March 2024
+
+(This is a talk I gave to 14 and 15 year olds about what to do now if they might want to start a startup later. Lots of schools think they should tell students something about startups. This is what I think they should tell them.)
+
+Most of you probably think that when you're released into the so-called real world you'll eventually have to get some kind of job. That's not true, and today I'm going to talk about a trick you can use to avoid ever having to get a job.
+
+The trick is to start your own company. So it's not a trick for avoiding work, because if you start your own company you'll work harder than you would if you had an ordinary job. But you will avoid many of the annoying things that come with a job, including a boss telling you what to do.
+
+It's more exciting to work on your own project than someone else's. And you can also get a lot richer. In fact, this is the standard way to get really rich. If you look at the lists of the richest people that occasionally get published in the press, nearly all of them did it by starting their own companies.
+
+Starting your own company can mean anything from starting a barber shop to starting Google. I'm here to talk about one extreme end of that continuum. I'm going to tell you how to start Google.
+
+The companies at the Google end of the continuum are called startups when they're young. The reason I know about them is that my wife Jessica and I started something called Y Combinator that is basically a startup factory. Since 2005, Y Combinator has funded over 4000 startups. So we know exactly what you need to start a startup, because we've helped people do it for the last 19 years.
+
+You might have thought I was joking when I said I was going to tell you how to start Google. You might be thinking "How could we start Google?" But that's effectively what the people who did start Google were thinking before they started it. If you'd told Larry Page and Sergey Brin, the founders of Google, that the company they were about to start would one day be worth over a trillion dollars, their heads would have exploded.
+
+All you can know when you start working on a startup is that it seems worth pursuing. You can't know whether it will turn into a company worth billions or one that goes out of business. So when I say I'm going to tell you how to start Google, I mean I'm going to tell you how to get to the point where you can start a company that has as much chance of being Google as Google had of being Google. [1]
+
+How do you get from where you are now to the point where you can start a successful startup? You need three things. You need to be good at some kind of technology, you need an idea for what you're going to build, and you need cofounders to start the company with.
+
+How do you get good at technology? And how do you choose which technology to get good at? Both of those questions turn out to have the same answer: work on your own projects. Don't try to guess whether gene editing or LLMs or rockets will turn out to be the most valuable technology to know about. No one can predict that. Just work on whatever interests you the most. You'll work much harder on something you're interested in than something you're doing because you think you're supposed to.
+
+If you're not sure what technology to get good at, get good at programming. That has been the source of the median startup for the last 30 years, and this is probably not going to change in the next 10.
+
+Those of you who are taking computer science classes in school may at this point be thinking, ok, we've got this sorted. We're already being taught all about programming. But sorry, this is not enough. You have to be working on your own projects, not just learning stuff in classes. You can do well in computer science classes without ever really learning to program. In fact you can graduate with a degree in computer science from a top university and still not be any good at programming. That's why tech companies all make you take a coding test before they'll hire you, regardless of where you went to university or how well you did there. They know grades and exam results prove nothing.
+
+If you really want to learn to program, you have to work on your own projects. You learn so much faster that way. Imagine you're writing a game and there's something you want to do in it, and you don't know how. You're going to figure out how a lot faster than you'd learn anything in a class.
+
+You don't have to learn programming, though. If you're wondering what counts as technology, it includes practically everything you could describe using the words "make" or "build." So welding would count, or making clothes, or making videos. Whatever you're most interested in. The critical distinction is whether you're producing or just consuming. Are you writing computer games, or just playing them? That's the cutoff.
+
+Steve Jobs, the founder of Apple, spent time when he was a teenager studying calligraphy — the sort of beautiful writing that you see in medieval manuscripts. No one, including him, thought that this would help him in his career. He was just doing it because he was interested in it. But it turned out to help him a lot. The computer that made Apple really big, the Macintosh, came out at just the moment when computers got powerful enough to make letters like the ones in printed books instead of the computery-looking letters you see in 8 bit games. Apple destroyed everyone else at this, and one reason was that Steve was one of the few people in the computer business who really got graphic design.
+
+Don't feel like your projects have to be serious. They can be as frivolous as you like, so long as you're building things you're excited about. Probably 90% of programmers start out building games. They and their friends like to play games. So they build the kind of things they and their friends want. And that's exactly what you should be doing at 15 if you want to start a startup one day.
+
+You don't have to do just one project. In fact it's good to learn about multiple things. Steve Jobs didn't just learn calligraphy. He also learned about electronics, which was even more valuable. Whatever you're interested in. (Do you notice a theme here?)
+
+So that's the first of the three things you need, to get good at some kind or kinds of technology. You do it the same way you get good at the violin or football: practice. If you start a startup at 22, and you start writing your own programs now, then by the time you start the company you'll have spent at least 7 years practicing writing code, and you can get pretty good at anything after practicing it for 7 years.
+
+Let's suppose you're 22 and you've succeeded: You're now really good at some technology. How do you get startup ideas? It might seem like that's the hard part. Even if you are a good programmer, how do you get the idea to start Google?
+
+Actually it's easy to get startup ideas once you're good at technology. Once you're good at some technology, when you look at the world you see dotted outlines around the things that are missing. You start to be able to see both the things that are missing from the technology itself, and all the broken things that could be fixed using it, and each one of these is a potential startup.
+
+In the town near our house there's a shop with a sign warning that the door is hard to close. The sign has been there for several years. To the people in the shop it must seem like this mysterious natural phenomenon that the door sticks, and all they can do is put up a sign warning customers about it. But any carpenter looking at this situation would think "why don't you just plane off the part that sticks?"
+
+Once you're good at programming, all the missing software in the world starts to become as obvious as a sticking door to a carpenter. I'll give you a real world example. Back in the 20th century, American universities used to publish printed directories with all the students' names and contact info. When I tell you what these directories were called, you'll know which startup I'm talking about. They were called facebooks, because they usually had a picture of each student next to their name.
+
+So Mark Zuckerberg shows up at Harvard in 2002, and the university still hasn't gotten the facebook online. Each individual house has an online facebook, but there isn't one for the whole university. The university administration has been diligently having meetings about this, and will probably have solved the problem in another decade or so. Most of the students don't consciously notice that anything is wrong. But Mark is a programmer. He looks at this situation and thinks "Well, this is stupid. I could write a program to fix this in one night. Just let people upload their own photos and then combine the data into a new site for the whole university." So he does. And almost literally overnight he has thousands of users.
+
+Of course Facebook was not a startup yet. It was just a... project. There's that word again. Projects aren't just the best way to learn about technology. They're also the best source of startup ideas.
+
+Facebook was not unusual in this respect. Apple and Google also began as projects. Apple wasn't meant to be a company. Steve Wozniak just wanted to build his own computer. It only turned into a company when Steve Jobs said "Hey, I wonder if we could sell plans for this computer to other people." That's how Apple started. They weren't even selling computers, just plans for computers. Can you imagine how lame this company seemed?
+
+Ditto for Google. Larry and Sergey weren't trying to start a company at first. They were just trying to make search better. Before Google, most search engines didn't try to sort the results they gave you in order of importance. If you searched for "rugby" they just gave you every web page that contained the word "rugby." And the web was so small in 1997 that this actually worked! Kind of. There might only be 20 or 30 pages with the word "rugby," but the web was growing exponentially, which meant this way of doing search was becoming exponentially more broken. Most users just thought, "Wow, I sure have to look through a lot of search results to find what I want." Door sticks. But like Mark, Larry and Sergey were programmers. Like Mark, they looked at this situation and thought "Well, this is stupid. Some pages about rugby matter more than others. Let's figure out which those are and show them first."
+
+It's obvious in retrospect that this was a great idea for a startup. It wasn't obvious at the time. It's never obvious. If it was obviously a good idea to start Apple or Google or Facebook, someone else would have already done it. That's why the best startups grow out of projects that aren't meant to be startups. You're not trying to start a company. You're just following your instincts about what's interesting. And if you're young and good at technology, then your unconscious instincts about what's interesting are better than your conscious ideas about what would be a good company.
+
+So it's critical, if you're a young founder, to build things for yourself and your friends to use. The biggest mistake young founders make is to build something for some mysterious group of other people. But if you can make something that you and your friends truly want to use — something your friends aren't just using out of loyalty to you, but would be really sad to lose if you shut it down — then you almost certainly have the germ of a good startup idea. It may not seem like a startup to you. It may not be obvious how to make money from it. But trust me, there's a way.
+
+What you need in a startup idea, and all you need, is something your friends actually want. And those ideas aren't hard to see once you're good at technology. There are sticking doors everywhere. [2]
+
+Now for the third and final thing you need: a cofounder, or cofounders. The optimal startup has two or three founders, so you need one or two cofounders. How do you find them? Can you predict what I'm going to say next? It's the same thing: projects. You find cofounders by working on projects with them. What you need in a cofounder is someone who's good at what they do and that you work well with, and the only way to judge this is to work with them on things.
+
+At this point I'm going to tell you something you might not want to hear. It really matters to do well in your classes, even the ones that are just memorization or blathering about literature, because you need to do well in your classes to get into a good university. And if you want to start a startup you should try to get into the best university you can, because that's where the best cofounders are. It's also where the best employees are. When Larry and Sergey started Google, they began by just hiring all the smartest people they knew out of Stanford, and this was a real advantage for them.
+
+The empirical evidence is clear on this. If you look at where the largest numbers of successful startups come from, it's pretty much the same as the list of the most selective universities.
+
+I don't think it's the prestigious names of these universities that cause more good startups to come out of them. Nor do I think it's because the quality of the teaching is better. What's driving this is simply the difficulty of getting in. You have to be pretty smart and determined to get into MIT or Cambridge, so if you do manage to get in, you'll find the other students include a lot of smart and determined people. [3]
+
+You don't have to start a startup with someone you meet at university. The founders of Twitch met when they were seven. The founders of Stripe, Patrick and John Collison, met when John was born. But universities are the main source of cofounders. And because they're where the cofounders are, they're also where the ideas are, because the best ideas grow out of projects you do with the people who become your cofounders.
+
+So the list of what you need to do to get from here to starting a startup is quite short. You need to get good at technology, and the way to do that is to work on your own projects. And you need to do as well in school as you can, so you can get into a good university, because that's where the cofounders and the ideas are.
+
+That's it, just two things, build stuff and do well in school.
+
+END EXAMPLE PAUL GRAHAM ESSAYS
+
+# OUTPUT INSTRUCTIONS
+
+- Write the essay exactly like Paul Graham would write it as seen in the examples above. 
+
+- Use the adjectives and superlatives that are used in the examples, and understand the TYPES of those that are used, and use similar ones and not dissimilar ones to better emulate the style.
+
+- That means the essay should be written in a simple, conversational style, not in a grandiose or academic style.
+
+- Use the same style, vocabulary level, and sentence structure as Paul Graham.
+
+# OUTPUT FORMAT
+
+- Output a full, publish-ready essay about the content provided using the instructions above.
+
+- Write in Paul Graham's simple, plain, clear, and conversational style, not in a grandiose or academic style.
+
+- Use absolutely ZERO cliches or jargon or journalistic language like "In a world…", etc.
+
+- Do not use cliches or jargon.
+
+- Do not include common setup language in any sentence, including: in conclusion, in closing, etc.
+
+- Do not output warnings or notes—just the output requested.
+
+
+# INPUT:
+
+INPUT:

plugins/ai/anthropic/anthropic.go

@@ -3,19 +3,22 @@ package anthropic
 import (
 	"context"
 	"fmt"
+	"net/http"
 	"strings"
 
-	"github.com/samber/lo"
-
 	"github.com/anthropics/anthropic-sdk-go"
 	"github.com/anthropics/anthropic-sdk-go/option"
+	"github.com/danielmiessler/fabric/chat"
 	"github.com/danielmiessler/fabric/common"
 	"github.com/danielmiessler/fabric/plugins"
-	goopenai "github.com/sashabaranov/go-openai"
 )
 
 const defaultBaseUrl = "https://api.anthropic.com/"
 
+const webSearchToolName = "web_search"
+const webSearchToolType = "web_search_20250305"
+const sourcesHeader = "## Sources"
+
 func NewClient() (ret *Client) {
 	vendorName := "Anthropic"
 	ret = &Client{}
@@ -28,10 +31,12 @@ func NewClient() (ret *Client) {
 
 	ret.ApiBaseURL = ret.AddSetupQuestion("API Base URL", false)
 	ret.ApiBaseURL.Value = defaultBaseUrl
-	ret.ApiKey = ret.PluginBase.AddSetupQuestion("API key", true)
-	ret.UseWebTool = ret.AddSetupQuestionBool("Web Search Tool Enabled", false)
-	ret.WebToolLocation = ret.AddSetupQuestionCustom("Web Search Tool Location", false,
-		"Enter your approximate timezone location for web search (e.g., 'America/Los_Angeles', see https://en.wikipedia.org/wiki/List_of_tz_database_time_zones).")
+	ret.UseOAuth = ret.AddSetupQuestionBool("Use OAuth login", false)
+	if plugins.ParseBoolElseFalse(ret.UseOAuth.Value) {
+		ret.ApiKey = ret.PluginBase.AddSetupQuestion("API key", false)
+	} else {
+		ret.ApiKey = ret.PluginBase.AddSetupQuestion("API key", true)
+	}
 
 	ret.maxTokens = 4096
 	ret.defaultRequiredUserMessage = "Hi"
@@ -49,10 +54,9 @@ func NewClient() (ret *Client) {
 
 type Client struct {
 	*plugins.PluginBase
-	ApiBaseURL      *plugins.SetupQuestion
-	ApiKey          *plugins.SetupQuestion
-	UseWebTool      *plugins.SetupQuestion
-	WebToolLocation *plugins.SetupQuestion
+	ApiBaseURL *plugins.SetupQuestion
+	ApiKey     *plugins.SetupQuestion
+	UseOAuth   *plugins.SetupQuestion
 
 	maxTokens                  int
 	defaultRequiredUserMessage string
@@ -61,24 +65,50 @@ type Client struct {
 	client anthropic.Client
 }
 
-func (an *Client) configure() (err error) {
-	if an.ApiBaseURL.Value != "" {
-		baseURL := an.ApiBaseURL.Value
+func (an *Client) Setup() (err error) {
+	if err = an.PluginBase.Ask(an.Name); err != nil {
+		return
+	}
 
-		// As of 2.0beta1, using v2 API endpoint.
-		// https://github.com/anthropics/anthropic-sdk-go/blob/main/CHANGELOG.md#020-beta1-2025-03-25
-		if strings.Contains(baseURL, "-") && !strings.HasSuffix(baseURL, "/v2") {
-			baseURL = strings.TrimSuffix(baseURL, "/")
-			baseURL = baseURL + "/v2"
+	if plugins.ParseBoolElseFalse(an.UseOAuth.Value) {
+		// Check if we have a valid stored token
+		storage, err := common.NewOAuthStorage()
+		if err != nil {
+			return err
 		}
 
-		an.client = anthropic.NewClient(
-			option.WithAPIKey(an.ApiKey.Value),
-			option.WithBaseURL(baseURL),
-		)
-	} else {
-		an.client = anthropic.NewClient(option.WithAPIKey(an.ApiKey.Value))
+		if !storage.HasValidToken("claude", 5) {
+			// No valid token, run OAuth flow
+			if _, err = RunOAuthFlow(); err != nil {
+				return err
+			}
+		}
 	}
+
+	err = an.configure()
+	return
+}
+
+func (an *Client) configure() (err error) {
+	opts := []option.RequestOption{}
+
+	if an.ApiBaseURL.Value != "" {
+		opts = append(opts, option.WithBaseURL(an.ApiBaseURL.Value))
+	}
+
+	if plugins.ParseBoolElseFalse(an.UseOAuth.Value) {
+		// For OAuth, use Bearer token with custom headers
+		// Create custom HTTP client that adds OAuth Bearer token and beta header
+		baseTransport := &http.Transport{}
+		httpClient := &http.Client{
+			Transport: NewOAuthTransport(an, baseTransport),
+		}
+		opts = append(opts, option.WithHTTPClient(httpClient))
+	} else {
+		opts = append(opts, option.WithAPIKey(an.ApiKey.Value))
+	}
+
+	an.client = anthropic.NewClient(opts...)
 	return
 }
 
@@ -87,7 +117,7 @@ func (an *Client) ListModels() (ret []string, err error) {
 }
 
 func (an *Client) SendStream(
-	msgs []*goopenai.ChatCompletionMessage, opts *common.ChatOptions, channel chan string,
+	msgs []*chat.ChatCompletionMessage, opts *common.ChatOptions, channel chan string,
 ) (err error) {
 	messages := an.toMessages(msgs)
 	if len(messages) == 0 {
@@ -127,20 +157,28 @@ func (an *Client) buildMessageParams(msgs []anthropic.MessageParam, opts *common
 		Messages:    msgs,
 	}
 
-	if plugins.ParseBoolElseFalse(an.UseWebTool.Value) {
-		// Build the web-search tool definition:
-		webTool := anthropic.WebSearchTool20250305Param{
-			Name:         "web_search",          // string literal instead of constant
-			Type:         "web_search_20250305", // string literal instead of constant
-			CacheControl: anthropic.NewCacheControlEphemeralParam(),
-			// Optional: restrict domains or max uses
-			// AllowedDomains: []string{"wikipedia.org", "openai.com"},
-			// MaxUses:        anthropic.Opt[int64](5),
+	// Add Claude Code spoofing system message for OAuth authentication
+	if plugins.ParseBoolElseFalse(an.UseOAuth.Value) {
+		params.System = []anthropic.TextBlockParam{
+			{
+				Type: "text",
+				Text: "You are Claude Code, Anthropic's official CLI for Claude.",
+			},
 		}
 
-		if an.WebToolLocation.Value != "" {
+	}
+
+	if opts.Search {
+		// Build the web-search tool definition:
+		webTool := anthropic.WebSearchTool20250305Param{
+			Name:         webSearchToolName,
+			Type:         webSearchToolType,
+			CacheControl: anthropic.NewCacheControlEphemeralParam(),
+		}
+
+		if opts.SearchLocation != "" {
 			webTool.UserLocation.Type = "approximate"
-			webTool.UserLocation.Timezone = anthropic.Opt(an.WebToolLocation.Value)
+			webTool.UserLocation.Timezone = anthropic.Opt(opts.SearchLocation)
 		}
 
 		// Wrap it in the union:
@@ -151,7 +189,7 @@ func (an *Client) buildMessageParams(msgs []anthropic.MessageParam, opts *common
 	return
 }
 
-func (an *Client) Send(ctx context.Context, msgs []*goopenai.ChatCompletionMessage, opts *common.ChatOptions) (
+func (an *Client) Send(ctx context.Context, msgs []*chat.ChatCompletionMessage, opts *common.ChatOptions) (
 	ret string, err error) {
 
 	messages := an.toMessages(msgs)
@@ -165,18 +203,47 @@ func (an *Client) Send(ctx context.Context, msgs []*goopenai.ChatCompletionMessa
 		return
 	}
 
-	texts := lo.FilterMap(message.Content, func(block anthropic.ContentBlockUnion, _ int) (ret string, ok bool) {
-		if ok = block.Type == "text" && block.Text != ""; ok {
-			ret = block.Text
+	var textParts []string
+	var citations []string
+	citationMap := make(map[string]bool) // To avoid duplicate citations
+
+	for _, block := range message.Content {
+		if block.Type == "text" && block.Text != "" {
+			textParts = append(textParts, block.Text)
+
+			// Extract citations from this text block
+			for _, citation := range block.Citations {
+				if citation.Type == "web_search_result_location" {
+					citationKey := citation.URL + "|" + citation.Title
+					if !citationMap[citationKey] {
+						citationMap[citationKey] = true
+						citationText := fmt.Sprintf("- [%s](%s)", citation.Title, citation.URL)
+						if citation.CitedText != "" {
+							citationText += fmt.Sprintf(" - \"%s\"", citation.CitedText)
+						}
+						citations = append(citations, citationText)
+					}
+				}
+			}
 		}
-		return
-	})
-	ret = strings.Join(texts, "")
+	}
+
+	var resultBuilder strings.Builder
+	resultBuilder.WriteString(strings.Join(textParts, ""))
+
+	// Append citations if any were found
+	if len(citations) > 0 {
+		resultBuilder.WriteString("\n\n")
+		resultBuilder.WriteString(sourcesHeader)
+		resultBuilder.WriteString("\n\n")
+		resultBuilder.WriteString(strings.Join(citations, "\n"))
+	}
+	ret = resultBuilder.String()
 
 	return
 }
 
-func (an *Client) toMessages(msgs []*goopenai.ChatCompletionMessage) (ret []anthropic.MessageParam) {
+func (an *Client) toMessages(msgs []*chat.ChatCompletionMessage) (ret []anthropic.MessageParam) {
 	// Custom normalization for Anthropic:
 	// - System messages become the first part of the first user message.
 	// - Messages must alternate user/assistant.
@@ -184,6 +251,9 @@ func (an *Client) toMessages(msgs []*goopenai.ChatCompletionMessage) (ret []anth
 
 	var anthropicMessages []anthropic.MessageParam
 	var systemContent string
+
+	// Note: Claude Code spoofing is now handled in buildMessageParams
+
 	isFirstUserMessage := true
 	lastRoleWasUser := false
 
@@ -193,14 +263,14 @@ func (an *Client) toMessages(msgs []*goopenai.ChatCompletionMessage) (ret []anth
 		}
 
 		switch msg.Role {
-		case goopenai.ChatMessageRoleSystem:
+		case chat.ChatMessageRoleSystem:
 			// Accumulate system content. It will be prepended to the first user message.
 			if systemContent != "" {
 				systemContent += "\\n" + msg.Content
 			} else {
 				systemContent = msg.Content
 			}
-		case goopenai.ChatMessageRoleUser:
+		case chat.ChatMessageRoleUser:
 			userContent := msg.Content
 			if isFirstUserMessage && systemContent != "" {
 				userContent = systemContent + "\\n\\n" + userContent
@@ -213,7 +283,7 @@ func (an *Client) toMessages(msgs []*goopenai.ChatCompletionMessage) (ret []anth
 			}
 			anthropicMessages = append(anthropicMessages, anthropic.NewUserMessage(anthropic.NewTextBlock(userContent)))
 			lastRoleWasUser = true
-		case goopenai.ChatMessageRoleAssistant:
+		case chat.ChatMessageRoleAssistant:
 			// If the first message is an assistant message, and we have system content,
 			// prepend a user message with the system content.
 			if isFirstUserMessage && systemContent != "" {

plugins/ai/anthropic/anthropic_test.go

@@ -1,7 +1,11 @@
 package anthropic
 
 import (
+	"strings"
 	"testing"
+
+	"github.com/anthropics/anthropic-sdk-go"
+	"github.com/danielmiessler/fabric/common"
 )
 
 // Test generated using Keploy
@@ -63,3 +67,192 @@ func TestClient_ListModels_ReturnsCorrectModels(t *testing.T) {
 		}
 	}
 }
+
+func TestBuildMessageParams_WithoutSearch(t *testing.T) {
+	client := NewClient()
+	opts := &common.ChatOptions{
+		Model:       "claude-3-5-sonnet-latest",
+		Temperature: 0.7,
+		Search:      false,
+	}
+
+	messages := []anthropic.MessageParam{
+		anthropic.NewUserMessage(anthropic.NewTextBlock("Hello")),
+	}
+
+	params := client.buildMessageParams(messages, opts)
+
+	if params.Tools != nil {
+		t.Error("Expected no tools when search is disabled, got tools")
+	}
+
+	if params.Model != anthropic.Model(opts.Model) {
+		t.Errorf("Expected model %s, got %s", opts.Model, params.Model)
+	}
+
+	if params.Temperature.Value != opts.Temperature {
+		t.Errorf("Expected temperature %f, got %f", opts.Temperature, params.Temperature.Value)
+	}
+}
+
+func TestBuildMessageParams_WithSearch(t *testing.T) {
+	client := NewClient()
+	opts := &common.ChatOptions{
+		Model:       "claude-3-5-sonnet-latest",
+		Temperature: 0.7,
+		Search:      true,
+	}
+
+	messages := []anthropic.MessageParam{
+		anthropic.NewUserMessage(anthropic.NewTextBlock("What's the weather today?")),
+	}
+
+	params := client.buildMessageParams(messages, opts)
+
+	if params.Tools == nil {
+		t.Fatal("Expected tools when search is enabled, got nil")
+	}
+
+	if len(params.Tools) != 1 {
+		t.Errorf("Expected 1 tool, got %d", len(params.Tools))
+	}
+
+	webTool := params.Tools[0].OfWebSearchTool20250305
+	if webTool == nil {
+		t.Fatal("Expected web search tool, got nil")
+	}
+
+	if webTool.Name != "web_search" {
+		t.Errorf("Expected tool name 'web_search', got %s", webTool.Name)
+	}
+
+	if webTool.Type != "web_search_20250305" {
+		t.Errorf("Expected tool type 'web_search_20250305', got %s", webTool.Type)
+	}
+}
+
+func TestBuildMessageParams_WithSearchAndLocation(t *testing.T) {
+	client := NewClient()
+	opts := &common.ChatOptions{
+		Model:          "claude-3-5-sonnet-latest",
+		Temperature:    0.7,
+		Search:         true,
+		SearchLocation: "America/Los_Angeles",
+	}
+
+	messages := []anthropic.MessageParam{
+		anthropic.NewUserMessage(anthropic.NewTextBlock("What's the weather in San Francisco?")),
+	}
+
+	params := client.buildMessageParams(messages, opts)
+
+	if params.Tools == nil {
+		t.Fatal("Expected tools when search is enabled, got nil")
+	}
+
+	webTool := params.Tools[0].OfWebSearchTool20250305
+	if webTool == nil {
+		t.Fatal("Expected web search tool, got nil")
+	}
+
+	if webTool.UserLocation.Type != "approximate" {
+		t.Errorf("Expected location type 'approximate', got %s", webTool.UserLocation.Type)
+	}
+
+	if webTool.UserLocation.Timezone.Value != opts.SearchLocation {
+		t.Errorf("Expected timezone %s, got %s", opts.SearchLocation, webTool.UserLocation.Timezone.Value)
+	}
+}
+
+func TestCitationFormatting(t *testing.T) {
+	// Test the citation formatting logic by creating a mock message with citations
+	message := &anthropic.Message{
+		Content: []anthropic.ContentBlockUnion{
+			{
+				Type: "text",
+				Text: "Based on recent research, artificial intelligence is advancing rapidly.",
+				Citations: []anthropic.TextCitationUnion{
+					{
+						Type:      "web_search_result_location",
+						URL:       "https://example.com/ai-research",
+						Title:     "AI Research Advances 2025",
+						CitedText: "artificial intelligence is advancing rapidly",
+					},
+					{
+						Type:      "web_search_result_location",
+						URL:       "https://another-source.com/tech-news",
+						Title:     "Technology News Today",
+						CitedText: "recent developments in AI",
+					},
+				},
+			},
+			{
+				Type: "text",
+				Text: " Machine learning models are becoming more sophisticated.",
+				Citations: []anthropic.TextCitationUnion{
+					{
+						Type:      "web_search_result_location",
+						URL:       "https://example.com/ai-research", // Duplicate URL should be deduplicated
+						Title:     "AI Research Advances 2025",
+						CitedText: "machine learning models",
+					},
+				},
+			},
+		},
+	}
+
+	// Extract text and citations using the same logic as the Send method
+	var textParts []string
+	var citations []string
+	citationMap := make(map[string]bool)
+
+	for _, block := range message.Content {
+		if block.Type == "text" && block.Text != "" {
+			textParts = append(textParts, block.Text)
+
+			for _, citation := range block.Citations {
+				if citation.Type == "web_search_result_location" {
+					citationKey := citation.URL + "|" + citation.Title
+					if !citationMap[citationKey] {
+						citationMap[citationKey] = true
+						citationText := "- [" + citation.Title + "](" + citation.URL + ")"
+						if citation.CitedText != "" {
+							citationText += " - \"" + citation.CitedText + "\""
+						}
+						citations = append(citations, citationText)
+					}
+				}
+			}
+		}
+	}
+
+	result := strings.Join(textParts, "")
+	if len(citations) > 0 {
+		result += "\n\n## Sources\n\n" + strings.Join(citations, "\n")
+	}
+
+	// Verify the result contains the expected text
+	expectedText := "Based on recent research, artificial intelligence is advancing rapidly. Machine learning models are becoming more sophisticated."
+	if !strings.Contains(result, expectedText) {
+		t.Errorf("Expected result to contain text: %s", expectedText)
+	}
+
+	// Verify citations are included
+	if !strings.Contains(result, "## Sources") {
+		t.Error("Expected result to contain Sources section")
+	}
+
+	if !strings.Contains(result, "[AI Research Advances 2025](https://example.com/ai-research)") {
+		t.Error("Expected result to contain first citation")
+	}
+
+	if !strings.Contains(result, "[Technology News Today](https://another-source.com/tech-news)") {
+		t.Error("Expected result to contain second citation")
+	}
+
+	// Verify deduplication - should only have 2 unique citations, not 3
+	citationCount := strings.Count(result, "- [")
+	if citationCount != 2 {
+		t.Errorf("Expected 2 unique citations, got %d", citationCount)
+	}
+}

plugins/ai/anthropic/oauth.go

@@ -0,0 +1,300 @@
+package anthropic
+
+import (
+	"bytes"
+	"crypto/rand"
+	"crypto/sha256"
+	"encoding/base64"
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+	"os/exec"
+	"strings"
+	"time"
+
+	"github.com/danielmiessler/fabric/common"
+	"golang.org/x/oauth2"
+)
+
+// OAuth configuration constants
+const (
+	oauthClientID    = "9d1c250a-e61b-44d9-88ed-5944d1962f5e"
+	oauthAuthURL     = "https://claude.ai/oauth/authorize"
+	oauthTokenURL    = "https://console.anthropic.com/v1/oauth/token"
+	oauthRedirectURL = "https://console.anthropic.com/oauth/code/callback"
+)
+
+// OAuthTransport is a custom HTTP transport that adds OAuth Bearer token and beta header
+type OAuthTransport struct {
+	client *Client
+	base   http.RoundTripper
+}
+
+// RoundTrip implements the http.RoundTripper interface
+func (t *OAuthTransport) RoundTrip(req *http.Request) (*http.Response, error) {
+	// Clone the request to avoid modifying the original
+	newReq := req.Clone(req.Context())
+
+	// Get current token (may refresh if needed)
+	token, err := t.getValidToken()
+	if err != nil {
+		return nil, fmt.Errorf("failed to get valid OAuth token: %w", err)
+	}
+
+	// Add OAuth Bearer token
+	newReq.Header.Set("Authorization", "Bearer "+token)
+
+	// Add the anthropic-beta header for OAuth
+	newReq.Header.Set("anthropic-beta", "oauth-2025-04-20")
+
+	// Set User-Agent to match AI SDK exactly
+	newReq.Header.Set("User-Agent", "ai-sdk/anthropic")
+
+	// Remove x-api-key header if present (OAuth doesn't use it)
+	newReq.Header.Del("x-api-key")
+
+	return t.base.RoundTrip(newReq)
+}
+
+// getValidToken returns a valid access token, refreshing if necessary
+func (t *OAuthTransport) getValidToken() (string, error) {
+	storage, err := common.NewOAuthStorage()
+	if err != nil {
+		return "", fmt.Errorf("failed to create OAuth storage: %w", err)
+	}
+
+	// Load stored token
+	token, err := storage.LoadToken("claude")
+	if err != nil {
+		return "", fmt.Errorf("failed to load stored token: %w", err)
+	}
+	// If no token exists, run OAuth flow
+	if token == nil {
+		fmt.Println("No OAuth token found, initiating authentication...")
+		newAccessToken, err := RunOAuthFlow()
+		if err != nil {
+			return "", fmt.Errorf("failed to authenticate: %w", err)
+		}
+		return newAccessToken, nil
+	}
+
+	// Check if token needs refresh (5 minute buffer)
+	if token.IsExpired(5) {
+		fmt.Println("OAuth token expired, refreshing...")
+		newAccessToken, err := RefreshToken()
+		if err != nil {
+			// If refresh fails, try re-authentication
+			fmt.Println("Token refresh failed, re-authenticating...")
+			newAccessToken, err = RunOAuthFlow()
+			if err != nil {
+				return "", fmt.Errorf("failed to refresh or re-authenticate: %w", err)
+			}
+		}
+
+		return newAccessToken, nil
+	}
+
+	return token.AccessToken, nil
+}
+
+// NewOAuthTransport creates a new OAuth transport for the given client
+func NewOAuthTransport(client *Client, base http.RoundTripper) *OAuthTransport {
+	return &OAuthTransport{
+		client: client,
+		base:   base,
+	}
+}
+
+// generatePKCE generates PKCE code verifier and challenge
+func generatePKCE() (verifier, challenge string, err error) {
+	b := make([]byte, 32)
+	if _, err = rand.Read(b); err != nil {
+		return
+	}
+	verifier = base64.RawURLEncoding.EncodeToString(b)
+	sum := sha256.Sum256([]byte(verifier))
+	challenge = base64.RawURLEncoding.EncodeToString(sum[:])
+	return
+}
+
+// openBrowser attempts to open the given URL in the default browser
+func openBrowser(url string) {
+	commands := [][]string{{"xdg-open", url}, {"open", url}, {"cmd", "/c", "start", url}}
+	for _, cmd := range commands {
+		if exec.Command(cmd[0], cmd[1:]...).Start() == nil {
+			return
+		}
+	}
+}
+
+// RunOAuthFlow executes the complete OAuth authorization flow
+func RunOAuthFlow() (token string, err error) {
+	verifier, challenge, err := generatePKCE()
+	if err != nil {
+		return
+	}
+
+	cfg := oauth2.Config{
+		ClientID:    oauthClientID,
+		Endpoint:    oauth2.Endpoint{AuthURL: oauthAuthURL, TokenURL: oauthTokenURL},
+		RedirectURL: oauthRedirectURL,
+		Scopes:      []string{"org:create_api_key", "user:profile", "user:inference"},
+	}
+
+	authURL := cfg.AuthCodeURL(verifier,
+		oauth2.SetAuthURLParam("code_challenge", challenge),
+		oauth2.SetAuthURLParam("code_challenge_method", "S256"),
+		oauth2.SetAuthURLParam("code", "true"),
+		oauth2.SetAuthURLParam("state", verifier),
+	)
+
+	fmt.Println("Open the following URL in your browser. Fabric would like to authorize:")
+	fmt.Println(authURL)
+	openBrowser(authURL)
+	fmt.Print("Paste the authorization code here: ")
+	var code string
+	fmt.Scanln(&code)
+	parts := strings.SplitN(code, "#", 2)
+	state := verifier
+	if len(parts) == 2 {
+		state = parts[1]
+	}
+
+	// Manual token exchange to match opencode implementation
+	tokenReq := map[string]string{
+		"code":          parts[0],
+		"state":         state,
+		"grant_type":    "authorization_code",
+		"client_id":     oauthClientID,
+		"redirect_uri":  oauthRedirectURL,
+		"code_verifier": verifier,
+	}
+
+	token, err = exchangeToken(tokenReq)
+	return
+}
+
+// exchangeToken exchanges authorization code for access token
+func exchangeToken(params map[string]string) (token string, err error) {
+	reqBody, err := json.Marshal(params)
+	if err != nil {
+		return
+	}
+
+	resp, err := http.Post(oauthTokenURL, "application/json", bytes.NewBuffer(reqBody))
+	if err != nil {
+		return
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != http.StatusOK {
+		body, _ := io.ReadAll(resp.Body)
+		err = fmt.Errorf("token exchange failed: %s - %s", resp.Status, string(body))
+		return
+	}
+
+	var result struct {
+		AccessToken  string `json:"access_token"`
+		RefreshToken string `json:"refresh_token"`
+		ExpiresIn    int    `json:"expires_in"`
+		TokenType    string `json:"token_type"`
+		Scope        string `json:"scope"`
+	}
+	if err = json.NewDecoder(resp.Body).Decode(&result); err != nil {
+		return
+	}
+
+	// Save the complete token information
+	storage, err := common.NewOAuthStorage()
+	if err != nil {
+		return result.AccessToken, fmt.Errorf("failed to create OAuth storage: %w", err)
+	}
+
+	oauthToken := &common.OAuthToken{
+		AccessToken:  result.AccessToken,
+		RefreshToken: result.RefreshToken,
+		ExpiresAt:    time.Now().Unix() + int64(result.ExpiresIn),
+		TokenType:    result.TokenType,
+		Scope:        result.Scope,
+	}
+
+	if err = storage.SaveToken("claude", oauthToken); err != nil {
+		return result.AccessToken, fmt.Errorf("failed to save OAuth token: %w", err)
+	}
+
+	token = result.AccessToken
+	return
+}
+
+// RefreshToken refreshes an expired OAuth token using the refresh token
+func RefreshToken() (string, error) {
+	storage, err := common.NewOAuthStorage()
+	if err != nil {
+		return "", fmt.Errorf("failed to create OAuth storage: %w", err)
+	}
+
+	// Load existing token
+	token, err := storage.LoadToken("claude")
+	if err != nil {
+		return "", fmt.Errorf("failed to load stored token: %w", err)
+	}
+	if token == nil || token.RefreshToken == "" {
+		return "", fmt.Errorf("no refresh token available")
+	}
+
+	// Prepare refresh request
+	refreshReq := map[string]string{
+		"grant_type":    "refresh_token",
+		"refresh_token": token.RefreshToken,
+		"client_id":     oauthClientID,
+	}
+
+	reqBody, err := json.Marshal(refreshReq)
+	if err != nil {
+		return "", fmt.Errorf("failed to marshal refresh request: %w", err)
+	}
+
+	// Make refresh request
+	resp, err := http.Post(oauthTokenURL, "application/json", bytes.NewBuffer(reqBody))
+	if err != nil {
+		return "", fmt.Errorf("refresh request failed: %w", err)
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != http.StatusOK {
+		body, _ := io.ReadAll(resp.Body)
+		return "", fmt.Errorf("token refresh failed: %s - %s", resp.Status, string(body))
+	}
+
+	var result struct {
+		AccessToken  string `json:"access_token"`
+		RefreshToken string `json:"refresh_token"`
+		ExpiresIn    int    `json:"expires_in"`
+		TokenType    string `json:"token_type"`
+		Scope        string `json:"scope"`
+	}
+	if err = json.NewDecoder(resp.Body).Decode(&result); err != nil {
+		return "", fmt.Errorf("failed to parse refresh response: %w", err)
+	}
+
+	// Update stored token
+	newToken := &common.OAuthToken{
+		AccessToken:  result.AccessToken,
+		RefreshToken: result.RefreshToken,
+		ExpiresAt:    time.Now().Unix() + int64(result.ExpiresIn),
+		TokenType:    result.TokenType,
+		Scope:        result.Scope,
+	}
+
+	// Use existing refresh token if new one not provided
+	if newToken.RefreshToken == "" {
+		newToken.RefreshToken = token.RefreshToken
+	}
+
+	if err = storage.SaveToken("claude", newToken); err != nil {
+		return "", fmt.Errorf("failed to save refreshed token: %w", err)
+	}
+
+	return result.AccessToken, nil
+}

plugins/ai/azure/azure.go

@@ -5,7 +5,8 @@ import (
 
 	"github.com/danielmiessler/fabric/plugins"
 	"github.com/danielmiessler/fabric/plugins/ai/openai"
-	goopenai "github.com/sashabaranov/go-openai"
+	openaiapi "github.com/openai/openai-go"
+	"github.com/openai/openai-go/option"
 )
 
 func NewClient() (ret *Client) {
@@ -29,11 +30,15 @@ type Client struct {
 
 func (oi *Client) configure() (err error) {
 	oi.apiDeployments = strings.Split(oi.ApiDeployments.Value, ",")
-	config := goopenai.DefaultAzureConfig(oi.ApiKey.Value, oi.ApiBaseURL.Value)
-	if oi.ApiVersion.Value != "" {
-		config.APIVersion = oi.ApiVersion.Value
+	opts := []option.RequestOption{option.WithAPIKey(oi.ApiKey.Value)}
+	if oi.ApiBaseURL.Value != "" {
+		opts = append(opts, option.WithBaseURL(oi.ApiBaseURL.Value))
 	}
-	oi.ApiClient = goopenai.NewClientWithConfig(config)
+	if oi.ApiVersion.Value != "" {
+		opts = append(opts, option.WithQuery("api-version", oi.ApiVersion.Value))
+	}
+	client := openaiapi.NewClient(opts...)
+	oi.ApiClient = &client
 	return
 }
 

plugins/ai/bedrock/bedrock.go

@@ -0,0 +1,274 @@
+// Package bedrock provides a plugin to use Amazon Bedrock models.
+// Supported models are defined in the MODELS variable.
+// To add additional models, append them to the MODELS array. Models must support the Converse and ConverseStream operations
+// Authentication uses the  AWS credential provider chain, similar.to the AWS CLI and SDKs
+// https://docs.aws.amazon.com/sdkref/latest/guide/standardized-credentials.html
+package bedrock
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/danielmiessler/fabric/common"
+	"github.com/danielmiessler/fabric/plugins"
+	"github.com/danielmiessler/fabric/plugins/ai"
+
+	"github.com/aws/aws-sdk-go-v2/aws"
+	"github.com/aws/aws-sdk-go-v2/aws/middleware"
+	"github.com/aws/aws-sdk-go-v2/config"
+	"github.com/aws/aws-sdk-go-v2/service/bedrock"
+	"github.com/aws/aws-sdk-go-v2/service/bedrockruntime"
+	"github.com/aws/aws-sdk-go-v2/service/bedrockruntime/types"
+
+	"github.com/danielmiessler/fabric/chat"
+)
+
+const (
+	userAgentKey   = "aiosc"
+	userAgentValue = "fabric"
+)
+
+// Ensure BedrockClient implements the ai.Vendor interface
+var _ ai.Vendor = (*BedrockClient)(nil)
+
+// BedrockClient is a plugin to add support for Amazon Bedrock.
+// It implements the plugins.Plugin interface and provides methods
+// for interacting with AWS Bedrock's Converse and ConverseStream APIs.
+type BedrockClient struct {
+	*plugins.PluginBase
+	runtimeClient      *bedrockruntime.Client
+	controlPlaneClient *bedrock.Client
+
+	bedrockRegion *plugins.SetupQuestion
+}
+
+// NewClient returns a new Bedrock plugin client
+func NewClient() (ret *BedrockClient) {
+	vendorName := "Bedrock"
+	ret = &BedrockClient{}
+
+	ctx := context.Background()
+	cfg, err := config.LoadDefaultConfig(ctx)
+	if err != nil {
+		// Create a minimal client that will fail gracefully during configuration
+		ret.PluginBase = &plugins.PluginBase{
+			Name:          vendorName,
+			EnvNamePrefix: plugins.BuildEnvVariablePrefix(vendorName),
+			ConfigureCustom: func() error {
+				return fmt.Errorf("unable to load AWS Config: %w", err)
+			},
+		}
+		ret.bedrockRegion = ret.PluginBase.AddSetupQuestion("AWS Region", true)
+		return
+	}
+
+	cfg.APIOptions = append(cfg.APIOptions, middleware.AddUserAgentKeyValue(userAgentKey, userAgentValue))
+
+	runtimeClient := bedrockruntime.NewFromConfig(cfg)
+	controlPlaneClient := bedrock.NewFromConfig(cfg)
+
+	ret.PluginBase = &plugins.PluginBase{
+		Name:            vendorName,
+		EnvNamePrefix:   plugins.BuildEnvVariablePrefix(vendorName),
+		ConfigureCustom: ret.configure,
+	}
+
+	ret.runtimeClient = runtimeClient
+	ret.controlPlaneClient = controlPlaneClient
+
+	ret.bedrockRegion = ret.PluginBase.AddSetupQuestion("AWS Region", true)
+
+	if cfg.Region != "" {
+		ret.bedrockRegion.Value = cfg.Region
+	}
+
+	return
+}
+
+// isValidAWSRegion validates AWS region format
+func isValidAWSRegion(region string) bool {
+	// Simple validation - AWS regions are typically 2-3 parts separated by hyphens
+	// Examples: us-east-1, eu-west-1, ap-southeast-2
+	if len(region) < 5 || len(region) > 30 {
+		return false
+	}
+	// Basic pattern check for AWS region format
+	return region != ""
+}
+
+// configure initializes the Bedrock clients with the specified AWS region.
+// If no region is specified, the default region from AWS config is used.
+func (c *BedrockClient) configure() error {
+	if c.bedrockRegion.Value == "" {
+		return nil // Use default region from AWS config
+	}
+
+	// Validate region format
+	if !isValidAWSRegion(c.bedrockRegion.Value) {
+		return fmt.Errorf("invalid AWS region: %s", c.bedrockRegion.Value)
+	}
+
+	ctx := context.Background()
+	cfg, err := config.LoadDefaultConfig(ctx, config.WithRegion(c.bedrockRegion.Value))
+	if err != nil {
+		return fmt.Errorf("unable to load AWS Config with region %s: %w", c.bedrockRegion.Value, err)
+	}
+
+	cfg.APIOptions = append(cfg.APIOptions, middleware.AddUserAgentKeyValue(userAgentKey, userAgentValue))
+
+	c.runtimeClient = bedrockruntime.NewFromConfig(cfg)
+	c.controlPlaneClient = bedrock.NewFromConfig(cfg)
+
+	return nil
+}
+
+// ListModels retrieves all available foundation models and inference profiles
+// from AWS Bedrock that can be used with this plugin.
+func (c *BedrockClient) ListModels() ([]string, error) {
+	models := []string{}
+	ctx := context.Background()
+
+	foundationModels, err := c.controlPlaneClient.ListFoundationModels(ctx, &bedrock.ListFoundationModelsInput{})
+	if err != nil {
+		return nil, fmt.Errorf("failed to list foundation models: %w", err)
+	}
+
+	for _, model := range foundationModels.ModelSummaries {
+		models = append(models, *model.ModelId)
+	}
+
+	inferenceProfilesPaginator := bedrock.NewListInferenceProfilesPaginator(c.controlPlaneClient, &bedrock.ListInferenceProfilesInput{})
+
+	for inferenceProfilesPaginator.HasMorePages() {
+		inferenceProfiles, err := inferenceProfilesPaginator.NextPage(ctx)
+		if err != nil {
+			return nil, fmt.Errorf("failed to list inference profiles: %w", err)
+		}
+
+		for _, profile := range inferenceProfiles.InferenceProfileSummaries {
+			models = append(models, *profile.InferenceProfileId)
+		}
+	}
+
+	return models, nil
+}
+
+// SendStream sends the messages to the the Bedrock ConverseStream API
+func (c *BedrockClient) SendStream(msgs []*chat.ChatCompletionMessage, opts *common.ChatOptions, channel chan string) (err error) {
+	// Ensure channel is closed on all exit paths to prevent goroutine leaks
+	defer func() {
+		if r := recover(); r != nil {
+			err = fmt.Errorf("panic in SendStream: %v", r)
+		}
+		close(channel)
+	}()
+
+	messages := c.toMessages(msgs)
+
+	var converseInput = bedrockruntime.ConverseStreamInput{
+		ModelId:  aws.String(opts.Model),
+		Messages: messages,
+		InferenceConfig: &types.InferenceConfiguration{
+			Temperature: aws.Float32(float32(opts.Temperature)),
+			TopP:        aws.Float32(float32(opts.TopP))},
+	}
+
+	response, err := c.runtimeClient.ConverseStream(context.Background(), &converseInput)
+	if err != nil {
+		return fmt.Errorf("bedrock conversestream failed for model %s: %w", opts.Model, err)
+	}
+
+	for event := range response.GetStream().Events() {
+		// Possible ConverseStream event types
+		// https://docs.aws.amazon.com/bedrock/latest/userguide/conversation-inference-call.html#conversation-inference-call-response-converse-stream
+		switch v := event.(type) {
+
+		case *types.ConverseStreamOutputMemberContentBlockDelta:
+			text, ok := v.Value.Delta.(*types.ContentBlockDeltaMemberText)
+			if ok {
+				channel <- text.Value
+			}
+
+		case *types.ConverseStreamOutputMemberMessageStop:
+			channel <- "\n"
+			return nil // Let defer handle the close
+
+		// Unused Events
+		case *types.ConverseStreamOutputMemberMessageStart,
+			*types.ConverseStreamOutputMemberContentBlockStart,
+			*types.ConverseStreamOutputMemberContentBlockStop,
+			*types.ConverseStreamOutputMemberMetadata:
+
+		default:
+			return fmt.Errorf("unknown stream event type: %T", v)
+		}
+	}
+
+	return nil
+}
+
+// Send sends the messages the Bedrock Converse API
+func (c *BedrockClient) Send(ctx context.Context, msgs []*chat.ChatCompletionMessage, opts *common.ChatOptions) (ret string, err error) {
+
+	messages := c.toMessages(msgs)
+
+	var converseInput = bedrockruntime.ConverseInput{
+		ModelId:  aws.String(opts.Model),
+		Messages: messages,
+	}
+	response, err := c.runtimeClient.Converse(ctx, &converseInput)
+	if err != nil {
+		return "", fmt.Errorf("bedrock converse failed for model %s: %w", opts.Model, err)
+	}
+
+	responseText, ok := response.Output.(*types.ConverseOutputMemberMessage)
+	if !ok {
+		return "", fmt.Errorf("unexpected response type: %T", response.Output)
+	}
+
+	if len(responseText.Value.Content) == 0 {
+		return "", fmt.Errorf("empty response content")
+	}
+
+	responseContentBlock := responseText.Value.Content[0]
+	text, ok := responseContentBlock.(*types.ContentBlockMemberText)
+	if !ok {
+		return "", fmt.Errorf("unexpected content block type: %T", responseContentBlock)
+	}
+
+	return text.Value, nil
+}
+
+// NeedsRawMode indicates whether the model requires raw mode processing.
+// Bedrock models do not require raw mode.
+func (c *BedrockClient) NeedsRawMode(modelName string) bool {
+	return false
+}
+
+// toMessages converts the array of input messages from the ChatCompletionMessageType to the
+// Bedrock Converse Message type.
+// The system role messages are mapped to the user role as they contain a mix of system messages,
+// pattern content and user input.
+func (c *BedrockClient) toMessages(inputMessages []*chat.ChatCompletionMessage) (messages []types.Message) {
+	for _, msg := range inputMessages {
+		roles := map[string]types.ConversationRole{
+			chat.ChatMessageRoleUser:      types.ConversationRoleUser,
+			chat.ChatMessageRoleAssistant: types.ConversationRoleAssistant,
+			chat.ChatMessageRoleSystem:    types.ConversationRoleUser,
+		}
+
+		role, ok := roles[msg.Role]
+		if !ok {
+			continue
+		}
+
+		message := types.Message{
+			Role:    role,
+			Content: []types.ContentBlock{&types.ContentBlockMemberText{Value: msg.Content}},
+		}
+		messages = append(messages, message)
+
+	}
+
+	return
+}

plugins/ai/dryrun/dryrun.go

@@ -4,8 +4,9 @@ import (
 	"bytes"
 	"context"
 	"fmt"
+	"strings"
 
-	goopenai "github.com/sashabaranov/go-openai"
+	"github.com/danielmiessler/fabric/chat"
 
 	"github.com/danielmiessler/fabric/common"
 	"github.com/danielmiessler/fabric/plugins"
@@ -23,62 +24,86 @@ func (c *Client) ListModels() ([]string, error) {
 	return []string{"dry-run-model"}, nil
 }
 
-func (c *Client) SendStream(msgs []*goopenai.ChatCompletionMessage, opts *common.ChatOptions, channel chan string) error {
-	output := "Dry run: Would send the following request:\n\n"
+func (c *Client) formatMultiContentMessage(msg *chat.ChatCompletionMessage) string {
+	var builder strings.Builder
+
+	if len(msg.MultiContent) > 0 {
+		builder.WriteString(fmt.Sprintf("%s:\n", msg.Role))
+		for _, part := range msg.MultiContent {
+			builder.WriteString(fmt.Sprintf("  - Type: %s\n", part.Type))
+			if part.Type == chat.ChatMessagePartTypeImageURL {
+				builder.WriteString(fmt.Sprintf("    Image URL: %s\n", part.ImageURL.URL))
+			} else {
+				builder.WriteString(fmt.Sprintf("    Text: %s\n", part.Text))
+			}
+		}
+		builder.WriteString("\n")
+	} else {
+		builder.WriteString(fmt.Sprintf("%s:\n%s\n\n", msg.Role, msg.Content))
+	}
+
+	return builder.String()
+}
+
+func (c *Client) formatMessages(msgs []*chat.ChatCompletionMessage) string {
+	var builder strings.Builder
 
 	for _, msg := range msgs {
 		switch msg.Role {
-		case goopenai.ChatMessageRoleSystem:
-			output += fmt.Sprintf("System:\n%s\n\n", msg.Content)
-		case goopenai.ChatMessageRoleAssistant:
-			output += fmt.Sprintf("Assistant:\n%s\n\n", msg.Content)
-		case goopenai.ChatMessageRoleUser:
-			output += fmt.Sprintf("User:\n%s\n\n", msg.Content)
+		case chat.ChatMessageRoleSystem:
+			builder.WriteString(fmt.Sprintf("System:\n%s\n\n", msg.Content))
+		case chat.ChatMessageRoleAssistant:
+			builder.WriteString(c.formatMultiContentMessage(msg))
+		case chat.ChatMessageRoleUser:
+			builder.WriteString(c.formatMultiContentMessage(msg))
 		default:
-			output += fmt.Sprintf("%s:\n%s\n\n", msg.Role, msg.Content)
+			builder.WriteString(fmt.Sprintf("%s:\n%s\n\n", msg.Role, msg.Content))
 		}
 	}
 
-	output += "Options:\n"
-	output += fmt.Sprintf("Model: %s\n", opts.Model)
-	output += fmt.Sprintf("Temperature: %f\n", opts.Temperature)
-	output += fmt.Sprintf("TopP: %f\n", opts.TopP)
-	output += fmt.Sprintf("PresencePenalty: %f\n", opts.PresencePenalty)
-	output += fmt.Sprintf("FrequencyPenalty: %f\n", opts.FrequencyPenalty)
+	return builder.String()
+}
+
+func (c *Client) formatOptions(opts *common.ChatOptions) string {
+	var builder strings.Builder
+
+	builder.WriteString("Options:\n")
+	builder.WriteString(fmt.Sprintf("Model: %s\n", opts.Model))
+	builder.WriteString(fmt.Sprintf("Temperature: %f\n", opts.Temperature))
+	builder.WriteString(fmt.Sprintf("TopP: %f\n", opts.TopP))
+	builder.WriteString(fmt.Sprintf("PresencePenalty: %f\n", opts.PresencePenalty))
+	builder.WriteString(fmt.Sprintf("FrequencyPenalty: %f\n", opts.FrequencyPenalty))
 	if opts.ModelContextLength != 0 {
-		output += fmt.Sprintf("ModelContextLength: %d\n", opts.ModelContextLength)
+		builder.WriteString(fmt.Sprintf("ModelContextLength: %d\n", opts.ModelContextLength))
+	}
+	if opts.Search {
+		builder.WriteString("Search: enabled\n")
+		if opts.SearchLocation != "" {
+			builder.WriteString(fmt.Sprintf("SearchLocation: %s\n", opts.SearchLocation))
+		}
+	}
+	if opts.ImageFile != "" {
+		builder.WriteString(fmt.Sprintf("ImageFile: %s\n", opts.ImageFile))
 	}
 
-	channel <- output
+	return builder.String()
+}
+
+func (c *Client) SendStream(msgs []*chat.ChatCompletionMessage, opts *common.ChatOptions, channel chan string) error {
+	var builder strings.Builder
+	builder.WriteString("Dry run: Would send the following request:\n\n")
+	builder.WriteString(c.formatMessages(msgs))
+	builder.WriteString(c.formatOptions(opts))
+
+	channel <- builder.String()
 	close(channel)
 	return nil
 }
 
-func (c *Client) Send(_ context.Context, msgs []*goopenai.ChatCompletionMessage, opts *common.ChatOptions) (string, error) {
+func (c *Client) Send(_ context.Context, msgs []*chat.ChatCompletionMessage, opts *common.ChatOptions) (string, error) {
 	fmt.Println("Dry run: Would send the following request:")
-
-	for _, msg := range msgs {
-		switch msg.Role {
-		case goopenai.ChatMessageRoleSystem:
-			fmt.Printf("System:\n%s\n\n", msg.Content)
-		case goopenai.ChatMessageRoleAssistant:
-			fmt.Printf("Assistant:\n%s\n\n", msg.Content)
-		case goopenai.ChatMessageRoleUser:
-			fmt.Printf("User:\n%s\n\n", msg.Content)
-		default:
-			fmt.Printf("%s:\n%s\n\n", msg.Role, msg.Content)
-		}
-	}
-
-	fmt.Println("Options:")
-	fmt.Printf("Model: %s\n", opts.Model)
-	fmt.Printf("Temperature: %f\n", opts.Temperature)
-	fmt.Printf("TopP: %f\n", opts.TopP)
-	fmt.Printf("PresencePenalty: %f\n", opts.PresencePenalty)
-	fmt.Printf("FrequencyPenalty: %f\n", opts.FrequencyPenalty)
-	if opts.ModelContextLength != 0 {
-		fmt.Printf("ModelContextLength: %d\n", opts.ModelContextLength)
-	}
+	fmt.Print(c.formatMessages(msgs))
+	fmt.Print(c.formatOptions(opts))
 
 	return "", nil
 }

plugins/ai/dryrun/dryrun_test.go

@@ -4,8 +4,8 @@ import (
 	"reflect"
 	"testing"
 
+	"github.com/danielmiessler/fabric/chat"
 	"github.com/danielmiessler/fabric/common"
-	"github.com/sashabaranov/go-openai"
 )
 
 // Test generated using Keploy
@@ -33,7 +33,7 @@ func TestSetup_ReturnsNil(t *testing.T) {
 // Test generated using Keploy
 func TestSendStream_SendsMessages(t *testing.T) {
 	client := NewClient()
-	msgs := []*openai.ChatCompletionMessage{
+	msgs := []*chat.ChatCompletionMessage{
 		{Role: "user", Content: "Test message"},
 	}
 	opts := &common.ChatOptions{

plugins/ai/exolab/exolab.go

@@ -5,8 +5,8 @@ import (
 
 	"github.com/danielmiessler/fabric/plugins"
 	"github.com/danielmiessler/fabric/plugins/ai/openai"
-
-	goopenai "github.com/sashabaranov/go-openai"
+	openaiapi "github.com/openai/openai-go"
+	"github.com/openai/openai-go/option"
 )
 
 func NewClient() (ret *Client) {
@@ -32,10 +32,12 @@ type Client struct {
 func (oi *Client) configure() (err error) {
 	oi.apiModels = strings.Split(oi.ApiModels.Value, ",")
 
-	config := goopenai.DefaultConfig("")
-	config.BaseURL = oi.ApiBaseURL.Value
-
-	oi.ApiClient = goopenai.NewClientWithConfig(config)
+	opts := []option.RequestOption{option.WithAPIKey(oi.ApiKey.Value)}
+	if oi.ApiBaseURL.Value != "" {
+		opts = append(opts, option.WithBaseURL(oi.ApiBaseURL.Value))
+	}
+	client := openaiapi.NewClient(opts...)
+	oi.ApiClient = &client
 	return
 }
 

plugins/ai/gemini/gemini.go

@@ -6,8 +6,8 @@ import (
 	"fmt"
 	"strings"
 
+	"github.com/danielmiessler/fabric/chat"
 	"github.com/danielmiessler/fabric/plugins"
-	goopenai "github.com/sashabaranov/go-openai"
 
 	"github.com/danielmiessler/fabric/common"
 	"github.com/google/generative-ai-go/genai"
@@ -60,7 +60,7 @@ func (o *Client) ListModels() (ret []string, err error) {
 	return
 }
 
-func (o *Client) Send(ctx context.Context, msgs []*goopenai.ChatCompletionMessage, opts *common.ChatOptions) (ret string, err error) {
+func (o *Client) Send(ctx context.Context, msgs []*chat.ChatCompletionMessage, opts *common.ChatOptions) (ret string, err error) {
 	systemInstruction, messages := toMessages(msgs)
 
 	var client *genai.Client
@@ -91,7 +91,7 @@ func (o *Client) buildModelNameFull(modelName string) string {
 	return fmt.Sprintf("%v%v", modelsNamePrefix, modelName)
 }
 
-func (o *Client) SendStream(msgs []*goopenai.ChatCompletionMessage, opts *common.ChatOptions, channel chan string) (err error) {
+func (o *Client) SendStream(msgs []*chat.ChatCompletionMessage, opts *common.ChatOptions, channel chan string) (err error) {
 	ctx := context.Background()
 	var client *genai.Client
 	if client, err = genai.NewClient(ctx, option.WithAPIKey(o.ApiKey.Value)); err != nil {
@@ -147,7 +147,7 @@ func (o *Client) NeedsRawMode(modelName string) bool {
 	return false
 }
 
-func toMessages(msgs []*goopenai.ChatCompletionMessage) (systemInstruction *genai.Content, messages []genai.Part) {
+func toMessages(msgs []*chat.ChatCompletionMessage) (systemInstruction *genai.Content, messages []genai.Part) {
 	if len(msgs) >= 2 {
 		systemInstruction = &genai.Content{
 			Parts: []genai.Part{

plugins/ai/lmstudio/lmstudio.go

@@ -9,7 +9,7 @@ import (
 	"io"
 	"net/http"
 
-	goopenai "github.com/sashabaranov/go-openai"
+	"github.com/danielmiessler/fabric/chat"
 
 	"github.com/danielmiessler/fabric/common"
 	"github.com/danielmiessler/fabric/plugins"
@@ -87,7 +87,7 @@ func (c *Client) ListModels() ([]string, error) {
 	return models, nil
 }
 
-func (c *Client) SendStream(msgs []*goopenai.ChatCompletionMessage, opts *common.ChatOptions, channel chan string) (err error) {
+func (c *Client) SendStream(msgs []*chat.ChatCompletionMessage, opts *common.ChatOptions, channel chan string) (err error) {
 	url := fmt.Sprintf("%s/chat/completions", c.ApiUrl.Value)
 
 	payload := map[string]interface{}{
@@ -173,7 +173,7 @@ func (c *Client) SendStream(msgs []*goopenai.ChatCompletionMessage, opts *common
 	return
 }
 
-func (c *Client) Send(ctx context.Context, msgs []*goopenai.ChatCompletionMessage, opts *common.ChatOptions) (content string, err error) {
+func (c *Client) Send(ctx context.Context, msgs []*chat.ChatCompletionMessage, opts *common.ChatOptions) (content string, err error) {
 	url := fmt.Sprintf("%s/chat/completions", c.ApiUrl.Value)
 
 	payload := map[string]interface{}{

plugins/ai/ollama/ollama.go

@@ -8,9 +8,9 @@ import (
 	"strings"
 	"time"
 
+	"github.com/danielmiessler/fabric/chat"
 	ollamaapi "github.com/ollama/ollama/api"
 	"github.com/samber/lo"
-	goopenai "github.com/sashabaranov/go-openai"
 
 	"github.com/danielmiessler/fabric/common"
 	"github.com/danielmiessler/fabric/plugins"
@@ -97,7 +97,7 @@ func (o *Client) ListModels() (ret []string, err error) {
 	return
 }
 
-func (o *Client) SendStream(msgs []*goopenai.ChatCompletionMessage, opts *common.ChatOptions, channel chan string) (err error) {
+func (o *Client) SendStream(msgs []*chat.ChatCompletionMessage, opts *common.ChatOptions, channel chan string) (err error) {
 	req := o.createChatRequest(msgs, opts)
 
 	respFunc := func(resp ollamaapi.ChatResponse) (streamErr error) {
@@ -115,7 +115,7 @@ func (o *Client) SendStream(msgs []*goopenai.ChatCompletionMessage, opts *common
 	return
 }
 
-func (o *Client) Send(ctx context.Context, msgs []*goopenai.ChatCompletionMessage, opts *common.ChatOptions) (ret string, err error) {
+func (o *Client) Send(ctx context.Context, msgs []*chat.ChatCompletionMessage, opts *common.ChatOptions) (ret string, err error) {
 	bf := false
 
 	req := o.createChatRequest(msgs, opts)
@@ -132,8 +132,8 @@ func (o *Client) Send(ctx context.Context, msgs []*goopenai.ChatCompletionMessag
 	return
 }
 
-func (o *Client) createChatRequest(msgs []*goopenai.ChatCompletionMessage, opts *common.ChatOptions) (ret ollamaapi.ChatRequest) {
-	messages := lo.Map(msgs, func(message *goopenai.ChatCompletionMessage, _ int) (ret ollamaapi.Message) {
+func (o *Client) createChatRequest(msgs []*chat.ChatCompletionMessage, opts *common.ChatOptions) (ret ollamaapi.ChatRequest) {
+	messages := lo.Map(msgs, func(message *chat.ChatCompletionMessage, _ int) (ret ollamaapi.Message) {
 		return ollamaapi.Message{Role: message.Role, Content: message.Content}
 	})
 

plugins/ai/openai/chat_completions.go

@@ -0,0 +1,116 @@
+package openai
+
+// This file contains helper methods for the Chat Completions API.
+// These methods are used as fallbacks for OpenAI-compatible providers
+// that don't support the newer Responses API (e.g., Groq, Mistral, etc.).
+
+import (
+	"context"
+	"strings"
+
+	"github.com/danielmiessler/fabric/chat"
+	"github.com/danielmiessler/fabric/common"
+	openai "github.com/openai/openai-go"
+	"github.com/openai/openai-go/shared"
+)
+
+// sendChatCompletions sends a request using the Chat Completions API
+func (o *Client) sendChatCompletions(ctx context.Context, msgs []*chat.ChatCompletionMessage, opts *common.ChatOptions) (ret string, err error) {
+	req := o.buildChatCompletionParams(msgs, opts)
+
+	var resp *openai.ChatCompletion
+	if resp, err = o.ApiClient.Chat.Completions.New(ctx, req); err != nil {
+		return
+	}
+	if len(resp.Choices) > 0 {
+		ret = resp.Choices[0].Message.Content
+	}
+	return
+}
+
+// sendStreamChatCompletions sends a streaming request using the Chat Completions API
+func (o *Client) sendStreamChatCompletions(
+	msgs []*chat.ChatCompletionMessage, opts *common.ChatOptions, channel chan string,
+) (err error) {
+	defer close(channel)
+
+	req := o.buildChatCompletionParams(msgs, opts)
+	stream := o.ApiClient.Chat.Completions.NewStreaming(context.Background(), req)
+	for stream.Next() {
+		chunk := stream.Current()
+		if len(chunk.Choices) > 0 && chunk.Choices[0].Delta.Content != "" {
+			channel <- chunk.Choices[0].Delta.Content
+		}
+	}
+	if stream.Err() == nil {
+		channel <- "\n"
+	}
+	return stream.Err()
+}
+
+// buildChatCompletionParams builds parameters for the Chat Completions API
+func (o *Client) buildChatCompletionParams(
+	inputMsgs []*chat.ChatCompletionMessage, opts *common.ChatOptions,
+) (ret openai.ChatCompletionNewParams) {
+
+	messages := make([]openai.ChatCompletionMessageParamUnion, len(inputMsgs))
+	for i, msgPtr := range inputMsgs {
+		msg := *msgPtr
+		if strings.Contains(opts.Model, "deepseek") && len(inputMsgs) == 1 && msg.Role == chat.ChatMessageRoleSystem {
+			msg.Role = chat.ChatMessageRoleUser
+		}
+		messages[i] = o.convertChatMessage(msg)
+	}
+
+	ret = openai.ChatCompletionNewParams{
+		Model:    shared.ChatModel(opts.Model),
+		Messages: messages,
+	}
+
+	if !opts.Raw {
+		ret.Temperature = openai.Float(opts.Temperature)
+		ret.TopP = openai.Float(opts.TopP)
+		if opts.MaxTokens != 0 {
+			ret.MaxTokens = openai.Int(int64(opts.MaxTokens))
+		}
+		if opts.PresencePenalty != 0 {
+			ret.PresencePenalty = openai.Float(opts.PresencePenalty)
+		}
+		if opts.FrequencyPenalty != 0 {
+			ret.FrequencyPenalty = openai.Float(opts.FrequencyPenalty)
+		}
+		if opts.Seed != 0 {
+			ret.Seed = openai.Int(int64(opts.Seed))
+		}
+	}
+	return
+}
+
+// convertChatMessage converts fabric chat message to OpenAI chat completion message
+func (o *Client) convertChatMessage(msg chat.ChatCompletionMessage) openai.ChatCompletionMessageParamUnion {
+	result := convertMessageCommon(msg)
+
+	switch result.Role {
+	case chat.ChatMessageRoleSystem:
+		return openai.SystemMessage(result.Content)
+	case chat.ChatMessageRoleUser:
+		// Handle multi-content messages (text + images)
+		if result.HasMultiContent {
+			var parts []openai.ChatCompletionContentPartUnionParam
+			for _, p := range result.MultiContent {
+				switch p.Type {
+				case chat.ChatMessagePartTypeText:
+					parts = append(parts, openai.TextContentPart(p.Text))
+				case chat.ChatMessagePartTypeImageURL:
+					parts = append(parts, openai.ImageContentPart(openai.ChatCompletionContentPartImageImageURLParam{URL: p.ImageURL.URL}))
+				}
+			}
+			return openai.UserMessage(parts)
+		}
+		return openai.UserMessage(result.Content)
+	case chat.ChatMessageRoleAssistant:
+		return openai.AssistantMessage(result.Content)
+	default:
+		return openai.UserMessage(result.Content)
+	}
+}

plugins/ai/openai/message_conversion.go

@@ -0,0 +1,21 @@
+package openai
+
+import "github.com/danielmiessler/fabric/chat"
+
+// MessageConversionResult holds the common conversion result
+type MessageConversionResult struct {
+	Role            string
+	Content         string
+	MultiContent    []chat.ChatMessagePart
+	HasMultiContent bool
+}
+
+// convertMessageCommon extracts common conversion logic
+func convertMessageCommon(msg chat.ChatCompletionMessage) MessageConversionResult {
+	return MessageConversionResult{
+		Role:            msg.Role,
+		Content:         msg.Content,
+		MultiContent:    msg.MultiContent,
+		HasMultiContent: len(msg.MultiContent) > 0,
+	}
+}

plugins/ai/openai/openai.go

@@ -2,19 +2,23 @@ package openai
 
 import (
 	"context"
-	"errors"
 	"fmt"
-	"io"
-	"log/slog"
+	"slices"
 	"strings"
 
+	"github.com/danielmiessler/fabric/chat"
 	"github.com/danielmiessler/fabric/common"
 	"github.com/danielmiessler/fabric/plugins"
-	goopenai "github.com/sashabaranov/go-openai"
+	openai "github.com/openai/openai-go"
+	"github.com/openai/openai-go/option"
+	"github.com/openai/openai-go/packages/pagination"
+	"github.com/openai/openai-go/responses"
+	"github.com/openai/openai-go/shared"
+	"github.com/openai/openai-go/shared/constant"
 )
 
 func NewClient() (ret *Client) {
-	return NewClientCompatible("OpenAI", "https://api.openai.com/v1", nil)
+	return NewClientCompatibleWithResponses("OpenAI", "https://api.openai.com/v1", true, nil)
 }
 
 func NewClientCompatible(vendorName string, defaultBaseUrl string, configureCustom func() error) (ret *Client) {
@@ -27,6 +31,17 @@ func NewClientCompatible(vendorName string, defaultBaseUrl string, configureCust
 	return
 }
 
+func NewClientCompatibleWithResponses(vendorName string, defaultBaseUrl string, implementsResponses bool, configureCustom func() error) (ret *Client) {
+	ret = NewClientCompatibleNoSetupQuestions(vendorName, configureCustom)
+
+	ret.ApiKey = ret.AddSetupQuestion("API Key", true)
+	ret.ApiBaseURL = ret.AddSetupQuestion("API Base URL", false)
+	ret.ApiBaseURL.Value = defaultBaseUrl
+	ret.ImplementsResponses = implementsResponses
+
+	return
+}
+
 func NewClientCompatibleNoSetupQuestions(vendorName string, configureCustom func() error) (ret *Client) {
 	ret = &Client{}
 
@@ -45,82 +60,98 @@ func NewClientCompatibleNoSetupQuestions(vendorName string, configureCustom func
 
 type Client struct {
 	*plugins.PluginBase
-	ApiKey     *plugins.SetupQuestion
-	ApiBaseURL *plugins.SetupQuestion
-	ApiClient  *goopenai.Client
+	ApiKey              *plugins.SetupQuestion
+	ApiBaseURL          *plugins.SetupQuestion
+	ApiClient           *openai.Client
+	ImplementsResponses bool // Whether this provider supports the Responses API
 }
 
 func (o *Client) configure() (ret error) {
-	config := goopenai.DefaultConfig(o.ApiKey.Value)
+	opts := []option.RequestOption{option.WithAPIKey(o.ApiKey.Value)}
 	if o.ApiBaseURL.Value != "" {
-		config.BaseURL = o.ApiBaseURL.Value
+		opts = append(opts, option.WithBaseURL(o.ApiBaseURL.Value))
 	}
-	o.ApiClient = goopenai.NewClientWithConfig(config)
+	client := openai.NewClient(opts...)
+	o.ApiClient = &client
 	return
 }
 
 func (o *Client) ListModels() (ret []string, err error) {
-	var models goopenai.ModelsList
-	if models, err = o.ApiClient.ListModels(context.Background()); err != nil {
+	var page *pagination.Page[openai.Model]
+	if page, err = o.ApiClient.Models.List(context.Background()); err != nil {
 		return
 	}
-
-	model := models.Models
-	for _, mod := range model {
+	for _, mod := range page.Data {
 		ret = append(ret, mod.ID)
 	}
 	return
 }
 
 func (o *Client) SendStream(
-	msgs []*goopenai.ChatCompletionMessage, opts *common.ChatOptions, channel chan string,
+	msgs []*chat.ChatCompletionMessage, opts *common.ChatOptions, channel chan string,
 ) (err error) {
-	req := o.buildChatCompletionRequest(msgs, opts)
-	req.Stream = true
+	// Use Responses API for OpenAI, Chat Completions API for other providers
+	if o.supportsResponsesAPI() {
+		return o.sendStreamResponses(msgs, opts, channel)
+	}
+	return o.sendStreamChatCompletions(msgs, opts, channel)
+}
 
-	var stream *goopenai.ChatCompletionStream
-	if stream, err = o.ApiClient.CreateChatCompletionStream(context.Background(), req); err != nil {
-		fmt.Printf("ChatCompletionStream error: %v\n", err)
+func (o *Client) sendStreamResponses(
+	msgs []*chat.ChatCompletionMessage, opts *common.ChatOptions, channel chan string,
+) (err error) {
+	defer close(channel)
+
+	req := o.buildResponseParams(msgs, opts)
+	stream := o.ApiClient.Responses.NewStreaming(context.Background(), req)
+	for stream.Next() {
+		event := stream.Current()
+		switch event.Type {
+		case string(constant.ResponseOutputTextDelta("").Default()):
+			channel <- event.AsResponseOutputTextDelta().Delta
+		case string(constant.ResponseOutputTextDone("").Default()):
+			channel <- event.AsResponseOutputTextDone().Text
+		}
+	}
+	if stream.Err() == nil {
+		channel <- "\n"
+	}
+	return stream.Err()
+}
+
+func (o *Client) Send(ctx context.Context, msgs []*chat.ChatCompletionMessage, opts *common.ChatOptions) (ret string, err error) {
+	// Use Responses API for OpenAI, Chat Completions API for other providers
+	if o.supportsResponsesAPI() {
+		return o.sendResponses(ctx, msgs, opts)
+	}
+	return o.sendChatCompletions(ctx, msgs, opts)
+}
+
+func (o *Client) sendResponses(ctx context.Context, msgs []*chat.ChatCompletionMessage, opts *common.ChatOptions) (ret string, err error) {
+	// Validate model supports image generation if image file is specified
+	if opts.ImageFile != "" && !supportsImageGeneration(opts.Model) {
+		return "", fmt.Errorf("model '%s' does not support image generation. Supported models: %s", opts.Model, strings.Join(ImageGenerationSupportedModels, ", "))
+	}
+
+	req := o.buildResponseParams(msgs, opts)
+
+	var resp *responses.Response
+	if resp, err = o.ApiClient.Responses.New(ctx, req); err != nil {
 		return
 	}
 
-	defer stream.Close()
-
-	for {
-		var response goopenai.ChatCompletionStreamResponse
-		if response, err = stream.Recv(); err == nil {
-			if len(response.Choices) > 0 {
-				channel <- response.Choices[0].Delta.Content
-			} else {
-				channel <- "\n"
-				close(channel)
-				break
-			}
-		} else if errors.Is(err, io.EOF) {
-			channel <- "\n"
-			close(channel)
-			err = nil
-			break
-		} else if err != nil {
-			fmt.Printf("\nStream error: %v\n", err)
-			break
-		}
+	// Extract and save images if requested
+	if err = o.extractAndSaveImages(resp, opts); err != nil {
+		return
 	}
+
+	ret = o.extractText(resp)
 	return
 }
 
-func (o *Client) Send(ctx context.Context, msgs []*goopenai.ChatCompletionMessage, opts *common.ChatOptions) (ret string, err error) {
-	req := o.buildChatCompletionRequest(msgs, opts)
-
-	var resp goopenai.ChatCompletionResponse
-	if resp, err = o.ApiClient.CreateChatCompletion(ctx, req); err != nil {
-		return
-	}
-	if len(resp.Choices) > 0 {
-		ret = resp.Choices[0].Message.Content
-		slog.Debug("SystemFingerprint: " + resp.SystemFingerprint)
-	}
-	return
+// supportsResponsesAPI determines if the provider supports the new Responses API
+func (o *Client) supportsResponsesAPI() bool {
+	return o.ImplementsResponses
 }
 
 func (o *Client) NeedsRawMode(modelName string) bool {
@@ -129,65 +160,150 @@ func (o *Client) NeedsRawMode(modelName string) bool {
 		"o3",
 		"o4",
 	}
+	openAIModelsNeedingRaw := []string{
+		"gpt-4o-mini-search-preview",
+		"gpt-4o-mini-search-preview-2025-03-11",
+		"gpt-4o-search-preview",
+		"gpt-4o-search-preview-2025-03-11",
+	}
 	for _, prefix := range openaiModelsPrefixes {
 		if strings.HasPrefix(modelName, prefix) {
 			return true
 		}
 	}
-	return false
+	return slices.Contains(openAIModelsNeedingRaw, modelName)
 }
 
-func (o *Client) buildChatCompletionRequest(
-	inputMsgs []*goopenai.ChatCompletionMessage, opts *common.ChatOptions,
-) (ret goopenai.ChatCompletionRequest) {
+func (o *Client) buildResponseParams(
+	inputMsgs []*chat.ChatCompletionMessage, opts *common.ChatOptions,
+) (ret responses.ResponseNewParams) {
 
-	// Create a new slice for messages to be sent, converting from []*Msg to []Msg.
-	// This also serves as a mutable copy for provider-specific modifications.
-	messagesForRequest := make([]goopenai.ChatCompletionMessage, len(inputMsgs))
+	items := make([]responses.ResponseInputItemUnionParam, len(inputMsgs))
 	for i, msgPtr := range inputMsgs {
-		messagesForRequest[i] = *msgPtr // Dereference and copy
+		msg := *msgPtr
+		if strings.Contains(opts.Model, "deepseek") && len(inputMsgs) == 1 && msg.Role == chat.ChatMessageRoleSystem {
+			msg.Role = chat.ChatMessageRoleUser
+		}
+		items[i] = convertMessage(msg)
 	}
 
-	// Provider-specific modification for DeepSeek:
-	// DeepSeek requires the last message to be a user message.
-	// If fabric constructs a single system message (common when a pattern includes user input),
-	// we change its role to user for DeepSeek.
-	if strings.Contains(opts.Model, "deepseek") { // Heuristic to identify DeepSeek models
-		if len(messagesForRequest) == 1 && messagesForRequest[0].Role == goopenai.ChatMessageRoleSystem {
-			messagesForRequest[0].Role = goopenai.ChatMessageRoleUser
-		}
-		// Note: This handles the most common case arising from pattern usage.
-		// More complex scenarios where a multi-message sequence ends in 'system'
-		// are not currently expected from chatter.go's BuildSession logic for OpenAI providers
-		// but might require further rules if they arise.
+	ret = responses.ResponseNewParams{
+		Model: shared.ResponsesModel(opts.Model),
+		Input: responses.ResponseNewParamsInputUnion{
+			OfInputItemList: items,
+		},
 	}
 
-	if opts.Raw {
-		ret = goopenai.ChatCompletionRequest{
-			Model:    opts.Model,
-			Messages: messagesForRequest,
+	// Add tools if enabled
+	var tools []responses.ToolUnionParam
+
+	// Add web search tool if enabled
+	if opts.Search {
+		webSearchTool := responses.ToolParamOfWebSearchPreview("web_search_preview")
+
+		// Add user location if provided
+		if opts.SearchLocation != "" {
+			webSearchTool.OfWebSearchPreview.UserLocation = responses.WebSearchToolUserLocationParam{
+				Type:     "approximate",
+				Timezone: openai.String(opts.SearchLocation),
+			}
 		}
-	} else {
-		if opts.Seed == 0 {
-			ret = goopenai.ChatCompletionRequest{
-				Model:            opts.Model,
-				Temperature:      float32(opts.Temperature),
-				TopP:             float32(opts.TopP),
-				PresencePenalty:  float32(opts.PresencePenalty),
-				FrequencyPenalty: float32(opts.FrequencyPenalty),
-				Messages:         messagesForRequest,
-			}
-		} else {
-			ret = goopenai.ChatCompletionRequest{
-				Model:            opts.Model,
-				Temperature:      float32(opts.Temperature),
-				TopP:             float32(opts.TopP),
-				PresencePenalty:  float32(opts.PresencePenalty),
-				FrequencyPenalty: float32(opts.FrequencyPenalty),
-				Messages:         messagesForRequest,
-				Seed:             &opts.Seed,
-			}
+
+		tools = append(tools, webSearchTool)
+	}
+
+	// Add image generation tool if needed
+	tools = o.addImageGenerationTool(opts, tools)
+
+	if len(tools) > 0 {
+		ret.Tools = tools
+	}
+
+	if !opts.Raw {
+		ret.Temperature = openai.Float(opts.Temperature)
+		ret.TopP = openai.Float(opts.TopP)
+		if opts.MaxTokens != 0 {
+			ret.MaxOutputTokens = openai.Int(int64(opts.MaxTokens))
+		}
+
+		// Add parameters not officially supported by Responses API as extra fields
+		extraFields := make(map[string]any)
+		if opts.PresencePenalty != 0 {
+			extraFields["presence_penalty"] = opts.PresencePenalty
+		}
+		if opts.FrequencyPenalty != 0 {
+			extraFields["frequency_penalty"] = opts.FrequencyPenalty
+		}
+		if opts.Seed != 0 {
+			extraFields["seed"] = opts.Seed
+		}
+		if len(extraFields) > 0 {
+			ret.SetExtraFields(extraFields)
 		}
 	}
 	return
 }
+
+func convertMessage(msg chat.ChatCompletionMessage) responses.ResponseInputItemUnionParam {
+	result := convertMessageCommon(msg)
+	role := responses.EasyInputMessageRole(result.Role)
+
+	if result.HasMultiContent {
+		var parts []responses.ResponseInputContentUnionParam
+		for _, p := range result.MultiContent {
+			switch p.Type {
+			case chat.ChatMessagePartTypeText:
+				parts = append(parts, responses.ResponseInputContentParamOfInputText(p.Text))
+			case chat.ChatMessagePartTypeImageURL:
+				part := responses.ResponseInputContentParamOfInputImage(responses.ResponseInputImageDetailAuto)
+				if part.OfInputImage != nil {
+					part.OfInputImage.ImageURL = openai.String(p.ImageURL.URL)
+				}
+				parts = append(parts, part)
+			}
+		}
+		contentList := responses.ResponseInputMessageContentListParam(parts)
+		return responses.ResponseInputItemParamOfMessage(contentList, role)
+	}
+	return responses.ResponseInputItemParamOfMessage(result.Content, role)
+}
+
+func (o *Client) extractText(resp *responses.Response) (ret string) {
+	var textParts []string
+	var citations []string
+	citationMap := make(map[string]bool) // To avoid duplicate citations
+
+	for _, item := range resp.Output {
+		if item.Type == "message" {
+			for _, c := range item.Content {
+				if c.Type == "output_text" {
+					outputText := c.AsOutputText()
+					textParts = append(textParts, outputText.Text)
+
+					// Extract citations from annotations
+					for _, annotation := range outputText.Annotations {
+						if annotation.Type == "url_citation" {
+							urlCitation := annotation.AsURLCitation()
+							citationKey := urlCitation.URL + "|" + urlCitation.Title
+							if !citationMap[citationKey] {
+								citationMap[citationKey] = true
+								citationText := fmt.Sprintf("- [%s](%s)", urlCitation.Title, urlCitation.URL)
+								citations = append(citations, citationText)
+							}
+						}
+					}
+				}
+			}
+			break
+		}
+	}
+
+	ret = strings.Join(textParts, "")
+
+	// Append citations if any were found
+	if len(citations) > 0 {
+		ret += "\n\n## Sources\n\n" + strings.Join(citations, "\n")
+	}
+
+	return
+}

plugins/ai/openai/openai_image.go

@@ -0,0 +1,146 @@
+package openai
+
+// This file contains helper methods for image generation and processing
+// using OpenAI's Responses API and Image API.
+
+import (
+	"encoding/base64"
+	"fmt"
+	"os"
+	"path/filepath"
+	"strings"
+
+	"github.com/danielmiessler/fabric/common"
+	"github.com/openai/openai-go/packages/param"
+	"github.com/openai/openai-go/responses"
+)
+
+// ImageGenerationResponseType is the type used for image generation calls in responses
+const ImageGenerationResponseType = "image_generation_call"
+const ImageGenerationToolType = "image_generation"
+
+// ImageGenerationSupportedModels lists all models that support image generation
+var ImageGenerationSupportedModels = []string{
+	"gpt-4o",
+	"gpt-4o-mini",
+	"gpt-4.1",
+	"gpt-4.1-mini",
+	"gpt-4.1-nano",
+	"o3",
+}
+
+// supportsImageGeneration checks if the given model supports the image_generation tool
+func supportsImageGeneration(model string) bool {
+	for _, supportedModel := range ImageGenerationSupportedModels {
+		if model == supportedModel {
+			return true
+		}
+	}
+	return false
+}
+
+// getOutputFormatFromExtension determines the API output format based on file extension
+func getOutputFormatFromExtension(imagePath string) string {
+	if imagePath == "" {
+		return "png" // Default format
+	}
+
+	ext := strings.ToLower(filepath.Ext(imagePath))
+	switch ext {
+	case ".png":
+		return "png"
+	case ".webp":
+		return "webp"
+	case ".jpg":
+		return "jpeg"
+	case ".jpeg":
+		return "jpeg"
+	default:
+		return "png" // Default fallback
+	}
+}
+
+// addImageGenerationTool adds the image generation tool to the request if needed
+func (o *Client) addImageGenerationTool(opts *common.ChatOptions, tools []responses.ToolUnionParam) []responses.ToolUnionParam {
+	// Check if the request seems to be asking for image generation
+	if o.shouldUseImageGeneration(opts) {
+		outputFormat := getOutputFormatFromExtension(opts.ImageFile)
+
+		// Build the image generation tool with user parameters
+		imageGenTool := responses.ToolUnionParam{
+			OfImageGeneration: &responses.ToolImageGenerationParam{
+				Type:         ImageGenerationToolType,
+				Model:        "gpt-image-1",
+				OutputFormat: outputFormat,
+			},
+		}
+
+		// Set quality if specified by user (otherwise let OpenAI use default)
+		if opts.ImageQuality != "" {
+			imageGenTool.OfImageGeneration.Quality = opts.ImageQuality
+		}
+
+		// Set size if specified by user (otherwise let OpenAI use default)
+		if opts.ImageSize != "" {
+			imageGenTool.OfImageGeneration.Size = opts.ImageSize
+		}
+
+		// Set background if specified by user (otherwise let OpenAI use default)
+		if opts.ImageBackground != "" {
+			imageGenTool.OfImageGeneration.Background = opts.ImageBackground
+		}
+
+		// Set compression if specified by user (only for jpeg/webp)
+		if opts.ImageCompression != 0 {
+			imageGenTool.OfImageGeneration.OutputCompression = param.NewOpt(int64(opts.ImageCompression))
+		}
+
+		tools = append(tools, imageGenTool)
+	}
+	return tools
+}
+
+// shouldUseImageGeneration determines if image generation should be enabled
+// This is a heuristic based on the presence of --image-file flag
+func (o *Client) shouldUseImageGeneration(opts *common.ChatOptions) bool {
+	return opts.ImageFile != ""
+}
+
+// extractAndSaveImages extracts generated images from the response and saves them
+func (o *Client) extractAndSaveImages(resp *responses.Response, opts *common.ChatOptions) error {
+	if opts.ImageFile == "" {
+		return nil // No image file specified, skip saving
+	}
+
+	// Extract image data from response
+	for _, item := range resp.Output {
+		if item.Type == ImageGenerationResponseType {
+			imageCall := item.AsImageGenerationCall()
+			if imageCall.Status == "completed" && imageCall.Result != "" {
+				// Decode base64 image data
+				imageData, err := base64.StdEncoding.DecodeString(imageCall.Result)
+				if err != nil {
+					return fmt.Errorf("failed to decode image data: %w", err)
+				}
+
+				// Ensure directory exists
+				dir := filepath.Dir(opts.ImageFile)
+				if dir != "." {
+					if err := os.MkdirAll(dir, 0755); err != nil {
+						return fmt.Errorf("failed to create directory %s: %w", dir, err)
+					}
+				}
+
+				// Save image to file
+				if err := os.WriteFile(opts.ImageFile, imageData, 0644); err != nil {
+					return fmt.Errorf("failed to save image to %s: %w", opts.ImageFile, err)
+				}
+
+				fmt.Printf("Image saved to: %s\n", opts.ImageFile)
+				return nil
+			}
+		}
+	}
+
+	return nil
+}

plugins/ai/openai/openai_image_test.go

@@ -0,0 +1,444 @@
+package openai
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+
+	"github.com/danielmiessler/fabric/chat"
+	"github.com/danielmiessler/fabric/common"
+	"github.com/openai/openai-go/responses"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestShouldUseImageGeneration(t *testing.T) {
+	client := NewClient()
+
+	// Test with image file specified
+	opts := &common.ChatOptions{
+		ImageFile: "output.png",
+	}
+	assert.True(t, client.shouldUseImageGeneration(opts), "Should use image generation when image file is specified")
+
+	// Test without image file
+	opts = &common.ChatOptions{
+		ImageFile: "",
+	}
+	assert.False(t, client.shouldUseImageGeneration(opts), "Should not use image generation when no image file is specified")
+}
+
+func TestAddImageGenerationTool(t *testing.T) {
+	client := NewClient()
+
+	// Test with image generation enabled
+	opts := &common.ChatOptions{
+		ImageFile: "output.png",
+	}
+	tools := []responses.ToolUnionParam{}
+	result := client.addImageGenerationTool(opts, tools)
+
+	assert.Len(t, result, 1, "Should add one image generation tool")
+	assert.NotNil(t, result[0].OfImageGeneration, "Should have image generation tool")
+	assert.Equal(t, "image_generation", string(result[0].OfImageGeneration.Type))
+	assert.Equal(t, "gpt-image-1", result[0].OfImageGeneration.Model)
+	assert.Equal(t, "png", result[0].OfImageGeneration.OutputFormat)
+
+	// Test without image generation
+	opts = &common.ChatOptions{
+		ImageFile: "",
+	}
+	tools = []responses.ToolUnionParam{}
+	result = client.addImageGenerationTool(opts, tools)
+
+	assert.Len(t, result, 0, "Should not add image generation tool when not needed")
+}
+
+func TestBuildResponseParams_WithImageGeneration(t *testing.T) {
+	client := NewClient()
+	opts := &common.ChatOptions{
+		Model:     "gpt-image-1",
+		ImageFile: "output.png",
+	}
+
+	msgs := []*chat.ChatCompletionMessage{
+		{Role: "user", Content: "Generate an image of a cat"},
+	}
+
+	params := client.buildResponseParams(msgs, opts)
+
+	assert.NotNil(t, params.Tools, "Expected tools when image generation is enabled")
+
+	// Should have image generation tool
+	hasImageTool := false
+	for _, tool := range params.Tools {
+		if tool.OfImageGeneration != nil {
+			hasImageTool = true
+			assert.Equal(t, "image_generation", string(tool.OfImageGeneration.Type))
+			assert.Equal(t, "gpt-image-1", tool.OfImageGeneration.Model)
+			break
+		}
+	}
+	assert.True(t, hasImageTool, "Should have image generation tool")
+}
+
+func TestBuildResponseParams_WithBothSearchAndImage(t *testing.T) {
+	client := NewClient()
+	opts := &common.ChatOptions{
+		Model:          "gpt-image-1",
+		Search:         true,
+		SearchLocation: "America/Los_Angeles",
+		ImageFile:      "output.png",
+	}
+
+	msgs := []*chat.ChatCompletionMessage{
+		{Role: "user", Content: "Search for cat images and generate one"},
+	}
+
+	params := client.buildResponseParams(msgs, opts)
+
+	assert.NotNil(t, params.Tools, "Expected tools when both search and image generation are enabled")
+	assert.Len(t, params.Tools, 2, "Should have both search and image generation tools")
+
+	hasSearchTool := false
+	hasImageTool := false
+
+	for _, tool := range params.Tools {
+		if tool.OfWebSearchPreview != nil {
+			hasSearchTool = true
+		}
+		if tool.OfImageGeneration != nil {
+			hasImageTool = true
+		}
+	}
+
+	assert.True(t, hasSearchTool, "Should have web search tool")
+	assert.True(t, hasImageTool, "Should have image generation tool")
+}
+
+func TestGetOutputFormatFromExtension(t *testing.T) {
+	tests := []struct {
+		name           string
+		imagePath      string
+		expectedFormat string
+	}{
+		{
+			name:           "PNG extension",
+			imagePath:      "/tmp/output.png",
+			expectedFormat: "png",
+		},
+		{
+			name:           "WEBP extension",
+			imagePath:      "/tmp/output.webp",
+			expectedFormat: "webp",
+		},
+		{
+			name:           "JPG extension",
+			imagePath:      "/tmp/output.jpg",
+			expectedFormat: "jpeg",
+		},
+		{
+			name:           "JPEG extension",
+			imagePath:      "/tmp/output.jpeg",
+			expectedFormat: "jpeg",
+		},
+		{
+			name:           "Uppercase PNG extension",
+			imagePath:      "/tmp/output.PNG",
+			expectedFormat: "png",
+		},
+		{
+			name:           "Mixed case JPEG extension",
+			imagePath:      "/tmp/output.JpEg",
+			expectedFormat: "jpeg",
+		},
+		{
+			name:           "Empty path",
+			imagePath:      "",
+			expectedFormat: "png",
+		},
+		{
+			name:           "No extension",
+			imagePath:      "/tmp/output",
+			expectedFormat: "png",
+		},
+		{
+			name:           "Unsupported extension",
+			imagePath:      "/tmp/output.gif",
+			expectedFormat: "png",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			result := getOutputFormatFromExtension(tt.imagePath)
+			assert.Equal(t, tt.expectedFormat, result)
+		})
+	}
+}
+
+func TestAddImageGenerationToolWithDynamicFormat(t *testing.T) {
+	client := NewClient()
+
+	tests := []struct {
+		name           string
+		imageFile      string
+		expectedFormat string
+	}{
+		{
+			name:           "PNG file",
+			imageFile:      "/tmp/output.png",
+			expectedFormat: "png",
+		},
+		{
+			name:           "WEBP file",
+			imageFile:      "/tmp/output.webp",
+			expectedFormat: "webp",
+		},
+		{
+			name:           "JPG file",
+			imageFile:      "/tmp/output.jpg",
+			expectedFormat: "jpeg",
+		},
+		{
+			name:           "JPEG file",
+			imageFile:      "/tmp/output.jpeg",
+			expectedFormat: "jpeg",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			opts := &common.ChatOptions{
+				ImageFile: tt.imageFile,
+			}
+
+			tools := client.addImageGenerationTool(opts, []responses.ToolUnionParam{})
+
+			assert.Len(t, tools, 1, "Should have one tool")
+			assert.NotNil(t, tools[0].OfImageGeneration, "Should be image generation tool")
+			assert.Equal(t, tt.expectedFormat, tools[0].OfImageGeneration.OutputFormat, "Output format should match file extension")
+		})
+	}
+}
+
+func TestSupportsImageGeneration(t *testing.T) {
+	tests := []struct {
+		name     string
+		model    string
+		expected bool
+	}{
+		{
+			name:     "gpt-4o supports image generation",
+			model:    "gpt-4o",
+			expected: true,
+		},
+		{
+			name:     "gpt-4o-mini supports image generation",
+			model:    "gpt-4o-mini",
+			expected: true,
+		},
+		{
+			name:     "gpt-4.1 supports image generation",
+			model:    "gpt-4.1",
+			expected: true,
+		},
+		{
+			name:     "gpt-4.1-mini supports image generation",
+			model:    "gpt-4.1-mini",
+			expected: true,
+		},
+		{
+			name:     "gpt-4.1-nano supports image generation",
+			model:    "gpt-4.1-nano",
+			expected: true,
+		},
+		{
+			name:     "o3 supports image generation",
+			model:    "o3",
+			expected: true,
+		},
+		{
+			name:     "o1 does not support image generation",
+			model:    "o1",
+			expected: false,
+		},
+		{
+			name:     "o1-mini does not support image generation",
+			model:    "o1-mini",
+			expected: false,
+		},
+		{
+			name:     "o3-mini does not support image generation",
+			model:    "o3-mini",
+			expected: false,
+		},
+		{
+			name:     "gpt-4 does not support image generation",
+			model:    "gpt-4",
+			expected: false,
+		},
+		{
+			name:     "gpt-3.5-turbo does not support image generation",
+			model:    "gpt-3.5-turbo",
+			expected: false,
+		},
+		{
+			name:     "empty model does not support image generation",
+			model:    "",
+			expected: false,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			result := supportsImageGeneration(tt.model)
+			assert.Equal(t, tt.expected, result)
+		})
+	}
+}
+
+func TestModelValidationLogic(t *testing.T) {
+	t.Run("Unsupported model with image file should return validation error", func(t *testing.T) {
+		opts := &common.ChatOptions{
+			Model:     "o1-mini",
+			ImageFile: "/tmp/output.png",
+		}
+
+		// Test the validation logic directly
+		if opts.ImageFile != "" && !supportsImageGeneration(opts.Model) {
+			err := fmt.Errorf("model '%s' does not support image generation. Supported models: %s", opts.Model, strings.Join(ImageGenerationSupportedModels, ", "))
+
+			assert.Contains(t, err.Error(), "does not support image generation")
+			assert.Contains(t, err.Error(), "o1-mini")
+			assert.Contains(t, err.Error(), "Supported models:")
+		} else {
+			t.Error("Expected validation to trigger")
+		}
+	})
+
+	t.Run("Supported model with image file should not trigger validation", func(t *testing.T) {
+		opts := &common.ChatOptions{
+			Model:     "gpt-4o",
+			ImageFile: "/tmp/output.png",
+		}
+
+		// Test the validation logic directly
+		shouldFail := opts.ImageFile != "" && !supportsImageGeneration(opts.Model)
+		assert.False(t, shouldFail, "Validation should not trigger for supported model")
+	})
+
+	t.Run("Unsupported model without image file should not trigger validation", func(t *testing.T) {
+		opts := &common.ChatOptions{
+			Model:     "o1-mini",
+			ImageFile: "", // No image file
+		}
+
+		// Test the validation logic directly
+		shouldFail := opts.ImageFile != "" && !supportsImageGeneration(opts.Model)
+		assert.False(t, shouldFail, "Validation should not trigger when no image file is specified")
+	})
+}
+
+func TestAddImageGenerationToolWithUserParameters(t *testing.T) {
+	client := NewClient()
+
+	tests := []struct {
+		name     string
+		opts     *common.ChatOptions
+		expected map[string]interface{}
+	}{
+		{
+			name: "All parameters specified",
+			opts: &common.ChatOptions{
+				ImageFile:        "/tmp/test.png",
+				ImageSize:        "1536x1024",
+				ImageQuality:     "high",
+				ImageBackground:  "transparent",
+				ImageCompression: 0, // Not applicable for PNG
+			},
+			expected: map[string]interface{}{
+				"size":          "1536x1024",
+				"quality":       "high",
+				"background":    "transparent",
+				"output_format": "png",
+			},
+		},
+		{
+			name: "JPEG with compression",
+			opts: &common.ChatOptions{
+				ImageFile:        "/tmp/test.jpg",
+				ImageSize:        "1024x1024",
+				ImageQuality:     "medium",
+				ImageBackground:  "opaque",
+				ImageCompression: 75,
+			},
+			expected: map[string]interface{}{
+				"size":               "1024x1024",
+				"quality":            "medium",
+				"background":         "opaque",
+				"output_format":      "jpeg",
+				"output_compression": int64(75),
+			},
+		},
+		{
+			name: "Only some parameters specified",
+			opts: &common.ChatOptions{
+				ImageFile:    "/tmp/test.webp",
+				ImageQuality: "low",
+			},
+			expected: map[string]interface{}{
+				"quality":       "low",
+				"output_format": "webp",
+			},
+		},
+		{
+			name: "No parameters specified (defaults)",
+			opts: &common.ChatOptions{
+				ImageFile: "/tmp/test.png",
+			},
+			expected: map[string]interface{}{
+				"output_format": "png",
+			},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			tools := client.addImageGenerationTool(tt.opts, []responses.ToolUnionParam{})
+
+			assert.Len(t, tools, 1)
+			assert.NotNil(t, tools[0].OfImageGeneration)
+
+			tool := tools[0].OfImageGeneration
+
+			// Check required fields
+			assert.Equal(t, "gpt-image-1", tool.Model)
+			assert.Equal(t, tt.expected["output_format"], tool.OutputFormat)
+
+			// Check optional fields
+			if expectedSize, ok := tt.expected["size"]; ok {
+				assert.Equal(t, expectedSize, tool.Size)
+			} else {
+				assert.Empty(t, tool.Size, "Size should not be set when not specified")
+			}
+
+			if expectedQuality, ok := tt.expected["quality"]; ok {
+				assert.Equal(t, expectedQuality, tool.Quality)
+			} else {
+				assert.Empty(t, tool.Quality, "Quality should not be set when not specified")
+			}
+
+			if expectedBackground, ok := tt.expected["background"]; ok {
+				assert.Equal(t, expectedBackground, tool.Background)
+			} else {
+				assert.Empty(t, tool.Background, "Background should not be set when not specified")
+			}
+
+			if expectedCompression, ok := tt.expected["output_compression"]; ok {
+				assert.Equal(t, expectedCompression, tool.OutputCompression.Value)
+			} else {
+				assert.Equal(t, int64(0), tool.OutputCompression.Value, "Compression should not be set when not specified")
+			}
+		})
+	}
+}

plugins/ai/openai/openai_test.go

@@ -1,102 +1,177 @@
 package openai
 
 import (
+	"strings"
 	"testing"
 
+	"github.com/danielmiessler/fabric/chat"
 	"github.com/danielmiessler/fabric/common"
-	"github.com/sashabaranov/go-openai"
-	goopenai "github.com/sashabaranov/go-openai"
+	openai "github.com/openai/openai-go"
+	"github.com/openai/openai-go/responses"
+	"github.com/openai/openai-go/shared"
 	"github.com/stretchr/testify/assert"
 )
 
-func TestBuildChatCompletionRequestPinSeed(t *testing.T) {
+func TestBuildResponseRequestWithMaxTokens(t *testing.T) {
 
-	var msgs []*goopenai.ChatCompletionMessage
+	var msgs []*chat.ChatCompletionMessage
 
 	for i := 0; i < 2; i++ {
-		msgs = append(msgs, &goopenai.ChatCompletionMessage{
+		msgs = append(msgs, &chat.ChatCompletionMessage{
 			Role:    "User",
 			Content: "My msg",
 		})
 	}
 
 	opts := &common.ChatOptions{
-		Temperature:      0.8,
-		TopP:             0.9,
-		PresencePenalty:  0.1,
-		FrequencyPenalty: 0.2,
-		Raw:              false,
-		Seed:             1,
-	}
-
-	var expectedMessages []openai.ChatCompletionMessage
-
-	for i := 0; i < 2; i++ {
-		expectedMessages = append(expectedMessages,
-			openai.ChatCompletionMessage{
-				Role:    msgs[i].Role,
-				Content: msgs[i].Content,
-			},
-		)
-	}
-
-	var expectedRequest = goopenai.ChatCompletionRequest{
-		Model:            opts.Model,
-		Temperature:      float32(opts.Temperature),
-		TopP:             float32(opts.TopP),
-		PresencePenalty:  float32(opts.PresencePenalty),
-		FrequencyPenalty: float32(opts.FrequencyPenalty),
-		Messages:         expectedMessages,
-		Seed:             &opts.Seed,
+		Temperature: 0.8,
+		TopP:        0.9,
+		Raw:         false,
+		MaxTokens:   50,
 	}
 
 	var client = NewClient()
-	request := client.buildChatCompletionRequest(msgs, opts)
-	assert.Equal(t, expectedRequest, request)
+	request := client.buildResponseParams(msgs, opts)
+	assert.Equal(t, shared.ResponsesModel(opts.Model), request.Model)
+	assert.Equal(t, openai.Float(opts.Temperature), request.Temperature)
+	assert.Equal(t, openai.Float(opts.TopP), request.TopP)
+	assert.Equal(t, openai.Int(int64(opts.MaxTokens)), request.MaxOutputTokens)
 }
 
-func TestBuildChatCompletionRequestNilSeed(t *testing.T) {
+func TestBuildResponseRequestNoMaxTokens(t *testing.T) {
 
-	var msgs []*goopenai.ChatCompletionMessage
+	var msgs []*chat.ChatCompletionMessage
 
 	for i := 0; i < 2; i++ {
-		msgs = append(msgs, &goopenai.ChatCompletionMessage{
+		msgs = append(msgs, &chat.ChatCompletionMessage{
 			Role:    "User",
 			Content: "My msg",
 		})
 	}
 
 	opts := &common.ChatOptions{
-		Temperature:      0.8,
-		TopP:             0.9,
-		PresencePenalty:  0.1,
-		FrequencyPenalty: 0.2,
-		Raw:              false,
-		Seed:             0,
-	}
-
-	var expectedMessages []openai.ChatCompletionMessage
-
-	for i := 0; i < 2; i++ {
-		expectedMessages = append(expectedMessages,
-			openai.ChatCompletionMessage{
-				Role:    msgs[i].Role,
-				Content: msgs[i].Content,
-			},
-		)
-	}
-
-	var expectedRequest = goopenai.ChatCompletionRequest{
-		Model:            opts.Model,
-		Temperature:      float32(opts.Temperature),
-		TopP:             float32(opts.TopP),
-		PresencePenalty:  float32(opts.PresencePenalty),
-		FrequencyPenalty: float32(opts.FrequencyPenalty),
-		Messages:         expectedMessages,
-		Seed:             nil,
+		Temperature: 0.8,
+		TopP:        0.9,
+		Raw:         false,
 	}
 
 	var client = NewClient()
-	request := client.buildChatCompletionRequest(msgs, opts)
-	assert.Equal(t, expectedRequest, request)
+	request := client.buildResponseParams(msgs, opts)
+	assert.Equal(t, shared.ResponsesModel(opts.Model), request.Model)
+	assert.Equal(t, openai.Float(opts.Temperature), request.Temperature)
+	assert.Equal(t, openai.Float(opts.TopP), request.TopP)
+	assert.False(t, request.MaxOutputTokens.Valid())
+}
+
+func TestBuildResponseParams_WithoutSearch(t *testing.T) {
+	client := NewClient()
+	opts := &common.ChatOptions{
+		Model:       "gpt-4o",
+		Temperature: 0.7,
+		Search:      false,
+	}
+
+	msgs := []*chat.ChatCompletionMessage{
+		{Role: "user", Content: "Hello"},
+	}
+
+	params := client.buildResponseParams(msgs, opts)
+
+	assert.Nil(t, params.Tools, "Expected no tools when search is disabled")
+	assert.Equal(t, shared.ResponsesModel(opts.Model), params.Model)
+	assert.Equal(t, openai.Float(opts.Temperature), params.Temperature)
+}
+
+func TestBuildResponseParams_WithSearch(t *testing.T) {
+	client := NewClient()
+	opts := &common.ChatOptions{
+		Model:       "gpt-4o",
+		Temperature: 0.7,
+		Search:      true,
+	}
+
+	msgs := []*chat.ChatCompletionMessage{
+		{Role: "user", Content: "What's the weather today?"},
+	}
+
+	params := client.buildResponseParams(msgs, opts)
+
+	assert.NotNil(t, params.Tools, "Expected tools when search is enabled")
+	assert.Len(t, params.Tools, 1, "Expected exactly one tool")
+
+	tool := params.Tools[0]
+	assert.NotNil(t, tool.OfWebSearchPreview, "Expected web search tool")
+	assert.Equal(t, responses.WebSearchToolType("web_search_preview"), tool.OfWebSearchPreview.Type)
+}
+
+func TestBuildResponseParams_WithSearchAndLocation(t *testing.T) {
+	client := NewClient()
+	opts := &common.ChatOptions{
+		Model:          "gpt-4o",
+		Temperature:    0.7,
+		Search:         true,
+		SearchLocation: "America/Los_Angeles",
+	}
+
+	msgs := []*chat.ChatCompletionMessage{
+		{Role: "user", Content: "What's the weather in San Francisco?"},
+	}
+
+	params := client.buildResponseParams(msgs, opts)
+
+	assert.NotNil(t, params.Tools, "Expected tools when search is enabled")
+	tool := params.Tools[0]
+	assert.NotNil(t, tool.OfWebSearchPreview, "Expected web search tool")
+
+	userLocation := tool.OfWebSearchPreview.UserLocation
+	assert.Equal(t, "approximate", string(userLocation.Type))
+	assert.True(t, userLocation.Timezone.Valid(), "Expected timezone to be set")
+	assert.Equal(t, opts.SearchLocation, userLocation.Timezone.Value)
+}
+
+func TestCitationFormatting(t *testing.T) {
+	// Test the citation formatting logic by simulating the citation extraction
+	var textParts []string
+	var citations []string
+	citationMap := make(map[string]bool)
+
+	// Simulate text content
+	textParts = append(textParts, "Based on recent research, artificial intelligence is advancing rapidly.")
+
+	// Simulate citations (as they would be extracted from OpenAI response)
+	mockCitations := []struct {
+		URL   string
+		Title string
+	}{
+		{"https://example.com/ai-research", "AI Research Advances 2025"},
+		{"https://another-source.com/tech-news", "Technology News Today"},
+		{"https://example.com/ai-research", "AI Research Advances 2025"}, // Duplicate to test deduplication
+	}
+
+	for _, citation := range mockCitations {
+		citationKey := citation.URL + "|" + citation.Title
+		if !citationMap[citationKey] {
+			citationMap[citationKey] = true
+			citationText := "- [" + citation.Title + "](" + citation.URL + ")"
+			citations = append(citations, citationText)
+		}
+	}
+
+	result := strings.Join(textParts, "")
+	if len(citations) > 0 {
+		result += "\n\n## Sources\n\n" + strings.Join(citations, "\n")
+	}
+
+	// Verify the result contains the expected text
+	expectedText := "Based on recent research, artificial intelligence is advancing rapidly."
+	assert.Contains(t, result, expectedText, "Expected result to contain original text")
+
+	// Verify citations are included
+	assert.Contains(t, result, "## Sources", "Expected result to contain Sources section")
+	assert.Contains(t, result, "[AI Research Advances 2025](https://example.com/ai-research)", "Expected result to contain first citation")
+	assert.Contains(t, result, "[Technology News Today](https://another-source.com/tech-news)", "Expected result to contain second citation")
+
+	// Verify deduplication - should only have 2 unique citations, not 3
+	citationCount := strings.Count(result, "- [")
+	assert.Equal(t, 2, citationCount, "Expected 2 unique citations")
 }

plugins/ai/openai_compatible/providers_config.go

@@ -1,13 +1,17 @@
 package openai_compatible
 
 import (
+	"os"
+	"strings"
+
 	"github.com/danielmiessler/fabric/plugins/ai/openai"
 )
 
 // ProviderConfig defines the configuration for an OpenAI-compatible API provider
 type ProviderConfig struct {
-	Name    string
-	BaseURL string
+	Name                string
+	BaseURL             string
+	ImplementsResponses bool // Whether the provider supports OpenAI's new Responses API
 }
 
 // Client is the common structure for all OpenAI-compatible providers
@@ -18,53 +22,98 @@ type Client struct {
 // NewClient creates a new OpenAI-compatible client for the specified provider
 func NewClient(providerConfig ProviderConfig) *Client {
 	client := &Client{}
-	client.Client = openai.NewClientCompatible(providerConfig.Name, providerConfig.BaseURL, nil)
+	client.Client = openai.NewClientCompatibleWithResponses(
+		providerConfig.Name,
+		providerConfig.BaseURL,
+		providerConfig.ImplementsResponses,
+		nil,
+	)
 	return client
 }
 
 // ProviderMap is a map of provider name to ProviderConfig for O(1) lookup
 var ProviderMap = map[string]ProviderConfig{
-	"Mistral": {
-		Name:    "Mistral",
-		BaseURL: "https://api.mistral.ai/v1",
-	},
-	"LiteLLM": {
-		Name:    "LiteLLM",
-		BaseURL: "http://localhost:4000",
-	},
-	"Groq": {
-		Name:    "Groq",
-		BaseURL: "https://api.groq.com/openai/v1",
-	},
-	"GrokAI": {
-		Name:    "GrokAI",
-		BaseURL: "https://api.x.ai/v1",
-	},
-	"DeepSeek": {
-		Name:    "DeepSeek",
-		BaseURL: "https://api.deepseek.com",
+	"AIML": {
+		Name:                "AIML",
+		BaseURL:             "https://api.aimlapi.com/v1",
+		ImplementsResponses: false,
 	},
 	"Cerebras": {
-		Name:    "Cerebras",
-		BaseURL: "https://api.cerebras.ai/v1",
+		Name:                "Cerebras",
+		BaseURL:             "https://api.cerebras.ai/v1",
+		ImplementsResponses: false,
+	},
+	"DeepSeek": {
+		Name:                "DeepSeek",
+		BaseURL:             "https://api.deepseek.com",
+		ImplementsResponses: false,
+	},
+	"GrokAI": {
+		Name:                "GrokAI",
+		BaseURL:             "https://api.x.ai/v1",
+		ImplementsResponses: false,
+	},
+	"Groq": {
+		Name:                "Groq",
+		BaseURL:             "https://api.groq.com/openai/v1",
+		ImplementsResponses: false,
+	},
+	"Langdock": {
+		Name:                "Langdock",
+		BaseURL:             "https://api.langdock.com/openai/{{REGION=us}}/v1",
+		ImplementsResponses: false,
+	},
+	"LiteLLM": {
+		Name:                "LiteLLM",
+		BaseURL:             "http://localhost:4000",
+		ImplementsResponses: false,
+	},
+	"Mistral": {
+		Name:                "Mistral",
+		BaseURL:             "https://api.mistral.ai/v1",
+		ImplementsResponses: false,
 	},
 	"OpenRouter": {
-		Name:    "OpenRouter",
-		BaseURL: "https://openrouter.ai/api/v1",
+		Name:                "OpenRouter",
+		BaseURL:             "https://openrouter.ai/api/v1",
+		ImplementsResponses: false,
 	},
 	"SiliconCloud": {
-		Name:    "SiliconCloud",
-		BaseURL: "https://api.siliconflow.cn/v1",
-	},
-	"AIML": {
-		Name:    "AIML",
-		BaseURL: "https://api.aimlapi.com/v1",
+		Name:                "SiliconCloud",
+		BaseURL:             "https://api.siliconflow.cn/v1",
+		ImplementsResponses: false,
 	},
 }
 
 // GetProviderByName returns the provider configuration for a given name with O(1) lookup
 func GetProviderByName(name string) (ProviderConfig, bool) {
 	provider, found := ProviderMap[name]
+	if strings.Contains(provider.BaseURL, "{{") && strings.Contains(provider.BaseURL, "}}") {
+		// Extract the template variable and default value
+		start := strings.Index(provider.BaseURL, "{{")
+		end := strings.Index(provider.BaseURL, "}}") + 2
+		template := provider.BaseURL[start:end]
+
+		// Parse the template to get variable name and default value
+		inner := template[2 : len(template)-2] // Remove {{ and }}
+		parts := strings.Split(inner, "=")
+		if len(parts) == 2 {
+			varName := strings.TrimSpace(parts[0])
+			defaultValue := strings.TrimSpace(parts[1])
+
+			// Create environment variable name
+			envVarName := strings.ToUpper(provider.Name) + "_" + varName
+
+			// Get value from environment or use default
+			envValue := os.Getenv(envVarName)
+			if envValue == "" {
+				envValue = defaultValue
+			}
+
+			// Replace the template with the actual value
+			provider.BaseURL = strings.Replace(provider.BaseURL, template, envValue, 1)
+		}
+	}
 	return provider, found
 }
 

plugins/ai/perplexity/perplexity.go

@@ -0,0 +1,246 @@
+package perplexity
+
+import (
+	"context"
+	"fmt"
+	"os"
+	"sync" // Added sync package
+
+	"github.com/danielmiessler/fabric/common"
+	"github.com/danielmiessler/fabric/plugins"
+	perplexity "github.com/sgaunet/perplexity-go/v2"
+
+	"github.com/danielmiessler/fabric/chat"
+)
+
+const (
+	providerName = "Perplexity"
+)
+
+var models = []string{
+	"r1-1776", "sonar", "sonar-pro", "sonar-reasoning", "sonar-reasoning-pro",
+}
+
+type Client struct {
+	*plugins.PluginBase
+	APIKey *plugins.SetupQuestion
+	client *perplexity.Client
+}
+
+func NewClient() *Client {
+	c := &Client{}
+	c.PluginBase = &plugins.PluginBase{
+		Name:            providerName,
+		EnvNamePrefix:   plugins.BuildEnvVariablePrefix(providerName),
+		ConfigureCustom: c.Configure, // Assign the Configure method
+	}
+	c.APIKey = c.AddSetupQuestion("API_KEY", true)
+	return c
+}
+
+func (c *Client) Configure() error {
+	// The PluginBase.Configure() is called by the framework if needed.
+	// We only need to handle specific logic for this plugin.
+	if c.APIKey.Value == "" {
+		// Attempt to get from environment variable if not set by user during setup
+		envKey := c.EnvNamePrefix + "API_KEY"
+		apiKeyFromEnv := os.Getenv(envKey)
+		if apiKeyFromEnv != "" {
+			c.APIKey.Value = apiKeyFromEnv
+		} else {
+			return fmt.Errorf("%s API key not configured. Please set the %s environment variable or run 'fabric --setup %s'", providerName, envKey, providerName)
+		}
+	}
+	c.client = perplexity.NewClient(c.APIKey.Value)
+	return nil
+}
+
+func (c *Client) ListModels() ([]string, error) {
+	// Perplexity API does not have a ListModels endpoint.
+	// We return a predefined list.
+	return models, nil
+}
+
+func (c *Client) Send(ctx context.Context, msgs []*chat.ChatCompletionMessage, opts *common.ChatOptions) (string, error) {
+	if c.client == nil {
+		if err := c.Configure(); err != nil {
+			return "", fmt.Errorf("failed to configure Perplexity client: %w", err)
+		}
+	}
+
+	var perplexityMessages []perplexity.Message
+	for _, msg := range msgs {
+		perplexityMessages = append(perplexityMessages, perplexity.Message{
+			Role:    msg.Role,
+			Content: msg.Content,
+		})
+	}
+
+	requestOptions := []perplexity.CompletionRequestOption{
+		perplexity.WithModel(opts.Model),
+		perplexity.WithMessages(perplexityMessages),
+	}
+	if opts.MaxTokens > 0 {
+		requestOptions = append(requestOptions, perplexity.WithMaxTokens(opts.MaxTokens))
+	}
+	if opts.Temperature > 0 { // Perplexity default is 1.0, only set if user specifies
+		requestOptions = append(requestOptions, perplexity.WithTemperature(opts.Temperature))
+	}
+	if opts.TopP > 0 { // Perplexity default is not specified, typically 1.0
+		requestOptions = append(requestOptions, perplexity.WithTopP(opts.TopP))
+	}
+	if opts.PresencePenalty != 0 {
+		// Corrected: Pass float64 directly
+		requestOptions = append(requestOptions, perplexity.WithPresencePenalty(opts.PresencePenalty))
+	}
+	if opts.FrequencyPenalty != 0 {
+		// Corrected: Pass float64 directly
+		requestOptions = append(requestOptions, perplexity.WithFrequencyPenalty(opts.FrequencyPenalty))
+	}
+
+	request := perplexity.NewCompletionRequest(requestOptions...)
+
+	// Corrected: Use SendCompletionRequest method from perplexity-go library
+	resp, err := c.client.SendCompletionRequest(request) // Pass request directly
+	if err != nil {
+		return "", fmt.Errorf("perplexity API request failed: %w", err) // Corrected capitalization
+	}
+
+	content := resp.GetLastContent()
+
+	// Append citations if available
+	citations := resp.GetCitations()
+	if len(citations) > 0 {
+		content += "\n\n# CITATIONS\n\n"
+		for i, citation := range citations {
+			content += fmt.Sprintf("- [%d] %s\n", i+1, citation)
+		}
+	}
+
+	return content, nil
+}
+
+func (c *Client) SendStream(msgs []*chat.ChatCompletionMessage, opts *common.ChatOptions, channel chan string) error {
+	if c.client == nil {
+		if err := c.Configure(); err != nil {
+			close(channel) // Ensure channel is closed on error
+			return fmt.Errorf("failed to configure Perplexity client: %w", err)
+		}
+	}
+
+	var perplexityMessages []perplexity.Message
+	for _, msg := range msgs {
+		perplexityMessages = append(perplexityMessages, perplexity.Message{
+			Role:    msg.Role,
+			Content: msg.Content,
+		})
+	}
+
+	requestOptions := []perplexity.CompletionRequestOption{
+		perplexity.WithModel(opts.Model),
+		perplexity.WithMessages(perplexityMessages),
+		perplexity.WithStream(true), // Enable streaming
+	}
+
+	if opts.MaxTokens > 0 {
+		requestOptions = append(requestOptions, perplexity.WithMaxTokens(opts.MaxTokens))
+	}
+	if opts.Temperature > 0 {
+		requestOptions = append(requestOptions, perplexity.WithTemperature(opts.Temperature))
+	}
+	if opts.TopP > 0 {
+		requestOptions = append(requestOptions, perplexity.WithTopP(opts.TopP))
+	}
+	if opts.PresencePenalty != 0 {
+		// Corrected: Pass float64 directly
+		requestOptions = append(requestOptions, perplexity.WithPresencePenalty(opts.PresencePenalty))
+	}
+	if opts.FrequencyPenalty != 0 {
+		// Corrected: Pass float64 directly
+		requestOptions = append(requestOptions, perplexity.WithFrequencyPenalty(opts.FrequencyPenalty))
+	}
+
+	request := perplexity.NewCompletionRequest(requestOptions...)
+
+	responseChan := make(chan perplexity.CompletionResponse)
+	var wg sync.WaitGroup // Use sync.WaitGroup
+	wg.Add(1)
+
+	go func() {
+		err := c.client.SendSSEHTTPRequest(&wg, request, responseChan)
+		if err != nil {
+			// Log error, can't send to string channel directly.
+			// Consider a mechanism to propagate this error if needed.
+			fmt.Fprintf(os.Stderr, "perplexity streaming error: %v\\n", err) // Corrected capitalization
+			// If the error occurs during stream setup, the channel might not have been closed by the receiver loop.
+			// However, closing it here might cause a panic if the receiver loop also tries to close it.
+			// close(channel) // Caution: Uncommenting this may cause panic, as channel is closed in the receiver goroutine.
+		}
+	}()
+
+	go func() {
+		defer close(channel) // Ensure the output channel is closed when this goroutine finishes
+		var lastResponse *perplexity.CompletionResponse
+		for resp := range responseChan {
+			lastResponse = &resp
+			if len(resp.Choices) > 0 {
+				content := ""
+				// Corrected: Check Delta.Content and Message.Content directly for non-emptiness
+				// as Delta and Message are structs, not pointers, in perplexity.Choice
+				if resp.Choices[0].Delta.Content != "" {
+					content = resp.Choices[0].Delta.Content
+				} else if resp.Choices[0].Message.Content != "" {
+					content = resp.Choices[0].Message.Content
+				}
+				if content != "" {
+					channel <- content
+				}
+			}
+		}
+
+		// Send citations at the end if available
+		if lastResponse != nil {
+			citations := lastResponse.GetCitations()
+			if len(citations) > 0 {
+				channel <- "\n\n# CITATIONS\n\n"
+				for i, citation := range citations {
+					channel <- fmt.Sprintf("- [%d] %s\n", i+1, citation)
+				}
+			}
+		}
+	}()
+
+	return nil
+}
+
+func (c *Client) NeedsRawMode(modelName string) bool {
+	return true
+}
+
+// Setup is called by the fabric CLI framework to guide the user through configuration.
+func (c *Client) Setup() error {
+	return c.PluginBase.Setup()
+}
+
+// GetName returns the name of the plugin.
+func (c *Client) GetName() string {
+	return c.PluginBase.Name
+}
+
+// GetEnvNamePrefix returns the environment variable prefix for the plugin.
+// Corrected: Receiver name
+func (c *Client) GetEnvNamePrefix() string {
+	return c.PluginBase.EnvNamePrefix
+}
+
+// AddSetupQuestion adds a setup question to the plugin.
+// This is a helper method, usually called from NewClient.
+func (c *Client) AddSetupQuestion(text string, isSensitive bool) *plugins.SetupQuestion {
+	return c.PluginBase.AddSetupQuestion(text, isSensitive)
+}
+
+// GetSetupQuestions returns the setup questions for the plugin.
+// Corrected: Return the slice of setup questions from PluginBase
+func (c *Client) GetSetupQuestions() []*plugins.SetupQuestion {
+	return c.PluginBase.SetupQuestions
+}

plugins/ai/vendor.go

@@ -3,8 +3,8 @@ package ai
 import (
 	"context"
 
+	"github.com/danielmiessler/fabric/chat"
 	"github.com/danielmiessler/fabric/plugins"
-	goopenai "github.com/sashabaranov/go-openai"
 
 	"github.com/danielmiessler/fabric/common"
 )
@@ -12,7 +12,7 @@ import (
 type Vendor interface {
 	plugins.Plugin
 	ListModels() ([]string, error)
-	SendStream([]*goopenai.ChatCompletionMessage, *common.ChatOptions, chan string) error
-	Send(context.Context, []*goopenai.ChatCompletionMessage, *common.ChatOptions) (string, error)
+	SendStream([]*chat.ChatCompletionMessage, *common.ChatOptions, chan string) error
+	Send(context.Context, []*chat.ChatCompletionMessage, *common.ChatOptions) (string, error)
 	NeedsRawMode(modelName string) bool
 }

plugins/db/fsdb/db.go

@@ -4,6 +4,7 @@ import (
 	"fmt"
 	"os"
 	"path/filepath"
+	"strings"
 	"time"
 
 	"github.com/joho/godotenv"
@@ -15,10 +16,22 @@ func NewDb(dir string) (db *Db) {
 
 	db.EnvFilePath = db.FilePath(".env")
 
+	// Check for custom patterns directory from environment variable
+	customPatternsDir := os.Getenv("CUSTOM_PATTERNS_DIRECTORY")
+	if customPatternsDir != "" {
+		// Expand home directory if needed
+		if strings.HasPrefix(customPatternsDir, "~/") {
+			if homeDir, err := os.UserHomeDir(); err == nil {
+				customPatternsDir = filepath.Join(homeDir, customPatternsDir[2:])
+			}
+		}
+	}
+
 	db.Patterns = &PatternsEntity{
 		StorageEntity:          &StorageEntity{Label: "Patterns", Dir: db.FilePath("patterns"), ItemIsDir: true},
 		SystemPatternFile:      "system.md",
 		UniquePatternsFilePath: db.FilePath("unique_patterns.txt"),
+		CustomPatternsDir:      customPatternsDir,
 	}
 
 	db.Sessions = &SessionsEntity{

plugins/db/fsdb/patterns.go

@@ -16,6 +16,7 @@ type PatternsEntity struct {
 	*StorageEntity
 	SystemPatternFile      string
 	UniquePatternsFilePath string
+	CustomPatternsDir      string
 }
 
 // Pattern represents a single pattern with its metadata
@@ -43,7 +44,7 @@ func (o *PatternsEntity) GetApplyVariables(
 		}
 
 		// Use the resolved absolute path to get the pattern
-		pattern, err = o.getFromFile(absPath)
+		pattern, _ = o.getFromFile(absPath)
 	} else {
 		// Otherwise, get the pattern from the database
 		pattern, err = o.getFromDB(source)
@@ -89,6 +90,19 @@ func (o *PatternsEntity) applyVariables(
 
 // retrieves a pattern from the database by name
 func (o *PatternsEntity) getFromDB(name string) (ret *Pattern, err error) {
+	// First check custom patterns directory if it exists
+	if o.CustomPatternsDir != "" {
+		customPatternPath := filepath.Join(o.CustomPatternsDir, name, o.SystemPatternFile)
+		if pattern, customErr := os.ReadFile(customPatternPath); customErr == nil {
+			ret = &Pattern{
+				Name:    name,
+				Pattern: string(pattern),
+			}
+			return ret, nil
+		}
+	}
+
+	// Fallback to main patterns directory
 	patternPath := filepath.Join(o.Dir, name, o.SystemPatternFile)
 
 	var pattern []byte
@@ -145,8 +159,61 @@ func (o *PatternsEntity) getFromFile(pathStr string) (pattern *Pattern, err erro
 	return
 }
 
+// GetNames overrides StorageEntity.GetNames to include custom patterns directory
+func (o *PatternsEntity) GetNames() (ret []string, err error) {
+	// Get names from main patterns directory
+	mainNames, err := o.StorageEntity.GetNames()
+	if err != nil {
+		return nil, err
+	}
+
+	// Create a map to track unique pattern names (custom patterns override main ones)
+	nameMap := make(map[string]bool)
+	for _, name := range mainNames {
+		nameMap[name] = true
+	}
+
+	// Get names from custom patterns directory if it exists
+	if o.CustomPatternsDir != "" {
+		// Create a temporary StorageEntity for the custom directory
+		customStorage := &StorageEntity{
+			Dir:           o.CustomPatternsDir,
+			ItemIsDir:     o.StorageEntity.ItemIsDir,
+			FileExtension: o.StorageEntity.FileExtension,
+		}
+
+		customNames, customErr := customStorage.GetNames()
+		if customErr == nil {
+			// Add custom patterns, they will override main patterns with same name
+			for _, name := range customNames {
+				nameMap[name] = true
+			}
+		}
+		// Ignore errors from custom directory (it might not exist)
+	}
+
+	// Convert map keys back to slice
+	ret = make([]string, 0, len(nameMap))
+	for name := range nameMap {
+		ret = append(ret, name)
+	}
+
+	return ret, nil
+}
+
 // Get required for Storage interface
 func (o *PatternsEntity) Get(name string) (*Pattern, error) {
 	// Use GetPattern with no variables
 	return o.GetApplyVariables(name, nil, "")
 }
+func (o *PatternsEntity) Save(name string, content []byte) (err error) {
+	patternDir := filepath.Join(o.Dir, name)
+	if err = os.MkdirAll(patternDir, os.ModePerm); err != nil {
+		return fmt.Errorf("could not create pattern directory: %v", err)
+	}
+	patternPath := filepath.Join(patternDir, o.SystemPatternFile)
+	if err = os.WriteFile(patternPath, content, 0644); err != nil {
+		return fmt.Errorf("could not save pattern: %v", err)
+	}
+	return nil
+}

plugins/db/fsdb/patterns_test.go

@@ -144,3 +144,141 @@ func TestGetApplyVariables(t *testing.T) {
 		})
 	}
 }
+
+func TestPatternsEntity_Save(t *testing.T) {
+	entity, cleanup := setupTestPatternsEntity(t)
+	defer cleanup()
+
+	name := "new-pattern"
+	content := []byte("test pattern content")
+	require.NoError(t, entity.Save(name, content))
+
+	patternDir := filepath.Join(entity.Dir, name)
+	info, err := os.Stat(patternDir)
+	require.NoError(t, err)
+	assert.True(t, info.IsDir())
+
+	data, err := os.ReadFile(filepath.Join(patternDir, entity.SystemPatternFile))
+	require.NoError(t, err)
+	assert.Equal(t, content, data)
+}
+
+func TestPatternsEntity_CustomPatterns(t *testing.T) {
+	// Create main patterns directory
+	mainDir, err := os.MkdirTemp("", "test-main-patterns-*")
+	require.NoError(t, err)
+	defer os.RemoveAll(mainDir)
+
+	// Create custom patterns directory
+	customDir, err := os.MkdirTemp("", "test-custom-patterns-*")
+	require.NoError(t, err)
+	defer os.RemoveAll(customDir)
+
+	entity := &PatternsEntity{
+		StorageEntity: &StorageEntity{
+			Dir:       mainDir,
+			Label:     "patterns",
+			ItemIsDir: true,
+		},
+		SystemPatternFile: "system.md",
+		CustomPatternsDir: customDir,
+	}
+
+	// Create a pattern in main directory
+	createTestPattern(t, &PatternsEntity{
+		StorageEntity: &StorageEntity{
+			Dir:       mainDir,
+			Label:     "patterns",
+			ItemIsDir: true,
+		},
+		SystemPatternFile: "system.md",
+	}, "main-pattern", "Main pattern content")
+
+	// Create a pattern in custom directory
+	createTestPattern(t, &PatternsEntity{
+		StorageEntity: &StorageEntity{
+			Dir:       customDir,
+			Label:     "patterns",
+			ItemIsDir: true,
+		},
+		SystemPatternFile: "system.md",
+	}, "custom-pattern", "Custom pattern content")
+
+	// Create a pattern with same name in both directories (custom should override)
+	createTestPattern(t, &PatternsEntity{
+		StorageEntity: &StorageEntity{
+			Dir:       mainDir,
+			Label:     "patterns",
+			ItemIsDir: true,
+		},
+		SystemPatternFile: "system.md",
+	}, "shared-pattern", "Main shared pattern")
+
+	createTestPattern(t, &PatternsEntity{
+		StorageEntity: &StorageEntity{
+			Dir:       customDir,
+			Label:     "patterns",
+			ItemIsDir: true,
+		},
+		SystemPatternFile: "system.md",
+	}, "shared-pattern", "Custom shared pattern")
+
+	// Test GetNames includes both directories
+	names, err := entity.GetNames()
+	require.NoError(t, err)
+	assert.Contains(t, names, "main-pattern")
+	assert.Contains(t, names, "custom-pattern")
+	assert.Contains(t, names, "shared-pattern")
+
+	// Test that custom pattern overrides main pattern
+	pattern, err := entity.getFromDB("shared-pattern")
+	require.NoError(t, err)
+	assert.Equal(t, "Custom shared pattern", pattern.Pattern)
+
+	// Test that main pattern is accessible when not overridden
+	pattern, err = entity.getFromDB("main-pattern")
+	require.NoError(t, err)
+	assert.Equal(t, "Main pattern content", pattern.Pattern)
+
+	// Test that custom pattern is accessible
+	pattern, err = entity.getFromDB("custom-pattern")
+	require.NoError(t, err)
+	assert.Equal(t, "Custom pattern content", pattern.Pattern)
+}
+
+func TestPatternsEntity_CustomPatternsEmpty(t *testing.T) {
+	// Test behavior when custom patterns directory is empty or doesn't exist
+	mainDir, err := os.MkdirTemp("", "test-main-patterns-*")
+	require.NoError(t, err)
+	defer os.RemoveAll(mainDir)
+
+	entity := &PatternsEntity{
+		StorageEntity: &StorageEntity{
+			Dir:       mainDir,
+			Label:     "patterns",
+			ItemIsDir: true,
+		},
+		SystemPatternFile: "system.md",
+		CustomPatternsDir: "/nonexistent/directory",
+	}
+
+	// Create a pattern in main directory
+	createTestPattern(t, &PatternsEntity{
+		StorageEntity: &StorageEntity{
+			Dir:       mainDir,
+			Label:     "patterns",
+			ItemIsDir: true,
+		},
+		SystemPatternFile: "system.md",
+	}, "main-pattern", "Main pattern content")
+
+	// Test GetNames works even with nonexistent custom directory
+	names, err := entity.GetNames()
+	require.NoError(t, err)
+	assert.Contains(t, names, "main-pattern")
+
+	// Test that main pattern is accessible
+	pattern, err := entity.getFromDB("main-pattern")
+	require.NoError(t, err)
+	assert.Equal(t, "Main pattern content", pattern.Pattern)
+}

plugins/db/fsdb/sessions.go

@@ -3,8 +3,8 @@ package fsdb
 import (
 	"fmt"
 
+	"github.com/danielmiessler/fabric/chat"
 	"github.com/danielmiessler/fabric/common"
-	goopenai "github.com/sashabaranov/go-openai"
 )
 
 type SessionsEntity struct {
@@ -38,16 +38,16 @@ func (o *SessionsEntity) SaveSession(session *Session) (err error) {
 
 type Session struct {
 	Name     string
-	Messages []*goopenai.ChatCompletionMessage
+	Messages []*chat.ChatCompletionMessage
 
-	vendorMessages []*goopenai.ChatCompletionMessage
+	vendorMessages []*chat.ChatCompletionMessage
 }
 
 func (o *Session) IsEmpty() bool {
 	return len(o.Messages) == 0
 }
 
-func (o *Session) Append(messages ...*goopenai.ChatCompletionMessage) {
+func (o *Session) Append(messages ...*chat.ChatCompletionMessage) {
 	if o.vendorMessages != nil {
 		for _, message := range messages {
 			o.Messages = append(o.Messages, message)
@@ -58,7 +58,7 @@ func (o *Session) Append(messages ...*goopenai.ChatCompletionMessage) {
 	}
 }
 
-func (o *Session) GetVendorMessages() (ret []*goopenai.ChatCompletionMessage) {
+func (o *Session) GetVendorMessages() (ret []*chat.ChatCompletionMessage) {
 	if len(o.vendorMessages) == 0 {
 		for _, message := range o.Messages {
 			o.appendVendorMessage(message)
@@ -68,13 +68,13 @@ func (o *Session) GetVendorMessages() (ret []*goopenai.ChatCompletionMessage) {
 	return
 }
 
-func (o *Session) appendVendorMessage(message *goopenai.ChatCompletionMessage) {
+func (o *Session) appendVendorMessage(message *chat.ChatCompletionMessage) {
 	if message.Role != common.ChatMessageRoleMeta {
 		o.vendorMessages = append(o.vendorMessages, message)
 	}
 }
 
-func (o *Session) GetLastMessage() (ret *goopenai.ChatCompletionMessage) {
+func (o *Session) GetLastMessage() (ret *chat.ChatCompletionMessage) {
 	if len(o.Messages) > 0 {
 		ret = o.Messages[len(o.Messages)-1]
 	}
@@ -86,9 +86,9 @@ func (o *Session) String() (ret string) {
 		ret += fmt.Sprintf("\n--- \n[%v]\n%v", message.Role, message.Content)
 		if message.MultiContent != nil {
 			for _, part := range message.MultiContent {
-				if part.Type == goopenai.ChatMessagePartTypeImageURL {
+				if part.Type == chat.ChatMessagePartTypeImageURL {
 					ret += fmt.Sprintf("\n%v: %v", part.Type, *part.ImageURL)
-				} else if part.Type == goopenai.ChatMessagePartTypeText {
+				} else if part.Type == chat.ChatMessagePartTypeText {
 					ret += fmt.Sprintf("\n%v: %v", part.Type, part.Text)
 				}
 			}

plugins/db/fsdb/sessions_test.go

@@ -3,7 +3,7 @@ package fsdb
 import (
 	"testing"
 
-	goopenai "github.com/sashabaranov/go-openai"
+	"github.com/danielmiessler/fabric/chat"
 )
 
 func TestSessions_GetOrCreateSession(t *testing.T) {
@@ -27,7 +27,7 @@ func TestSessions_SaveSession(t *testing.T) {
 		StorageEntity: &StorageEntity{Dir: dir, FileExtension: ".json"},
 	}
 	sessionName := "testSession"
-	session := &Session{Name: sessionName, Messages: []*goopenai.ChatCompletionMessage{{Content: "message1"}}}
+	session := &Session{Name: sessionName, Messages: []*chat.ChatCompletionMessage{{Content: "message1"}}}
 	err := sessions.SaveSession(session)
 	if err != nil {
 		t.Fatalf("failed to save session: %v", err)

plugins/plugin.go

@@ -152,7 +152,6 @@ func (o *Setting) FillEnvFileContent(buffer *bytes.Buffer) {
 		}
 		buffer.WriteString("\n")
 	}
-	return
 }
 
 func ParseBoolElseFalse(val string) (ret bool) {
@@ -279,7 +278,6 @@ func (o Settings) FillEnvFileContent(buffer *bytes.Buffer) {
 	for _, setting := range o {
 		setting.FillEnvFileContent(buffer)
 	}
-	return
 }
 
 type SetupQuestions []*SetupQuestion

plugins/template/sys_test.go

@@ -93,7 +93,7 @@ func TestSysPlugin(t *testing.T) {
 				if !filepath.IsAbs(got) {
 					return fmt.Errorf("expected absolute path, got %s", got)
 				}
-				if !strings.Contains(got, "home") && !strings.Contains(got, "Users") {
+				if !strings.Contains(got, "home") && !strings.Contains(got, "Users") && got != "/root" {
 					return fmt.Errorf("path %s doesn't look like a home directory", got)
 				}
 				return nil

plugins/tools/custom_patterns/custom_patterns.go

@@ -0,0 +1,61 @@
+package custom_patterns
+
+import (
+	"os"
+	"path/filepath"
+	"strings"
+
+	"github.com/danielmiessler/fabric/plugins"
+)
+
+func NewCustomPatterns() (ret *CustomPatterns) {
+	label := "Custom Patterns"
+	ret = &CustomPatterns{}
+
+	ret.PluginBase = &plugins.PluginBase{
+		Name:             label,
+		SetupDescription: "Custom Patterns - Set directory for your custom patterns (optional)",
+		EnvNamePrefix:    plugins.BuildEnvVariablePrefix(label),
+		ConfigureCustom:  ret.configure,
+	}
+
+	ret.CustomPatternsDir = ret.AddSetupQuestionCustom("Directory", false,
+		"Enter the path to your custom patterns directory (leave empty to skip)")
+
+	return
+}
+
+type CustomPatterns struct {
+	*plugins.PluginBase
+	CustomPatternsDir *plugins.SetupQuestion
+}
+
+func (o *CustomPatterns) configure() error {
+	if o.CustomPatternsDir.Value != "" {
+		// Expand home directory if needed
+		if strings.HasPrefix(o.CustomPatternsDir.Value, "~/") {
+			if homeDir, err := os.UserHomeDir(); err == nil {
+				o.CustomPatternsDir.Value = filepath.Join(homeDir, o.CustomPatternsDir.Value[2:])
+			}
+		}
+
+		// Convert to absolute path
+		if absPath, err := filepath.Abs(o.CustomPatternsDir.Value); err == nil {
+			o.CustomPatternsDir.Value = absPath
+		}
+
+		// Create the directory if it doesn't exist
+		if err := os.MkdirAll(o.CustomPatternsDir.Value, 0755); err != nil {
+			// If we can't create it, clear the value to avoid errors
+			o.CustomPatternsDir.Value = ""
+		}
+	}
+
+	return nil
+}
+
+// IsConfigured returns true if a custom patterns directory has been set
+func (o *CustomPatterns) IsConfigured() bool {
+	// Check if the plugin has been configured with a directory
+	return o.CustomPatternsDir.Value != ""
+}

plugins/tools/custom_patterns/custom_patterns_test.go

@@ -0,0 +1,79 @@
+package custom_patterns
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func TestNewCustomPatterns(t *testing.T) {
+	plugin := NewCustomPatterns()
+
+	assert.NotNil(t, plugin)
+	assert.Equal(t, "Custom Patterns", plugin.GetName())
+	assert.Equal(t, "Custom Patterns - Set directory for your custom patterns (optional)", plugin.GetSetupDescription())
+	assert.False(t, plugin.IsConfigured()) // Should not be configured initially
+}
+func TestCustomPatterns_Configure(t *testing.T) {
+	plugin := NewCustomPatterns()
+
+	// Test with empty directory (should work)
+	plugin.CustomPatternsDir.Value = ""
+	err := plugin.configure()
+	assert.NoError(t, err)
+
+	// Test with home directory expansion
+	plugin.CustomPatternsDir.Value = "~/test-patterns"
+	err = plugin.configure()
+	assert.NoError(t, err)
+
+	homeDir, _ := os.UserHomeDir()
+	expectedPath := filepath.Join(homeDir, "test-patterns")
+	absExpected, _ := filepath.Abs(expectedPath)
+	assert.Equal(t, absExpected, plugin.CustomPatternsDir.Value)
+
+	// Clean up
+	os.RemoveAll(plugin.CustomPatternsDir.Value)
+}
+
+func TestCustomPatterns_ConfigureWithTempDir(t *testing.T) {
+	plugin := NewCustomPatterns()
+
+	// Test with a temporary directory
+	tmpDir, err := os.MkdirTemp("", "test-custom-patterns-*")
+	require.NoError(t, err)
+	defer os.RemoveAll(tmpDir)
+
+	plugin.CustomPatternsDir.Value = tmpDir
+	err = plugin.configure()
+	assert.NoError(t, err)
+
+	absPath, _ := filepath.Abs(tmpDir)
+	assert.Equal(t, absPath, plugin.CustomPatternsDir.Value)
+
+	// Verify directory exists
+	info, err := os.Stat(plugin.CustomPatternsDir.Value)
+	assert.NoError(t, err)
+	assert.True(t, info.IsDir())
+
+	// Should be configured now
+	assert.True(t, plugin.IsConfigured())
+}
+
+func TestCustomPatterns_IsConfigured(t *testing.T) {
+	plugin := NewCustomPatterns()
+
+	// Initially not configured
+	assert.False(t, plugin.IsConfigured())
+
+	// Set a directory
+	plugin.CustomPatternsDir.Value = "/some/path"
+	assert.True(t, plugin.IsConfigured())
+
+	// Clear the directory
+	plugin.CustomPatternsDir.Value = ""
+	assert.False(t, plugin.IsConfigured())
+}

plugins/tools/youtube/youtube.go

@@ -1,20 +1,29 @@
+// Package youtube provides YouTube video transcript and comment extraction functionality.
+//
+// Requirements:
+// - yt-dlp: Required for transcript extraction (must be installed separately)
+// - YouTube API key: Optional, only needed for comments and metadata extraction
+//
+// The implementation uses yt-dlp for reliable transcript extraction and the YouTube API
+// for comments/metadata. Old YouTube scraping methods have been removed due to
+// frequent changes and rate limiting.
 package youtube
 
 import (
+	"bytes"
 	"context"
 	"encoding/csv"
-	"encoding/json"
 	"flag"
 	"fmt"
 	"log"
-	"net/url"
 	"os"
+	"os/exec"
+	"path/filepath"
 	"regexp"
 	"strconv"
 	"strings"
 	"time"
 
-	"github.com/anaskhan96/soup"
 	"github.com/danielmiessler/fabric/plugins"
 	"google.golang.org/api/option"
 	"google.golang.org/api/youtube/v3"
@@ -27,7 +36,7 @@ func NewYouTube() (ret *YouTube) {
 
 	ret.PluginBase = &plugins.PluginBase{
 		Name:             label,
-		SetupDescription: label + " - to grab video transcripts and comments",
+		SetupDescription: label + " - to grab video transcripts (via yt-dlp) and comments/metadata (via YouTube API)",
 		EnvNamePrefix:    plugins.BuildEnvVariablePrefix(label),
 	}
 
@@ -46,6 +55,10 @@ type YouTube struct {
 
 func (o *YouTube) initService() (err error) {
 	if o.service == nil {
+		if o.ApiKey.Value == "" {
+			err = fmt.Errorf("YouTube API key required for comments and metadata. Run 'fabric --setup' to configure")
+			return
+		}
 		o.normalizeRegex = regexp.MustCompile(`[^a-zA-Z0-9]+`)
 		ctx := context.Background()
 		o.service, err = youtube.NewService(ctx, option.WithAPIKey(o.ApiKey.Value))
@@ -54,10 +67,6 @@ func (o *YouTube) initService() (err error) {
 }
 
 func (o *YouTube) GetVideoOrPlaylistId(url string) (videoId string, playlistId string, err error) {
-	if err = o.initService(); err != nil {
-		return
-	}
-
 	// Video ID pattern
 	videoPattern := `(?:https?:\/\/)?(?:www\.)?(?:youtube\.com\/(?:live\/|[^\/\n\s]+\/\S+\/|(?:v|e(?:mbed)?)\/|(?:s(?:horts)\/)|\S*?[?&]v=)|youtu\.be\/)([a-zA-Z0-9_-]*)`
 	videoRe := regexp.MustCompile(videoPattern)
@@ -94,112 +103,182 @@ func (o *YouTube) GrabTranscriptForUrl(url string, language string) (ret string,
 }
 
 func (o *YouTube) GrabTranscript(videoId string, language string) (ret string, err error) {
-	var transcript string
-	if transcript, err = o.GrabTranscriptBase(videoId, language); err != nil {
-		err = fmt.Errorf("transcript not available. (%v)", err)
-		return
-	}
-
-	// Parse the XML transcript
-	doc := soup.HTMLParse(transcript)
-	// Extract the text content from the <text> tags
-	textTags := doc.FindAll("text")
-	var textBuilder strings.Builder
-	for _, textTag := range textTags {
-		textBuilder.WriteString(strings.ReplaceAll(textTag.Text(), "&#39;", "'"))
-		textBuilder.WriteString(" ")
-		ret = textBuilder.String()
-	}
-	return
+	// Use yt-dlp for reliable transcript extraction
+	return o.tryMethodYtDlp(videoId, language)
 }
 
 func (o *YouTube) GrabTranscriptWithTimestamps(videoId string, language string) (ret string, err error) {
-	var transcript string
-	if transcript, err = o.GrabTranscriptBase(videoId, language); err != nil {
-		err = fmt.Errorf("transcript not available. (%v)", err)
+	// Use yt-dlp for reliable transcript extraction with timestamps
+	return o.tryMethodYtDlpWithTimestamps(videoId, language)
+}
+
+// tryMethodYtDlpInternal is a helper function to reduce duplication between
+// tryMethodYtDlp and tryMethodYtDlpWithTimestamps.
+func (o *YouTube) tryMethodYtDlpInternal(videoId string, language string, processVTTFileFunc func(filename string) (string, error)) (ret string, err error) {
+	// Check if yt-dlp is available
+	if _, err = exec.LookPath("yt-dlp"); err != nil {
+		err = fmt.Errorf("yt-dlp not found in PATH. Please install yt-dlp to use YouTube transcript functionality")
 		return
 	}
 
-	// Parse the XML transcript
-	doc := soup.HTMLParse(transcript)
-	// Extract the text content from the <text> tags
-	textTags := doc.FindAll("text")
-	var textBuilder strings.Builder
-	for _, textTag := range textTags {
-		// Extract the start and duration attributes
-		start := textTag.Attrs()["start"]
-		dur := textTag.Attrs()["dur"]
-		end := fmt.Sprintf("%f", parseFloat(start)+parseFloat(dur))
-		// Format the timestamps
-		startFormatted := formatTimestamp(parseFloat(start))
-		endFormatted := formatTimestamp(parseFloat(end))
-		text := strings.ReplaceAll(textTag.Text(), "&#39;", "'")
-		textBuilder.WriteString(fmt.Sprintf("[%s - %s] %s\n", startFormatted, endFormatted, text))
+	// Create a temporary directory for yt-dlp output (cross-platform)
+	tempDir := filepath.Join(os.TempDir(), "fabric-youtube-"+videoId)
+	if err = os.MkdirAll(tempDir, 0755); err != nil {
+		err = fmt.Errorf("failed to create temp directory: %v", err)
+		return
+	}
+	defer os.RemoveAll(tempDir)
+
+	// Use yt-dlp to get transcript
+	videoURL := "https://www.youtube.com/watch?v=" + videoId
+	outputPath := filepath.Join(tempDir, "%(title)s.%(ext)s")
+	lang_match := language
+	if len(language) > 2 {
+		lang_match = language[:2]
+	}
+	cmd := exec.Command("yt-dlp",
+		"--write-auto-subs",
+		"--sub-lang", lang_match,
+		"--skip-download",
+		"--sub-format", "vtt",
+		"--quiet",
+		"--no-warnings",
+		"-o", outputPath,
+		videoURL)
+
+	var stderr bytes.Buffer
+	cmd.Stderr = &stderr
+
+	if err = cmd.Run(); err != nil {
+		err = fmt.Errorf("yt-dlp failed: %v, stderr: %s", err, stderr.String())
+		return
+	}
+
+	// Find VTT files using cross-platform approach
+	vttFiles, err := o.findVTTFiles(tempDir, language)
+	if err != nil {
+		return "", err
+	}
+
+	return processVTTFileFunc(vttFiles[0])
+}
+
+func (o *YouTube) tryMethodYtDlp(videoId string, language string) (ret string, err error) {
+	return o.tryMethodYtDlpInternal(videoId, language, o.readAndCleanVTTFile)
+}
+
+func (o *YouTube) tryMethodYtDlpWithTimestamps(videoId string, language string) (ret string, err error) {
+	return o.tryMethodYtDlpInternal(videoId, language, o.readAndFormatVTTWithTimestamps)
+}
+
+func (o *YouTube) readAndCleanVTTFile(filename string) (ret string, err error) {
+	var content []byte
+	if content, err = os.ReadFile(filename); err != nil {
+		return
+	}
+
+	// Convert VTT to plain text
+	lines := strings.Split(string(content), "\n")
+	var textBuilder strings.Builder
+
+	for _, line := range lines {
+		line = strings.TrimSpace(line)
+		// Skip WEBVTT header, timestamps, and empty lines
+		if line == "" || line == "WEBVTT" || strings.Contains(line, "-->") ||
+			strings.HasPrefix(line, "NOTE") || strings.HasPrefix(line, "STYLE") ||
+			strings.HasPrefix(line, "Kind:") || strings.HasPrefix(line, "Language:") ||
+			isTimeStamp(line) {
+			continue
+		}
+		// Remove VTT formatting tags
+		line = removeVTTTags(line)
+		if line != "" {
+			textBuilder.WriteString(line)
+			textBuilder.WriteString(" ")
+		}
+	}
+
+	ret = strings.TrimSpace(textBuilder.String())
+	if ret == "" {
+		err = fmt.Errorf("no transcript content found in VTT file")
 	}
-	ret = textBuilder.String()
 	return
 }
 
-func parseFloat(s string) float64 {
-	f, _ := strconv.ParseFloat(s, 64)
-	return f
-}
-
-func formatTimestamp(seconds float64) string {
-	hours := int(seconds) / 3600
-	minutes := (int(seconds) % 3600) / 60
-	secs := int(seconds) % 60
-	return fmt.Sprintf("%02d:%02d:%02d", hours, minutes, secs)
-}
-
-func (o *YouTube) GrabTranscriptBase(videoId string, language string) (ret string, err error) {
-	if err = o.initService(); err != nil {
+func (o *YouTube) readAndFormatVTTWithTimestamps(filename string) (ret string, err error) {
+	var content []byte
+	if content, err = os.ReadFile(filename); err != nil {
 		return
 	}
 
-	watchUrl := "https://www.youtube.com/watch?v=" + videoId
-	var resp string
-	if resp, err = soup.Get(watchUrl); err != nil {
-		return
-	}
+	// Parse VTT and preserve timestamps
+	lines := strings.Split(string(content), "\n")
+	var textBuilder strings.Builder
+	var currentTimestamp string
 
-	doc := soup.HTMLParse(resp)
-	scriptTags := doc.FindAll("script")
-	for _, scriptTag := range scriptTags {
-		if strings.Contains(scriptTag.Text(), "captionTracks") {
-			regex := regexp.MustCompile(`"captionTracks":(\[.*?\])`)
-			match := regex.FindStringSubmatch(scriptTag.Text())
-			if len(match) > 1 {
-				var captionTracks []struct {
-					BaseURL string `json:"baseUrl"`
-				}
+	for _, line := range lines {
+		line = strings.TrimSpace(line)
 
-				if err = json.Unmarshal([]byte(match[1]), &captionTracks); err != nil {
-					return
-				}
+		// Skip WEBVTT header and empty lines
+		if line == "" || line == "WEBVTT" || strings.HasPrefix(line, "NOTE") ||
+			strings.HasPrefix(line, "STYLE") || strings.HasPrefix(line, "Kind:") ||
+			strings.HasPrefix(line, "Language:") {
+			continue
+		}
 
-				if len(captionTracks) > 0 {
-					transcriptURL := captionTracks[0].BaseURL
-					for _, captionTrack := range captionTracks {
-						parsedUrl, error := url.Parse(captionTrack.BaseURL)
-						if error != nil {
-							err = fmt.Errorf("error parsing caption track")
-						}
-						parsedUrlParams, _ := url.ParseQuery(parsedUrl.RawQuery)
-						if parsedUrlParams["lang"][0] == language {
-							transcriptURL = captionTrack.BaseURL
-						}
-					}
-					ret, err = soup.Get(transcriptURL)
-					return
-				}
+		// Check if this line is a timestamp
+		if strings.Contains(line, "-->") {
+			// Extract start time for this segment
+			parts := strings.Split(line, " --> ")
+			if len(parts) >= 1 {
+				currentTimestamp = formatVTTTimestamp(parts[0])
+			}
+			continue
+		}
+
+		// Skip numeric sequence identifiers
+		if isTimeStamp(line) && !strings.Contains(line, ":") {
+			continue
+		}
+
+		// This should be transcript text
+		if line != "" {
+			// Remove VTT formatting tags
+			cleanText := removeVTTTags(line)
+			if cleanText != "" && currentTimestamp != "" {
+				textBuilder.WriteString(fmt.Sprintf("[%s] %s\n", currentTimestamp, cleanText))
 			}
 		}
 	}
-	err = fmt.Errorf("transcript not found")
+
+	ret = strings.TrimSpace(textBuilder.String())
+	if ret == "" {
+		err = fmt.Errorf("no transcript content found in VTT file")
+	}
 	return
 }
 
+func formatVTTTimestamp(vttTime string) string {
+	// VTT timestamps are in format "00:00:01.234" - convert to "00:00:01"
+	parts := strings.Split(vttTime, ".")
+	if len(parts) > 0 {
+		return parts[0]
+	}
+	return vttTime
+}
+
+func isTimeStamp(s string) bool {
+	// Match timestamps like "00:00:01.234" or just numbers
+	timestampRegex := regexp.MustCompile(`^\d+$|^\d{2}:\d{2}:\d{2}`)
+	return timestampRegex.MatchString(s)
+}
+
+func removeVTTTags(s string) string {
+	// Remove VTT tags like <c.colorE5E5E5>, </c>, etc.
+	tagRegex := regexp.MustCompile(`<[^>]*>`)
+	return tagRegex.ReplaceAllString(s, "")
+}
+
 func (o *YouTube) GrabComments(videoId string) (ret []string, err error) {
 	if err = o.initService(); err != nil {
 		return
@@ -411,6 +490,41 @@ func (o *YouTube) normalizeFileName(name string) string {
 
 }
 
+// findVTTFiles searches for VTT files in a directory using cross-platform approach
+func (o *YouTube) findVTTFiles(dir, language string) ([]string, error) {
+	var vttFiles []string
+
+	// Walk through the directory to find VTT files
+	err := filepath.Walk(dir, func(path string, info os.FileInfo, err error) error {
+		if err != nil {
+			return err
+		}
+
+		if !info.IsDir() && strings.HasSuffix(strings.ToLower(path), ".vtt") {
+			vttFiles = append(vttFiles, path)
+		}
+		return nil
+	})
+
+	if err != nil {
+		return nil, fmt.Errorf("failed to walk directory: %v", err)
+	}
+
+	if len(vttFiles) == 0 {
+		return nil, fmt.Errorf("no VTT files found in directory")
+	}
+
+	// Prefer files with the specified language
+	for _, file := range vttFiles {
+		if strings.Contains(file, "."+language+".vtt") {
+			return []string{file}, nil
+		}
+	}
+
+	// Return the first VTT file found if no language-specific file exists
+	return []string{vttFiles[0]}, nil
+}
+
 type VideoMeta struct {
 	Id              string
 	Title           string

restapi/chat.go

@@ -3,14 +3,13 @@ package restapi
 import (
 	"encoding/json"
 	"fmt"
-	"io/ioutil"
 	"log"
 	"net/http"
 	"os"
 	"path/filepath"
 	"strings"
 
-	goopenai "github.com/sashabaranov/go-openai"
+	"github.com/danielmiessler/fabric/chat"
 
 	"github.com/danielmiessler/fabric/common"
 	"github.com/danielmiessler/fabric/core"
@@ -24,12 +23,13 @@ type ChatHandler struct {
 }
 
 type PromptRequest struct {
-	UserInput    string `json:"userInput"`
-	Vendor       string `json:"vendor"`
-	Model        string `json:"model"`
-	ContextName  string `json:"contextName"`
-	PatternName  string `json:"patternName"`
-	StrategyName string `json:"strategyName"` // Optional strategy name
+	UserInput    string            `json:"userInput"`
+	Vendor       string            `json:"vendor"`
+	Model        string            `json:"model"`
+	ContextName  string            `json:"contextName"`
+	PatternName  string            `json:"patternName"`
+	StrategyName string            `json:"strategyName"`        // Optional strategy name
+	Variables    map[string]string `json:"variables,omitempty"` // Pattern variables
 }
 
 type ChatRequest struct {
@@ -94,7 +94,7 @@ func (h *ChatHandler) HandleChat(c *gin.Context) {
 				// Load and prepend strategy prompt if strategyName is set
 				if p.StrategyName != "" {
 					strategyFile := filepath.Join(os.Getenv("HOME"), ".config", "fabric", "strategies", p.StrategyName+".json")
-					data, err := ioutil.ReadFile(strategyFile)
+					data, err := os.ReadFile(strategyFile)
 					if err == nil {
 						var s struct {
 							Prompt string `json:"prompt"`
@@ -114,13 +114,14 @@ func (h *ChatHandler) HandleChat(c *gin.Context) {
 
 				// Pass the language received in the initial request to the common.ChatRequest
 				chatReq := &common.ChatRequest{
-					Message: &goopenai.ChatCompletionMessage{
+					Message: &chat.ChatCompletionMessage{
 						Role:    "user",
 						Content: p.UserInput,
 					},
-					PatternName: p.PatternName,
-					ContextName: p.ContextName,
-					Language:    request.Language, // Pass the language field
+					PatternName:      p.PatternName,
+					ContextName:      p.ContextName,
+					PatternVariables: p.Variables,      // Pass pattern variables
+					Language:         request.Language, // Pass the language field
 				}
 
 				opts := &common.ChatOptions{

restapi/configuration.go

@@ -57,17 +57,18 @@ func (h *ConfigHandler) GetConfig(c *gin.Context) {
 	}
 
 	config := map[string]string{
-		"openai":     os.Getenv("OPENAI_API_KEY"),
-		"anthropic":  os.Getenv("ANTHROPIC_API_KEY"),
-		"groq":       os.Getenv("GROQ_API_KEY"),
-		"mistral":    os.Getenv("MISTRAL_API_KEY"),
-		"gemini":     os.Getenv("GEMINI_API_KEY"),
-		"ollama":     os.Getenv("OLLAMA_URL"),
-		"openrouter": os.Getenv("OPENROUTER_API_KEY"),
-		"silicon":    os.Getenv("SILICON_API_KEY"),
-		"deepseek":   os.Getenv("DEEPSEEK_API_KEY"),
-		"grokai":     os.Getenv("GROKAI_API_KEY"),
-		"lmstudio":   os.Getenv("LM_STUDIO_API_BASE_URL"),
+		"openai":                    os.Getenv("OPENAI_API_KEY"),
+		"anthropic":                 os.Getenv("ANTHROPIC_API_KEY"),
+		"anthropic_use_oauth_login": os.Getenv("ANTHROPIC_USE_OAUTH_LOGIN"),
+		"groq":                      os.Getenv("GROQ_API_KEY"),
+		"mistral":                   os.Getenv("MISTRAL_API_KEY"),
+		"gemini":                    os.Getenv("GEMINI_API_KEY"),
+		"ollama":                    os.Getenv("OLLAMA_URL"),
+		"openrouter":                os.Getenv("OPENROUTER_API_KEY"),
+		"silicon":                   os.Getenv("SILICON_API_KEY"),
+		"deepseek":                  os.Getenv("DEEPSEEK_API_KEY"),
+		"grokai":                    os.Getenv("GROKAI_API_KEY"),
+		"lmstudio":                  os.Getenv("LM_STUDIO_API_BASE_URL"),
 	}
 
 	c.JSON(http.StatusOK, config)
@@ -80,17 +81,18 @@ func (h *ConfigHandler) UpdateConfig(c *gin.Context) {
 	}
 
 	var config struct {
-		OpenAIApiKey     string `json:"openai_api_key"`
-		AnthropicApiKey  string `json:"anthropic_api_key"`
-		GroqApiKey       string `json:"groq_api_key"`
-		MistralApiKey    string `json:"mistral_api_key"`
-		GeminiApiKey     string `json:"gemini_api_key"`
-		OllamaURL        string `json:"ollama_url"`
-		OpenRouterApiKey string `json:"openrouter_api_key"`
-		SiliconApiKey    string `json:"silicon_api_key"`
-		DeepSeekApiKey   string `json:"deepseek_api_key"`
-		GrokaiApiKey     string `json:"grokai_api_key"`
-		LMStudioURL      string `json:"lm_studio_base_url"`
+		OpenAIApiKey          string `json:"openai_api_key"`
+		AnthropicApiKey       string `json:"anthropic_api_key"`
+		AnthropicUseAuthToken string `json:"anthropic_use_auth_token"`
+		GroqApiKey            string `json:"groq_api_key"`
+		MistralApiKey         string `json:"mistral_api_key"`
+		GeminiApiKey          string `json:"gemini_api_key"`
+		OllamaURL             string `json:"ollama_url"`
+		OpenRouterApiKey      string `json:"openrouter_api_key"`
+		SiliconApiKey         string `json:"silicon_api_key"`
+		DeepSeekApiKey        string `json:"deepseek_api_key"`
+		GrokaiApiKey          string `json:"grokai_api_key"`
+		LMStudioURL           string `json:"lm_studio_base_url"`
 	}
 
 	if err := c.ShouldBindJSON(&config); err != nil {
@@ -99,17 +101,18 @@ func (h *ConfigHandler) UpdateConfig(c *gin.Context) {
 	}
 
 	envVars := map[string]string{
-		"OPENAI_API_KEY":         config.OpenAIApiKey,
-		"ANTHROPIC_API_KEY":      config.AnthropicApiKey,
-		"GROQ_API_KEY":           config.GroqApiKey,
-		"MISTRAL_API_KEY":        config.MistralApiKey,
-		"GEMINI_API_KEY":         config.GeminiApiKey,
-		"OLLAMA_URL":             config.OllamaURL,
-		"OPENROUTER_API_KEY":     config.OpenRouterApiKey,
-		"SILICON_API_KEY":        config.SiliconApiKey,
-		"DEEPSEEK_API_KEY":       config.DeepSeekApiKey,
-		"GROKAI_API_KEY":         config.GrokaiApiKey,
-		"LM_STUDIO_API_BASE_URL": config.LMStudioURL,
+		"OPENAI_API_KEY":            config.OpenAIApiKey,
+		"ANTHROPIC_API_KEY":         config.AnthropicApiKey,
+		"ANTHROPIC_USE_OAUTH_LOGIN": config.AnthropicUseAuthToken,
+		"GROQ_API_KEY":              config.GroqApiKey,
+		"MISTRAL_API_KEY":           config.MistralApiKey,
+		"GEMINI_API_KEY":            config.GeminiApiKey,
+		"OLLAMA_URL":                config.OllamaURL,
+		"OPENROUTER_API_KEY":        config.OpenRouterApiKey,
+		"SILICON_API_KEY":           config.SiliconApiKey,
+		"DEEPSEEK_API_KEY":          config.DeepSeekApiKey,
+		"GROKAI_API_KEY":            config.GrokaiApiKey,
+		"LM_STUDIO_API_BASE_URL":    config.LMStudioURL,
 	}
 
 	var envContent strings.Builder

restapi/docs/API_VARIABLES_EXAMPLE.md

@@ -0,0 +1,105 @@
+# REST API Pattern Variables Example
+
+This example demonstrates how to use pattern variables in REST API calls to the `/chat` endpoint.
+
+## Example: Using the `translate` pattern with variables
+
+### Request
+
+```json
+{
+  "prompts": [
+    {
+      "userInput": "Hello my name is Kayvan",
+      "patternName": "translate",
+      "model": "gpt-4o",
+      "vendor": "openai",
+      "contextName": "",
+      "strategyName": "",
+      "variables": {
+        "lang_code": "fr"
+      }
+    }
+  ],
+  "language": "en",
+  "temperature": 0.7,
+  "topP": 0.9,
+  "frequencyPenalty": 0.0,
+  "presencePenalty": 0.0
+}
+```
+
+### Pattern Content
+
+The `translate` pattern contains:
+
+```markdown
+You are an expert translator... translate them as accurately and perfectly as possible into the language specified by its language code {{lang_code}}...
+
+...
+
+- Translate the document as accurately as possible keeping a 1:1 copy of the original text translated to {{lang_code}}.
+
+{{input}}
+```
+
+### How it works
+
+1. The pattern is loaded from `patterns/translate/system.md`
+2. The `{{lang_code}}` variable is replaced with `"fr"` from the variables map
+3. The `{{input}}` placeholder is replaced with `"Hello my name is Kayvan"`
+4. The resulting processed pattern is sent to the AI model
+
+### Expected Result
+
+The AI would receive a prompt asking it to translate "Hello my name is Kayvan" to French (fr), and would respond with something like "Bonjour, je m'appelle Kayvan".
+
+## Testing with curl
+
+```bash
+curl -X POST http://localhost:8080/api/chat \
+  -H "Content-Type: application/json" \
+  -d '{
+    "prompts": [
+      {
+        "userInput": "Hello my name is Kayvan",
+        "patternName": "translate",
+        "model": "gpt-4o",
+        "vendor": "openai",
+        "variables": {
+          "lang_code": "fr"
+        }
+      }
+    ],
+    "temperature": 0.7
+  }'
+```
+
+## Multiple Variables Example
+
+For patterns that use multiple variables:
+
+```json
+{
+  "prompts": [
+    {
+      "userInput": "Analyze this business model",
+      "patternName": "custom_analysis",
+      "model": "gpt-4o",
+      "variables": {
+        "role": "expert consultant",
+        "experience": "15",
+        "focus_areas": "revenue, scalability, market fit",
+        "output_format": "bullet points"
+      }
+    }
+  ]
+}
+```
+
+## Implementation Details
+
+- Variables are passed in the `variables` field as a key-value map
+- Variables are processed using Go's template system
+- The `{{input}}` variable is automatically handled and should not be included in the variables map
+- Variables support the same features as CLI variables (plugins, extensions, etc.)

restapi/ollama.go

@@ -103,7 +103,6 @@ func ServeOllama(registry *core.PluginRegistry, address string, version string)
 	r.GET("/api/tags", typeConversion.ollamaTags)
 	r.GET("/api/version", func(c *gin.Context) {
 		c.Data(200, "application/json", []byte(fmt.Sprintf("{\"%s\"}", version)))
-		return
 	})
 	r.POST("/api/chat", typeConversion.ollamaChat)
 
@@ -262,15 +261,10 @@ func (f APIConvert) ollamaChat(c *gin.Context) {
 			c.JSON(http.StatusInternalServerError, gin.H{"error": err})
 			return
 		}
-		for _, bytein := range marshalled {
-			res = append(res, bytein)
-		}
-		for _, bytebreak := range []byte("\n") {
-			res = append(res, bytebreak)
-		}
+		res = append(res, marshalled...)
+		res = append(res, '\n')
 	}
 	c.Data(200, "application/json", res)
 
 	//c.JSON(200, forwardedResponse)
-	return
 }

restapi/patterns.go

@@ -15,20 +15,70 @@ type PatternsHandler struct {
 
 // NewPatternsHandler creates a new PatternsHandler
 func NewPatternsHandler(r *gin.Engine, patterns *fsdb.PatternsEntity) (ret *PatternsHandler) {
-	ret = &PatternsHandler{
-		StorageHandler: NewStorageHandler(r, "patterns", patterns), patterns: patterns}
+	// Create a storage handler but don't register any routes yet
+	storageHandler := &StorageHandler[fsdb.Pattern]{storage: patterns}
+	ret = &PatternsHandler{StorageHandler: storageHandler, patterns: patterns}
 
-	// TODO: Add custom, replacement routes here
-	//r.GET("/patterns/:name", ret.Get)
+	// Register routes manually - use custom Get for patterns, others from StorageHandler
+	r.GET("/patterns/:name", ret.Get)                       // Custom method with variables support
+	r.GET("/patterns/names", ret.GetNames)                  // From StorageHandler
+	r.DELETE("/patterns/:name", ret.Delete)                 // From StorageHandler
+	r.GET("/patterns/exists/:name", ret.Exists)             // From StorageHandler
+	r.PUT("/patterns/rename/:oldName/:newName", ret.Rename) // From StorageHandler
+	r.POST("/patterns/:name", ret.Save)                     // From StorageHandler
+	// Add POST route for patterns with variables in request body
+	r.POST("/patterns/:name/apply", ret.ApplyPattern)
 	return
 }
 
-// Get handles the GET /patterns/:name route
+// Get handles the GET /patterns/:name route - returns raw pattern without variable processing
 func (h *PatternsHandler) Get(c *gin.Context) {
 	name := c.Param("name")
-	variables := make(map[string]string) // Assuming variables are passed somehow
-	input := ""                          // Assuming input is passed somehow
-	pattern, err := h.patterns.GetApplyVariables(name, variables, input)
+
+	// Get the raw pattern content without any variable processing
+	content, err := h.patterns.Load(name + "/" + h.patterns.SystemPatternFile)
+	if err != nil {
+		c.JSON(http.StatusInternalServerError, err.Error())
+		return
+	}
+
+	// Return raw pattern in the same format as the processed patterns
+	pattern := &fsdb.Pattern{
+		Name:        name,
+		Description: "",
+		Pattern:     string(content),
+	}
+	c.JSON(http.StatusOK, pattern)
+}
+
+// PatternApplyRequest represents the request body for applying a pattern
+type PatternApplyRequest struct {
+	Input     string            `json:"input"`
+	Variables map[string]string `json:"variables,omitempty"`
+}
+
+// ApplyPattern handles the POST /patterns/:name/apply route
+func (h *PatternsHandler) ApplyPattern(c *gin.Context) {
+	name := c.Param("name")
+
+	var request PatternApplyRequest
+	if err := c.ShouldBindJSON(&request); err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+		return
+	}
+
+	// Merge query parameters with request body variables (body takes precedence)
+	variables := make(map[string]string)
+	for key, values := range c.Request.URL.Query() {
+		if len(values) > 0 {
+			variables[key] = values[0]
+		}
+	}
+	for key, value := range request.Variables {
+		variables[key] = value
+	}
+
+	pattern, err := h.patterns.GetApplyVariables(name, variables, request.Input)
 	if err != nil {
 		c.JSON(http.StatusInternalServerError, err.Error())
 		return

restapi/serve.go

@@ -26,6 +26,7 @@ func Serve(registry *core.PluginRegistry, address string, apiKey string) (err er
 	NewContextsHandler(r, fabricDb.Contexts)
 	NewSessionsHandler(r, fabricDb.Sessions)
 	NewChatHandler(r, registry, fabricDb)
+	NewYouTubeHandler(r, registry)
 	NewConfigHandler(r, fabricDb)
 	NewModelsHandler(r, registry.VendorManager)
 	NewStrategiesHandler(r)

restapi/strategies.go

@@ -2,7 +2,6 @@ package restapi
 
 import (
 	"encoding/json"
-	"io/ioutil"
 	"net/http"
 	"os"
 	"path/filepath"
@@ -23,7 +22,7 @@ func NewStrategiesHandler(r *gin.Engine) {
 	r.GET("/strategies", func(c *gin.Context) {
 		strategiesDir := filepath.Join(os.Getenv("HOME"), ".config", "fabric", "strategies")
 
-		files, err := ioutil.ReadDir(strategiesDir)
+		files, err := os.ReadDir(strategiesDir)
 		if err != nil {
 			c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to read strategies directory"})
 			return
@@ -37,7 +36,7 @@ func NewStrategiesHandler(r *gin.Engine) {
 			}
 
 			fullPath := filepath.Join(strategiesDir, file.Name())
-			data, err := ioutil.ReadFile(fullPath)
+			data, err := os.ReadFile(fullPath)
 			if err != nil {
 				continue
 			}

restapi/youtube.go

@@ -0,0 +1,70 @@
+package restapi
+
+import (
+	"net/http"
+
+	"github.com/danielmiessler/fabric/core"
+	"github.com/danielmiessler/fabric/plugins/tools/youtube"
+	"github.com/gin-gonic/gin"
+)
+
+type YouTubeHandler struct {
+	yt *youtube.YouTube
+}
+
+type YouTubeRequest struct {
+	URL        string `json:"url"`
+	Language   string `json:"language"`
+	Timestamps bool   `json:"timestamps"`
+}
+
+type YouTubeResponse struct {
+	Transcript string `json:"transcript"`
+	Title      string `json:"title"`
+}
+
+func NewYouTubeHandler(r *gin.Engine, registry *core.PluginRegistry) *YouTubeHandler {
+	handler := &YouTubeHandler{yt: registry.YouTube}
+	r.POST("/youtube/transcript", handler.Transcript)
+	return handler
+}
+
+func (h *YouTubeHandler) Transcript(c *gin.Context) {
+	var req YouTubeRequest
+	if err := c.BindJSON(&req); err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"error": "invalid request"})
+		return
+	}
+	if req.URL == "" {
+		c.JSON(http.StatusBadRequest, gin.H{"error": "url is required"})
+		return
+	}
+	language := req.Language
+	if language == "" {
+		language = "en"
+	}
+
+	var videoID, playlistID string
+	var err error
+	if videoID, playlistID, err = h.yt.GetVideoOrPlaylistId(req.URL); err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+		return
+	}
+	if videoID == "" && playlistID != "" {
+		c.JSON(http.StatusBadRequest, gin.H{"error": "URL is a playlist, not a video"})
+		return
+	}
+
+	var transcript string
+	if req.Timestamps {
+		transcript, err = h.yt.GrabTranscriptWithTimestamps(videoID, language)
+	} else {
+		transcript, err = h.yt.GrabTranscript(videoID, language)
+	}
+	if err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+		return
+	}
+
+	c.JSON(http.StatusOK, YouTubeResponse{Transcript: transcript, Title: videoID})
+}

version.go

@@ -1,3 +1,3 @@
 package main
 
-var version = "v1.4.199"
+var version = "v1.4.232"

web/pnpm-lock.yaml

@@ -608,6 +608,9 @@ packages:
   '@types/estree@1.0.7':
     resolution: {integrity: sha512-w28IoSUCJpidD/TGviZwwMJckNESJZXFu7NBZ5YJ4mEUnNraUn9Pm8HSZm/jDF1pDWYKspWE7oVphigUPRakIQ==}
 
+  '@types/estree@1.0.8':
+    resolution: {integrity: sha512-dWHzHa2WqEXI/O1E9OjrocMTKJl2mSrEolh1Iomrv6U+JuNwaHXsXx9bLu5gG7BUWFIN0skIQJQ/L1rIex4X6w==}
+
   '@types/hast@3.0.4':
     resolution: {integrity: sha512-WPs+bbQw5aCj+x6laNGWLH3wviHtoCv/P3+otBhbOhJgG8qtpdAMlTCxLtsTWA7LH1Oh/bFCHsBn0TPS5m30EQ==}
 
@@ -654,6 +657,11 @@ packages:
     engines: {node: '>=0.4.0'}
     hasBin: true
 
+  acorn@8.15.0:
+    resolution: {integrity: sha512-NZyJarBfL7nWwIq+FDL6Zp/yHEhePMNnnJ0y3qfieCrmNvYct8uvtiV41UvlSe6apAfk0fY1FbWx+NwfmpvtTg==}
+    engines: {node: '>=0.4.0'}
+    hasBin: true
+
   agent-base@6.0.2:
     resolution: {integrity: sha512-RZNwNclF7+MS/8bDg70amg32dyeZGZxiDuQmZxKLAlQjr3jGyLx+4Kkk58UO7D2QdgFIQCovuSuZESne6RG6XQ==}
     engines: {node: '>= 6.0.0'}
@@ -746,11 +754,11 @@ packages:
     resolution: {integrity: sha512-Ceh+7ox5qe7LJuLHoY0feh3pHuUDHAcRUeyL2VYghZwfpkNIy/+8Ocg0a3UuSoYzavmylwuLWQOf3hl0jjMMIw==}
     engines: {node: '>=8'}
 
-  brace-expansion@1.1.11:
-    resolution: {integrity: sha512-iCuPHDFgrHX7H2vEI/5xpz07zSHB00TpugqhmYtVmMO6518mCuRMoOYFldEBl0g187ufozdaHgWKcYFb61qGiA==}
+  brace-expansion@1.1.12:
+    resolution: {integrity: sha512-9T9UjW3r0UW5c1Q7GTwllptXwhvYmEzFhzMfZ9H7FQWt+uZePjZPjBP/W1ZEyZ1twGWom5/56TF4lPcqjnDHcg==}
 
-  brace-expansion@2.0.1:
-    resolution: {integrity: sha512-XnAIvQ8eM+kC6aULx6wuQiwVsnzsi9d3WxzV3FpWTGA19F621kwdbsAcFKXgKUHZWsy+mY6iL1sHTxWEFCytDA==}
+  brace-expansion@2.0.2:
+    resolution: {integrity: sha512-Jt0vHyM+jmUBqojB7E1NIYadt0vI0Qxjxd2TErW94wDz+E2LAm5vKMXXwg6ZZBTHPuUlDgQHKXvjGBdfcF1ZDQ==}
 
   braces@3.0.3:
     resolution: {integrity: sha512-yQbXgO/OSZVD2IsiLlro+7Hf6Q18EJrKSEsdoMzKePKXct3gvD8oLcOQdIzGupr5Fj+EDe8gO/lxc1BzfMpxvA==}
@@ -1019,16 +1027,16 @@ packages:
     resolution: {integrity: sha512-dOt21O7lTMhDM+X9mB4GX+DZrZtCUJPL/wlcTqxyrx5IvO0IYtILdtrQGQp+8n5S0gwSVmOf9NQrjMOgfQZlIg==}
     engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0}
 
-  eslint-scope@8.3.0:
-    resolution: {integrity: sha512-pUNxi75F8MJ/GdeKtVLSbYg4ZI34J6C0C7sbL4YOp2exGwen7ZsuBqKzUhXd0qMQ362yET3z+uPwKeg/0C2XCQ==}
+  eslint-scope@8.4.0:
+    resolution: {integrity: sha512-sNXOfKCn74rt8RICKMvJS7XKV/Xk9kA7DyJr8mJik3S7Cwgy3qlkkmyS2uQB3jiJg6VNdZd/pDBJu0nvG2NlTg==}
     engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
 
   eslint-visitor-keys@3.4.3:
     resolution: {integrity: sha512-wpc+LXeiyiisxPlEkUzU6svyS1frIO3Mgxj1fdy7Pm8Ygzguax2N3Fa/D/ag1WqbOprdI+uY6wMUl8/a2G+iag==}
     engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0}
 
-  eslint-visitor-keys@4.2.0:
-    resolution: {integrity: sha512-UyLnSehNt62FFhSwjZlHmeokpRK59rcz29j+F1/aDgbkbRTk7wIc9XzdoasMUbRNKDM0qQt/+BJ4BrpFeABemw==}
+  eslint-visitor-keys@4.2.1:
+    resolution: {integrity: sha512-Uhdk5sfqcee/9H/rCOJikYz67o0a2Tw2hGRPOG2Y1R2dg7brRe1uG0yaNQDHu+TO/uQPF/5eCapvYSmHUjt7JQ==}
     engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
 
   eslint@9.17.0:
@@ -1047,8 +1055,8 @@ packages:
   esm-env@1.2.2:
     resolution: {integrity: sha512-Epxrv+Nr/CaL4ZcFGPJIYLWFom+YeV1DqMLHJoEd9SYRxNbaFruBwfEX/kkHUJf55j2+TUbmDcmuilbP1TmXHA==}
 
-  espree@10.3.0:
-    resolution: {integrity: sha512-0QYC8b24HWY8zjRnDTL6RiHfDbAWn63qb4LMj1Z4b076A4une81+z03Kg7l7mn/48PUTqoLptSXez8oknU8Clg==}
+  espree@10.4.0:
+    resolution: {integrity: sha512-j6PAQ2uUr79PZhBjP5C5fhl8e39FmRnOjsD5lGnWrFU8i2G776tBK7+nP8KuQUTTyAZUwfQqXAgrVH5MbH9CYQ==}
     engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
 
   espree@9.6.1:
@@ -2472,7 +2480,7 @@ snapshots:
     dependencies:
       ajv: 6.12.6
       debug: 4.4.1
-      espree: 10.3.0
+      espree: 10.4.0
       globals: 14.0.0
       ignore: 5.3.2
       import-fresh: 3.3.1
@@ -2747,6 +2755,8 @@ snapshots:
 
   '@types/estree@1.0.7': {}
 
+  '@types/estree@1.0.8': {}
+
   '@types/hast@3.0.4':
     dependencies:
       '@types/unist': 3.0.3
@@ -2782,8 +2792,14 @@ snapshots:
     dependencies:
       acorn: 8.14.1
 
+  acorn-jsx@5.3.2(acorn@8.15.0):
+    dependencies:
+      acorn: 8.15.0
+
   acorn@8.14.1: {}
 
+  acorn@8.15.0: {}
+
   agent-base@6.0.2:
     dependencies:
       debug: 4.4.1
@@ -2866,12 +2882,12 @@ snapshots:
 
   binary-extensions@2.3.0: {}
 
-  brace-expansion@1.1.11:
+  brace-expansion@1.1.12:
     dependencies:
       balanced-match: 1.0.2
       concat-map: 0.0.1
 
-  brace-expansion@2.0.1:
+  brace-expansion@2.0.2:
     dependencies:
       balanced-match: 1.0.2
 
@@ -3146,14 +3162,14 @@ snapshots:
       esrecurse: 4.3.0
       estraverse: 5.3.0
 
-  eslint-scope@8.3.0:
+  eslint-scope@8.4.0:
     dependencies:
       esrecurse: 4.3.0
       estraverse: 5.3.0
 
   eslint-visitor-keys@3.4.3: {}
 
-  eslint-visitor-keys@4.2.0: {}
+  eslint-visitor-keys@4.2.1: {}
 
   eslint@9.17.0(jiti@1.21.7):
     dependencies:
@@ -3167,16 +3183,16 @@ snapshots:
       '@humanfs/node': 0.16.6
       '@humanwhocodes/module-importer': 1.0.1
       '@humanwhocodes/retry': 0.4.3
-      '@types/estree': 1.0.7
+      '@types/estree': 1.0.8
       '@types/json-schema': 7.0.15
       ajv: 6.12.6
       chalk: 4.1.2
       cross-spawn: 7.0.6
       debug: 4.4.1
       escape-string-regexp: 4.0.0
-      eslint-scope: 8.3.0
-      eslint-visitor-keys: 4.2.0
-      espree: 10.3.0
+      eslint-scope: 8.4.0
+      eslint-visitor-keys: 4.2.1
+      espree: 10.4.0
       esquery: 1.6.0
       esutils: 2.0.3
       fast-deep-equal: 3.1.3
@@ -3200,11 +3216,11 @@ snapshots:
 
   esm-env@1.2.2: {}
 
-  espree@10.3.0:
+  espree@10.4.0:
     dependencies:
-      acorn: 8.14.1
-      acorn-jsx: 5.3.2(acorn@8.14.1)
-      eslint-visitor-keys: 4.2.0
+      acorn: 8.15.0
+      acorn-jsx: 5.3.2(acorn@8.15.0)
+      eslint-visitor-keys: 4.2.1
 
   espree@9.6.1:
     dependencies:
@@ -3710,11 +3726,11 @@ snapshots:
 
   minimatch@3.1.2:
     dependencies:
-      brace-expansion: 1.1.11
+      brace-expansion: 1.1.12
 
   minimatch@9.0.5:
     dependencies:
-      brace-expansion: 2.0.1
+      brace-expansion: 2.0.2
 
   minimist@1.2.8: {}
 

web/src/lib/components/chat/DropdownGroup.svelte

@@ -3,8 +3,11 @@
   import Models from "./Models.svelte";
   import ModelConfig from "./ModelConfig.svelte";
   import { Select } from "$lib/components/ui/select";
+  import { Input } from "$lib/components/ui/input";
+  import { Label } from "$lib/components/ui/label";
   import { languageStore } from '$lib/store/language-store';
   import { strategies, selectedStrategy, fetchStrategies } from '$lib/store/strategy-store';
+  import { patternVariables } from '$lib/store/pattern-store';
   import { onMount } from 'svelte';
 
   const languages = [
@@ -18,6 +21,25 @@
     { code: 'it', name: 'Italian' }
   ];
 
+  let variablesJsonString = '';
+
+  // Parse JSON string and update variables store
+  function updateVariables() {
+    try {
+      if (variablesJsonString.trim() === '') {
+        patternVariables.set({});
+      } else {
+        const parsed = JSON.parse(variablesJsonString);
+        if (typeof parsed === 'object' && parsed !== null && !Array.isArray(parsed)) {
+          patternVariables.set(parsed);
+        }
+      }
+    } catch (e) {
+      // Don't update the store if JSON is invalid - just ignore the error
+      // This allows partial typing without breaking
+    }
+  }
+
   onMount(() => {
     fetchStrategies();
   });
@@ -33,7 +55,7 @@
       <Models />
     </div>
     <div>
-      <Select 
+      <Select
         bind:value={$languageStore}
         class="bg-primary-800/30 border-none hover:bg-primary-800/40 transition-colors"
       >
@@ -43,7 +65,7 @@
       </Select>
     </div>
     <div>
-      <Select 
+      <Select
         bind:value={$selectedStrategy}
         class="bg-primary-800/30 border-none hover:bg-primary-800/40 transition-colors"
       >
@@ -53,8 +75,19 @@
         {/each}
       </Select>
     </div>
+    <div>
+      <Label for="pattern-variables" class="text-xs text-white/70 mb-1 block">Pattern Variables (JSON)</Label>
+      <textarea
+        id="pattern-variables"
+        bind:value={variablesJsonString}
+        on:input={updateVariables}
+        placeholder="{`{\"lang_code\": \"fr\", \"role\": \"expert\"}`}"
+        class="w-full h-20 px-3 py-2 text-sm bg-primary-800/30 border-none rounded-md hover:bg-primary-800/40 transition-colors text-white placeholder-white/50 resize-none focus:ring-1 focus:ring-white/20 focus:outline-none"
+        style="font-family: 'JetBrains Mono', 'Fira Code', 'Consolas', monospace;"
+      ></textarea>
+    </div>
   </div>
-  
+
   <!-- Right side - Model Config -->
   <div class="w-[65%]">
     <ModelConfig />

web/src/lib/interfaces/chat-interface.ts

@@ -8,6 +8,7 @@ export interface ChatPrompt {
   model: string;
   patternName?: string;
   strategyName?: string; // Optional strategy name to prepend strategy prompt
+  variables?: { [key: string]: string }; // Pattern variables
 }
 
 export interface ChatConfig {

web/src/lib/services/ChatService.ts

@@ -6,7 +6,7 @@ import type {
 } from '$lib/interfaces/chat-interface';
 import { get } from 'svelte/store';
 import { modelConfig } from '$lib/store/model-store';
-import { systemPrompt, selectedPatternName } from '$lib/store/pattern-store';
+import { systemPrompt, selectedPatternName, patternVariables } from '$lib/store/pattern-store';
 import { chatConfig } from '$lib/store/chat-config';
 import { messageStore } from '$lib/store/chat-store';
 import { languageStore } from '$lib/store/language-store';
@@ -75,48 +75,46 @@ export class ChatService {
 
   private cleanPatternOutput(content: string): string {
     // Remove markdown fence if present
-    content = content.replace(/^```markdown\n/, '');
-    content = content.replace(/\n```$/, '');
-    
+    let cleaned = content.replace(/^```markdown\n/, '');
+    cleaned = cleaned.replace(/\n```$/, '');
+
     // Existing cleaning
-    content = content.replace(/^# OUTPUT\s*\n/, '');
-    content = content.replace(/^\s*\n/, '');
-    content = content.replace(/\n\s*$/, '');
-    content = content.replace(/^#\s+([A-Z]+):/gm, '$1:');
-    content = content.replace(/^#\s+([A-Z]+)\s*$/gm, '$1');
-    content = content.trim();
-    content = content.replace(/\n{3,}/g, '\n\n');
-    return content;
+    cleaned = cleaned.replace(/^# OUTPUT\s*\n/, '');
+    cleaned = cleaned.replace(/^\s*\n/, '');
+    cleaned = cleaned.replace(/\n\s*$/, '');
+    cleaned = cleaned.replace(/^#\s+([A-Z]+):/gm, '$1:');
+    cleaned = cleaned.replace(/^#\s+([A-Z]+)\s*$/gm, '$1');
+    cleaned = cleaned.trim();
+    cleaned = cleaned.replace(/\n{3,}/g, '\n\n');
+    return cleaned;
   }
-  
-      
-      
-      private createMessageStream(reader: ReadableStreamDefaultReader<Uint8Array>): ReadableStream<StreamResponse> {
-          let buffer = '';
-          const cleanPatternOutput = this.cleanPatternOutput.bind(this);
-          const language = get(languageStore);
-          const validator = new LanguageValidator(language);
-      
-          const processResponse = (response: StreamResponse) => {
-              const pattern = get(selectedPatternName);
-              
-              if (pattern) {
-                  response.content = cleanPatternOutput(response.content);
-                  // Simplified format determination - always markdown unless mermaid
-                  const isMermaid = [
-                      'graph TD', 'gantt', 'flowchart', 
-                      'sequenceDiagram', 'classDiagram', 'stateDiagram'
-                  ].some(starter => response.content.trim().startsWith(starter));
-                  
-                  response.format = isMermaid ? 'mermaid' : 'markdown';
-              }
-      
-              if (response.type === 'content') {
-                  response.content = validator.enforceLanguage(response.content);
-              }
-      
-              return response;
-          };
+
+  private createMessageStream(reader: ReadableStreamDefaultReader<Uint8Array>): ReadableStream<StreamResponse> {
+      let buffer = '';
+      const cleanPatternOutput = this.cleanPatternOutput.bind(this);
+      const language = get(languageStore);
+      const validator = new LanguageValidator(language);
+
+      const processResponse = (response: StreamResponse) => {
+          const pattern = get(selectedPatternName);
+
+          if (pattern) {
+              response.content = cleanPatternOutput(response.content);
+              // Simplified format determination - always markdown unless mermaid
+              const isMermaid = [
+                  'graph TD', 'gantt', 'flowchart',
+                  'sequenceDiagram', 'classDiagram', 'stateDiagram'
+              ].some(starter => response.content.trim().startsWith(starter));
+
+              response.format = isMermaid ? 'mermaid' : 'markdown';
+          }
+
+          if (response.type === 'content') {
+              response.content = validator.enforceLanguage(response.content);
+          }
+
+          return response;
+      };
       return new ReadableStream({
           async start(controller) {
               try {
@@ -162,18 +160,18 @@ export class ChatService {
           }
       });
   }
- 
+
   private createChatPrompt(userInput: string, systemPromptText?: string): ChatPrompt {
     const config = get(modelConfig);
     const language = get(languageStore);
-    
-    const languageInstruction = language !== 'en' 
+
+    const languageInstruction = language !== 'en'
         ? `You MUST respond in ${language} language. All output must be in ${language}. `
         // ? `You MUST respond in ${language} language. ALL output, including section headers, titles, and formatting, MUST be translated into ${language}.  It is CRITICAL that you translate ALL headers, such as SUMMARY, IDEAS, QUOTES, TAKEAWAYS, MAIN POINTS, etc., into ${language}. Maintain markdown formatting in the response. Do not output any English headers.`
         : '';
-    
+
     const finalSystemPrompt = languageInstruction + (systemPromptText ?? get(systemPrompt));
-    
+
     const finalUserInput = language !== 'en'
         ? `${userInput}\n\nIMPORTANT: Respond in ${language} language only.`
         : userInput;
@@ -183,15 +181,11 @@ export class ChatService {
         systemPrompt: finalSystemPrompt,
         model: config.model,
         patternName: get(selectedPatternName),
-        strategyName: get(selectedStrategy) // Add selected strategy to prompt
+        strategyName: get(selectedStrategy), // Add selected strategy to prompt
+        variables: get(patternVariables) // Add pattern variables
     };
 }
 
-
-  
-    
-
-
   public async createChatRequest(userInput: string, systemPromptText?: string, isPattern: boolean = false): Promise<ChatRequest> {
     const prompt = this.createChatPrompt(userInput, systemPromptText);
     const config = get(chatConfig);
@@ -221,16 +215,16 @@ export class ChatService {
     onError: (error: Error) => void
   ): Promise<void> {
     const reader = stream.getReader();
-  
+
     try {
       while (true) {
         const { done, value } = await reader.read();
         if (done) break;
-  
+
         if (value.type === 'error') {
           throw new ChatError(value.content, 'STREAM_CONTENT_ERROR');
         }
-  
+
         if (value.type === 'content') {
           onContent(value.content, value);
         }
@@ -239,11 +233,7 @@ export class ChatService {
       onError(error instanceof ChatError ? error : new ChatError('Stream processing error', 'STREAM_ERROR', error));
     } finally {
       reader.releaseLock();
-      
+
     }
   }
-  
-  
-   
-    
 }

web/src/lib/services/transcriptService.ts

@@ -1,5 +1,5 @@
-import { get } from 'svelte/store';
 import { languageStore } from '$lib/store/language-store';
+import { get } from 'svelte/store';
 
 export interface TranscriptResponse {
   transcript: string;
@@ -18,18 +18,18 @@ export async function getTranscript(url: string): Promise<TranscriptResponse> {
     console.log('\n=== YouTube Transcript Service Start ===');
     console.log('1. Request details:', {
       url,
-      endpoint: '/chat',
+      endpoint: '/api/youtube/transcript',
       method: 'POST',
       isYouTubeURL: url.includes('youtube.com') || url.includes('youtu.be'),
       originalLanguage
     });
 
-    const response = await fetch('/chat', {
+    const response = await fetch('/api/youtube/transcript', {
       method: 'POST',
       headers: {
         'Content-Type': 'application/json',
       },
-      body: JSON.stringify({ 
+      body: JSON.stringify({
         url,
         language: originalLanguage // Pass original language to server
       })

web/src/lib/store/pattern-store.ts

@@ -15,11 +15,11 @@ export const patterns = derived(
     return $allPatterns.filter(p => {
       // Keep all patterns if no language is selected
       if (!$language) return true;
-      
+
       // Check if pattern has a language prefix (e.g., en_, fr_)
       const match = p.Name.match(/^([a-z]{2})_/);
       if (!match) return true; // Keep patterns without language prefix
-      
+
       // Only filter out patterns that have a different language prefix
       const patternLang = match[1];
       return patternLang === $language;
@@ -30,6 +30,9 @@ export const patterns = derived(
 export const systemPrompt = writable<string>('');
 export const selectedPatternName = writable<string>('');
 
+// Pattern variables store
+export const patternVariables = writable<Record<string, string>>({});
+
 export const setSystemPrompt = (prompt: string) => {
   console.log('Setting system prompt:', prompt);
   systemPrompt.set(prompt);
@@ -60,13 +63,13 @@ export const patternAPI = {
           const patternResponse = await fetch(`/api/patterns/${pattern}`);
           const patternData = await patternResponse.json();
           console.log(`Pattern ${pattern} content length:`, patternData.Pattern?.length || 0);
-          
+
           // Find matching description from JSON
           const desc = descriptions.find(d => d.patternName === pattern);
           if (!desc) {
             console.warn(`No description found for pattern: ${pattern}`);
           }
-          
+
           return {
             Name: pattern,
             Description: desc?.description || pattern.charAt(0).toUpperCase() + pattern.slice(1),

web/static/data/pattern_descriptions.json

@@ -1634,8 +1634,8 @@
       ]
     },
     {
-      "patternName": "write_essay",
-      "description": "Create essays with thesis statements and arguments.",
+      "patternName": "write_essay_pg",
+      "description": "Create essays with thesis statements and arguments in the style of Paul Graham.",
       "tags": [
         "WRITING",
         "RESEARCH",
@@ -1703,22 +1703,22 @@
     {
       "patternName": "analyze_bill",
       "description": "Analyze a legislative bill and implications.",
-      "tags": [ 
+      "tags": [
         "ANALYSIS",
         "BILL"
       ]
     },
     {
       "patternName": "analyze_bill_short",
-      "description": "Consended - Analyze a legislative bill and implications.",
-      "tags": [ 
+      "description": "Condensed - Analyze a legislative bill and implications.",
+      "tags": [
         "ANALYSIS",
         "BILL"
       ]
     },
     {
       "patternName": "create_coding_feature",
-      "description": "[Description pending]",
+      "description": "Generate secure and composable code features using latest technology and best practices.",
       "tags": [
         "DEVELOPMENT"
       ]
@@ -1774,6 +1774,76 @@
       "tags": [
         "SUMMARIZE"
       ]
+    },
+    {
+      "patternName": "analyze_paper_simple",
+      "description": "Analyze research papers to determine primary findings and assess scientific rigor.",
+      "tags": [
+        "ANALYSIS",
+        "RESEARCH",
+        "WRITING"
+      ]
+    },
+    {
+      "patternName": "analyze_terraform_plan",
+      "description": "Analyze Terraform plans for infrastructure changes, security risks, and cost implications.",
+      "tags": [
+        "ANALYSIS",
+        "DEVOPS"
+      ]
+    },
+    {
+      "patternName": "create_mnemonic_phrases",
+      "description": "Create memorable mnemonic sentences using given words in exact order for memory aids.",
+      "tags": [
+        "CREATIVITY",
+        "LEARNING"
+      ]
+    },
+    {
+      "patternName": "summarize_board_meeting",
+      "description": "Convert board meeting transcripts into formal meeting notes for corporate records.",
+      "tags": [
+        "ANALYSIS",
+        "BUSINESS"
+      ]
+    },
+    {
+      "patternName": "write_essay",
+      "description": "Write essays on given topics in the distinctive style of specified authors.",
+      "tags": [
+        "WRITING",
+        "CREATIVITY"
+      ]
+    },
+    {
+      "patternName": "extract_alpha",
+      "description": "Extracts the most novel and surprising ideas (\"alpha\") from content, inspired by information theory.",
+      "tags": [
+        "EXTRACT",
+        "ANALYSIS",
+        "CR THINKING",
+        "WISDOM"
+      ]
+    },
+    {
+      "patternName": "extract_mcp_servers",
+      "description": "Analyzes content to identify and extract detailed information about Model Context Protocol (MCP) servers.",
+      "tags": [
+        "ANALYSIS",
+        "EXTRACT",
+        "DEVELOPMENT",
+        "AI"
+      ]
+    },
+    {
+      "patternName": "review_code",
+      "description": "Performs a comprehensive code review, providing detailed feedback on correctness, security, and performance.",
+      "tags": [
+        "DEVELOPMENT",
+        "REVIEW",
+        "SECURITY"
+      ]
     }
   ]
-}
+}