Free Vision Skill: visual evidence for text agents

Image → Vision model → Long description → Main model

Vision model output: "This image shows a terminal window containing
a Python error message. The error type is ModuleNotFoundError, and
the message says that the module named 'requests' could not be found.
The error occurs on line 42 of /Users/user/project/app.py..."
→ About 3000 tokens

VEP/1|src=zhipu/glm-4.6v-flash|m=error|a="ModuleNotFoundError: No module named 'requests'"|t="app.py:42"|c=0.97
→ About 130 tokens

Image + Question
  ↓
Free vision API, extracting only facts needed for the current task
  ↓
Compress into a VEP, or Visual Evidence Packet
  ↓
DeepSeek / Codex / Claude Code / OpenCode continues reasoning

VEP/1|src=zhipu/glm-4.6v-flash|m=error|
a="Cannot find module ethers"|
t="src/app.ts:42"|
e=[dependency error]|
c=0.97

flowchart TB
    C[CLI commands] --> P[Provider registry]
    P --> K[Cache lookup]
    K --> Q[Request pool and rate limit]
    Q --> V[Vision API]
    V --> E[VEP encoder]
    E --> O[Compact evidence packet]

// Configuration for 13 providers
export function resolveProviderOrder(requested: string, region: Region): ProviderConfig[] {
	if (requested !== 'auto') return [getProvider(requested)];

	// Automatic fallback: prefer the same region, then use fallback providers
	const preferred = registry.providers
		.filter((p) => p.region === region)
		.sort((a, b) => a.priority - b.priority);

	const fallback = registry.providers
		.filter((p) => p.region !== region)
		.sort((a, b) => a.priority - b.priority);

	return [...preferred, ...fallback];
}

class RequestPool<T> {
	// Retry with exponential backoff
	private async execute(item): Promise<void> {
		for (let attempt = 0; attempt <= maxRetries; attempt++) {
			try {
				const value = await this.withTimeout(fn(), timeoutMs);
				return resolve({ success: true, value });
			} catch (error) {
				// Exponential backoff: 1000ms → 2000ms → 4000ms
				const delay = Math.min(baseDelayMs * Math.pow(2, attempt), maxDelayMs);
				await sleep(delay);
			}
		}
	}
}

export function toVep(result: VisionResult, maxChars: number): string {
	const parts = [
		'VEP/1',
		`src=${result.provider}/${result.model}`,
		`m=${result.mode}`,
		result.answer ? `a="${result.answer}"` : '',
		result.text ? `t="${result.text}"` : '',
		result.issues?.length ? `e=[${result.issues.join(',')}]` : '',
		`c=${result.confidence?.toFixed(2)}`
	]
		.filter(Boolean)
		.join('|');

	return compact.slice(0, maxChars);
}

// Serial checks, each with a 5s timeout
for (const provider of providers) {
	await checkProviderHealth(provider); // 5s each
	await sleep(1000); // Delay between batches
}
// 13 providers × 5s = 65s

// Check concurrent batches
const batchSize = 3;
for (let i = 0; i < providers.length; i += batchSize) {
	const batch = providers.slice(i, i + batchSize);
	await Promise.all(batch.map((p) => checkProviderHealth(p)));
	await sleep(500); // Delay between batches
}
// 13 providers: [3 + 3 + 3 + 1] = ~2s

// Local example: 65s -> ~2s

TTL: 24 hours
Maximum entries: 1000
LRU eviction: least accessed first

Hit Rate:     87.5% (7/8)
Misses:       1
Evictions:    0
Size:         8 entries

{
  maxConcurrency: 3,    // Maximum concurrency
  timeoutMs: 30000,     // Timeout
  maxRetries: 2,        // Maximum retries
  baseDelayMs: 1000,    // Base delay
  maxDelayMs: 10000     // Maximum delay
}

Attempt 1: Failure → Delay 1000ms
Attempt 2: Failure → Delay 2000ms
Attempt 3: Failure → Give up (total: 3000ms)

free-vision see --image ./error.png \
  --question "Extract only the error message and line number"

VEP/1|src=zhipu/glm-4.6v-flash|m=error|
a="Cannot find module 'lodash'"|
t="webpack.config.js:15"|
e=[module resolution error]|
c=0.98

free-vision see --image ./ui-screenshot.png \
  --question "List all clipped, overlapping, or disabled UI elements"

VEP/1|src=zhipu/glm-4.6v-flash|m=ui|
o=[{name:"Submit",issue:"disabled"},{name:"Avatar",issue:"clipped"}]|
c=0.95

free-vision see --image ./table.png \
  --question "Extract all text and the table structure"

VEP/1|src=zhipu/glm-4.6v-flash|m=ocr|
a="Q3 sales report"|
t=["Product","Sales","Growth rate"],["A",12000,"15%"],["B",8500,"8%"]|
c=0.92

free-vision see --image ./chart.png \
  --question "Return only the chart title, trend, and three key values"

VEP/1|src=zhipu/glm-4.6v-flash|m=chart|
a="Monthly revenue growth"|
v=[45200,58300,72100]|
c=0.96

free-vision see --image ./screenshot.png --auto-crop \
  --question "Extract only the error message"

✂️  Cropped: 400x300 → 369x58
   Reduction: 82%
   Saved to: ./screenshot.cropped.png

# The Claude Code Hook automatically detects images
npx skills add lora-sys/free-vision-skill

# One-command installation script
curl -fsSL https://raw.githubusercontent.com/lora-sys/free-vision-skill/main/installers/codex-install.sh | bash

{
	"agents": {
		"coder": {
			"skills": ["free-vision"],
			"vision": {
				"provider": "auto",
				"region": "cn",
				"auto-detect-images": true
			}
		}
	}
}

# General-purpose invocation
free-vision see --image ./screenshot.png --question "Your question"