@compilr-dev/sdk 0.18.9 → 0.18.11

package/dist/canvas/ramp.js

@@ -0,0 +1,98 @@
+/**
+ * The surface ramp the host injects.
+ *
+ * ⚠️ WHY THE HOST AND NOT CSS. A single `color-mix` cannot serve both polarities: a light
+ * theme's ground has no headroom above it (Catppuccin Latte sits at ~95% lightness, so a
+ * card 6% "above" it would be past white), while a dark theme's has plenty. CSS cannot
+ * branch on a palette's polarity. Whatever computes this has to know the luminance, so it
+ * lives here — pure, testable, and shared with the validator so the two cannot disagree
+ * about what "5–7% apart" means.
+ *
+ * ⚠️ THE GROUND MOVES ONLY WHEN IT MUST. The handoff's worked examples darken the ground
+ * in every case; this does it only when there is no room for the raised surface, so a
+ * dark theme's canvas keeps exactly the background its theme specifies and nothing about
+ * an existing canvas shifts. Latte has no room, so it darkens — there is no alternative
+ * that also keeps the card raised, which is the point of the ramp.
+ */
+import { parseColor, oklabLightness, SURFACE_DELTA_TARGET, HAIRLINE_MIN_PCT, HAIRLINE_MAX_PCT, } from './color.js';
+const hex = (n) => Math.round(Math.min(1, Math.max(0, n)) * 255)
+    .toString(16)
+    .padStart(2, '0');
+const toHex = ({ r, g, b }) => `#${hex(r)}${hex(g)}${hex(b)}`;
+const mix = (a, b, t) => ({
+    r: a.r + (b.r - a.r) * t,
+    g: a.g + (b.g - a.g) * t,
+    b: a.b + (b.b - a.b) * t,
+});
+const WHITE = { r: 1, g: 1, b: 1 };
+const BLACK = { r: 0, g: 0, b: 0 };
+/**
+ * The same colour at a different perceived lightness.
+ *
+ * ⚠️ Binary search over a mix toward white or black rather than an OKLab inverse. It
+ * keeps the hue of the ground (a tinted terminal ground stays tinted, which is most of
+ * why these palettes look like themselves) and cannot produce an out-of-gamut value,
+ * which an inverse transform can.
+ */
+export function withLightness(color, targetL) {
+    const current = oklabLightness(color);
+    if (Math.abs(current - targetL) < 0.001)
+        return color;
+    const toward = targetL > current ? WHITE : BLACK;
+    let lo = 0;
+    let hi = 1;
+    let out = color;
+    for (let i = 0; i < 24; i++) {
+        const mid = (lo + hi) / 2;
+        out = mix(color, toward, mid);
+        const l = oklabLightness(out);
+        if (Math.abs(l - targetL) < 0.0005)
+            break;
+        if (targetL > current ? l < targetL : l > targetL)
+            lo = mid;
+        else
+            hi = mid;
+    }
+    return out;
+}
+/**
+ * Derive the three ramp tokens from a theme's ground and foreground.
+ *
+ * Raised is always lighter and inset always darker, in both polarities — a card that
+ * recedes from its page does not read as a card. When the ground cannot support both
+ * steps, the ground itself is moved just far enough to make room, and the returned `bg`
+ * says so.
+ */
+export function deriveSurfaceRamp(bgInput, fgInput) {
+    const bg = parseColor(bgInput);
+    const fg = parseColor(fgInput);
+    if (!bg || !fg)
+        return null;
+    const step = SURFACE_DELTA_TARGET / 100;
+    let ground = oklabLightness(bg);
+    /*
+      Keep both steps inside the gamut by sliding the ground, never by shrinking the step —
+      a 3% ramp is the defect this exists to fix, so the separation is the invariant and the
+      ground's exact value is not.
+    */
+    const headroom = 1 - (ground + step);
+    const footroom = ground - step;
+    if (headroom < 0)
+        ground += headroom;
+    else if (footroom < 0)
+        ground -= footroom;
+    const groundRgb = withLightness(bg, ground);
+    /*
+      The hairline sits a fixed fraction of the way toward the foreground. Terminal palettes
+      derive their border from a comment or selection colour, which lands 35–100% of the way
+      there — that is the "hard borders" complaint, and it is why this ignores
+      --canvas-border entirely rather than trying to soften it.
+    */
+    const hairlineMix = (HAIRLINE_MIN_PCT + HAIRLINE_MAX_PCT) / 2 / 100;
+    return {
+        bg: toHex(groundRgb),
+        surface1: toHex(withLightness(groundRgb, ground + step)),
+        surface2: toHex(withLightness(groundRgb, ground - step)),
+        hairline: toHex(mix(groundRgb, fg, hairlineMix)),
+    };
+}

package/dist/capabilities/packs.js

@@ -244,11 +244,19 @@ export const CAPABILITY_PACKS = {
             'canvas_delete',
             'canvas_validate',
             'canvas_screenshot',
+            'canvas_guide',
         ],
         readOnly: false,
         promptModules: ['platform-tool-hints'],
-        promptSnippet: 'Visual canvases (infographic/carousel/board) rendered from sandboxed HTML/SVG. Create/replace with canvas_write (raw HTML only — host injects the CSP; inline <style>/<script> only, no network/remote assets; optional Tweaks controls manifest). EDIT via canvas_get (outline=true or startLine/maxLines) then canvas_edit (str_replace/append/prepend) — never re-send the whole document. After authoring, canvas_validate (static) then canvas_screenshot to SEE the render (vision models) — fix overflow/readability with canvas_edit.',
-        estimatedPromptTokens: 150,
+        promptSnippet: 'Visual canvases (infographic/carousel/board) rendered from sandboxed HTML/SVG. ' +
+            // ⚠️ FIRST, and stated as a requirement rather than a suggestion. The craft guides
+            // used to be reachable only when a user typed /canvas, so most canvases were
+            // authored with no design guidance at all — see canvas_guide.
+            'START by calling canvas_guide("canvas") — the design rules live there, not here, and a ' +
+            'canvas authored without them renders correctly and still reads as generic. Then ' +
+            'canvas_guide on the type you pick. ' +
+            'Create/replace with canvas_write (raw HTML only — host injects the CSP; inline <style>/<script> only, no network/remote assets; optional Tweaks controls manifest). EDIT via canvas_get (outline=true or startLine/maxLines) then canvas_edit (str_replace/append/prepend) — never re-send the whole document. After authoring, canvas_validate (static) then canvas_screenshot to SEE the render (vision models) — fix overflow/readability with canvas_edit.',
+        estimatedPromptTokens: 190,
         estimatedToolTokens: 1500,
     },
     plans: {

package/dist/config.d.ts

@@ -49,7 +49,7 @@ export interface CapabilitiesConfig {
 /**
  * Supported provider types for auto-detection
  */
-export type ProviderType = 'claude' | 'openai' | 'gemini' | 'ollama' | 'together' | 'groq' | 'fireworks' | 'perplexity' | 'openrouter' | 'custom';
+export type ProviderType = 'claude' | 'openai' | 'gemini' | 'ollama' | 'ollama-anthropic' | 'together' | 'groq' | 'fireworks' | 'perplexity' | 'openrouter' | 'custom';
 /**
  * Tool configuration for controlling which tools are available
  */

package/dist/index.d.ts

@@ -45,7 +45,7 @@ export type { Preset } from './presets/index.js';
 export type { AnyTool } from './presets/types.js';
 export { resolveProvider, detectProviderFromEnv, createProviderFromType } from './provider.js';
 export { DEFAULT_MODELS, getContextWindow, DEFAULT_CONTEXT_WINDOW } from './models.js';
-export { type ModelTier, type TierInfo, type ProviderModelMap, MODEL_TIERS, TIER_INFO, isValidTier, type ThinkingFormat, type ModelStatus, type ModelInfo, MODEL_REGISTRY, getModelsForProvider, getModelsSortedForDisplay, getModelInfo, isKnownModel, isModelSupported, modelSupportsImages, modelSupportsTools, getThinkingFormat, getStatusIndicator, getStatusLabel, getDefaultModelForTier, areThinkingFormatsCompatible, shouldClearHistoryOnModelChange, getModelContextWindow, getModelDisplayName, getModelDescription, getModelForTier, getTierMappings, getTierDisplayName, getShortModelName, getDefaultTierMappings, type ProviderMetadata, type OthersProviderModel, PROVIDER_METADATA, TOGETHER_MODELS, GROQ_MODELS, FIREWORKS_MODELS, PERPLEXITY_MODELS, OPENROUTER_MODELS, getModelsForOthersProvider, getOthersProviders, getProviderMetadata, isOthersProvider, } from './models/index.js';
+export { type ModelTier, type TierInfo, type ProviderModelMap, MODEL_TIERS, TIER_INFO, isValidTier, type ThinkingFormat, type ModelStatus, type ModelInfo, MODEL_REGISTRY, getModelsForProvider, getModelsSortedForDisplay, getModelInfo, isKnownModel, isModelSupported, modelSupportsImages, modelSupportsTools, getThinkingFormat, getStatusIndicator, getStatusLabel, getDefaultModelForTier, areThinkingFormatsCompatible, shouldClearHistoryOnModelChange, getModelContextWindow, getModelDisplayName, getModelDescription, getModelForTier, getTierMappings, getTierDisplayName, getShortModelName, getDefaultTierMappings, type ProviderMetadata, type OthersProviderModel, PROVIDER_METADATA, TOGETHER_MODELS, GROQ_MODELS, FIREWORKS_MODELS, PERPLEXITY_MODELS, OPENROUTER_MODELS, getModelsForOthersProvider, getOthersProviders, getProviderMetadata, isOthersProvider, type OllamaModelInfo, type OllamaModelsResult, OLLAMA_ANTHROPIC_MIN_VERSION, listOllamaModels, getOllamaVersion, isOllamaAnthropicCompatible, clearOllamaModelsCache, formatOllamaModelSize, getOllamaModelDisplayName, getOllamaModelDescription, } from './models/index.js';
 export { assembleTools, deduplicateTools } from './tools.js';
 export { MetaToolsRegistry, createMetaTools, META_TOOLS_SYSTEM_PROMPT_PREFIX, } from './meta-tools/index.js';
 export type { MetaToolStats, MetaTools, FallbackOptions } from './meta-tools/index.js';

package/dist/index.js

@@ -85,7 +85,7 @@ export { DEFAULT_MODELS, getContextWindow, DEFAULT_CONTEXT_WINDOW } from './mode
 // =============================================================================
 export { MODEL_TIERS, TIER_INFO, isValidTier, MODEL_REGISTRY, getModelsForProvider, getModelsSortedForDisplay, getModelInfo, isKnownModel, isModelSupported, modelSupportsImages, modelSupportsTools, getThinkingFormat, getStatusIndicator, getStatusLabel, getDefaultModelForTier, areThinkingFormatsCompatible, shouldClearHistoryOnModelChange, getModelContextWindow, getModelDisplayName, getModelDescription, 
 // Model tiers (pure, settings-free)
-getModelForTier, getTierMappings, getTierDisplayName, getShortModelName, getDefaultTierMappings, PROVIDER_METADATA, TOGETHER_MODELS, GROQ_MODELS, FIREWORKS_MODELS, PERPLEXITY_MODELS, OPENROUTER_MODELS, getModelsForOthersProvider, getOthersProviders, getProviderMetadata, isOthersProvider, } from './models/index.js';
+getModelForTier, getTierMappings, getTierDisplayName, getShortModelName, getDefaultTierMappings, PROVIDER_METADATA, TOGETHER_MODELS, GROQ_MODELS, FIREWORKS_MODELS, PERPLEXITY_MODELS, OPENROUTER_MODELS, getModelsForOthersProvider, getOthersProviders, getProviderMetadata, isOthersProvider, OLLAMA_ANTHROPIC_MIN_VERSION, listOllamaModels, getOllamaVersion, isOllamaAnthropicCompatible, clearOllamaModelsCache, formatOllamaModelSize, getOllamaModelDisplayName, getOllamaModelDescription, } from './models/index.js';
 // =============================================================================
 // Tool Assembly
 // =============================================================================

package/dist/models/index.d.ts

@@ -5,3 +5,4 @@ export { type ModelTier, type TierInfo, type ProviderModelMap, MODEL_TIERS, TIER
 export { type ThinkingFormat, type ModelStatus, type ModelInfo, MODEL_REGISTRY, getModelsForProvider, getModelsSortedForDisplay, getModelInfo, isKnownModel, isModelSupported, modelSupportsImages, modelSupportsTools, getThinkingFormat, getStatusIndicator, getStatusLabel, getDefaultModelForTier, areThinkingFormatsCompatible, shouldClearHistoryOnModelChange, getModelContextWindow, getModelDisplayName, getModelDescription, } from './model-registry.js';
 export { getModelForTier, getTierMappings, getTierDisplayName, getShortModelName, getDefaultTierMappings, } from './model-tiers.js';
 export { type ProviderMetadata, type OthersProviderModel, PROVIDER_METADATA, TOGETHER_MODELS, GROQ_MODELS, FIREWORKS_MODELS, PERPLEXITY_MODELS, OPENROUTER_MODELS, getModelsForOthersProvider, getOthersProviders, getProviderMetadata, isOthersProvider, } from './providers.js';
+export { type OllamaModelInfo, type OllamaModelsResult, OLLAMA_ANTHROPIC_MIN_VERSION, listOllamaModels, getOllamaVersion, isOllamaAnthropicCompatible, clearOllamaModelsCache, formatOllamaModelSize, getOllamaModelDisplayName, getOllamaModelDescription, } from './ollama-discovery.js';

package/dist/models/index.js

@@ -9,3 +9,5 @@ export { MODEL_REGISTRY, getModelsForProvider, getModelsSortedForDisplay, getMod
 export { getModelForTier, getTierMappings, getTierDisplayName, getShortModelName, getDefaultTierMappings, } from './model-tiers.js';
 // Provider metadata
 export { PROVIDER_METADATA, TOGETHER_MODELS, GROQ_MODELS, FIREWORKS_MODELS, PERPLEXITY_MODELS, OPENROUTER_MODELS, getModelsForOthersProvider, getOthersProviders, getProviderMetadata, isOthersProvider, } from './providers.js';
+// Ollama discovery (host-agnostic — list installed models + version gate)
+export { OLLAMA_ANTHROPIC_MIN_VERSION, listOllamaModels, getOllamaVersion, isOllamaAnthropicCompatible, clearOllamaModelsCache, formatOllamaModelSize, getOllamaModelDisplayName, getOllamaModelDescription, } from './ollama-discovery.js';

package/dist/models/model-registry.js

@@ -684,6 +684,7 @@ function getProviderContextLimitFallback(provider) {
         case 'openai':
             return 128000;
         case 'ollama':
+        case 'ollama-anthropic':
             return 32000;
         case 'together':
             return 131072;

package/dist/models/ollama-discovery.d.ts

@@ -0,0 +1,63 @@
+/**
+ * Ollama discovery — host-agnostic helpers to list locally-pulled models and
+ * detect the Ollama version. Shared by CLI + Desktop so both surface installed
+ * models (closing the Desktop parity gap) for BOTH ollama providers
+ * (`ollama` OpenAI-compat and `ollama-anthropic`). Uses Ollama's native
+ * `/api/tags` and `/api/version` (same on both providers — same port).
+ *
+ * The base URL is a parameter (hosts pass their configured value); this module
+ * has no settings dependency. Results are cached per base URL for 30s.
+ * See ollama-anthropic-provider-spec.md §6.
+ */
+/** Minimum Ollama version that supports the native Anthropic `/v1/messages` endpoint. */
+export declare const OLLAMA_ANTHROPIC_MIN_VERSION = "0.14.0";
+/** Information about an Ollama model as returned by `/api/tags`. */
+export interface OllamaModelInfo {
+    /** Model name/tag (e.g., "llama3.3:70b", "ornith:latest") */
+    name: string;
+    /** Model size in bytes */
+    size: number;
+    /** When the model was modified/pulled */
+    modifiedAt: string;
+    /** Model digest (hash) */
+    digest: string;
+    /** Model details (family, parameter size, quantization) */
+    details?: {
+        family?: string;
+        parameterSize?: string;
+        quantizationLevel?: string;
+    };
+}
+/** Result of listing Ollama models. */
+export interface OllamaModelsResult {
+    success: boolean;
+    models: OllamaModelInfo[];
+    error?: string;
+    /** Whether the Ollama server responded at all */
+    ollamaRunning: boolean;
+    fetchedAt: number;
+}
+/** Clear the models cache (testing / forced refresh). */
+export declare function clearOllamaModelsCache(): void;
+/**
+ * List locally-available Ollama models via `/api/tags`. Cached per base URL for
+ * 30s. Returns gracefully (success:false) when Ollama isn't running.
+ */
+export declare function listOllamaModels(baseUrl?: string, forceRefresh?: boolean): Promise<OllamaModelsResult>;
+/**
+ * Get the running Ollama server version via `/api/version`, or null if
+ * unreachable. Used to gate the `ollama-anthropic` provider.
+ */
+export declare function getOllamaVersion(baseUrl?: string): Promise<string | null>;
+/**
+ * Whether the Ollama server supports the native Anthropic `/v1/messages`
+ * endpoint (version >= 0.14.0). Returns false if unreachable/unknown — callers
+ * should treat that as "offer classic ollama, gate/warn on ollama-anthropic".
+ */
+export declare function isOllamaAnthropicCompatible(baseUrl?: string): Promise<boolean>;
+/** Format a byte size for display (e.g. "4.1 GB"). */
+export declare function formatOllamaModelSize(bytes: number): string;
+/** Friendly display name for a model tag (e.g. "ornith:latest" → "Ornith (latest)"). */
+export declare function getOllamaModelDisplayName(name: string): string;
+/** Short description from model metadata (params · quant · size). */
+export declare function getOllamaModelDescription(model: OllamaModelInfo): string;

package/dist/models/ollama-discovery.js

@@ -0,0 +1,172 @@
+/**
+ * Ollama discovery — host-agnostic helpers to list locally-pulled models and
+ * detect the Ollama version. Shared by CLI + Desktop so both surface installed
+ * models (closing the Desktop parity gap) for BOTH ollama providers
+ * (`ollama` OpenAI-compat and `ollama-anthropic`). Uses Ollama's native
+ * `/api/tags` and `/api/version` (same on both providers — same port).
+ *
+ * The base URL is a parameter (hosts pass their configured value); this module
+ * has no settings dependency. Results are cached per base URL for 30s.
+ * See ollama-anthropic-provider-spec.md §6.
+ */
+const DEFAULT_BASE_URL = 'http://localhost:11434';
+/** Minimum Ollama version that supports the native Anthropic `/v1/messages` endpoint. */
+export const OLLAMA_ANTHROPIC_MIN_VERSION = '0.14.0';
+const CACHE_DURATION_MS = 30_000;
+const modelsCache = new Map();
+function resolveBaseUrl(baseUrl) {
+    return baseUrl ?? process.env.OLLAMA_BASE_URL ?? process.env.OLLAMA_HOST ?? DEFAULT_BASE_URL;
+}
+/** Clear the models cache (testing / forced refresh). */
+export function clearOllamaModelsCache() {
+    modelsCache.clear();
+}
+/**
+ * List locally-available Ollama models via `/api/tags`. Cached per base URL for
+ * 30s. Returns gracefully (success:false) when Ollama isn't running.
+ */
+export async function listOllamaModels(baseUrl, forceRefresh = false) {
+    const host = resolveBaseUrl(baseUrl);
+    const cached = modelsCache.get(host);
+    if (!forceRefresh && cached && Date.now() - cached.fetchedAt < CACHE_DURATION_MS) {
+        return cached;
+    }
+    try {
+        const response = await fetch(`${host}/api/tags`, {
+            method: 'GET',
+            signal: AbortSignal.timeout(5000),
+        });
+        if (!response.ok) {
+            const result = {
+                success: false,
+                models: [],
+                error: `Ollama returned status ${String(response.status)}`,
+                ollamaRunning: true,
+                fetchedAt: Date.now(),
+            };
+            modelsCache.set(host, result);
+            return result;
+        }
+        const data = (await response.json());
+        const models = (data.models ?? [])
+            .map((m) => ({
+            name: m.name,
+            size: m.size,
+            modifiedAt: m.modified_at,
+            digest: m.digest,
+            details: m.details
+                ? {
+                    family: m.details.family,
+                    parameterSize: m.details.parameter_size,
+                    quantizationLevel: m.details.quantization_level,
+                }
+                : undefined,
+        }))
+            .sort((a, b) => a.name.localeCompare(b.name));
+        const result = {
+            success: true,
+            models,
+            ollamaRunning: true,
+            fetchedAt: Date.now(),
+        };
+        modelsCache.set(host, result);
+        return result;
+    }
+    catch (error) {
+        let errorMsg = 'Unknown error';
+        const ollamaRunning = false;
+        if (error instanceof Error) {
+            if (error.name === 'AbortError' || error.message.includes('timeout')) {
+                errorMsg = 'Connection timed out';
+            }
+            else if (error.message.includes('ECONNREFUSED') || error.message.includes('fetch failed')) {
+                errorMsg = 'Ollama is not running. Start it with: ollama serve';
+            }
+            else {
+                errorMsg = error.message;
+            }
+        }
+        const result = {
+            success: false,
+            models: [],
+            error: errorMsg,
+            ollamaRunning,
+            fetchedAt: Date.now(),
+        };
+        modelsCache.set(host, result);
+        return result;
+    }
+}
+/**
+ * Get the running Ollama server version via `/api/version`, or null if
+ * unreachable. Used to gate the `ollama-anthropic` provider.
+ */
+export async function getOllamaVersion(baseUrl) {
+    const host = resolveBaseUrl(baseUrl);
+    try {
+        const response = await fetch(`${host}/api/version`, {
+            method: 'GET',
+            signal: AbortSignal.timeout(5000),
+        });
+        if (!response.ok)
+            return null;
+        const data = (await response.json());
+        return data.version ?? null;
+    }
+    catch {
+        return null;
+    }
+}
+/** Compare dotted numeric versions: -1 / 0 / 1. Non-numeric segments treated as 0. */
+function compareVersions(a, b) {
+    const pa = a.split('.').map((n) => parseInt(n, 10) || 0);
+    const pb = b.split('.').map((n) => parseInt(n, 10) || 0);
+    const len = Math.max(pa.length, pb.length);
+    for (let i = 0; i < len; i++) {
+        const d = (pa[i] ?? 0) - (pb[i] ?? 0);
+        if (d !== 0)
+            return d < 0 ? -1 : 1;
+    }
+    return 0;
+}
+/**
+ * Whether the Ollama server supports the native Anthropic `/v1/messages`
+ * endpoint (version >= 0.14.0). Returns false if unreachable/unknown — callers
+ * should treat that as "offer classic ollama, gate/warn on ollama-anthropic".
+ */
+export async function isOllamaAnthropicCompatible(baseUrl) {
+    const version = await getOllamaVersion(baseUrl);
+    if (!version)
+        return false;
+    return compareVersions(version, OLLAMA_ANTHROPIC_MIN_VERSION) >= 0;
+}
+// ── Display helpers (shared so hosts format installed models consistently) ──
+/** Format a byte size for display (e.g. "4.1 GB"). */
+export function formatOllamaModelSize(bytes) {
+    if (bytes < 1024)
+        return `${String(bytes)} B`;
+    if (bytes < 1024 * 1024)
+        return `${(bytes / 1024).toFixed(1)} KB`;
+    if (bytes < 1024 * 1024 * 1024)
+        return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+    return `${(bytes / (1024 * 1024 * 1024)).toFixed(1)} GB`;
+}
+/** Friendly display name for a model tag (e.g. "ornith:latest" → "Ornith (latest)"). */
+export function getOllamaModelDisplayName(name) {
+    const [baseName, tag] = name.split(':');
+    const formattedBase = baseName
+        .split(/[-_]/)
+        .map((w) => w.charAt(0).toUpperCase() + w.slice(1))
+        .join(' ');
+    return tag ? `${formattedBase} (${tag})` : formattedBase;
+}
+/** Short description from model metadata (params · quant · size). */
+export function getOllamaModelDescription(model) {
+    const parts = [];
+    if (model.details?.parameterSize)
+        parts.push(model.details.parameterSize);
+    if (model.details?.quantizationLevel)
+        parts.push(model.details.quantizationLevel);
+    parts.push(formatOllamaModelSize(model.size));
+    return parts.join(' · ');
+}

package/dist/models/providers.js

@@ -56,6 +56,16 @@ export const PROVIDER_METADATA = {
         requiresKey: false,
         category: 'local',
     },
+    'ollama-anthropic': {
+        type: 'ollama-anthropic',
+        displayName: 'Ollama (Claude API)',
+        description: "Local models via Ollama's Anthropic endpoint (thinking; needs Ollama ≥ 0.14)",
+        endpoint: 'http://localhost:11434',
+        envVar: '',
+        keyUrl: 'https://ollama.ai',
+        requiresKey: false,
+        category: 'local',
+    },
     // "Others" providers (OpenAI-compatible APIs)
     together: {
         type: 'together',

package/dist/platform/tools/canvas-tools.d.ts

@@ -29,7 +29,7 @@ export interface CanvasIssue {
     message: string;
 }
 /** Run deterministic static checks on canvas content. No rendering. */
-export declare function runCanvasChecks(html: string, type: CanvasType): CanvasIssue[];
+export declare function runCanvasChecks(html: string, type: CanvasType, manifest?: ControlManifest): CanvasIssue[];
 export declare function createCanvasTools(config: PlatformToolsConfig): (import("@compilr-dev/agents").Tool<{
     type: string;
     title: string;
@@ -50,4 +50,6 @@ export declare function createCanvasTools(config: PlatformToolsConfig): (import(
     new_str?: string;
     content?: string;
     replace_all?: boolean;
+}> | import("@compilr-dev/agents").Tool<{
+    topic: string;
 }>)[];

package/dist/platform/tools/canvas-tools.js

@@ -12,9 +12,13 @@
  */
 import { defineTool, createSuccessResult, createErrorResult } from '@compilr-dev/agents';
 import { truncateContent } from './truncate.js';
+import { runQualityChecks } from '../../canvas/quality-checks.js';
 const PAGE_SIZES = ['16:9', '4:3', '1:1', '4:5', '9:16'];
 import { seedValues } from '../../canvas/types.js';
 import { validateControlManifest } from '../../canvas/validate.js';
+import { canvasSkill, infographicSkill, carouselSkill, boardSkill, canvasStylesSkill, } from '../../skills/canvas-skills.js';
+import { canvasExemplarInfographicSkill, canvasExemplarAppScreenSkill, } from '../../skills/canvas-exemplars.js';
+import { canvasIconsSkill } from '../../skills/canvas-icons.js';
 const CANVAS_TYPES = ['infographic', 'carousel', 'board'];
 /** Render content as numbered lines (1-based), optionally a slice. */
 function numberedLines(content, startLine, maxLines) {
@@ -133,7 +137,7 @@ function offCanvasNodes(src, bounds) {
     return out;
 }
 /** Run deterministic static checks on canvas content. No rendering. */
-export function runCanvasChecks(html, type) {
+export function runCanvasChecks(html, type, manifest) {
     const issues = [];
     const src = html.trim();
     if (!src) {
@@ -200,6 +204,14 @@ export function runCanvasChecks(html, type) {
             });
         }
     }
+    /*
+      The quality checks — surfaces, contrast, hue count, dead Tweaks. A separate module
+      because they are pure arithmetic on declared values and want testing without a
+      platform context; see `canvas/quality-checks.ts` for what each one deliberately
+      cannot know.
+    */
+    for (const issue of runQualityChecks(src, manifest))
+        issues.push(issue);
     return issues;
 }
 // eslint-disable-next-line @typescript-eslint/explicit-function-return-type
@@ -294,7 +306,19 @@ export function createCanvasTools(config) {
                     });
                     if (!updated)
                         return createErrorResult(`Canvas ${String(input.canvas_id)} not found.`);
-                    return createSuccessResult(`Updated canvas "${updated.title}" (${updated.type})\nID: ${String(updated.id)}`);
+                    /*
+                      ⚠️ The prose is UNCHANGED, deliberately. Desktop's auto-split parses the id out
+                      of this exact wording (`renderer/src/lib/canvas-authored.ts`), and the model has
+                      been reading it for every canvas it has ever written. The id now also travels as
+                      a structured sibling so the host can stop regex-parsing prose — but both must
+                      ship together for one version, or a Desktop that has not updated silently stops
+                      splitting on author.
+                    */
+                    return {
+                        success: true,
+                        result: `Updated canvas "${updated.title}" (${updated.type})\nID: ${String(updated.id)}`,
+                        canvas: { id: updated.id, title: updated.title, type: updated.type, action: 'updated' },
+                    };
                 }
                 const projectId = input.project_id ?? ctx.currentProjectId;
                 if (!projectId) {
@@ -310,7 +334,11 @@ export function createCanvasTools(config) {
                     values: seedValues(controls),
                     pageSize: input.page_size,
                 });
-                return createSuccessResult(`Created canvas "${created.title}" (${created.type})\nID: ${String(created.id)}`);
+                return {
+                    success: true,
+                    result: `Created canvas "${created.title}" (${created.type})\nID: ${String(created.id)}`,
+                    canvas: { id: created.id, title: created.title, type: created.type, action: 'created' },
+                };
             }
             catch (error) {
                 return createErrorResult(`Failed to write canvas: ${error instanceof Error ? error.message : String(error)}`);
@@ -537,12 +565,17 @@ export function createCanvasTools(config) {
             try {
                 let html;
                 let type;
+                // ⚠️ The manifest travels with a STORED canvas only. Validating raw html has no
+                // manifest to check against, so the dead-Tweak check is silent there rather than
+                // reporting every control as unbound — a canvas is written before it is stored.
+                let manifest;
                 if (input.canvas_id !== undefined) {
                     const c = await canvases.getById(input.canvas_id);
                     if (!c)
                         return createErrorResult(`Canvas ${String(input.canvas_id)} not found.`);
                     html = c.content;
                     type = c.type;
+                    manifest = c.controls;
                 }
                 else if (input.html !== undefined) {
                     html = input.html;
@@ -551,7 +584,7 @@ export function createCanvasTools(config) {
                 else {
                     return createErrorResult('Provide canvas_id (a stored canvas) or html (+ type) to validate.');
                 }
-                const issues = runCanvasChecks(html, type);
+                const issues = runCanvasChecks(html, type, manifest);
                 if (issues.length === 0) {
                     return createSuccessResult('✓ Passed all static checks — no structural/technical issues. (Visual/aesthetic review is a separate pass.)');
                 }
@@ -625,6 +658,76 @@ export function createCanvasTools(config) {
             }
         },
     });
+    /*
+      ⚠️ THIS TOOL EXISTS BECAUSE THE CRAFT GUIDANCE WAS UNREACHABLE.
+  
+      Skills are delivered by the HOST when a user types a slash command — Desktop fetches
+      the prompt and sends it as a user message. Nothing else delivers them: there is no
+      path from the agent to a skill, and the capability pack's snippet covers mechanics
+      only (canvas_write, the CSP, editing). So "make me an infographic" produced a canvas
+      authored with no design guidance at all, and every rule about hierarchy, restraint and
+      the elevation ramp reached the model only if the user happened to know to type
+      `/canvas` first.
+  
+      That is the wrong shape: the agent, not the user, is the one who knows it is about to
+      author a canvas. So the guides become readable on demand — lazy, like the pack itself,
+      costing nothing until a canvas is actually being made.
+    */
+    const canvasGuideTool = defineTool({
+        name: 'canvas_guide',
+        description: 'Read the design guidance for a canvas BEFORE authoring one. Call with topic "canvas" ' +
+            'first — it covers the steps, the sandbox rules and the theme tokens, and routes you to ' +
+            'the right craft guide. Then read the guide for the type you picked ("infographic", ' +
+            '"carousel" or "board"), "styles" when choosing a look, and an "exemplar-*" topic for a ' +
+            'worked example to adapt. Skipping this produces a canvas that renders but reads as ' +
+            'generic — the exemplars in particular are worth more than any amount of description.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                topic: {
+                    type: 'string',
+                    enum: [
+                        'canvas',
+                        'infographic',
+                        'carousel',
+                        'board',
+                        'styles',
+                        'exemplar-infographic',
+                        'exemplar-app-screen',
+                        'icons',
+                    ],
+                    description: 'canvas = mechanics + steps (read this first) · infographic/carousel/board = the ' +
+                        'craft guide for that type · styles = the aesthetic catalogue · ' +
+                        'exemplar-infographic / exemplar-app-screen = a worked example to adapt, which is ' +
+                        'worth more than any amount of description.',
+                },
+            },
+            required: ['topic'],
+        },
+        execute: (input) => {
+            /*
+              ⚠️ `| undefined` is load-bearing. Without it `Record<string, T>` indexing claims a
+              value for every key, so the linter calls the guard below dead code — while at
+              runtime an unknown topic is exactly what it catches (asserted in canvas-guide
+              tests). The type was lying, not the guard.
+            */
+            const guides = {
+                canvas: canvasSkill,
+                infographic: infographicSkill,
+                carousel: carouselSkill,
+                board: boardSkill,
+                styles: canvasStylesSkill,
+                'exemplar-infographic': canvasExemplarInfographicSkill,
+                'exemplar-app-screen': canvasExemplarAppScreenSkill,
+                icons: canvasIconsSkill,
+            };
+            const guide = guides[input.topic];
+            if (!guide) {
+                return Promise.resolve(createErrorResult(`Unknown topic "${input.topic}". One of: ${Object.keys(guides).join(', ')}.`));
+            }
+            return Promise.resolve(createSuccessResult(guide.prompt));
+        },
+    });
     return [
         canvasWriteTool,
         canvasEditTool,
@@ -633,5 +736,6 @@ export function createCanvasTools(config) {
         canvasDeleteTool,
         canvasValidateTool,
         canvasScreenshotTool,
+        canvasGuideTool,
     ];
 }

package/dist/provider.js

@@ -48,6 +48,22 @@ export function createProviderFromType(type, options) {
             return createGeminiNativeProvider({ model, apiKey, estimateTokens, maxTokens });
         case 'ollama':
             return createOllamaProvider({ model, baseUrl, estimateTokens, maxTokens });
+        case 'ollama-anthropic':
+            // Ollama's native Anthropic Messages endpoint (Ollama >= 0.14). Reuses the
+            // Claude provider pointed at the Ollama base URL — the Anthropic SDK POSTs
+            // to {baseURL}/v1/messages. Anthropic-only features Ollama doesn't support
+            // are disabled; the dummy key is accepted-not-validated. Surfaces thinking
+            // that the OpenAI-compat `ollama` path drops. See ollama-anthropic spec.
+            return createClaudeProvider({
+                model,
+                apiKey: apiKey || 'ollama',
+                baseURL: baseUrl ?? 'http://localhost:11434',
+                estimateTokens,
+                maxTokens,
+                enablePromptCaching: false,
+                enableTokenEfficientTools: false,
+                enableExtendedContext: false,
+            });
         case 'together':
             return createTogetherProvider({ model, apiKey, estimateTokens, maxTokens });
         case 'groq':