@zenera/cli 1.1.24 → 1.1.25

package/dist/meta/model.d.ts

@@ -0,0 +1,44 @@
+import { type KeyStore, type Provider } from './host.ts';
+/** The variable a project's `.env` names it with — a zen ref, not a wire id. */
+export declare const MODEL_ENV = "ZENERA_META_MODEL";
+export type ModelSource = 'flag' | 'shell' | 'env' | 'store' | 'project' | 'default';
+export interface ModelChoice {
+    /** a zen ref: `vertex/gemini-3.8-flash`, or a bare id for the default provider */
+    ref: string;
+    from: ModelSource;
+}
+export interface ModelSources {
+    flag?: string;
+    /** `ZENERA_META_MODEL` as it stood before the project's `.env` was folded in */
+    shell?: string;
+    /** the same variable after it was, which is the `.env` answer when they differ */
+    env?: string;
+    stored?: string;
+    /** the project's `agents.yaml` `model:` */
+    project?: string;
+    /** what a held key recommends, when nothing above answered */
+    fallback?: string;
+}
+/** Where the answer is looked for, best first. */
+export declare const ORDER: readonly ModelSource[];
+export declare function chooseModel(sources: ModelSources): ModelChoice | undefined;
+export declare const SOURCE_LABELS: Record<ModelSource, string>;
+/** First of each row is the default; the rest are what `--pick` offers beside it. */
+export declare const RECOMMENDED: Partial<Record<Provider, readonly string[]>>;
+/** The recommended ref for the first provider with a key, or for `only`. */
+export declare function defaultRef(store: KeyStore, only?: Provider): string | undefined;
+export interface MetaFile {
+    version: 1;
+    model?: string;
+}
+export declare const readMeta: () => Promise<MetaFile>;
+export declare function writeMeta(file: MetaFile): void;
+/**
+ * The provider a misspelt prefix was reaching for, if that is what it is.
+ *
+ * `vertes/gemini-3.8-flash` is shaped exactly like the OpenRouter id
+ * `meta-llama/llama-4`, so an unknown prefix cannot be an error on its own —
+ * only one close enough to a real provider name to be a slip of the hand.
+ */
+export declare function misspelledProvider(ref: string): Provider | undefined;
+//# sourceMappingURL=model.d.ts.map

package/dist/meta/model.js

@@ -0,0 +1,119 @@
+import { paths, PROVIDER_NAMES, readJson, writeJson, } from "./host.js";
+// ---------------------------------------------------------------------------
+// The model
+// ---------------------------------------------------------------------------
+/** The variable a project's `.env` names it with — a zen ref, not a wire id. */
+export const MODEL_ENV = 'ZENERA_META_MODEL';
+/** Where the answer is looked for, best first. */
+export const ORDER = [
+    'flag',
+    'shell',
+    'env',
+    'store',
+    'project',
+    'default',
+];
+export function chooseModel(sources) {
+    const at = {
+        flag: sources.flag,
+        // `.env` only fills gaps, so an answer that survived it came from the shell
+        shell: sources.shell,
+        env: sources.shell ? undefined : sources.env,
+        store: sources.stored,
+        project: sources.project,
+        default: sources.fallback,
+    };
+    for (const from of ORDER) {
+        const ref = at[from]?.trim();
+        if (ref) {
+            return { ref, from };
+        }
+    }
+    return undefined;
+}
+export const SOURCE_LABELS = {
+    flag: '--model',
+    shell: `${MODEL_ENV} (shell)`,
+    env: `${MODEL_ENV} (.env)`,
+    store: 'zen meta model',
+    project: 'agents.yaml model:',
+    default: 'recommended',
+};
+// ---------------------------------------------------------------------------
+// What to run when nobody said
+//
+// A first `zen meta` should work on a machine that has a key and nothing else,
+// so the last resort is the best model the keys on hand can buy rather than an
+// error. Deep tier deliberately: this agent is pointed at the project itself,
+// and a cheap model reading a specification is a false economy.
+// ---------------------------------------------------------------------------
+/** First of each row is the default; the rest are what `--pick` offers beside it. */
+export const RECOMMENDED = {
+    openai: ['gpt-5.6-sol', 'gpt-5.6-terra'],
+    anthropic: ['claude-opus-5', 'claude-sonnet-5'],
+    vertex: ['gemini-3.8-flash', 'gemini-3.5-flash-lite'],
+    google: ['gemini-3.8-flash', 'gemini-3.5-flash-lite'],
+    openrouter: ['anthropic/claude-opus-5', 'openai/gpt-5.6-sol'],
+};
+/** Which provider is tried first when several are held. */
+const PREFERENCE = ['anthropic', 'openai', 'vertex', 'google', 'openrouter'];
+/** The recommended ref for the first provider with a key, or for `only`. */
+export function defaultRef(store, only) {
+    for (const provider of only ? [only] : PREFERENCE) {
+        const id = RECOMMENDED[provider]?.[0];
+        if (id && store.active(provider)) {
+            return `${provider}/${id}`;
+        }
+    }
+    return undefined;
+}
+const EMPTY = { version: 1 };
+export const readMeta = () => readJson(paths.meta(), EMPTY);
+export function writeMeta(file) {
+    writeJson(paths.meta(), file);
+}
+// ---------------------------------------------------------------------------
+// Refs
+// ---------------------------------------------------------------------------
+/**
+ * The provider a misspelt prefix was reaching for, if that is what it is.
+ *
+ * `vertes/gemini-3.8-flash` is shaped exactly like the OpenRouter id
+ * `meta-llama/llama-4`, so an unknown prefix cannot be an error on its own —
+ * only one close enough to a real provider name to be a slip of the hand.
+ */
+export function misspelledProvider(ref) {
+    const slash = ref.indexOf('/');
+    if (slash <= 0) {
+        return undefined;
+    }
+    const head = ref.slice(0, slash).toLowerCase();
+    if (PROVIDER_NAMES.has(head)) {
+        return undefined;
+    }
+    for (const name of PROVIDER_NAMES) {
+        // Two, so that a transposition — which Levenshtein counts twice — reads
+        // as the typo it is. No provider name is short enough for that to be loose.
+        if (distance(head, name) <= 2) {
+            return name;
+        }
+    }
+    return undefined;
+}
+/** Levenshtein, one row at a time. Both operands are a word long. */
+function distance(a, b) {
+    if (Math.abs(a.length - b.length) > 2) {
+        return 3;
+    }
+    let row = Array.from({ length: b.length + 1 }, (_, i) => i);
+    for (let i = 1; i <= a.length; i++) {
+        const next = [i];
+        for (let j = 1; j <= b.length; j++) {
+            const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+            next[j] = Math.min(next[j - 1] + 1, row[j] + 1, row[j - 1] + cost);
+        }
+        row = next;
+    }
+    return row[b.length];
+}
+//# sourceMappingURL=model.js.map

package/dist/meta/prompts.d.ts

@@ -0,0 +1,18 @@
+export declare const PROMPT_DIR = ".github/prompts";
+/** `/project-review`, `project-review`, `project-review.prompt.md` or a path. */
+export declare function promptPath(dir: string, name: string): string;
+export interface StoredPrompt {
+    name: string;
+    path: string;
+    description?: string;
+    body: string;
+}
+/**
+ * Frontmatter is the editor's business — `mode`, `tools`, `description` — and
+ * none of it means anything to copilot, so only the body is sent. `description`
+ * is kept for the one line of narration that says which prompt is running.
+ */
+export declare function readPrompt(path: string, name: string, text: string): StoredPrompt;
+export declare function loadPrompt(dir: string, name: string): Promise<StoredPrompt>;
+export declare function listPrompts(dir: string): Promise<string[]>;
+//# sourceMappingURL=prompts.d.ts.map

package/dist/meta/prompts.js

@@ -0,0 +1,61 @@
+import { existsSync } from 'node:fs';
+import { readFile } from 'node:fs/promises';
+import { usageError } from "./host.js";
+// ---------------------------------------------------------------------------
+// Stored prompts
+//
+// Copilot reads `AGENTS.md`, `.github/skills/` and `.github/agents/`, but it
+// has no notion of `.github/prompts/*.prompt.md` — the files an editor offers
+// as slash commands. Reading one and handing over its body is the whole of
+// `zen meta run`, and it is why that subcommand exists.
+// ---------------------------------------------------------------------------
+export const PROMPT_DIR = '.github/prompts';
+const PROMPT_SUFFIX = '.prompt.md';
+/** `/project-review`, `project-review`, `project-review.prompt.md` or a path. */
+export function promptPath(dir, name) {
+    const bare = name.replace(/^\//, '');
+    if (bare.includes('/') || bare.endsWith('.md')) {
+        return `${dir}/${bare}`;
+    }
+    return `${dir}/${PROMPT_DIR}/${bare}${PROMPT_SUFFIX}`;
+}
+/**
+ * Frontmatter is the editor's business — `mode`, `tools`, `description` — and
+ * none of it means anything to copilot, so only the body is sent. `description`
+ * is kept for the one line of narration that says which prompt is running.
+ */
+export function readPrompt(path, name, text) {
+    let body = text;
+    let description;
+    const match = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?/.exec(text);
+    if (match) {
+        body = text.slice(match[0].length);
+        const found = /^description:\s*(.+)$/m.exec(match[1]);
+        description = found?.[1].trim().replace(/^['"]|['"]$/g, '');
+    }
+    return { name, path, description, body: body.trim() };
+}
+export async function loadPrompt(dir, name) {
+    const path = promptPath(dir, name);
+    if (!existsSync(path)) {
+        const known = await listPrompts(dir);
+        throw usageError(`no prompt named ${name.replace(/^\//, '')}`, known.length > 0
+            ? `try: ${known.map((p) => `/${p}`).join(', ')}`
+            : `put one in ${PROMPT_DIR}/`);
+    }
+    return readPrompt(path, name.replace(/^\//, ''), await readFile(path, 'utf8'));
+}
+export async function listPrompts(dir) {
+    const { readdir } = await import('node:fs/promises');
+    try {
+        const names = await readdir(`${dir}/${PROMPT_DIR}`);
+        return names
+            .filter((n) => n.endsWith(PROMPT_SUFFIX))
+            .map((n) => n.slice(0, -PROMPT_SUFFIX.length))
+            .sort();
+    }
+    catch {
+        return [];
+    }
+}
+//# sourceMappingURL=prompts.js.map

package/dist/meta/relay.d.ts

@@ -0,0 +1,20 @@
+export interface Relay {
+    url: string;
+    close(): Promise<void>;
+}
+export interface RelaySpec {
+    /** the per-session secret copilot must present; anything else on the machine is refused */
+    key: string;
+    /** `https://…/v1/projects/<project>/locations/<location>` */
+    base: string;
+    token: () => Promise<string>;
+}
+export interface VertexRelaySpec {
+    key: string;
+    project: string;
+    location: string;
+    keyFile: string;
+}
+export declare function startVertexRelay(spec: VertexRelaySpec): Promise<Relay>;
+export declare function startRelay(spec: RelaySpec): Promise<Relay>;
+//# sourceMappingURL=relay.d.ts.map

package/dist/meta/relay.js

@@ -0,0 +1,123 @@
+import { vertexEndpoint } from '@zenera/neo';
+import { GoogleAuth } from 'google-auth-library';
+import { timingSafeEqual } from 'node:crypto';
+import { createServer } from 'node:http';
+import { Readable } from 'node:stream';
+const VERTEX_VERSION = 'vertex-2023-10-16';
+export async function startVertexRelay(spec) {
+    const auth = new GoogleAuth({
+        keyFile: spec.keyFile,
+        scopes: ['https://www.googleapis.com/auth/cloud-platform'],
+    });
+    const at = vertexEndpoint({
+        project: spec.project,
+        location: spec.location,
+        token: async () => {
+            const token = await auth.getAccessToken();
+            if (!token) {
+                throw new Error(`${spec.keyFile} minted no access token`);
+            }
+            return token;
+        },
+    });
+    return startRelay({ key: spec.key, base: at.base, token: at.token });
+}
+export async function startRelay(spec) {
+    const server = createServer((req, res) => {
+        relay(spec, req, res).catch((err) => {
+            fail(res, 502, 'api_error', `relay to vertex: ${err.message}`);
+        });
+    });
+    await new Promise((done, reject) => {
+        server.once('error', reject);
+        server.listen(0, '127.0.0.1', done);
+    });
+    const { port } = server.address();
+    return {
+        url: `http://127.0.0.1:${port}`,
+        close: () => new Promise((done) => {
+            server.closeAllConnections();
+            server.close(() => done());
+        }),
+    };
+}
+async function relay(spec, req, res) {
+    if (!authorized(spec.key, req)) {
+        fail(res, 401, 'authentication_error', 'not this session’s relay key');
+        return;
+    }
+    const path = new URL(req.url ?? '/', 'http://relay').pathname;
+    const counting = path === '/v1/messages/count_tokens';
+    if (req.method !== 'POST' || (path !== '/v1/messages' && !counting)) {
+        fail(res, 404, 'not_found_error', `vertex serves no ${req.method} ${path} for Claude`);
+        return;
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(await readBody(req));
+    }
+    catch {
+        fail(res, 400, 'invalid_request_error', 'the body is not JSON');
+        return;
+    }
+    const { model, ...rest } = parsed;
+    if (!model) {
+        fail(res, 400, 'invalid_request_error', 'no model in the body');
+        return;
+    }
+    const url = counting
+        ? `${spec.base}/publishers/anthropic/models/count-tokens:rawPredict`
+        : `${spec.base}/publishers/anthropic/models/${encodeURIComponent(model)}:${rest.stream ? 'streamRawPredict' : 'rawPredict'}`;
+    const body = counting ? parsed : { ...rest, anthropic_version: VERTEX_VERSION };
+    const abort = new AbortController();
+    res.on('close', () => {
+        if (!res.writableFinished) {
+            abort.abort();
+        }
+    });
+    const beta = req.headers['anthropic-beta'];
+    const upstream = await fetch(url, {
+        method: 'POST',
+        headers: {
+            authorization: `Bearer ${await spec.token()}`,
+            'content-type': 'application/json',
+            ...(typeof beta === 'string' ? { 'anthropic-beta': beta } : {}),
+        },
+        body: JSON.stringify(body),
+        signal: abort.signal,
+    });
+    res.writeHead(upstream.status, {
+        'content-type': upstream.headers.get('content-type') ?? 'application/json',
+    });
+    if (!upstream.body) {
+        res.end();
+        return;
+    }
+    Readable.fromWeb(upstream.body)
+        .on('error', () => res.destroy())
+        .pipe(res);
+}
+function authorized(key, req) {
+    const header = req.headers['x-api-key'] ?? req.headers.authorization?.replace(/^Bearer /i, '');
+    const given = Buffer.from(typeof header === 'string' ? header : '');
+    const wanted = Buffer.from(key);
+    return given.length === wanted.length && timingSafeEqual(given, wanted);
+}
+function readBody(req) {
+    return new Promise((done, reject) => {
+        const chunks = [];
+        req.on('data', (c) => chunks.push(c));
+        req.on('end', () => done(Buffer.concat(chunks).toString('utf8')));
+        req.on('error', reject);
+    });
+}
+/** Anthropic's error shape, so copilot reports it as it would a direct call. */
+function fail(res, code, type, message) {
+    if (res.headersSent) {
+        res.destroy();
+        return;
+    }
+    res.writeHead(code, { 'content-type': 'application/json' });
+    res.end(JSON.stringify({ type: 'error', error: { type, message } }));
+}
+//# sourceMappingURL=relay.js.map

package/dist/meta/tokens.d.ts

@@ -0,0 +1,52 @@
+import type { ModelUsage, TokenUsage } from '@zenera/neo';
+export interface MetaCall {
+    model: string;
+    usage: TokenUsage;
+    cacheWriteTokens?: number;
+    startedAt: string;
+    durationMs: number;
+    session?: string;
+    traceId?: string;
+    spanId?: string;
+}
+/**
+ * One line of the span file, as a model call - anything else is undefined.
+ * Only counts are read off it: whatever else a span may carry, none of it
+ * reaches the ledger.
+ */
+export declare function readSpan(line: string): MetaCall | undefined;
+/** Whole lines out of a stream read in chunks; the unfinished tail is carried. */
+export declare function splitLines(carry: string, chunk: string): {
+    lines: string[];
+    carry: string;
+};
+/** Reads a span file as it grows. `stop()` reads what is left, once. */
+export declare function tailSpans(path: string, onCall: (call: MetaCall) => void, everyMs?: number): {
+    stop: () => void;
+};
+/** Calls and tokens so far, in the one line the status row and the summary share. */
+export declare class Tally {
+    calls: number;
+    usage: TokenUsage;
+    add(call: MetaCall): void;
+    toString(): string;
+}
+/** 950, 12.3k, 1.8M. */
+export declare function compact(n: number): string;
+/**
+ * Copilot's own per-model totals from the last `session.shutdown` in a session's
+ * events - cumulative over every resume of it. Reasoning folded into output,
+ * as everywhere in zen.
+ */
+export declare function shutdownModels(events: string): ModelUsage[] | undefined;
+export declare function sessionTotals(sessionId: string): ModelUsage[] | undefined;
+/** Whether this machine holds the session, which is what `--resume` needs. */
+export declare function sessionKept(sessionId: string): boolean;
+/**
+ * The model a session's history was written by: its last answer's, else the one it started on.
+ * A failed resume on another model writes no answer, so it never becomes the session's model.
+ */
+export declare function sessionModel(sessionId: string): string | undefined;
+/** `google/gemini-3.8-flash` and `gemini-3.8-flash` are one model to copilot. */
+export declare const sameModel: (a: string, b: string) => boolean;
+//# sourceMappingURL=tokens.d.ts.map

package/dist/meta/tokens.js

@@ -0,0 +1,226 @@
+import { closeSync, existsSync, openSync, readFileSync, readSync, statSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+/** An OTel time: `[seconds, nanoseconds]` in this exporter; epoch ms either way. */
+function epochMs(t) {
+    if (Array.isArray(t) && typeof t[0] === 'number') {
+        return t[0] * 1000 + Number(t[1] ?? 0) / 1e6;
+    }
+    if (typeof t === 'number') {
+        return t;
+    }
+    return typeof t === 'string' ? Date.parse(t) : undefined;
+}
+/**
+ * One line of the span file, as a model call - anything else is undefined.
+ * Only counts are read off it: whatever else a span may carry, none of it
+ * reaches the ledger.
+ */
+export function readSpan(line) {
+    let span;
+    try {
+        span = JSON.parse(line);
+    }
+    catch {
+        return undefined;
+    }
+    const attrs = (span.attributes ?? {});
+    if (span.type !== 'span' || attrs['gen_ai.operation.name'] !== 'chat') {
+        return undefined;
+    }
+    const num = (key) => Number(attrs[key] ?? 0) || 0;
+    const start = epochMs(span.startTime) ?? 0;
+    const end = epochMs(span.endTime) ?? start;
+    // Copilot counts reasoning beside the output; zen counts it inside.
+    const reasoning = num('gen_ai.usage.reasoning.output_tokens');
+    const cacheWrite = num('gen_ai.usage.cache_creation.input_tokens') ||
+        num('gen_ai.usage.cache_creation_input_tokens');
+    return {
+        model: String(attrs['gen_ai.response.model'] ?? attrs['gen_ai.request.model'] ?? '?'),
+        usage: {
+            inputTokens: num('gen_ai.usage.input_tokens'),
+            cachedInputTokens: num('gen_ai.usage.cache_read.input_tokens') ||
+                num('gen_ai.usage.cache_read_input_tokens'),
+            outputTokens: num('gen_ai.usage.output_tokens') + reasoning,
+            reasoningTokens: reasoning,
+        },
+        ...(cacheWrite ? { cacheWriteTokens: cacheWrite } : {}),
+        startedAt: new Date(start).toISOString(),
+        durationMs: Math.max(0, Math.round(end - start)),
+        session: typeof attrs['gen_ai.conversation.id'] === 'string'
+            ? attrs['gen_ai.conversation.id']
+            : undefined,
+        traceId: typeof span.traceId === 'string' ? span.traceId : undefined,
+        spanId: typeof span.spanId === 'string' ? span.spanId : undefined,
+    };
+}
+/** Whole lines out of a stream read in chunks; the unfinished tail is carried. */
+export function splitLines(carry, chunk) {
+    const parts = `${carry}${chunk}`.split('\n');
+    const rest = parts.pop() ?? '';
+    return { lines: parts.filter((l) => l.trim()), carry: rest };
+}
+/** Reads a span file as it grows. `stop()` reads what is left, once. */
+export function tailSpans(path, onCall, everyMs = 1000) {
+    let offset = 0;
+    let carry = '';
+    const poll = () => {
+        let fd;
+        try {
+            const size = statSync(path).size;
+            if (size <= offset) {
+                return;
+            }
+            fd = openSync(path, 'r');
+            const buf = Buffer.alloc(size - offset);
+            readSync(fd, buf, 0, buf.length, offset);
+            offset = size;
+            const split = splitLines(carry, buf.toString('utf8'));
+            carry = split.carry;
+            for (const line of split.lines) {
+                const call = readSpan(line);
+                if (call) {
+                    onCall(call);
+                }
+            }
+        }
+        catch {
+            // Not there yet: copilot creates it at the first span.
+        }
+        finally {
+            if (fd !== undefined) {
+                closeSync(fd);
+            }
+        }
+    };
+    const timer = setInterval(poll, everyMs);
+    timer.unref();
+    return {
+        stop: () => {
+            clearInterval(timer);
+            poll();
+        },
+    };
+}
+/** Calls and tokens so far, in the one line the status row and the summary share. */
+export class Tally {
+    calls = 0;
+    usage = {
+        inputTokens: 0,
+        cachedInputTokens: 0,
+        outputTokens: 0,
+        reasoningTokens: 0,
+    };
+    add(call) {
+        this.calls += 1;
+        this.usage = {
+            inputTokens: this.usage.inputTokens + call.usage.inputTokens,
+            cachedInputTokens: this.usage.cachedInputTokens + call.usage.cachedInputTokens,
+            outputTokens: this.usage.outputTokens + call.usage.outputTokens,
+            reasoningTokens: this.usage.reasoningTokens + call.usage.reasoningTokens,
+        };
+    }
+    toString() {
+        const u = this.usage;
+        const cached = u.cachedInputTokens ? ` (${compact(u.cachedInputTokens)} cached)` : '';
+        return (`${this.calls} call${this.calls === 1 ? '' : 's'} · ${compact(u.inputTokens)} in${cached}` +
+            ` · ${compact(u.outputTokens)} out`);
+    }
+}
+/** 950, 12.3k, 1.8M. */
+export function compact(n) {
+    if (n < 1000) {
+        return String(n);
+    }
+    if (n < 1e6) {
+        return `${(n / 1e3).toFixed(n < 1e4 ? 1 : 0)}k`;
+    }
+    return `${(n / 1e6).toFixed(n < 1e7 ? 2 : 1)}M`;
+}
+/**
+ * Copilot's own per-model totals from the last `session.shutdown` in a session's
+ * events - cumulative over every resume of it. Reasoning folded into output,
+ * as everywhere in zen.
+ */
+export function shutdownModels(events) {
+    const line = events
+        .split('\n')
+        .reverse()
+        .find((l) => l.includes('"session.shutdown"'));
+    if (!line) {
+        return undefined;
+    }
+    let metrics;
+    try {
+        metrics = JSON.parse(line).data?.modelMetrics ?? {};
+    }
+    catch {
+        return undefined;
+    }
+    return Object.entries(metrics).map(([model, m]) => {
+        const u = m.usage ?? {};
+        const reasoning = Number(u.reasoningTokens ?? 0);
+        return {
+            model,
+            calls: Number(m.requests?.count ?? 0),
+            usage: {
+                inputTokens: Number(u.inputTokens ?? 0),
+                cachedInputTokens: Number(u.cacheReadTokens ?? 0),
+                outputTokens: Number(u.outputTokens ?? 0) + reasoning,
+                reasoningTokens: reasoning,
+            },
+        };
+    });
+}
+export function sessionTotals(sessionId) {
+    const home = process.env.COPILOT_HOME ?? join(homedir(), '.copilot');
+    try {
+        return shutdownModels(readFileSync(join(home, 'session-state', sessionId, 'events.jsonl'), 'utf8'));
+    }
+    catch {
+        return undefined;
+    }
+}
+/** Whether this machine holds the session, which is what `--resume` needs. */
+export function sessionKept(sessionId) {
+    const home = process.env.COPILOT_HOME ?? join(homedir(), '.copilot');
+    return existsSync(join(home, 'session-state', sessionId));
+}
+/**
+ * The model a session's history was written by: its last answer's, else the one it started on.
+ * A failed resume on another model writes no answer, so it never becomes the session's model.
+ */
+export function sessionModel(sessionId) {
+    const home = process.env.COPILOT_HOME ?? join(homedir(), '.copilot');
+    let text;
+    try {
+        text = readFileSync(join(home, 'session-state', sessionId, 'events.jsonl'), 'utf8');
+    }
+    catch {
+        return undefined;
+    }
+    let started;
+    const lines = text.split('\n');
+    for (let i = lines.length - 1; i >= 0; i--) {
+        const line = lines[i];
+        if (!line.includes('"assistant.message"') && !line.includes('"session.start"')) {
+            continue;
+        }
+        try {
+            const event = JSON.parse(line);
+            if (event.type === 'assistant.message' && typeof event.data?.model === 'string') {
+                return event.data.model;
+            }
+            if (event.type === 'session.start' && typeof event.data?.selectedModel === 'string') {
+                started = event.data.selectedModel;
+            }
+        }
+        catch {
+            // A line cut by a crash says nothing.
+        }
+    }
+    return started;
+}
+/** `google/gemini-3.8-flash` and `gemini-3.8-flash` are one model to copilot. */
+export const sameModel = (a, b) => a.replace(/^.*\//, '').toLowerCase() === b.replace(/^.*\//, '').toLowerCase();
+//# sourceMappingURL=tokens.js.map