@cogineai/dearharness 0.1.0

package/dist/harness/source.js

@@ -0,0 +1,224 @@
+import { createHash } from 'node:crypto';
+import { promises as fs } from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { gunzipSync, unzipSync } from 'fflate';
+import { validateHarnessSource } from './manifest.js';
+const DEFAULT_MAX_ARCHIVE_BYTES = 50 * 1024 * 1024;
+const MANIFEST_FILE = 'dearharness.manifest.json';
+const TAR_BLOCK_SIZE = 512;
+function detectSourceKind(input) {
+    let url;
+    try {
+        url = new URL(input);
+    }
+    catch {
+        throw new Error(`harness source must be an http(s) .zip or .tar.gz URL: ${input}`);
+    }
+    if (url.protocol !== 'http:' && url.protocol !== 'https:') {
+        throw new Error(`harness source must be an http(s) .zip or .tar.gz URL: ${input}`);
+    }
+    const lowercasePath = url.pathname.toLowerCase();
+    if (lowercasePath.endsWith('.zip'))
+        return 'zip-url';
+    if (lowercasePath.endsWith('.tar.gz'))
+        return 'targz-url';
+    throw new Error(`harness source URL must point to a .zip or .tar.gz archive: ${input}`);
+}
+async function downloadArchive(input, fetchImpl, maxArchiveBytes) {
+    const response = await fetchImpl(input);
+    if (!response.ok) {
+        throw new Error(`failed to download harness source ${input}: HTTP ${response.status}`);
+    }
+    const contentLength = response.headers.get('content-length');
+    if (contentLength && Number(contentLength) > maxArchiveBytes) {
+        throw new Error(`harness source archive exceeds ${maxArchiveBytes} bytes`);
+    }
+    const archive = Buffer.from(await response.arrayBuffer());
+    if (archive.byteLength > maxArchiveBytes) {
+        throw new Error(`harness source archive exceeds ${maxArchiveBytes} bytes`);
+    }
+    return archive;
+}
+function safeArchiveEntryPath(root, entryName) {
+    if (!entryName || entryName.includes('\0')) {
+        throw new Error(`unsafe archive entry path: ${entryName}`);
+    }
+    const normalized = entryName.replace(/\\/g, '/');
+    if (normalized.startsWith('/') || /^[A-Za-z]:\//.test(normalized)) {
+        throw new Error(`unsafe archive entry path: ${entryName}`);
+    }
+    const parts = normalized.split('/').filter(Boolean);
+    if (parts.length === 0 || parts.includes('..')) {
+        throw new Error(`unsafe archive entry path: ${entryName}`);
+    }
+    const target = path.resolve(root, ...parts);
+    const relative = path.relative(root, target);
+    if (relative.startsWith('..') || path.isAbsolute(relative)) {
+        throw new Error(`unsafe archive entry path: ${entryName}`);
+    }
+    return target;
+}
+async function extractZipToStaging(archive, stagingPath) {
+    const entries = unzipSync(archive);
+    for (const [entryName, data] of Object.entries(entries)) {
+        const target = safeArchiveEntryPath(stagingPath, entryName);
+        if (entryName.replace(/\\/g, '/').endsWith('/')) {
+            await fs.mkdir(target, { recursive: true });
+            continue;
+        }
+        await fs.mkdir(path.dirname(target), { recursive: true });
+        await fs.writeFile(target, data);
+    }
+}
+function isZeroBlock(view) {
+    for (let i = 0; i < view.byteLength; i++) {
+        if (view[i] !== 0)
+            return false;
+    }
+    return true;
+}
+function readCString(buffer, start, length) {
+    const slice = buffer.subarray(start, start + length);
+    let end = 0;
+    while (end < slice.byteLength && slice[end] !== 0)
+        end++;
+    return slice.subarray(0, end).toString('utf8');
+}
+function parseTarOctal(value, label) {
+    const trimmed = value.replace(/[\0 ]+$/g, '').trim();
+    if (trimmed.length === 0)
+        return 0;
+    if (!/^[0-7]+$/.test(trimmed)) {
+        throw new Error(`invalid octal value in tar entry ${label}: ${JSON.stringify(value)}`);
+    }
+    return parseInt(trimmed, 8);
+}
+function parseTarEntries(archive) {
+    const entries = [];
+    let offset = 0;
+    while (offset + TAR_BLOCK_SIZE <= archive.byteLength) {
+        const header = archive.subarray(offset, offset + TAR_BLOCK_SIZE);
+        if (isZeroBlock(header))
+            break;
+        const name = readCString(header, 0, 100);
+        const sizeRaw = readCString(header, 124, 12);
+        const typeflagByte = header[156] ?? 0;
+        const typeflag = typeflagByte === 0 ? '\0' : String.fromCharCode(typeflagByte);
+        const magic = readCString(header, 257, 6).trimEnd();
+        const prefix = readCString(header, 345, 155);
+        if (magic && magic !== 'ustar') {
+            throw new Error(`unsupported tar entry magic: ${JSON.stringify(magic)}`);
+        }
+        const size = parseTarOctal(sizeRaw, 'size');
+        const dataStart = offset + TAR_BLOCK_SIZE;
+        const dataEnd = dataStart + size;
+        const dataBlocks = Math.ceil(size / TAR_BLOCK_SIZE);
+        const nextOffset = dataStart + dataBlocks * TAR_BLOCK_SIZE;
+        if (dataEnd > archive.byteLength || nextOffset > archive.byteLength) {
+            throw new Error('tar entry data exceeds archive bounds');
+        }
+        offset = nextOffset;
+        const fullName = prefix ? `${prefix}/${name}` : name;
+        if (typeflag === 'x' || typeflag === 'g') {
+            continue;
+        }
+        if (typeflag === '5') {
+            entries.push({ kind: 'directory', name: fullName });
+            continue;
+        }
+        if (typeflag === '0' || typeflag === '\0' || typeflag === '7') {
+            const data = Buffer.from(archive.subarray(dataStart, dataEnd));
+            entries.push({ kind: 'file', name: fullName, data });
+            continue;
+        }
+        if (typeflag === '2') {
+            throw new Error(`unsupported tar entry type symlink: ${fullName}`);
+        }
+        if (typeflag === '1') {
+            throw new Error(`unsupported tar entry type hardlink: ${fullName}`);
+        }
+        throw new Error(`unsupported tar entry type ${JSON.stringify(typeflag)}: ${fullName}`);
+    }
+    return entries;
+}
+async function extractTarGzToStaging(archive, stagingPath) {
+    let inflated;
+    try {
+        inflated = gunzipSync(archive);
+    }
+    catch (error) {
+        throw new Error(`failed to decompress harness source gzip stream: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    const tarBuffer = Buffer.from(inflated);
+    const entries = parseTarEntries(tarBuffer);
+    for (const entry of entries) {
+        const target = safeArchiveEntryPath(stagingPath, entry.name);
+        if (entry.kind === 'directory') {
+            await fs.mkdir(target, { recursive: true });
+            continue;
+        }
+        await fs.mkdir(path.dirname(target), { recursive: true });
+        await fs.writeFile(target, entry.data);
+    }
+}
+async function pathExists(target) {
+    try {
+        await fs.access(target);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function findHarnessRoot(stagingPath) {
+    if (await pathExists(path.join(stagingPath, MANIFEST_FILE))) {
+        return stagingPath;
+    }
+    const entries = await fs.readdir(stagingPath, { withFileTypes: true });
+    const manifestRoots = [];
+    for (const entry of entries) {
+        if (!entry.isDirectory())
+            continue;
+        const candidate = path.join(stagingPath, entry.name);
+        if (await pathExists(path.join(candidate, MANIFEST_FILE))) {
+            manifestRoots.push(candidate);
+        }
+    }
+    return manifestRoots.length === 1 ? manifestRoots[0] : stagingPath;
+}
+export async function materializeHarnessSource(input, options = {}) {
+    const kind = detectSourceKind(input);
+    const tempRoot = options.tempRoot ?? os.tmpdir();
+    const stagingPath = await fs.mkdtemp(path.join(tempRoot, 'dearharness-source-'));
+    try {
+        const archive = await downloadArchive(input, options.fetch ?? fetch, options.maxArchiveBytes ?? DEFAULT_MAX_ARCHIVE_BYTES);
+        const sha256 = createHash('sha256').update(archive).digest('hex');
+        if (options.expectedSha256 && options.expectedSha256.toLowerCase() !== sha256) {
+            throw new Error(`harness source sha256 mismatch: expected ${options.expectedSha256}, got ${sha256}`);
+        }
+        if (kind === 'zip-url') {
+            await extractZipToStaging(archive, stagingPath);
+        }
+        else {
+            await extractTarGzToStaging(archive, stagingPath);
+        }
+        const rootPath = await findHarnessRoot(stagingPath);
+        const validation = await validateHarnessSource(rootPath);
+        return {
+            input,
+            kind,
+            stagingPath,
+            rootPath,
+            sha256,
+            validation,
+            cleanup: async () => {
+                await fs.rm(stagingPath, { recursive: true, force: true });
+            },
+        };
+    }
+    catch (error) {
+        await fs.rm(stagingPath, { recursive: true, force: true });
+        throw error;
+    }
+}

package/dist/harness/transaction.js

@@ -0,0 +1,77 @@
+import { createHash } from 'node:crypto';
+import { promises as fs } from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+function toPosixPath(value) {
+    return value.split(path.sep).join('/');
+}
+async function assertDirectory(target, label) {
+    const stat = await fs.stat(target);
+    if (!stat.isDirectory()) {
+        throw new Error(`${label} must be a directory: ${target}`);
+    }
+}
+export async function createWorkspaceTransaction(targetWorkspaceInput, options = {}) {
+    const targetWorkspace = path.resolve(targetWorkspaceInput);
+    await assertDirectory(targetWorkspace, 'targetWorkspace');
+    const tempRoot = options.tempRoot ?? os.tmpdir();
+    const stagingPath = await fs.mkdtemp(path.join(tempRoot, 'dearharness-transaction-'));
+    const candidateWorkspace = path.join(stagingPath, 'workspace');
+    try {
+        await fs.cp(targetWorkspace, candidateWorkspace, { recursive: true });
+        return {
+            targetWorkspace,
+            stagingPath,
+            candidateWorkspace,
+            cleanup: async () => {
+                await fs.rm(stagingPath, { recursive: true, force: true });
+            },
+        };
+    }
+    catch (error) {
+        await fs.rm(stagingPath, { recursive: true, force: true });
+        throw error;
+    }
+}
+async function hashFile(target) {
+    return createHash('sha256').update(await fs.readFile(target)).digest('hex');
+}
+async function collectFileHashes(root) {
+    const files = new Map();
+    async function visit(directory) {
+        const entries = await fs.readdir(directory, { withFileTypes: true });
+        for (const entry of entries) {
+            const target = path.join(directory, entry.name);
+            if (entry.isDirectory()) {
+                await visit(target);
+                continue;
+            }
+            if (!entry.isFile()) {
+                continue;
+            }
+            files.set(toPosixPath(path.relative(root, target)), await hashFile(target));
+        }
+    }
+    await visit(root);
+    return files;
+}
+export async function diffWorkspaceTransaction(transaction) {
+    const before = await collectFileHashes(transaction.targetWorkspace);
+    const after = await collectFileHashes(transaction.candidateWorkspace);
+    const paths = [...new Set([...before.keys(), ...after.keys()])].sort((a, b) => a.localeCompare(b));
+    const diff = [];
+    for (const relativePath of paths) {
+        const beforeHash = before.get(relativePath);
+        const afterHash = after.get(relativePath);
+        if (beforeHash === undefined && afterHash !== undefined) {
+            diff.push({ path: relativePath, kind: 'add' });
+        }
+        else if (beforeHash !== undefined && afterHash === undefined) {
+            diff.push({ path: relativePath, kind: 'delete' });
+        }
+        else if (beforeHash !== afterHash) {
+            diff.push({ path: relativePath, kind: 'modify' });
+        }
+    }
+    return diff;
+}

package/dist/harness/workspace.js

@@ -0,0 +1,61 @@
+import { promises as fs } from 'node:fs';
+import path from 'node:path';
+import { readInstallLockfile } from './lockfile.js';
+const BOOTSTRAP_FILES = ['AGENTS.md', 'SOUL.md', 'USER.md', 'IDENTITY.md', 'TOOLS.md', 'HEARTBEAT.md', 'BOOTSTRAP.md'];
+async function statFile(target) {
+    try {
+        return await fs.stat(target);
+    }
+    catch {
+        return null;
+    }
+}
+async function readBootstrapFiles(workspace) {
+    const files = [];
+    for (const name of BOOTSTRAP_FILES) {
+        const stat = await statFile(path.join(workspace, name));
+        files.push({ name, present: Boolean(stat?.isFile()), sizeBytes: stat?.isFile() ? stat.size : null });
+    }
+    return files;
+}
+async function readSkills(workspace) {
+    const skillsDir = path.join(workspace, 'skills');
+    let entries;
+    try {
+        entries = await fs.readdir(skillsDir, { withFileTypes: true });
+    }
+    catch {
+        return [];
+    }
+    const skills = [];
+    for (const entry of entries) {
+        if (!entry.isDirectory())
+            continue;
+        const skillEntry = await statFile(path.join(skillsDir, entry.name, 'SKILL.md'));
+        skills.push({ slug: entry.name, hasEntry: Boolean(skillEntry?.isFile()) });
+    }
+    return skills.sort((a, b) => a.slug.localeCompare(b.slug));
+}
+export async function inspectOpenClawWorkspace(workspaceInput) {
+    const workspace = path.resolve(workspaceInput);
+    const lockfile = await readInstallLockfile(workspace);
+    const stat = await statFile(workspace);
+    if (!stat?.isDirectory()) {
+        return {
+            workspace,
+            exists: false,
+            bootstrapFiles: [],
+            skills: [],
+            lockfile,
+            errors: [`workspace does not exist: ${workspace}`],
+        };
+    }
+    return {
+        workspace,
+        exists: true,
+        bootstrapFiles: await readBootstrapFiles(workspace),
+        skills: await readSkills(workspace),
+        lockfile,
+        errors: [...lockfile.errors],
+    };
+}

package/dist/index.js

@@ -0,0 +1,9 @@
+#!/usr/bin/env node
+import { renderUnhandledError, runCli } from './cli.js';
+runCli(process.argv).catch((error) => {
+    const message = renderUnhandledError(error);
+    if (message) {
+        console.error(message);
+    }
+    process.exit(1);
+});

package/dist/instructions/builder.js

@@ -0,0 +1,33 @@
+import { promises as fs } from 'node:fs';
+import { resolveWorkspacePath } from '../tools/path.js';
+export async function loadWorkspaceInstructionFiles(cwd, files) {
+    const loaded = [];
+    for (const file of files) {
+        const { targetRealPath } = await resolveWorkspacePath(cwd, file);
+        loaded.push((await fs.readFile(targetRealPath, 'utf8')).trim());
+    }
+    return loaded.filter(Boolean);
+}
+export async function buildInstructionMessages(options) {
+    const messages = [
+        { role: 'system', layer: 'core', source: 'base', content: options.basePrompt }
+    ];
+    for (const instruction of options.workspaceInstructions) {
+        messages.push({
+            role: 'system',
+            layer: 'workspace',
+            source: 'workspace',
+            content: instruction
+        });
+    }
+    for (const skill of options.skills) {
+        messages.push({
+            role: 'system',
+            layer: 'skill',
+            source: `skill:${skill.name}`,
+            content: skill.prompt
+        });
+    }
+    messages.push(...options.extensionMessages);
+    return messages;
+}

package/dist/instructions/types.js

@@ -0,0 +1 @@
+export {};

package/dist/model/config.js

@@ -0,0 +1,100 @@
+import { OLLAMA_DEFAULT_MODEL_HINT } from '../config.js';
+import { discoverOllamaModels, selectDefaultOllamaModel } from './providers/ollama-discovery.js';
+import { DEFAULT_MODEL_CONFIG, getModelProvider, isProviderName } from './registry.js';
+export function isStreamingMode(value) {
+    return value === 'auto' || value === 'on' || value === 'off';
+}
+function firstDefined(...values) {
+    for (const value of values) {
+        if (value !== undefined && value !== null && value !== '') {
+            return value;
+        }
+    }
+    return undefined;
+}
+function getProviderApiKey(provider) {
+    if (provider === 'openrouter')
+        return process.env.OPENROUTER_API_KEY;
+    if (provider === 'anthropic')
+        return process.env.ANTHROPIC_API_KEY;
+    if (provider === 'openai')
+        return process.env.OPENAI_API_KEY;
+    if (provider === 'openai-compatible') {
+        return firstDefined(process.env.CLIQ_MODEL_API_KEY, process.env.OPENAI_COMPATIBLE_API_KEY);
+    }
+    return undefined;
+}
+function requireApiKey(provider, apiKey) {
+    if (provider === 'ollama' || provider === 'openai-compatible') {
+        return;
+    }
+    if (!apiKey) {
+        throw new Error(`${provider} API key is required`);
+    }
+}
+function buildNoLocalModelConfiguredError(baseUrl, cause) {
+    const causeMessage = cause instanceof Error ? cause.message : cause ? String(cause) : '';
+    return new Error([
+        'No model provider or local Ollama model configured.',
+        '',
+        `Cliq defaults to local Ollama at ${baseUrl} when no model provider is configured, but no local model could be selected.`,
+        '',
+        'Options:',
+        `  - Install a local model: ollama pull ${OLLAMA_DEFAULT_MODEL_HINT}`,
+        '  - Select an existing local model: cliq --provider ollama --model <model> "task"',
+        '  - Configure a remote provider with --provider, --model, and the required API key',
+        ...(causeMessage ? ['', `Ollama discovery error: ${causeMessage}`] : [])
+    ].join('\n'));
+}
+async function discoverDefaultOllamaModel(baseUrl) {
+    let models;
+    try {
+        models = await discoverOllamaModels(baseUrl);
+    }
+    catch (error) {
+        throw buildNoLocalModelConfiguredError(baseUrl, error);
+    }
+    const selected = selectDefaultOllamaModel(models);
+    if (!selected) {
+        throw buildNoLocalModelConfiguredError(baseUrl);
+    }
+    return selected;
+}
+export async function resolveModelConfig({ workspace, cli }) {
+    const rawProvider = firstDefined(cli.provider, workspace.model?.provider, process.env.CLIQ_MODEL_PROVIDER);
+    let provider;
+    if (rawProvider) {
+        if (!isProviderName(rawProvider)) {
+            throw new Error(`Unknown model provider: ${rawProvider}`);
+        }
+        provider = rawProvider;
+    }
+    else {
+        provider = 'ollama';
+    }
+    const providerDef = getModelProvider(provider);
+    const rawStreaming = firstDefined(cli.streaming, workspace.model?.streaming, process.env.CLIQ_MODEL_STREAMING, DEFAULT_MODEL_CONFIG.streaming);
+    if (!rawStreaming || !isStreamingMode(rawStreaming)) {
+        throw new Error(`Invalid streaming mode: ${rawStreaming ?? ''}`);
+    }
+    let model = firstDefined(cli.model, workspace.model?.model, process.env.CLIQ_MODEL, providerDef.getDefaultModel());
+    const baseUrl = firstDefined(cli.baseUrl, workspace.model?.baseUrl, process.env.CLIQ_MODEL_BASE_URL, providerDef.defaultBaseUrl);
+    if (!baseUrl) {
+        throw new Error(`baseUrl is required for provider ${provider}`);
+    }
+    if (!model && provider === 'ollama') {
+        model = await discoverDefaultOllamaModel(baseUrl);
+    }
+    if (!model) {
+        throw new Error(`model is required for provider ${provider}`);
+    }
+    const apiKey = getProviderApiKey(provider);
+    requireApiKey(provider, apiKey);
+    return {
+        provider,
+        model,
+        baseUrl,
+        ...(apiKey ? { apiKey } : {}),
+        streaming: rawStreaming
+    };
+}

package/dist/model/http.js

@@ -0,0 +1,128 @@
+import { MODEL_TIMEOUT_MS } from '../config.js';
+export function joinUrl(baseUrl, pathname) {
+    return `${baseUrl.replace(/\/+$/, '')}/${pathname.replace(/^\/+/, '')}`;
+}
+export async function fetchWithTimeout(url, init, timeoutMs = MODEL_TIMEOUT_MS) {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+        return await fetch(url, { ...init, signal: controller.signal });
+    }
+    catch (error) {
+        if (error instanceof Error && error.name === 'AbortError') {
+            throw new Error(`Model request timed out after ${timeoutMs}ms`);
+        }
+        throw error;
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}
+export async function readJsonResponse(response, providerName) {
+    if (!response.ok) {
+        throw new Error(`${providerName} error ${response.status}: ${await response.text()}`);
+    }
+    return (await response.json());
+}
+export async function readTextStream(response, onChunk) {
+    if (!response.ok) {
+        throw new Error(`Model stream error ${response.status}: ${await response.text()}`);
+    }
+    if (!response.body) {
+        throw new Error('Model stream response is missing a body');
+    }
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder();
+    let output = '';
+    for (;;) {
+        const { done, value } = await reader.read();
+        if (done)
+            break;
+        const text = decoder.decode(value, { stream: true });
+        output += text;
+        await onChunk(text);
+    }
+    const finalText = decoder.decode();
+    output += finalText;
+    if (finalText) {
+        await onChunk(finalText);
+    }
+    return output;
+}
+function warnMalformedStreamPayload(format, payload, error) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.warn(`Malformed model ${format} payload skipped: ${message}; payload=${payload}`);
+}
+export async function readSseDeltas(response, extractDelta, onDelta) {
+    let buffer = '';
+    let content = '';
+    async function processFrame(frame) {
+        for (const line of frame.split('\n')) {
+            const normalized = line.trimEnd();
+            if (!normalized.startsWith('data:'))
+                continue;
+            const payload = normalized.slice('data:'.length).trim();
+            if (!payload || payload === '[DONE]')
+                continue;
+            let parsed;
+            try {
+                parsed = JSON.parse(payload);
+            }
+            catch (error) {
+                warnMalformedStreamPayload('SSE', payload, error);
+                continue;
+            }
+            const delta = extractDelta(parsed);
+            if (delta) {
+                content += delta;
+                await onDelta(delta);
+            }
+        }
+    }
+    await readTextStream(response, async (chunk) => {
+        buffer += chunk;
+        const frames = buffer.split(/\r?\n\r?\n/);
+        buffer = frames.pop() ?? '';
+        for (const frame of frames) {
+            await processFrame(frame);
+        }
+    });
+    if (buffer.trim()) {
+        await processFrame(buffer);
+    }
+    return content;
+}
+export async function readNdjsonDeltas(response, extractDelta, onDelta) {
+    let buffer = '';
+    let content = '';
+    async function processLine(line) {
+        const payload = line.trim();
+        if (!payload)
+            return;
+        let parsed;
+        try {
+            parsed = JSON.parse(payload);
+        }
+        catch (error) {
+            warnMalformedStreamPayload('NDJSON', payload, error);
+            return;
+        }
+        const delta = extractDelta(parsed);
+        if (delta) {
+            content += delta;
+            await onDelta(delta);
+        }
+    }
+    await readTextStream(response, async (chunk) => {
+        buffer += chunk;
+        const lines = buffer.split('\n');
+        buffer = lines.pop() ?? '';
+        for (const line of lines) {
+            await processLine(line);
+        }
+    });
+    if (buffer.trim()) {
+        await processLine(buffer);
+    }
+    return content;
+}

package/dist/model/index.js

@@ -0,0 +1,22 @@
+import { getModelProvider, registerModelClientFactory } from './registry.js';
+import { createAnthropicClient } from './providers/anthropic.js';
+import { createOllamaClient } from './providers/ollama.js';
+import { createOpenAIClient } from './providers/openai.js';
+import { createOpenAICompatibleClient } from './providers/openai-compatible.js';
+import { createOpenRouterClient } from './providers/openrouter.js';
+let registered = false;
+export function registerBuiltInModelProviders() {
+    if (registered) {
+        return;
+    }
+    registerModelClientFactory('openrouter', createOpenRouterClient);
+    registerModelClientFactory('anthropic', createAnthropicClient);
+    registerModelClientFactory('openai', createOpenAIClient);
+    registerModelClientFactory('openai-compatible', createOpenAICompatibleClient);
+    registerModelClientFactory('ollama', createOllamaClient);
+    registered = true;
+}
+export function createModelClient(config) {
+    registerBuiltInModelProviders();
+    return getModelProvider(config.provider).createClient(config);
+}

package/dist/model/openrouter.js

@@ -0,0 +1,9 @@
+import { DEFAULT_MODEL_CONFIG } from './registry.js';
+import { createOpenRouterClient as createOpenRouterProviderClient } from './providers/openrouter.js';
+export function createOpenRouterClient(config) {
+    const resolved = config ?? {
+        ...DEFAULT_MODEL_CONFIG,
+        apiKey: process.env.OPENROUTER_API_KEY
+    };
+    return createOpenRouterProviderClient(resolved);
+}