@stringsync/splates 0.0.61 → 1.13.3

package/vendor/@stringsync/splates-server/merge/refusal.d.ts

@@ -0,0 +1,58 @@
+import type { Git } from "../git";
+import type { Facts } from "../records";
+import type { FailedTest, WorktreeService } from "../tasks";
+import type { MergeState } from "./merge-state";
+/** What a failing gate said and ran on, as `refuseTestsFailed` reports it. */
+export interface GateFailed {
+    task: string;
+    branch: string;
+    base: string;
+    /** The task's checkout, where the failing files can be run. */
+    cwd: string;
+    /** The gate's command, named in the refusal. */
+    command: string;
+    /** The gate's whole output, printed whole up to a cap. */
+    output: string;
+    /** The file holding all of it, when the gate printed to one. */
+    log?: string;
+    exitCode: number;
+    /** The failing cases of its JUnit report, for what landed since. */
+    failing: FailedTest[];
+    /** The base commit the branch sits on now, which it was tested against alone. */
+    onto: string;
+    /** The commit the task was gated on: `onto`, or the stack under it in a batch. */
+    rebasedOnto: string;
+    /** The branch's tip as gated. */
+    testedHead: string;
+    /** The base the branch sat on before the merge rebased it, if known. */
+    lastBase: string | null;
+    /** The tasks it was gated with, leader first, and the stack commit to reproduce on. */
+    batch?: {
+        tasks: string[];
+        at: string;
+    };
+}
+/**
+ * Refuses a merge whose gate failed: records the failure on the task,
+ * spending an attempt only where the charge rules say, names what landed on
+ * the base meanwhile, and ends in `tests_failed` with the failing tests and
+ * what to do last, where an agent reading the end finds them.
+ */
+export declare function refuseTestsFailed({ git, service, state, }: {
+    git: Git;
+    service: WorktreeService;
+    state: MergeState;
+}, failed: GateFailed, facts: Partial<Facts["merge"]>): Promise<never>;
+/**
+ * The end of what git or the gate printed, bounded for the merge event,
+ * which the page opens to say why a merge was refused.
+ */
+export declare function said(output: string): string;
+/**
+ * What a failing gate printed, whole while it fits the caps. Past them the
+ * start and the end stay, since the first error is often the cause, and the
+ * cut says how much it left out and where all of it is.
+ */
+export declare function shown(output: string, log?: string): string;
+export declare function tail(output: string, lines?: number): string;
+export declare function indent(text: string): string;

package/vendor/@stringsync/splates-server/merge/split.d.ts

@@ -0,0 +1,34 @@
+import type { Logger } from "../../../core/log/index.js";
+import type { Git } from "../git";
+import type { FailedTest } from "../tasks";
+import type { FailureAttribution } from "./attribution";
+import type { Member, MergeBatch } from "./batch";
+import type { GateRun, MergeGate } from "./gate";
+import type { MergeState } from "./merge-state";
+/**
+ * Settles a batch whose gate failed, by what the failure was pinned on, and
+ * says what the leader does next: `again` gates the batch once more without
+ * the follower whose commits the failing tests first fail with, told its
+ * refusal; `alone` lets every follower go and gates the leader by itself,
+ * since the failure told nothing one task can be blamed for; `refuse` ends
+ * the leader's merge as the gate said, every follower told the same where
+ * the base fails alone.
+ */
+export declare function splitBatch({ batch, gate, git, log, state, }: {
+    batch: MergeBatch;
+    gate: MergeGate;
+    git: Git;
+    log: Logger;
+    state: MergeState;
+}, { cwd, task, stack, gated, kind, failed, }: {
+    /** The checkout of the stack's tip the gate ran in. */
+    cwd: string;
+    /** The leader. */
+    task: string;
+    /** The leader first, then each follower on the one before. */
+    stack: Member[];
+    gated: GateRun;
+    kind: FailureAttribution | undefined;
+    /** The failing tests the gate named, with their files. */
+    failed: FailedTest[];
+}): Promise<"again" | "alone" | "refuse">;

package/vendor/@stringsync/splates-server/merge/steps.d.ts

@@ -0,0 +1,37 @@
+import { type Clock, type WallClock } from "../../../core/time/index.js";
+import type { LivePhase, MergeProgress, MergeStep } from "../tasks";
+/**
+ * The steps a merge under way has taken, as its task's record keeps them for
+ * the page to show it moving: each step from when it began, and the
+ * premerge's phases while it tests.
+ */
+export declare class MergeSteps {
+    private readonly clock;
+    private readonly wall;
+    private steps;
+    private phases;
+    private readonly starts;
+    constructor(clock?: Clock, wall?: WallClock);
+    /**
+     * Begins `step`, unless it is the one under way, and gives the record to
+     * save. `output` names the file its command prints to, for the page to
+     * follow; given for the step under way, it takes it too.
+     */
+    enter(step: MergeStep, output?: string): MergeProgress;
+    /**
+     * Marks the premerge under way as a batch's that split, the branch let
+     * go to wait for its own turn, and begins that wait.
+     */
+    leftBatch(): MergeProgress;
+    /** Takes the premerge's phases so far, and gives the record to save. */
+    phased(phases: LivePhase[]): MergeProgress;
+    /**
+     * The milliseconds spent in each step so far, each step's runs summed
+     * across retests, the one under way up to now. A premerge in a batch
+     * that split counts as waiting, the branch's own turn still to come.
+     */
+    get ms(): Partial<Record<MergeStep, number>>;
+    /** Where the step to come, the merge's next, would keep its output. */
+    outputOf(gitDir: string, step: MergeStep): string;
+    get progress(): MergeProgress;
+}

package/vendor/@stringsync/splates-server/merge/test-report.d.ts

@@ -0,0 +1,29 @@
+import type { FailedTest } from "../tasks";
+/** One test as a JUnit report timed it. */
+export interface TimedTest {
+    /** Its describe blocks and its own name, joined as bun prints them: `outer > inner > name`. */
+    name: string;
+    /** The file it is in, when the report says. */
+    file?: string;
+    seconds: number;
+}
+/**
+ * Each test in a JUnit XML report with the time it took, as `bun test
+ * --reporter=junit`, vitest, jest-junit and pytest write it. The outermost
+ * suite is the file or the runner, so only the suites inside it name the
+ * test's describe blocks.
+ */
+export declare function timedTests(xml: string): TimedTest[];
+/** A failed JUnit case; file is absent when the runner did not locate it. */
+export interface FailingCase extends FailedTest {
+    file?: string;
+}
+/** Failures and errors in a complete JUnit report, including inherited suite files. */
+export declare function failingCases(xml: string): FailingCase[];
+/**
+ * The tests a runner reported as failing, each with what it said, which the
+ * tail cuts off. Another runner prints none, so the tail alone is what the
+ * agent gets. An error thrown between tests fails the run with no test
+ * failing, so it is named for the file it came from.
+ */
+export declare function failedTests(output: string): FailedTest[];

package/vendor/@stringsync/splates-server/merge/timing.d.ts

@@ -0,0 +1,20 @@
+import type { Clock } from "../../../core/time/index.js";
+import type { Facts, GatePhases } from "../records";
+import type { MergeTimes } from "../tasks";
+import type { MergeSteps } from "./steps";
+/** Updates the caller's facts even when a merge or a gate refuses. */
+export declare class MergeTiming implements Disposable {
+    private readonly facts;
+    private readonly clock;
+    private readonly started;
+    private steps;
+    constructor(facts: Partial<Facts["merge"]>, clock: Clock);
+    track(fact: "gateMs" | "capacityWaitMs"): Disposable;
+    /** Keeps the time of each of `steps` once the merge ends. */
+    stepping(steps: MergeSteps): void;
+    /** Keeps a whole gate run's phases, each run's in place of the last's. */
+    gated(phases: GatePhases): void;
+    /** How long the merge so far waited for the premerge lock, and ran besides. */
+    get times(): MergeTimes;
+    [Symbol.dispose](): void;
+}

package/vendor/@stringsync/splates-server/merge/trunk.d.ts

@@ -0,0 +1,69 @@
+import type { Fs } from "../../../core/system/index.js";
+import { z } from "zod";
+import type { Config } from "../config";
+import type { Git } from "../git";
+/** Who holds the merge lease, as its `holder.json` names them. */
+export declare const LeaseHolder: z.ZodObject<{
+    pid: z.ZodNumber;
+    hostname: z.ZodString;
+}, z.core.$strip>;
+export type LeaseHolder = z.infer<typeof LeaseHolder>;
+/**
+ * What a merge holding the lease lands: `head`, the
+ * tested `splates/<task>` it pushed, onto `onto`, the trunk commit it
+ * rebased onto and tested on.
+ */
+export declare const LandRequest: z.ZodObject<{
+    task: z.ZodString;
+    onto: z.ZodString;
+    head: z.ZodString;
+    holder: z.ZodObject<{
+        pid: z.ZodNumber;
+        hostname: z.ZodString;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type LandRequest = z.infer<typeof LandRequest>;
+/** How a landing went. */
+export type Landed = 
+/** Trunk is `head` on the remote; `local` says what became of the server's own checkout. */
+{
+    status: "landed";
+    local: "moved" | {
+        stuck: string;
+    };
+}
+/** Refused before trunk moved, for `why`. */
+ | {
+    status: "refused";
+    why: string;
+}
+/** Trunk moved: rebase and test again without charging an attempt. */
+ | {
+    status: "moved";
+};
+/** Moves trunk on the central remote to a task's tested branch. */
+export interface TrunkLanding {
+    land(request: LandRequest): Promise<Landed>;
+}
+/**
+ * Lands a tested branch on the remote's trunk, from the server's machine,
+ * refused unless the request's holder still holds the merge lease and trunk
+ * has not moved since the branch was tested.
+ */
+export declare class CoordinatorLanding implements TrunkLanding {
+    private readonly deps;
+    constructor(deps: {
+        git: Git;
+        fs: Fs;
+        config: Pick<Config, "remote" | "trunk">;
+        /** The merge lease's directory, `merge.lock`. */
+        lease: string;
+    });
+    land({ task, onto, head, holder }: LandRequest): Promise<Landed>;
+    /**
+     * Brings the server's own trunk to `head`, where it is checked out,
+     * so a single machine sees what landed as it did before the remote.
+     */
+    private fastForward;
+    private holder;
+}

package/vendor/@stringsync/splates-server/models/codex-limits.d.ts

@@ -0,0 +1,19 @@
+import { type Timer } from "../../../core/time/index.js";
+import type { Agent, Launch, Limit } from "../conversations";
+/** Whether `agent` is Codex's ACP adapter, which says its limits only in `/status`. */
+export declare function isCodex(agent: Agent): boolean;
+/**
+ * Asks Codex's app server, the one its ACP adapter runs, for the plan's
+ * windows, since the adapter never sends them: a window Claude also has goes
+ * by Claude's name, any other by its length, as `43200_minutes`. None when
+ * Codex will not say.
+ */
+export declare function codexLimits(deps: {
+    launch: Launch;
+    timer: Timer;
+    now: () => number;
+    /** Where it runs: anywhere does, since the plan is the account's. */
+    cwd: string;
+    /** Where `codex` is, as the adapter reads it; `codex` on the path otherwise. */
+    codex?: string;
+}): Promise<Limit[]>;

package/vendor/@stringsync/splates-server/models/effort.d.ts

@@ -0,0 +1,22 @@
+import type { Setting } from "../conversations";
+/** The thinking levels `offered` lets an agent work at; none without a thinking setting. */
+export declare function thinkingOf(offered: Setting[]): Setting["options"];
+/** The thinking levels `offered` lets an agent work at, by value; none without a thinking setting. */
+export declare function effortsOf(offered: Setting[]): string[];
+/** The setting `effort` goes in, by its id; none when it is unset or `offered` has nowhere for it. */
+export declare function effortSettings(effort: string | undefined, offered: Setting[]): Record<string, string>;
+/**
+ * What a conversation started on a pick opens with: `effort` as
+ * {@link effortSettings} has it, and the `auto` permission mode when `offered`
+ * has it, else the person's saved mode for the agent, so a pick never leaves
+ * the agent on its own manual mode.
+ */
+export declare function pickSettings(effort: string | undefined, offered: Setting[]): Record<string, string>;
+/**
+ * `effort` as one of the thinking levels `agent` offers, by its value or
+ * name in any case, so it goes in the setting as the agent takes it.
+ * Refuses a level the agent does not offer, or any level for an agent with
+ * no thinking setting, saying so with `data`. An agent never started here
+ * has offered nothing yet, so it takes the level as given.
+ */
+export declare function pickEffort(offered: Setting[] | undefined, agent: string, effort: string, data?: Record<string, unknown>): string;

package/vendor/@stringsync/splates-server/models/index.d.ts

@@ -0,0 +1,13 @@
+export { codexLimits, isCodex } from "./codex-limits";
+export { effortSettings, effortsOf, pickEffort, pickSettings, thinkingOf, } from "./effort";
+export { KIMI_CLI, kimiInstalled } from "./kimi";
+export type { KimiSubscription } from "./kimi-limits";
+export { isKimi, kimiLimits, kimiSubscription } from "./kimi-limits";
+export { kimiTurnUsage, kimiUsage, kimiUsageIn, kimiUsagePath, } from "./kimi-usage";
+export { Limits } from "./limits";
+export { modelOption, modelValue, ranWith, renamedModelOption, } from "./models";
+export { Offered } from "./offered";
+export type { ObservedTurn, OpenCodeUsage } from "./opencode-usage";
+export { finishObservation, metric, observeTokens, safeOpenCodeUpdate, } from "./opencode-usage";
+export type { AgentPick, RosterAgent, RosterFile } from "./roster";
+export { DEFAULT_AGENTS, modelsOf, pickAgent, pickLabel, Roster, splatesHome, traitsOf, } from "./roster";

package/vendor/@stringsync/splates-server/models/index.js

@@ -0,0 +1,76 @@
+import {
+  isCodex2,
+  codexLimits2,
+  thinkingOf2,
+  effortsOf2,
+  effortSettings2,
+  pickSettings2,
+  pickEffort2,
+  KIMI_CLI2,
+  kimiInstalled2,
+  isKimi2,
+  kimiLimits2,
+  kimiSubscription2,
+  kimiUsagePath2,
+  kimiUsage2,
+  kimiUsageIn2,
+  kimiTurnUsage2,
+  Limits2,
+  modelOption2,
+  renamedModelOption2,
+  modelValue2,
+  ranWith2,
+  Offered2,
+  metric2,
+  finishObservation2,
+  safeOpenCodeUpdate2,
+  observeTokens2,
+  Roster2,
+  DEFAULT_AGENTS2,
+  modelsOf2,
+  traitsOf2,
+  pickLabel2,
+  pickAgent2,
+  splatesHome2
+} from "../index-caep3sde.js";
+import"../index-01z7ycdk.js";
+import"../index-e9z7s5hh.js";
+import"../index-kmzdvvt0.js";
+import"../index-t9w5a8ed.js";
+import"../index-0jttnv86.js";
+import"../index-g18nxyn7.js";
+export {
+  DEFAULT_AGENTS2 as DEFAULT_AGENTS,
+  KIMI_CLI2 as KIMI_CLI,
+  Limits2 as Limits,
+  Offered2 as Offered,
+  Roster2 as Roster,
+  codexLimits2 as codexLimits,
+  effortSettings2 as effortSettings,
+  effortsOf2 as effortsOf,
+  finishObservation2 as finishObservation,
+  isCodex2 as isCodex,
+  isKimi2 as isKimi,
+  kimiInstalled2 as kimiInstalled,
+  kimiLimits2 as kimiLimits,
+  kimiSubscription2 as kimiSubscription,
+  kimiTurnUsage2 as kimiTurnUsage,
+  kimiUsage2 as kimiUsage,
+  kimiUsageIn2 as kimiUsageIn,
+  kimiUsagePath2 as kimiUsagePath,
+  metric2 as metric,
+  modelOption2 as modelOption,
+  modelValue2 as modelValue,
+  modelsOf2 as modelsOf,
+  observeTokens2 as observeTokens,
+  pickAgent2 as pickAgent,
+  pickEffort2 as pickEffort,
+  pickLabel2 as pickLabel,
+  pickSettings2 as pickSettings,
+  ranWith2 as ranWith,
+  renamedModelOption2 as renamedModelOption,
+  safeOpenCodeUpdate2 as safeOpenCodeUpdate,
+  splatesHome2 as splatesHome,
+  thinkingOf2 as thinkingOf,
+  traitsOf2 as traitsOf
+};

package/vendor/@stringsync/splates-server/models/kimi-limits.d.ts

@@ -0,0 +1,37 @@
+import type { Fs } from "../../../core/system/index.js";
+import type { Agent, Limit } from "../conversations";
+/** Whether `agent` is Kimi Code, whose limits only {@link kimiLimits} reads. */
+export declare function isKimi(agent: Agent): boolean;
+/**
+ * Kimi Code's plan windows, as its own `/usage` shows them: none when Kimi
+ * is signed out, its sign-in has expired since it last ran, or the endpoint
+ * will not say.
+ */
+export declare function kimiLimits(deps: {
+    fs: Fs;
+    now: () => number;
+    /** `~/.kimi-code`, or `KIMI_CODE_HOME`. */
+    home: string;
+    /** `KIMI_CODE_BASE_URL`, which Kimi reads before its config. */
+    baseUrl?: string;
+    /** A test's stands in for the network. */
+    fetcher?: typeof fetch;
+}): Promise<Limit[]>;
+/** A Kimi membership's next renewal at its monthly list price. */
+export interface KimiSubscription {
+    service: string;
+    since: string;
+    amount: number;
+    currency: string;
+    everyMonths: number;
+}
+/** Kimi's plan and next renewal at its monthly list price; null for anything it cannot confirm. */
+export declare function kimiSubscription(deps: {
+    fs: Fs;
+    now: () => number;
+    home: string;
+    baseUrl?: string;
+    fetcher?: typeof fetch;
+}): Promise<KimiSubscription | null>;
+/** The windows in a `/usages` answer that say how much is used and when it resets. */
+export declare function limitsIn(payload: unknown, at: string): Limit[];

package/vendor/@stringsync/splates-server/models/kimi-usage.d.ts

@@ -0,0 +1,19 @@
+import type * as acp from "@agentclientprotocol/sdk";
+import type { Fs } from "../../../core/system/index.js";
+/** Where Kimi Code writes the main agent's records for `session` in `cwd`. */
+export declare function kimiUsagePath({ home, cwd, session, }: {
+    home: string;
+    cwd: string;
+    session: string;
+}): string;
+/** Every main-agent model call's tokens in Kimi's wire log; null when unreadable or malformed. */
+export declare function kimiUsage(deps: {
+    fs: Fs;
+    home: string;
+    cwd: string;
+    session: string;
+}): Promise<acp.Usage | null>;
+/** The tokens in a wire log's `usage.record` lines, not their context-event copies. */
+export declare function kimiUsageIn(wire: string): acp.Usage | null;
+/** The calls between two cumulative readings; null for a lost, negative or empty delta. */
+export declare function kimiTurnUsage(before: acp.Usage | null, after: acp.Usage | null): acp.Usage | null;

package/vendor/@stringsync/splates-server/models/kimi.d.ts

@@ -0,0 +1,10 @@
+import type { Fs, Ps } from "../../../core/system/index.js";
+/** Kimi Code's roster `argv`, starting it as an ACP agent; set `KIMI_PATH` to run a `kimi` of your own. */
+export declare const KIMI_ARGV: string[];
+/** `kimi` as found for {@link KIMI_ARGV}, ahead of the arguments to run it with. */
+export declare const KIMI_CLI: string[];
+/** Whether Kimi Code is installed on this machine, where {@link KIMI_ARGV} looks. */
+export declare function kimiInstalled({ fs, ps, }: {
+    fs: Fs;
+    ps: Ps;
+}): Promise<boolean>;

package/vendor/@stringsync/splates-server/models/limits.d.ts

@@ -0,0 +1,32 @@
+import { type Limit } from "../conversations";
+import type { Document } from "../storage";
+/**
+ * Each agent's plan limits as it last said, from any project, kept under the
+ * user's home: a new conversation shows how much of the plan is left before
+ * any conversation in its project has said.
+ */
+export declare class Limits {
+    /** `~/.splates/limits.json`, or a test's own. */
+    private readonly doc;
+    /** Read once, then kept: this process is the one writing it. */
+    private known;
+    /** Set when a newer splates wrote the file, which this one leaves alone. */
+    private newer;
+    /** Writes one after another, so none is lost to another. */
+    private writing;
+    constructor(
+    /** `~/.splates/limits.json`, or a test's own. */
+    doc: Document<{
+        format?: number;
+        agents?: Record<string, Limit[]>;
+    }>);
+    /** Every agent's limits, by its id; none for one that never said. */
+    all(): Promise<Record<string, Limit[]>>;
+    /**
+     * Keeps each of `limits` that is newer than what `agent` said of its
+     * window before: a log read back can be older than another project's.
+     */
+    remember(agent: string, limits: Limit[]): Promise<void>;
+    private read;
+    private write;
+}

package/vendor/@stringsync/splates-server/models/models.d.ts

@@ -0,0 +1,36 @@
+import type { Entry, Setting } from "../conversations";
+import type { Log } from "../storage";
+/**
+ * Where `model` is among `settings`: the model setting's id, and the value
+ * there whose value or name it is; null when none offers it. Provider-qualified
+ * values always require an exact ID; `exact` also disables all display aliases.
+ */
+export declare function modelOption(settings: Setting[], model: string, exact?: boolean): {
+    setting: string;
+    value: string;
+} | null;
+/**
+ * Where the model `before` offered as `model` is among `settings`, found by
+ * its name; null when `before` did not offer it or `settings` has no model
+ * of that name. A resumed session can offer a model under another value:
+ * Claude's offers its `fable` as `claude-fable-5-1` once resumed on it.
+ */
+export declare function renamedModelOption(before: Setting[], settings: Setting[], model: string): {
+    setting: string;
+    value: string;
+} | null;
+/**
+ * The model `settings` has picked, by its name, `Opus 5.5`; for a default,
+ * the model its description says it stands for. Null when none is offered.
+ */
+export declare function pickedModel(settings: Setting[]): string | null;
+/** The value of the model `settings` has picked, `gpt-6.1-sol`; null when none is offered. */
+export declare function modelValue(settings: Setting[]): string | null;
+/**
+ * The agent the conversation logged in `log` runs, and the model it last had
+ * picked; null when there is no such log.
+ */
+export declare function ranWith(log: Log<Entry>): Promise<{
+    agent: string;
+    model: string | null;
+} | null>;

package/vendor/@stringsync/splates-server/models/offered.d.ts

@@ -0,0 +1,47 @@
+import type { Conversation, Setting } from "../conversations";
+import type { Document } from "../storage";
+/**
+ * The agent settings offered across projects, with defaults changed only by
+ * user selections. Session reports can refresh available options without
+ * replacing the values the person picked.
+ */
+export declare class Offered {
+    /** `~/.splates/offered.json`, or a test's own. */
+    private readonly doc;
+    /** Read once, then kept: this process is the one writing it. */
+    private known;
+    /** Whether each agent last said it takes images, read with {@link known}. */
+    private images;
+    /** Set when a newer splates wrote the file, which this one leaves alone. */
+    private newer;
+    /** Writes one after another, so none is lost to another. */
+    private writing;
+    constructor(
+    /** `~/.splates/offered.json`, or a test's own. */
+    doc: Document<{
+        format?: number;
+        agents?: Record<string, Setting[]>;
+        images?: Record<string, boolean>;
+    }>);
+    /** Reads the file again on next use, once any write under way is done, as after an import. */
+    reload(): Promise<void>;
+    /** Every agent's settings, by its id; none for one never started. */
+    all(): Promise<Record<string, Setting[]>>;
+    /** Whether each agent that connected here last said it takes images, by its id. */
+    sights(): Promise<Record<string, boolean>>;
+    /** Keeps whether `agent` said it takes images, which Auto pick reads before it connects. */
+    see(agent: string, sees: boolean): Promise<void>;
+    /**
+     * Keeps `settings` as what `agent`'s sessions offer from now on, or, with
+     * `preserveChoices`, refreshes options while keeping existing default values.
+     */
+    remember(agent: string, settings: Setting[], { preserveChoices }?: {
+        preserveChoices?: boolean;
+    }): Promise<void>;
+    /** Saves only settings the person selected, leaving other defaults alone. */
+    choose(agent: string, settings: Setting[], ids: string[]): Promise<void>;
+    /** Tracks capabilities separately from explicit choices, including the opening form. */
+    track(conversation: Conversation, changed: () => void, picks?: Record<string, string>): void;
+    private read;
+    private write;
+}

package/vendor/@stringsync/splates-server/models/opencode-usage.d.ts

@@ -0,0 +1,37 @@
+import type * as acp from "@agentclientprotocol/sdk";
+import type { ConversationState } from "../conversations";
+/** Observations, never a quota estimate or evidence of an invoice. */
+export interface OpenCodeUsage {
+    turns: ObservedTurn[];
+    costAt: string | null;
+    retry: {
+        attempt: number | null;
+        nextRetryAt: string | null;
+        message: string;
+        type: string | null;
+        status: number | null;
+    } | null;
+}
+/** Null means absent or invalid, including in logs predating instrumentation. */
+export interface ObservedTurn {
+    at: string;
+    until: string | null;
+    firstText: string | null;
+    requested: string | null;
+    confirmed: string | null;
+    cwd: string | null;
+    /** ACP prompt response; per turn, parent session only. */
+    tokens: {
+        input: number | null;
+        output: number | null;
+        cachedRead: number | null;
+        cachedWrite: number | null;
+    } | null;
+}
+export declare function metric(value: unknown): number | null;
+/** End exactly once, including cancellation, failure and worker reattachment. */
+export declare function finishObservation(state: ConversationState, at: string | null): void;
+/** Keep only documented retry fields; provider response bodies are not diagnostics. */
+export declare function safeOpenCodeUpdate(update: acp.SessionUpdate): acp.SessionUpdate;
+/** Snapshot fields independently; optional cache data is not evidence of zero. */
+export declare function observeTokens(state: ConversationState, usage: acp.Usage): void;