@denizokcu/haze 0.0.2 → 0.0.3

package/dist/config/providers.js

@@ -0,0 +1,88 @@
+export const DEFAULT_PROVIDER_NAME = 'openrouter';
+export const DEFAULT_PROVIDER_URL = 'https://openrouter.ai/api/v1';
+export const DEFAULT_MODEL = 'x-ai/grok-build-0.1';
+function normalizeModels(models, fallbackModel) {
+    const values = Array.isArray(models) ? models : [];
+    const normalized = values
+        .filter((model) => typeof model === 'string')
+        .map(model => model.trim())
+        .filter(Boolean);
+    if (normalized.length > 0)
+        return [...new Set(normalized)];
+    return fallbackModel ? [fallbackModel] : [];
+}
+function normalizeProvider(provider, fallbackModel) {
+    const name = provider.name?.trim();
+    const url = provider.url?.trim();
+    if (!name || !url)
+        return undefined;
+    const key = provider.key?.trim();
+    return {
+        name,
+        url,
+        ...(key ? { key } : {}),
+        models: normalizeModels(provider.models, fallbackModel),
+    };
+}
+export function configuredProviders(settings) {
+    const providers = (settings.providers ?? [])
+        .map(provider => normalizeProvider(provider))
+        .filter((provider) => Boolean(provider));
+    const legacyUrl = settings.baseURL ?? (settings.provider === DEFAULT_PROVIDER_NAME || settings.apiKey ? DEFAULT_PROVIDER_URL : undefined);
+    if (legacyUrl && !providers.some(provider => provider.name === DEFAULT_PROVIDER_NAME)) {
+        providers.unshift({
+            name: DEFAULT_PROVIDER_NAME,
+            url: legacyUrl,
+            ...(settings.apiKey ? { key: settings.apiKey } : {}),
+            models: normalizeModels([], settings.model ?? DEFAULT_MODEL),
+        });
+    }
+    if (providers.length === 0) {
+        return [{ name: DEFAULT_PROVIDER_NAME, url: DEFAULT_PROVIDER_URL, models: [settings.model ?? DEFAULT_MODEL] }];
+    }
+    return providers;
+}
+export function findProvider(settings, name) {
+    return configuredProviders(settings).find(provider => provider.name === name);
+}
+export function activeProvider(settings) {
+    const providers = configuredProviders(settings);
+    return providers.find(provider => provider.name === settings.provider) ?? providers[0];
+}
+export function activeModel(settings) {
+    const provider = activeProvider(settings);
+    const model = settings.model && provider.models.includes(settings.model)
+        ? settings.model
+        : settings.model ?? provider.models[0] ?? DEFAULT_MODEL;
+    return { provider, model };
+}
+export function resolveModelSelector(settings, selector) {
+    const trimmed = selector.trim();
+    if (!trimmed)
+        return { status: 'missing' };
+    const separator = trimmed.indexOf(':');
+    if (separator > 0) {
+        const providerName = trimmed.slice(0, separator).trim();
+        const model = trimmed.slice(separator + 1).trim();
+        const provider = findProvider(settings, providerName);
+        if (!provider || !model || !provider.models.includes(model))
+            return { status: 'missing' };
+        return { status: 'found', provider, model };
+    }
+    const matches = configuredProviders(settings).filter(provider => provider.models.includes(trimmed));
+    if (matches.length === 1)
+        return { status: 'found', provider: matches[0], model: trimmed };
+    if (matches.length > 1)
+        return { status: 'ambiguous', model: trimmed, providers: matches };
+    return { status: 'missing' };
+}
+export function modelSelector(provider, model) {
+    return `${provider.name}:${model}`;
+}
+export function upsertProvider(settings, provider) {
+    const providers = configuredProviders(settings).filter(existing => existing.name !== provider.name);
+    return [...providers, provider];
+}
+export function providerHasKey(settings, provider) {
+    return Boolean(provider.key ?? (provider.name === DEFAULT_PROVIDER_NAME ? settings.apiKey : undefined));
+}

package/dist/config/settings.d.ts

@@ -1,8 +1,15 @@
+export interface HazeProviderSettings {
+    name: string;
+    url: string;
+    key?: string;
+    models: string[];
+}
 export interface HazeSettings {
-    provider?: 'openrouter';
+    provider?: string;
+    model?: string;
+    providers?: HazeProviderSettings[];
     apiKey?: string;
     baseURL?: string;
-    model?: string;
 }
 export declare const SETTINGS_FILE: string;
 export declare function readSettings(): Promise<HazeSettings>;

package/dist/core/agent/compaction.d.ts

@@ -0,0 +1,13 @@
+import type { ModelMessage } from 'ai';
+export interface CompactionResult {
+    compacted: boolean;
+    messages: ModelMessage[];
+    olderCount: number;
+    keptCount: number;
+    summary?: string;
+}
+export declare function modelMessageText(message: ModelMessage): string;
+export declare function compactModelMessages(messages: ModelMessage[], options?: {
+    keepRecentMessages?: number;
+    instructions?: string;
+}): CompactionResult;

package/dist/core/agent/compaction.js

@@ -0,0 +1,34 @@
+export function modelMessageText(message) {
+    const content = message.content;
+    if (typeof content === 'string')
+        return content;
+    if (!Array.isArray(content))
+        return '';
+    return content.map(part => typeof part === 'object' && part != null && 'text' in part && typeof part.text === 'string' ? part.text : '').filter(Boolean).join('\n');
+}
+export function compactModelMessages(messages, options = {}) {
+    const keepRecentMessages = options.keepRecentMessages ?? 12;
+    if (messages.length <= keepRecentMessages) {
+        return { compacted: false, messages, olderCount: 0, keptCount: messages.length };
+    }
+    const older = messages.slice(0, -keepRecentMessages);
+    const recent = messages.slice(-keepRecentMessages);
+    const oldText = older.map(message => {
+        const text = modelMessageText(message).replace(/\s+/g, ' ').trim();
+        return text ? `- ${message.role}: ${text.slice(0, 500)}` : '';
+    }).filter(Boolean).join('\n');
+    const summary = [
+        'Compacted prior Haze conversation. Continue preserving the user goal, constraints, decisions, files touched, validation results, and unresolved next steps from this summary.',
+        options.instructions ? `User compaction instructions: ${options.instructions}` : undefined,
+        '',
+        'Older context summary:',
+        oldText || '- Older messages were tool-only or non-text.',
+    ].filter((line) => line !== undefined).join('\n');
+    return {
+        compacted: true,
+        messages: [{ role: 'system', content: summary }, ...recent],
+        olderCount: older.length,
+        keptCount: recent.length,
+        summary,
+    };
+}

package/dist/core/agent/errors.d.ts

@@ -0,0 +1,3 @@
+export declare function errorText(error: unknown): string;
+export declare function isContextOverflowError(error: unknown): boolean;
+export declare function isRetryableModelError(error: unknown): boolean;

package/dist/core/agent/errors.js

@@ -0,0 +1,13 @@
+export function errorText(error) {
+    return (error instanceof Error ? `${error.name} ${error.message}` : String(error)).toLowerCase();
+}
+export function isContextOverflowError(error) {
+    const text = errorText(error);
+    return /context length|context window|context limit|maximum context|max context|token limit|too many tokens|input too long|prompt too long|context.*exceed|tokens.*exceed/.test(text);
+}
+export function isRetryableModelError(error) {
+    const text = errorText(error);
+    if (isContextOverflowError(error) || /quota|billing|balance|auth|api key|invalid request|permission|forbidden|401|403|400/.test(text))
+        return false;
+    return /overload|rate limit|429|500|502|503|504|network|connection|stream|timeout|timed? out|econnreset|etimedout|fetch failed/.test(text);
+}

package/dist/core/agent/events.d.ts

@@ -0,0 +1,58 @@
+export type AgentEvent = {
+    type: 'turn_start';
+    request: string;
+    at: string;
+} | {
+    type: 'turn_end';
+    request: string;
+    at: string;
+    status: 'complete' | 'aborted' | 'failed';
+} | {
+    type: 'message_start';
+    id: string;
+    role: 'assistant';
+    at: string;
+} | {
+    type: 'message_update';
+    id: string;
+    text: string;
+    at: string;
+} | {
+    type: 'message_end';
+    id: string;
+    text: string;
+    at: string;
+    hidden?: boolean;
+} | {
+    type: 'tool_start';
+    id: string;
+    name: string;
+    input: unknown;
+    at: string;
+} | {
+    type: 'tool_end';
+    id: string;
+    name: string;
+    success: boolean;
+    output?: unknown;
+    error?: unknown;
+    durationMs: number;
+    at: string;
+} | {
+    type: 'retry';
+    attempt: number;
+    maxAttempts: number;
+    delayMs: number;
+    error: string;
+    at: string;
+} | {
+    type: 'context_overflow';
+    recovered: boolean;
+    error: string;
+    at: string;
+};
+export type AgentEventSink = (event: AgentEvent) => void;
+export type AgentEventInput = AgentEvent extends infer Event ? Event extends {
+    at: string;
+} ? Omit<Event, 'at'> : never : never;
+export declare function agentEvent(event: AgentEventInput): AgentEvent;

package/dist/core/agent/events.js

@@ -0,0 +1,3 @@
+export function agentEvent(event) {
+    return { ...event, at: new Date().toISOString() };
+}

package/dist/core/goal/completionPolicy.d.ts

@@ -0,0 +1,27 @@
+import type { SessionGoal } from './sessionGoal.js';
+export declare function looksIncomplete(text: string): boolean;
+export declare function looksBlocked(text: string): boolean;
+export interface CompletionPolicyInput {
+    request: string;
+    goal: SessionGoal;
+    assistantText: string;
+    sawReadOnlyTool: boolean;
+    sawToolCall: boolean;
+    mutatingToolSucceeded: boolean;
+    validationToolSucceeded: boolean;
+    validationToolFailed: boolean;
+    editFileFailed: boolean;
+    editRecoveryPath?: string;
+}
+export interface CompletionDecision {
+    needsActionContinuation: boolean;
+    needsValidationContinuation: boolean;
+    requestCompletedByTools: boolean;
+    assistantAdmitsIncomplete: boolean;
+    assistantReportsBlocker: boolean;
+    continuationPrompt?: string;
+}
+export declare function completionDecision(input: CompletionPolicyInput): CompletionDecision;
+export declare function toolLoopBudgetPrompt(): string;
+export declare function postContinuationPrompt(): string;
+export declare function noTextAfterToolPrompt(allowTools: boolean): "Continue the original request now. If it asks for a change, edit or write the necessary files. If it asks to run or verify tests, run the command. Do not provide only a retrospective summary unless blocked." | "Continue from the tool result and answer my original request. Do not call tools. Summarize only current-turn changes and validation; do not recap unrelated earlier tasks.";

package/dist/core/goal/completionPolicy.js

@@ -0,0 +1,67 @@
+import { isActionRequest, isPlanOnlyRequest, isValidationRequest } from './requestClassifier.js';
+export function looksIncomplete(text) {
+    return /\b(incomplete|what remains|remains:|remaining:|next:|not implemented|not created|no tests exist|created no docs|has not been|have not been|not yet|never executed|not executed|not run|cannot retry|cannot write|cannot validate|tool budget reached)/i.test(text);
+}
+export function looksBlocked(text) {
+    return /\b(blocked|blocker|needs user|need user|missing permission|permission denied|missing dependency|no practical validation|unable to validate|can't validate|cannot validate)\b/i.test(text);
+}
+export function completionDecision(input) {
+    const likelyPlanOnlyRequest = isPlanOnlyRequest(input.request);
+    const likelyActionRequest = isActionRequest(input.request);
+    const likelyValidationRequest = isValidationRequest(input.request);
+    const assistantAdmitsIncomplete = looksIncomplete(input.assistantText);
+    const assistantReportsBlocker = looksBlocked(input.assistantText);
+    const requestCompletedByTools = input.mutatingToolSucceeded && input.validationToolSucceeded && !input.editRecoveryPath;
+    const changedActionNeedsValidation = likelyActionRequest
+        && !likelyPlanOnlyRequest
+        && input.mutatingToolSucceeded
+        && !input.validationToolSucceeded
+        && !input.validationToolFailed
+        && !input.editRecoveryPath
+        && !assistantReportsBlocker;
+    const needsActionContinuation = likelyActionRequest
+        && !likelyPlanOnlyRequest
+        && !requestCompletedByTools
+        && ((input.sawReadOnlyTool && !input.mutatingToolSucceeded) || input.validationToolFailed || input.editFileFailed || assistantAdmitsIncomplete);
+    const needsValidationContinuation = (likelyValidationRequest || changedActionNeedsValidation)
+        && !requestCompletedByTools
+        && !input.validationToolSucceeded
+        && !assistantReportsBlocker;
+    let continuationPrompt;
+    if (input.editFileFailed) {
+        continuationPrompt = 'Your editFile attempt failed. Use the latest readFile line-numbered output and replaceLines to complete the requested change. Continue with any remaining tests or validation if relevant. Do not stop with a summary.';
+    }
+    else if (input.validationToolFailed && input.mutatingToolSucceeded) {
+        continuationPrompt = 'Validation failed after files changed in this task. Inspect the failure output, fix failures that are plausibly caused by the current change, then rerun the relevant validation once. If the failure is clearly unrelated or environment-specific, summarize the blocker instead of expanding scope.';
+    }
+    else if (needsValidationContinuation) {
+        continuationPrompt = changedActionNeedsValidation
+            ? 'Files changed for this request, but no validation has run yet. Continue by running the smallest relevant test/check command you can identify from the project. If no practical validation exists, state that concrete blocker briefly instead of claiming the goal is complete.'
+            : 'You have not run the requested validation yet. Continue now by running the appropriate test/check command. Summarize only after the command finishes.';
+    }
+    else if (input.mutatingToolSucceeded && assistantAdmitsIncomplete) {
+        continuationPrompt = 'Your previous response says the current request is incomplete. Continue now with the remaining edits and validation for this same request. Do not summarize a plan unless blocked.';
+    }
+    else if (needsActionContinuation) {
+        continuationPrompt = 'You inspected files but have not made the requested change yet. Continue now by editing or writing the necessary files. Do not summarize a plan unless blocked.';
+    }
+    return {
+        needsActionContinuation,
+        needsValidationContinuation,
+        requestCompletedByTools,
+        assistantAdmitsIncomplete,
+        assistantReportsBlocker,
+        continuationPrompt,
+    };
+}
+export function toolLoopBudgetPrompt() {
+    return 'Tool budget reached. You cannot call tools now, and you must not output XML, JSON tool-call syntax, <tool_call> blocks, or function-call markup. If the current request is complete, summarize only current-turn changes and validation. If the requested change is incomplete, state the concrete blocker briefly. Do not claim tools are unavailable, recap unrelated earlier tasks, or provide a generic remains list.';
+}
+export function postContinuationPrompt() {
+    return 'Your previous response still described unfinished work, missing validation, or a tool-budget issue. If any tools are still available, complete the remaining edit or run the final validation now. Only call something a blocker if a concrete tool failure prevents progress.';
+}
+export function noTextAfterToolPrompt(allowTools) {
+    return allowTools
+        ? 'Continue the original request now. If it asks for a change, edit or write the necessary files. If it asks to run or verify tests, run the command. Do not provide only a retrospective summary unless blocked.'
+        : 'Continue from the tool result and answer my original request. Do not call tools. Summarize only current-turn changes and validation; do not recap unrelated earlier tasks.';
+}

package/dist/core/goal/requestClassifier.d.ts

@@ -0,0 +1,6 @@
+export type RequestIntent = 'implement' | 'fix' | 'test' | 'review' | 'plan' | 'answer' | 'unknown';
+export declare function isPlanOnlyRequest(value: string): boolean;
+export declare function isPlanImplementationRequest(value: string): boolean;
+export declare function isValidationRequest(value: string): boolean;
+export declare function isActionRequest(value: string): boolean;
+export declare function classifyRequestIntent(value: string): RequestIntent;

package/dist/core/goal/requestClassifier.js

@@ -0,0 +1,31 @@
+export function isPlanOnlyRequest(value) {
+    return /\b(create|make|write|draft|outline)\s+(?:a\s+)?plan\b|\bplan\s+(?:for|to)\b/i.test(value) && !/\bimplement|execute|do\b/i.test(value);
+}
+export function isPlanImplementationRequest(value) {
+    return /\b(implement|execute|do)\b.*\bplan\b|\bplan\.md\b|\btest_plan\.md\b/i.test(value);
+}
+export function isValidationRequest(value) {
+    if (isPlanOnlyRequest(value))
+        return false;
+    return /\b(run|verify|test|tests|check|validate)\b/i.test(value);
+}
+export function isActionRequest(value) {
+    if (isPlanOnlyRequest(value))
+        return false;
+    return /\b(add|create|write|implement|update|fix|change|support|wire|test|tests|document|docs|documentation|run|verify)\b/i.test(value);
+}
+export function classifyRequestIntent(value) {
+    if (isPlanOnlyRequest(value))
+        return 'plan';
+    if (/\b(review|audit|inspect|analy[sz]e|compare)\b/i.test(value))
+        return 'review';
+    if (/\b(fix|repair|resolve|debug)\b/i.test(value))
+        return 'fix';
+    if (/\b(run|verify|check|validate)\b/i.test(value) || /\btests?\b/i.test(value) && !/\b(add|create|write)\b/i.test(value))
+        return 'test';
+    if (/\b(add|create|write|implement|update|change|support|wire|document|docs|documentation)\b/i.test(value))
+        return 'implement';
+    if (/\b(what|why|how|explain|tell me)\b/i.test(value))
+        return 'answer';
+    return 'unknown';
+}

package/dist/core/goal/sessionGoal.d.ts

@@ -0,0 +1,30 @@
+import { type RequestIntent } from './requestClassifier.js';
+export type SessionGoalStatus = 'active' | 'needs-user' | 'blocked' | 'complete' | 'aborted';
+export type ValidationStatus = 'pending' | 'passed' | 'failed';
+export interface SessionGoal {
+    id: string;
+    originalUserRequest: string;
+    normalizedIntent: RequestIntent;
+    successCriteria: string[];
+    constraints: string[];
+    touchedFiles: string[];
+    validationCommands: Array<{
+        command: string;
+        status: ValidationStatus;
+    }>;
+    status: SessionGoalStatus;
+    phase: 'starting' | 'inspecting' | 'editing' | 'validating' | 'summarizing' | 'done';
+    blocker?: string;
+    lastProgressAt: number;
+}
+export interface GoalToolEvent {
+    toolName: string;
+    input?: unknown;
+    success: boolean;
+    output?: unknown;
+    error?: unknown;
+    duplicateSkipped?: boolean;
+}
+export declare function createSessionGoal(request: string, now?: number): SessionGoal;
+export declare function observeGoalToolEvent(goal: SessionGoal, event: GoalToolEvent, now?: number): SessionGoal;
+export declare function formatGoalStatus(goal: SessionGoal): string;

package/dist/core/goal/sessionGoal.js

@@ -0,0 +1,88 @@
+import { classifyRequestIntent } from './requestClassifier.js';
+function shortRequest(value) {
+    return value.replace(/\s+/g, ' ').trim().slice(0, 160) || 'current request';
+}
+function inputPath(input) {
+    return typeof input === 'object' && input != null && 'path' in input && typeof input.path === 'string'
+        ? input.path
+        : undefined;
+}
+function bashCommand(input) {
+    return typeof input === 'object' && input != null && 'command' in input && typeof input.command === 'string'
+        ? input.command
+        : undefined;
+}
+function uniquePush(values, value) {
+    if (!values.includes(value))
+        values.push(value);
+}
+export function createSessionGoal(request, now = Date.now()) {
+    const intent = classifyRequestIntent(request);
+    const criteria = intent === 'plan'
+        ? ['Create or update the requested plan artifact/answer', 'Do not implement source changes unless asked']
+        : intent === 'test'
+            ? ['Run the requested validation or closest relevant check', 'Report pass/fail accurately']
+            : intent === 'review'
+                ? ['Inspect the relevant current project state', 'Return evidence-based findings with file paths']
+                : intent === 'answer'
+                    ? ['Answer the user using current project context when needed']
+                    : ['Inspect the relevant files', 'Make the requested change when needed', 'Validate the change when practical', 'Summarize only current-task changes and validation'];
+    return {
+        id: `goal-${now}-${Math.random().toString(36).slice(2)}`,
+        originalUserRequest: request,
+        normalizedIntent: intent,
+        successCriteria: criteria,
+        constraints: [],
+        touchedFiles: [],
+        validationCommands: [],
+        status: 'active',
+        phase: 'starting',
+        lastProgressAt: now,
+    };
+}
+export function observeGoalToolEvent(goal, event, now = Date.now()) {
+    if (event.duplicateSkipped)
+        return goal;
+    if (event.success && ['listFiles', 'readFile'].includes(event.toolName)) {
+        goal.phase = goal.phase === 'editing' || goal.phase === 'validating' ? goal.phase : 'inspecting';
+        goal.lastProgressAt = now;
+    }
+    if (['editFile', 'replaceLines', 'writeFile'].includes(event.toolName)) {
+        const path = inputPath(event.input);
+        if (path)
+            uniquePush(goal.touchedFiles, path);
+        if (event.success) {
+            goal.phase = 'editing';
+            goal.lastProgressAt = now;
+        }
+        else {
+            goal.blocker = `File edit failed${path ? ` for ${path}` : ''}; recovery read is required before retry.`;
+        }
+    }
+    if (event.toolName === 'bash') {
+        const command = bashCommand(event.input);
+        if (command) {
+            const ok = typeof event.output === 'object' && event.output != null && 'ok' in event.output ? Boolean(event.output.ok) : event.success;
+            const existing = goal.validationCommands.find(item => item.command === command);
+            const status = ok ? 'passed' : 'failed';
+            if (existing)
+                existing.status = status;
+            else
+                goal.validationCommands.push({ command, status });
+            goal.phase = 'validating';
+            goal.lastProgressAt = now;
+            if (!ok)
+                goal.blocker = `Validation command failed: ${command}`;
+        }
+    }
+    return goal;
+}
+export function formatGoalStatus(goal) {
+    const action = goal.phase === 'starting' ? 'starting'
+        : goal.phase === 'inspecting' ? 'inspecting'
+            : goal.phase === 'editing' ? `${goal.touchedFiles.length} file${goal.touchedFiles.length === 1 ? '' : 's'} changed`
+                : goal.phase === 'validating' ? `validation ${goal.validationCommands.at(-1)?.status ?? 'running'}`
+                    : goal.phase === 'summarizing' ? 'summarizing'
+                        : 'done';
+    return `Goal: ${shortRequest(goal.originalUserRequest)} · ${action}`;
+}

package/dist/core/session/sessionStore.d.ts

@@ -0,0 +1,37 @@
+import type { ModelMessage } from 'ai';
+export type SessionEntry = {
+    type: 'header';
+    id: string;
+    cwd: string;
+    createdAt: string;
+    hazeVersion?: string;
+} | {
+    type: 'ui_message';
+    at: string;
+    role: 'system' | 'user' | 'assistant' | 'tool';
+    text: string;
+} | {
+    type: 'conversation_snapshot';
+    at: string;
+    messages: ModelMessage[];
+} | {
+    type: 'event';
+    at: string;
+    name: string;
+    text?: string;
+};
+export interface HazeSession {
+    id: string;
+    file: string;
+    cwd: string;
+}
+export declare function createSession(options?: {
+    cwd?: string;
+    hazeVersion?: string;
+    sessionsDir?: string;
+}): Promise<HazeSession>;
+export declare function latestSession(cwd?: string, sessionsDir?: string): Promise<HazeSession | undefined>;
+export declare function appendSessionEntry(session: HazeSession, entry: SessionEntry): Promise<void>;
+export declare function readSessionEntries(session: HazeSession): Promise<SessionEntry[]>;
+export declare function restoreConversation(session: HazeSession): Promise<ModelMessage[]>;
+export declare function formatSession(session: HazeSession): string;

package/dist/core/session/sessionStore.js

@@ -0,0 +1,59 @@
+import crypto from 'node:crypto';
+import path from 'node:path';
+import fs from 'fs-extra';
+import { HAZE_DIR } from '../../config/paths.js';
+const DEFAULT_SESSIONS_DIR = path.join(HAZE_DIR, 'sessions');
+function cwdHash(cwd = process.cwd()) {
+    return crypto.createHash('sha256').update(path.resolve(cwd)).digest('hex').slice(0, 16);
+}
+function sessionDir(cwd = process.cwd(), sessionsDir = DEFAULT_SESSIONS_DIR) {
+    return path.join(sessionsDir, cwdHash(cwd));
+}
+function sessionFile(id, cwd = process.cwd(), sessionsDir = DEFAULT_SESSIONS_DIR) {
+    return path.join(sessionDir(cwd, sessionsDir), `${id}.jsonl`);
+}
+function newSessionId(now = new Date()) {
+    return now.toISOString().replace(/[:.]/g, '-');
+}
+export async function createSession(options = {}) {
+    const cwd = path.resolve(options.cwd ?? process.cwd());
+    const id = newSessionId();
+    const file = sessionFile(id, cwd, options.sessionsDir);
+    await fs.ensureDir(path.dirname(file));
+    await appendSessionEntry({ id, file, cwd }, { type: 'header', id, cwd, createdAt: new Date().toISOString(), hazeVersion: options.hazeVersion });
+    return { id, file, cwd };
+}
+export async function latestSession(cwd = process.cwd(), sessionsDir = DEFAULT_SESSIONS_DIR) {
+    const dir = sessionDir(cwd, sessionsDir);
+    const files = (await fs.readdir(dir).catch(() => []))
+        .filter(file => file.endsWith('.jsonl'))
+        .sort();
+    const latest = files.at(-1);
+    if (!latest)
+        return undefined;
+    const id = path.basename(latest, '.jsonl');
+    return { id, file: path.join(dir, latest), cwd: path.resolve(cwd) };
+}
+export async function appendSessionEntry(session, entry) {
+    await fs.ensureDir(path.dirname(session.file));
+    await fs.appendFile(session.file, `${JSON.stringify(entry)}\n`, 'utf8');
+}
+export async function readSessionEntries(session) {
+    const raw = await fs.readFile(session.file, 'utf8');
+    return raw.split('\n').filter(Boolean).flatMap(line => {
+        try {
+            return [JSON.parse(line)];
+        }
+        catch {
+            return [];
+        }
+    });
+}
+export async function restoreConversation(session) {
+    const entries = await readSessionEntries(session);
+    const snapshots = entries.filter((entry) => entry.type === 'conversation_snapshot');
+    return snapshots.at(-1)?.messages ?? [];
+}
+export function formatSession(session) {
+    return `${session.id} · ${session.file}`;
+}

package/dist/llm/client.d.ts

@@ -1 +1 @@
-export declare function model(): Promise<import("@ai-sdk/provider").LanguageModelV3 | null>;
+export declare function model(): Promise<import("@ai-sdk/provider").LanguageModelV3>;

package/dist/llm/client.js

@@ -1,11 +1,11 @@
 import { createOpenAI } from '@ai-sdk/openai';
 import { readSettings } from '../config/settings.js';
+import { activeModel } from '../config/providers.js';
 export async function model() {
     const settings = await readSettings();
-    const baseURL = process.env.OPENAI_BASE_URL ?? settings.baseURL;
-    const apiKey = process.env.OPENAI_API_KEY ?? settings.apiKey;
-    const name = process.env.HAZE_MODEL ?? settings.model ?? 'x-ai/grok-build-0.1';
-    if (!apiKey)
-        return null;
-    return createOpenAI({ apiKey, baseURL })(name);
+    const selection = activeModel(settings);
+    const baseURL = process.env.OPENAI_BASE_URL ?? selection.provider.url;
+    const apiKey = process.env.OPENAI_API_KEY ?? selection.provider.key ?? settings.apiKey ?? 'not-needed';
+    const name = process.env.HAZE_MODEL ?? selection.model;
+    return createOpenAI({ apiKey, baseURL }).chat(name);
 }