@namzu/sdk 42.0.2 → 44.0.0

package/dist/types/run/replay.d.ts

@@ -1,53 +0,0 @@
-import type { CheckpointId, RunId, ToolCallId } from '../ids/index.js';
-import type { ToolResult } from '../tool/index.js';
-/**
- * Controlled mutation applied at the fork point during {@link replay}.
- *
- * v1 ships a single variant: `injectToolResponse` — the 80% debugging use
- * case. Additional variants (`swapProvider`, `overrideBudget`, etc.) are
- * deferred; see ses_005-deterministic-replay §3.3.
- */
-export type Mutation = {
-    type: 'injectToolResponse';
-    toolCallId: ToolCallId;
-    response: ToolResult;
-};
-/**
- * Lightweight listing entry returned by {@link listCheckpoints}. Projected
- * from {@link import('../hitl/index.js').IterationCheckpoint} — not a full
- * checkpoint payload, just enough to pick a fork point.
- *
- * Named `CheckpointListEntry` (not `CheckpointSummary`) to avoid collision
- * with the pre-existing HITL `CheckpointSummary` shape at
- * `types/hitl/index.ts`.
- */
-export interface CheckpointListEntry {
-    id: CheckpointId;
-    runId: RunId;
-    iteration: number;
-    createdAt: number;
-    messageCount: number;
-}
-/**
- * Attribution record stamped on a {@link Run} produced by {@link replay}.
- * Non-replay runs have `replayOf === undefined`. Shape mirrors voltagent's
- * `replayedFromExecutionId` / `replayFromStepId` pattern, folded into a
- * single optional rather than three parallel ones.
- */
-export interface ReplayAttribution {
-    sourceRunId: RunId;
-    fromCheckpointId: CheckpointId;
-    mutations: Mutation[];
-    replayedAt: number;
-}
-/**
- * Thrown when a {@link Mutation} cannot be applied at the resolved fork
- * point. Currently raised by `injectToolResponse` when the supplied
- * `toolCallId` does not match any pending tool call in the checkpoint's
- * last assistant message.
- */
-export declare class MutationNotApplicableError extends Error {
-    readonly availableToolCallIds: readonly ToolCallId[];
-    constructor(message: string, availableToolCallIds: readonly ToolCallId[]);
-}
-//# sourceMappingURL=replay.d.ts.map

package/dist/types/run/replay.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"replay.d.ts","sourceRoot":"","sources":["../../../src/types/run/replay.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,KAAK,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAA;AACtE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAA;AAElD;;;;;;GAMG;AACH,MAAM,MAAM,QAAQ,GAAG;IACtB,IAAI,EAAE,oBAAoB,CAAA;IAC1B,UAAU,EAAE,UAAU,CAAA;IACtB,QAAQ,EAAE,UAAU,CAAA;CACpB,CAAA;AAED;;;;;;;;GAQG;AACH,MAAM,WAAW,mBAAmB;IACnC,EAAE,EAAE,YAAY,CAAA;IAChB,KAAK,EAAE,KAAK,CAAA;IACZ,SAAS,EAAE,MAAM,CAAA;IACjB,SAAS,EAAE,MAAM,CAAA;IACjB,YAAY,EAAE,MAAM,CAAA;CACpB;AAED;;;;;GAKG;AACH,MAAM,WAAW,iBAAiB;IACjC,WAAW,EAAE,KAAK,CAAA;IAClB,gBAAgB,EAAE,YAAY,CAAA;IAC9B,SAAS,EAAE,QAAQ,EAAE,CAAA;IACrB,UAAU,EAAE,MAAM,CAAA;CAClB;AAED;;;;;GAKG;AACH,qBAAa,0BAA2B,SAAQ,KAAK;aAGnC,oBAAoB,EAAE,SAAS,UAAU,EAAE;gBAD3D,OAAO,EAAE,MAAM,EACC,oBAAoB,EAAE,SAAS,UAAU,EAAE;CAK5D"}

package/dist/types/run/replay.js

@@ -1,15 +0,0 @@
-/**
- * Thrown when a {@link Mutation} cannot be applied at the resolved fork
- * point. Currently raised by `injectToolResponse` when the supplied
- * `toolCallId` does not match any pending tool call in the checkpoint's
- * last assistant message.
- */
-export class MutationNotApplicableError extends Error {
-    availableToolCallIds;
-    constructor(message, availableToolCallIds) {
-        super(message);
-        this.availableToolCallIds = availableToolCallIds;
-        this.name = 'MutationNotApplicableError';
-    }
-}
-//# sourceMappingURL=replay.js.map

package/dist/types/run/replay.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"replay.js","sourceRoot":"","sources":["../../../src/types/run/replay.ts"],"names":[],"mappings":"AA8CA;;;;;GAKG;AACH,MAAM,OAAO,0BAA2B,SAAQ,KAAK;IAGnC;IAFjB,YACC,OAAe,EACC,oBAA2C;QAE3D,KAAK,CAAC,OAAO,CAAC,CAAA;QAFE,yBAAoB,GAApB,oBAAoB,CAAuB;QAG3D,IAAI,CAAC,IAAI,GAAG,4BAA4B,CAAA;IACzC,CAAC;CACD"}

package/dist/types/run/schema-version.d.ts

@@ -1,19 +0,0 @@
-/**
- * RunEvent envelope schema version. Bumped on breaking envelope change.
- *
- * - v1: pre-0.2.0 (implicit; untagged events are treated as v1 by consumers).
- * - v2: 0.2.0+ — adds `schemaVersion`, `lineage`, and sub-session lifecycle
- *   events.
- * - v3: 2026-05-01 — removes `llm_response`; adds message + tool-input
- *   lifecycle variants (`message_started`, `text_delta`,
- *   `message_completed`, `tool_input_started`, `tool_input_delta`,
- *   `tool_input_completed`); `tool_executing`/`tool_completed` carry
- *   required `toolUseId`; `tool_completed` carries required `isError`.
- *   See ses_001-tool-stream-events.
- *
- * See session-hierarchy.md §10.1 (Event-schema evolution contract) and
- * §13.3.2 (`schemaVersion` back-compat).
- */
-export declare const RUN_EVENT_SCHEMA_VERSION: 3;
-export type RunEventSchemaVersion = typeof RUN_EVENT_SCHEMA_VERSION;
-//# sourceMappingURL=schema-version.d.ts.map

package/dist/types/run/schema-version.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"schema-version.d.ts","sourceRoot":"","sources":["../../../src/types/run/schema-version.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,wBAAwB,EAAG,CAAU,CAAA;AAElD,MAAM,MAAM,qBAAqB,GAAG,OAAO,wBAAwB,CAAA"}

package/dist/types/run/schema-version.js

@@ -1,18 +0,0 @@
-/**
- * RunEvent envelope schema version. Bumped on breaking envelope change.
- *
- * - v1: pre-0.2.0 (implicit; untagged events are treated as v1 by consumers).
- * - v2: 0.2.0+ — adds `schemaVersion`, `lineage`, and sub-session lifecycle
- *   events.
- * - v3: 2026-05-01 — removes `llm_response`; adds message + tool-input
- *   lifecycle variants (`message_started`, `text_delta`,
- *   `message_completed`, `tool_input_started`, `tool_input_delta`,
- *   `tool_input_completed`); `tool_executing`/`tool_completed` carry
- *   required `toolUseId`; `tool_completed` carries required `isError`.
- *   See ses_001-tool-stream-events.
- *
- * See session-hierarchy.md §10.1 (Event-schema evolution contract) and
- * §13.3.2 (`schemaVersion` back-compat).
- */
-export const RUN_EVENT_SCHEMA_VERSION = 3;
-//# sourceMappingURL=schema-version.js.map

package/dist/types/run/schema-version.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"schema-version.js","sourceRoot":"","sources":["../../../src/types/run/schema-version.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AACH,MAAM,CAAC,MAAM,wBAAwB,GAAG,CAAU,CAAA"}

package/dist/types/run/state.d.ts

@@ -1,109 +0,0 @@
-import type { CostInfo, RunExecutionStatus, TokenUsage } from '../common/index.js';
-import type { CheckpointId, PendingDecision } from '../hitl/index.js';
-import type { RunId, SessionId, TenantId } from '../ids/index.js';
-import type { Message } from '../message/index.js';
-import type { ProjectId, TopicId } from '../session/ids.js';
-import type { StopReason } from './stop-reason.js';
-import type { TokenBudgetBinding } from './token-budget-store.js';
-/**
- * Everything needed to pick a run back up in a DIFFERENT process.
- *
- * A run's live state was spread across objects that only exist in memory —
- * `RunPersistence`, `GuardCoordinator`, the suspended `await` inside a HITL
- * gate. `IterationCheckpoint` carries the history and the budgets, but it
- * is keyed by a store scope the reader has to already know, and it says
- * nothing about the run's status or why it stopped. So "resume this run"
- * meant "the original process is still alive and holding it".
- *
- * That is the constraint this removes. `RunState` is a flat, JSON-safe
- * snapshot: a serverless handler writes one when a run parks, returns, and
- * a later invocation — a different container — reads it back and continues.
- *
- * It is a SNAPSHOT, not a live handle. Nothing in it points at a socket, a
- * sandbox, a provider client, or an open file. Re-establishing those is the
- * host's job on the way back in, which is exactly why they are absent.
- */
-export interface RunState {
-    /** Reference to the canonical tree ledger; a checkpoint never resets it. */
-    readonly budgetBinding?: TokenBudgetBinding;
-    /** Also present for non-durable accounts; those require the live authority on resume. */
-    readonly budgetAccountId?: string;
-    /**
-     * Schema version. Versions 1–3 are coerced forward by {@link parseRunState}.
-     * Version 4 carries aggregate token authority references; earlier readers
-     * must refuse it rather than silently discarding that authority on resume.
-     * Other unrecognized versions are refused instead of partially restored.
-     */
-    readonly version: 4;
-    readonly runId: RunId;
-    readonly sessionId: SessionId;
-    readonly topicId: TopicId;
-    readonly projectId: ProjectId;
-    readonly tenantId: TenantId;
-    /** Present for sub-runs, so a hierarchical store can key the snapshot. */
-    readonly parentRunId?: RunId;
-    readonly agentId?: string;
-    readonly agentName?: string;
-    readonly status: RunExecutionStatus;
-    readonly stopReason?: StopReason;
-    readonly lastError?: string;
-    readonly messages: Message[];
-    readonly tokenUsage: TokenUsage;
-    readonly costInfo: CostInfo;
-    readonly currentIteration: number;
-    readonly startedAt: number;
-    /**
-     * Wall-clock the run has already consumed. Restored into the guard so a
-     * resumed run does not get a fresh timeout budget — the timeout is a
-     * property of the RUN, not of the process hosting it.
-     */
-    readonly elapsedMs: number;
-    /**
-     * The checkpoint this snapshot corresponds to, when one was written.
-     * Pass it as `resumeFromCheckpoint`.
-     */
-    readonly checkpointId?: CheckpointId;
-    /**
-     * The decision the run is parked on, if any. A host reads this to know
-     * what to ask a human, and feeds the answer back as
-     * `QueryParams.pendingDecision`.
-     */
-    readonly pending?: PendingDecision;
-    readonly capturedAt: number;
-}
-/** Thrown by {@link parseRunState} when a snapshot cannot be trusted. */
-export declare class RunStateVersionError extends Error {
-    readonly found: unknown;
-    readonly expected: number;
-    constructor(found: unknown, expected: number);
-}
-export declare const RUN_STATE_VERSION: 4;
-/**
- * Parse a serialized snapshot, refusing anything this SDK cannot fully
- * restore.
- *
- * The version guard is the point. A snapshot is written by one deployment
- * and read by another, possibly weeks later and possibly after an SDK
- * upgrade; a silent partial restore there produces a run that looks healthy
- * and has lost its budgets. Failing loudly is the only honest option — for
- * every version this build does not otherwise recognize. Versions 1 through 3
- * are the exceptions: they are coerced forward rather than refused, the
- * same shape-tolerant rename `store/schema.ts`'s migrations use for the
- * on-disk session record, because a host that parks a run across either
- * release boundary would otherwise have every in-flight snapshot refused
- * on the way back in. `threadId` is renamed only when present (v1), and
- * topic IDs are validated without changing their value. Retired `thd_`
- * values are refused; opaque UUIDs
- * are preserved. An absent topic field is not added.
- * Nothing here re-persists the coerced snapshot — a host that calls
- * `parseRunState` and then serializes the result back out upgrades the
- * record on THAT write, same as `store/schema.ts`'s "migrate on read,
- * re-stamp on next write" contract.
- *
- * A snapshot from a NEWER build read by an OLDER SDK is refused, not
- * partially restored: that SDK's `RUN_STATE_VERSION` is behind, so a
- * record's `version` matches neither the current version nor a legacy
- * version it knows how to coerce, and falls through to the throw below.
- */
-export declare function parseRunState(json: string | unknown): RunState;
-//# sourceMappingURL=state.d.ts.map

package/dist/types/run/state.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"state.d.ts","sourceRoot":"","sources":["../../../src/types/run/state.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,QAAQ,EAAE,kBAAkB,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAA;AAClF,OAAO,KAAK,EAAE,YAAY,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAA;AACrE,OAAO,KAAK,EAAE,KAAK,EAAE,SAAS,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAA;AACjE,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAA;AAClD,OAAO,KAAK,EAAE,SAAS,EAAE,OAAO,EAAE,MAAM,mBAAmB,CAAA;AAC3D,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAA;AAElD,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAA;AAEjE;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,WAAW,QAAQ;IACxB,4EAA4E;IAC5E,QAAQ,CAAC,aAAa,CAAC,EAAE,kBAAkB,CAAA;IAC3C,yFAAyF;IACzF,QAAQ,CAAC,eAAe,CAAC,EAAE,MAAM,CAAA;IACjC;;;;;OAKG;IACH,QAAQ,CAAC,OAAO,EAAE,CAAC,CAAA;IAEnB,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAA;IACrB,QAAQ,CAAC,SAAS,EAAE,SAAS,CAAA;IAC7B,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAA;IACzB,QAAQ,CAAC,SAAS,EAAE,SAAS,CAAA;IAC7B,QAAQ,CAAC,QAAQ,EAAE,QAAQ,CAAA;IAC3B,0EAA0E;IAC1E,QAAQ,CAAC,WAAW,CAAC,EAAE,KAAK,CAAA;IAE5B,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAA;IACzB,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAA;IAE3B,QAAQ,CAAC,MAAM,EAAE,kBAAkB,CAAA;IACnC,QAAQ,CAAC,UAAU,CAAC,EAAE,UAAU,CAAA;IAChC,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAA;IAE3B,QAAQ,CAAC,QAAQ,EAAE,OAAO,EAAE,CAAA;IAC5B,QAAQ,CAAC,UAAU,EAAE,UAAU,CAAA;IAC/B,QAAQ,CAAC,QAAQ,EAAE,QAAQ,CAAA;IAC3B,QAAQ,CAAC,gBAAgB,EAAE,MAAM,CAAA;IACjC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;IAC1B;;;;OAIG;IACH,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;IAE1B;;;OAGG;IACH,QAAQ,CAAC,YAAY,CAAC,EAAE,YAAY,CAAA;IAEpC;;;;OAIG;IACH,QAAQ,CAAC,OAAO,CAAC,EAAE,eAAe,CAAA;IAElC,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAA;CAC3B;AAED,yEAAyE;AACzE,qBAAa,oBAAqB,SAAQ,KAAK;IAE7C,QAAQ,CAAC,KAAK,EAAE,OAAO;IACvB,QAAQ,CAAC,QAAQ,EAAE,MAAM;gBADhB,KAAK,EAAE,OAAO,EACd,QAAQ,EAAE,MAAM;CAO1B;AAED,eAAO,MAAM,iBAAiB,EAAG,CAAU,CAAA;AAmC3C;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,GAAG,QAAQ,CAuC9D"}

package/dist/types/run/state.js

@@ -1,109 +0,0 @@
-import { asCheckpointId, asProjectId, asRunId, asSessionId, asTenantId, asTopicId, } from '../../utils/id.js';
-import { validateTokenBudgetBinding } from './token-budget-store.js';
-/** Thrown by {@link parseRunState} when a snapshot cannot be trusted. */
-export class RunStateVersionError extends Error {
-    found;
-    expected;
-    constructor(found, expected) {
-        super(`RunState version mismatch: snapshot declares ${JSON.stringify(found)}, this SDK reads ${expected}. Restoring across an incompatible version would silently drop fields; re-run instead.`);
-        this.found = found;
-        this.expected = expected;
-        this.name = 'RunStateVersionError';
-    }
-}
-export const RUN_STATE_VERSION = 4;
-/** The shape `RunState` had before NZ-TOPIC-03: `threadId`, not `topicId`. */
-const RUN_STATE_LEGACY_VERSION = 1;
-/**
- * The shape `RunState` had between NZ-TOPIC-03 and NZ-TOPIC-04: `topicId`
- * is already the field name, but its value can still carry the
- * pre-narrowing `thd_` prefix.
- */
-const RUN_STATE_PRE_PREFIX_VERSION = 2;
-/** Before checkpoints referred to a canonical aggregate token ledger. */
-const RUN_STATE_PRE_BUDGET_VERSION = 3;
-/** Require UUIDs on every supplied identity field without rewriting records. */
-function requireEntityIds(record) {
-    if (record.budgetBinding !== undefined)
-        validateTokenBudgetBinding(record.budgetBinding);
-    if (record.budgetAccountId !== undefined)
-        asRunId(record.budgetAccountId);
-    const validators = {
-        runId: asRunId,
-        parentRunId: asRunId,
-        sessionId: asSessionId,
-        projectId: asProjectId,
-        tenantId: asTenantId,
-        topicId: asTopicId,
-        checkpointId: asCheckpointId,
-    };
-    for (const [field, validate] of Object.entries(validators)) {
-        const value = record[field];
-        if (value !== undefined)
-            validate(value);
-    }
-    return record;
-}
-/**
- * Parse a serialized snapshot, refusing anything this SDK cannot fully
- * restore.
- *
- * The version guard is the point. A snapshot is written by one deployment
- * and read by another, possibly weeks later and possibly after an SDK
- * upgrade; a silent partial restore there produces a run that looks healthy
- * and has lost its budgets. Failing loudly is the only honest option — for
- * every version this build does not otherwise recognize. Versions 1 through 3
- * are the exceptions: they are coerced forward rather than refused, the
- * same shape-tolerant rename `store/schema.ts`'s migrations use for the
- * on-disk session record, because a host that parks a run across either
- * release boundary would otherwise have every in-flight snapshot refused
- * on the way back in. `threadId` is renamed only when present (v1), and
- * topic IDs are validated without changing their value. Retired `thd_`
- * values are refused; opaque UUIDs
- * are preserved. An absent topic field is not added.
- * Nothing here re-persists the coerced snapshot — a host that calls
- * `parseRunState` and then serializes the result back out upgrades the
- * record on THAT write, same as `store/schema.ts`'s "migrate on read,
- * re-stamp on next write" contract.
- *
- * A snapshot from a NEWER build read by an OLDER SDK is refused, not
- * partially restored: that SDK's `RUN_STATE_VERSION` is behind, so a
- * record's `version` matches neither the current version nor a legacy
- * version it knows how to coerce, and falls through to the throw below.
- */
-export function parseRunState(json) {
-    const raw = typeof json === 'string' ? JSON.parse(json) : json;
-    if (typeof raw !== 'object' || raw === null) {
-        throw new RunStateVersionError(raw, RUN_STATE_VERSION);
-    }
-    const record = raw;
-    const version = record.version;
-    if ((version === RUN_STATE_LEGACY_VERSION ||
-        version === RUN_STATE_PRE_PREFIX_VERSION ||
-        version === RUN_STATE_PRE_BUDGET_VERSION) &&
-        (record.budgetBinding !== undefined || record.budgetAccountId !== undefined)) {
-        throw new RunStateVersionError(version, RUN_STATE_VERSION);
-    }
-    if (version === RUN_STATE_LEGACY_VERSION) {
-        const { threadId, ...rest } = record;
-        const withTopicId = {
-            ...rest,
-            ...(threadId !== undefined ? { topicId: threadId } : {}),
-        };
-        return {
-            ...requireEntityIds(withTopicId),
-            version: RUN_STATE_VERSION,
-        };
-    }
-    if (version === RUN_STATE_PRE_PREFIX_VERSION || version === RUN_STATE_PRE_BUDGET_VERSION) {
-        return {
-            ...requireEntityIds(record),
-            version: RUN_STATE_VERSION,
-        };
-    }
-    if (version !== RUN_STATE_VERSION) {
-        throw new RunStateVersionError(version, RUN_STATE_VERSION);
-    }
-    return requireEntityIds(record);
-}
-//# sourceMappingURL=state.js.map

package/dist/types/run/state.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"state.js","sourceRoot":"","sources":["../../../src/types/run/state.ts"],"names":[],"mappings":"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"}

package/dist/types/run/status.d.ts

@@ -1,26 +0,0 @@
-/**
- * Domain Run status enum. See session-hierarchy.md §4.6 + §5.2 state machine.
- *
- * Distinct from the wire-side {@link WireRunStatus} in `contracts/api.ts`,
- * which maps these states onto HTTP payload shapes (`completed` /
- * `cancelling` / `expired`). Keep this enum purely the domain surface; any
- * consumer that needs the HTTP representation should translate at the bridge
- * boundary.
- *
- * Variants:
- *  - `queued` — run created, not yet started.
- *  - `running` — iteration loop in flight.
- *  - `awaiting_hitl` — synchronous-wait on a HITL gate (user present).
- *  - `awaiting_hitl_resolution` — persisted-wait after a HITL timeout under
- *    `HITLConfig.onTimeout = 'pause_run_until_resolved'`. User absent; Run
- *    persists until resolved or cancelled (permission-policies.md §13.3).
- *  - `awaiting_subsession` — parent Run has delegated to a child SubSession
- *    and is suspended until the Materializer seals the child's summary.
- *    Session-level fan-in treats this as `active` (delegation in flight
- *    means the parent IS active). See session-hierarchy.md §5.1.
- *  - `succeeded` — terminal, run completed without error.
- *  - `failed` — terminal, run errored out.
- *  - `cancelled` — terminal, explicitly cancelled.
- */
-export type RunStatus = 'queued' | 'running' | 'awaiting_hitl' | 'awaiting_hitl_resolution' | 'awaiting_subsession' | 'succeeded' | 'failed' | 'cancelled';
-//# sourceMappingURL=status.d.ts.map

package/dist/types/run/status.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"status.d.ts","sourceRoot":"","sources":["../../../src/types/run/status.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,MAAM,MAAM,SAAS,GAClB,QAAQ,GACR,SAAS,GACT,eAAe,GACf,0BAA0B,GAC1B,qBAAqB,GACrB,WAAW,GACX,QAAQ,GACR,WAAW,CAAA"}

package/dist/types/run/status.js

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=status.js.map

package/dist/types/run/status.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"status.js","sourceRoot":"","sources":["../../../src/types/run/status.ts"],"names":[],"mappings":""}

package/dist/types/run/step.d.ts

@@ -1,198 +0,0 @@
-import type { CostInfo, TokenUsage } from '../common/index.js';
-import type { MessageId } from '../ids/index.js';
-import type { ProviderRoute, ToolCall } from '../message/index.js';
-import type { ProviderErrorCode } from '../provider/errors.js';
-/**
- * What one iteration of the agent loop did.
- *
- * None of this was reachable before. `Run` and `BaseAgentResult` have no
- * `steps[]`, so a host that persisted the returned `Run` — the natural
- * thing — permanently lost per-step attribution: answering "which step
- * cost the most" meant correlating raw `RunEvent`s by iteration number and
- * diffing cumulative counters, and per-tool duration was never emitted at
- * all. Every field here was already computed somewhere in the loop.
- */
-export interface StepResult {
-    /** 1-based, matching `iteration` on the run events. */
-    stepNumber: number;
-    /**
-     * The model this step ASKED for: the run's configured model, or the
-     * override a `prepareStep` hook returned for this step.
-     *
-     * It used to be the run's model unconditionally — the loop passed its own
-     * `model` here while building the request from `step.model ?? model` a few
-     * lines above — so a host that routed one step to a cheaper model read the
-     * expensive one back out of the ledger. No chain was needed to see it.
-     *
-     * What was asked for and what answered are two facts, and after a provider
-     * chain falls over they differ. This is the first; {@link servedBy} is the
-     * second.
-     */
-    model: string;
-    /**
-     * Who actually answered, and with which model.
-     *
-     * Equal to {@link model} and to `run.metadata.provider` on every run
-     * without a chain, which is most of them; it diverges exactly when
-     * `withProviderFallback` advanced. Recorded even when it agrees, because a
-     * ledger that carries the fact only when it is surprising cannot be read as
-     * evidence — a reader could not tell "the head served" from "nobody wrote
-     * it down".
-     *
-     * Optional only for records that predate the field. Absence means "not
-     * recorded", and it is left meaning that rather than backfilled: the sdk
-     * shipped a chain that could fall over one release before it recorded
-     * which member did, so filling those in from the declared head would state
-     * as fact the exact thing that release got wrong, on exactly the runs
-     * where it was wrong. Every step this build produces has it.
-     *
-     * **Reaches a host through the returned `Run`, not through `run.json`.**
-     * `RunDiskStore.writeRunMeta` persists the metadata and the counters and
-     * does not write `steps` at all, so the built-in store carries the
-     * run-level {@link
-     * import('./entity.js').RunStateMetadata.servingProvider} and none of
-     * this. A host that wants per-step provenance on disk persists the `Run`
-     * it is handed.
-     */
-    servedBy?: StepProvenance;
-    /**
-     * The assistant message this step produced.
-     *
-     * Absent only on a step whose iteration ended before the model's message
-     * was announced — a compaction failure, a lifecycle hook that threw, a
-     * transport error raised before the first chunk. Absence is left meaning
-     * "there was no message" rather than filled with an id the event stream
-     * never carried: a `messageId` a reader cannot find a `message_started`
-     * for is worse evidence than no id at all, because it invites the
-     * correlation and then loses it.
-     *
-     * Present, and correlatable, on every step whose iteration got as far as
-     * the provider call — including one that failed mid-stream. The loop
-     * mints the id before the call that announces it, and a dying stream
-     * emits `message_completed` on its way out, so the events carry both
-     * ends of the message a failed step points at.
-     */
-    messageId?: MessageId;
-    /** Assistant text for this step, if any. */
-    content: string | null;
-    toolCalls: readonly ToolCall[];
-    /**
-     * Tool outcomes, in the same order as `toolCalls`.
-     *
-     * Shorter than `toolCalls` on a step that ended in failure: only the
-     * outcomes that exist are recorded, so a call with no entry here reads
-     * as "never came back" rather than as an empty success. Pair by
-     * `toolCallId`, not by index.
-     */
-    toolResults: readonly StepToolResult[];
-    /**
-     * How the turn ended.
-     *
-     * `error` and `cancelled` are not provider verdicts — no provider reports
-     * them — but a step exists for a failed iteration too, and it has to say
-     * how it ended in the same field a reader already sorts by. `error` comes
-     * with {@link failure}; `cancelled` means a Stop tore the turn down and
-     * there is no failure to report.
-     */
-    finishReason: 'stop' | 'tool_calls' | 'length' | 'content_filter' | 'error' | 'cancelled';
-    /**
-     * What went wrong, on a step with `finishReason: 'error'`.
-     *
-     * Absent everywhere else. A run whose ledger is complete except on the
-     * turns that failed reads as "nothing went wrong" precisely when
-     * something did, which is worse than an absent record — so the failed
-     * turn gets the same record as every other, and this is what makes it
-     * legible as a failure.
-     */
-    failure?: StepFailure;
-    /** Usage for THIS step, not the run's cumulative total. */
-    usage: TokenUsage;
-    /** Cost delta attributable to this step. Zero without a pricing table. */
-    costDelta: CostInfo;
-    startedAt: number;
-    /** Wall-clock for the whole step, including tool execution. */
-    durationMs: number;
-    /** Portion of `durationMs` spent inside tools. */
-    toolExecutionMs: number;
-}
-/**
- * The chain member that served one step.
- *
- * `chainIndex` is a position in the chain the host declared, and it is here
- * rather than derived from `providerId` because a chain may legitimately name
- * the same provider twice — two models, or two credentials, on one driver.
- * `providerId` alone could not tell those apart.
- */
-export interface StepProvenance extends ProviderRoute {
-}
-/**
- * Why a step ended in `finishReason: 'error'`.
- *
- * The step-level counterpart of the pair a failed run already carries —
- * {@link import('./entity.js').Run.lastError} and
- * {@link import('./entity.js').Run.lastProviderError} — and shaped from the
- * same classification, so the two agree when the failed step is the one that
- * ended the run. What a run records once, a run of twenty iterations records
- * per iteration, which is the difference between "this run failed" and "this
- * turn failed, and the next four succeeded".
- */
-export interface StepFailure {
-    /** The failure's message, as the iteration's span and log recorded it. */
-    readonly message: string;
-    /**
-     * Where the classifier placed it.
-     *
-     * `unknown` for a failure that is not a provider failure at all — a
-     * plugin hook that threw, a bug in a tool wrapper. That is the honest
-     * reading of the code's own contract ("unclassifiable"), and it is left
-     * saying so rather than being given a more specific-looking code.
-     */
-    readonly code: ProviderErrorCode;
-    /** HTTP status, when the failure carried one. */
-    readonly status?: number;
-    /** Whether sending the same request again could have worked. */
-    readonly retryable: boolean;
-}
-export interface StepToolResult {
-    toolCallId: string;
-    toolName: string;
-    /** Text form, after the model-visible output budget was applied. */
-    output: string;
-    isError: boolean;
-    durationMs: number;
-}
-/**
- * A programmable halt condition, evaluated after each step's tools have
- * run.
- *
- * `GuardCoordinator` — the only halt before this — consumes
- * `{aborted, totalTokens, totalCost, currentIteration, startTime}` and
- * never sees messages, tool calls or results. So "stop after three steps
- * with no progress" and "stop once the plan is complete" were
- * inexpressible, and a terminal `submit_answer` tool could not end the
- * run: the model had to be prompt-begged to stop, with `maxIterations:
- * 200` as the only backstop.
- *
- * Returning `true` ends the run with `stop_reason: 'stop_condition'`.
- */
-export type StopCondition = (state: StopConditionState) => boolean | Promise<boolean>;
-export interface StopConditionState {
-    /** Every step so far, most recent last. */
-    readonly steps: readonly StepResult[];
-    readonly latestStep: StepResult;
-    readonly totalUsage: TokenUsage;
-    readonly totalCost: CostInfo;
-}
-/** Stop once `n` steps have completed. */
-export declare function stepCountIs(n: number): StopCondition;
-/**
- * Stop when the latest step called any of `names`.
- *
- * The tool still executes and its result is still recorded — the run ends
- * after, not instead. That is what makes a `submit_answer` / `verify` tool
- * usable as a terminator without losing its output.
- */
-export declare function hasToolCall(...names: string[]): StopCondition;
-/** Stop when any of the given conditions does. */
-export declare function anyOf(...conditions: StopCondition[]): StopCondition;
-//# sourceMappingURL=step.d.ts.map

package/dist/types/run/step.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"step.d.ts","sourceRoot":"","sources":["../../../src/types/run/step.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAA;AAC9D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAA;AAChD,OAAO,KAAK,EAAE,aAAa,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAA;AAClE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAA;AAE9D;;;;;;;;;GASG;AACH,MAAM,WAAW,UAAU;IAC1B,uDAAuD;IACvD,UAAU,EAAE,MAAM,CAAA;IAClB;;;;;;;;;;;;OAYG;IACH,KAAK,EAAE,MAAM,CAAA;IACb;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACH,QAAQ,CAAC,EAAE,cAAc,CAAA;IACzB;;;;;;;;;;;;;;;;OAgBG;IACH,SAAS,CAAC,EAAE,SAAS,CAAA;IACrB,4CAA4C;IAC5C,OAAO,EAAE,MAAM,GAAG,IAAI,CAAA;IACtB,SAAS,EAAE,SAAS,QAAQ,EAAE,CAAA;IAC9B;;;;;;;OAOG;IACH,WAAW,EAAE,SAAS,cAAc,EAAE,CAAA;IACtC;;;;;;;;OAQG;IACH,YAAY,EAAE,MAAM,GAAG,YAAY,GAAG,QAAQ,GAAG,gBAAgB,GAAG,OAAO,GAAG,WAAW,CAAA;IACzF;;;;;;;;OAQG;IACH,OAAO,CAAC,EAAE,WAAW,CAAA;IACrB,2DAA2D;IAC3D,KAAK,EAAE,UAAU,CAAA;IACjB,0EAA0E;IAC1E,SAAS,EAAE,QAAQ,CAAA;IACnB,SAAS,EAAE,MAAM,CAAA;IACjB,+DAA+D;IAC/D,UAAU,EAAE,MAAM,CAAA;IAClB,kDAAkD;IAClD,eAAe,EAAE,MAAM,CAAA;CACvB;AAED;;;;;;;GAOG;AACH,MAAM,WAAW,cAAe,SAAQ,aAAa;CAAG;AAExD;;;;;;;;;;GAUG;AACH,MAAM,WAAW,WAAW;IAC3B,0EAA0E;IAC1E,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;IACxB;;;;;;;OAOG;IACH,QAAQ,CAAC,IAAI,EAAE,iBAAiB,CAAA;IAChC,iDAAiD;IACjD,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAA;IACxB,gEAAgE;IAChE,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAA;CAC3B;AAED,MAAM,WAAW,cAAc;IAC9B,UAAU,EAAE,MAAM,CAAA;IAClB,QAAQ,EAAE,MAAM,CAAA;IAChB,oEAAoE;IACpE,MAAM,EAAE,MAAM,CAAA;IACd,OAAO,EAAE,OAAO,CAAA;IAChB,UAAU,EAAE,MAAM,CAAA;CAClB;AAED;;;;;;;;;;;;;GAaG;AACH,MAAM,MAAM,aAAa,GAAG,CAAC,KAAK,EAAE,kBAAkB,KAAK,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,CAAA;AAErF,MAAM,WAAW,kBAAkB;IAClC,2CAA2C;IAC3C,QAAQ,CAAC,KAAK,EAAE,SAAS,UAAU,EAAE,CAAA;IACrC,QAAQ,CAAC,UAAU,EAAE,UAAU,CAAA;IAC/B,QAAQ,CAAC,UAAU,EAAE,UAAU,CAAA;IAC/B,QAAQ,CAAC,SAAS,EAAE,QAAQ,CAAA;CAC5B;AAED,0CAA0C;AAC1C,wBAAgB,WAAW,CAAC,CAAC,EAAE,MAAM,GAAG,aAAa,CAEpD;AAED;;;;;;GAMG;AACH,wBAAgB,WAAW,CAAC,GAAG,KAAK,EAAE,MAAM,EAAE,GAAG,aAAa,CAG7D;AAED,kDAAkD;AAClD,wBAAgB,KAAK,CAAC,GAAG,UAAU,EAAE,aAAa,EAAE,GAAG,aAAa,CAOnE"}

package/dist/types/run/step.js

@@ -1,26 +0,0 @@
-/** Stop once `n` steps have completed. */
-export function stepCountIs(n) {
-    return ({ steps }) => steps.length >= n;
-}
-/**
- * Stop when the latest step called any of `names`.
- *
- * The tool still executes and its result is still recorded — the run ends
- * after, not instead. That is what makes a `submit_answer` / `verify` tool
- * usable as a terminator without losing its output.
- */
-export function hasToolCall(...names) {
-    const wanted = new Set(names);
-    return ({ latestStep }) => latestStep.toolCalls.some((tc) => wanted.has(tc.function.name));
-}
-/** Stop when any of the given conditions does. */
-export function anyOf(...conditions) {
-    return async (state) => {
-        for (const condition of conditions) {
-            if (await condition(state))
-                return true;
-        }
-        return false;
-    };
-}
-//# sourceMappingURL=step.js.map

package/dist/types/run/step.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"step.js","sourceRoot":"","sources":["../../../src/types/run/step.ts"],"names":[],"mappings":"AA+LA,0CAA0C;AAC1C,MAAM,UAAU,WAAW,CAAC,CAAS;IACpC,OAAO,CAAC,EAAE,KAAK,EAAE,EAAE,EAAE,CAAC,KAAK,CAAC,MAAM,IAAI,CAAC,CAAA;AACxC,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,WAAW,CAAC,GAAG,KAAe;IAC7C,MAAM,MAAM,GAAG,IAAI,GAAG,CAAC,KAAK,CAAC,CAAA;IAC7B,OAAO,CAAC,EAAE,UAAU,EAAE,EAAE,EAAE,CAAC,UAAU,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,MAAM,CAAC,GAAG,CAAC,EAAE,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAA;AAC3F,CAAC;AAED,kDAAkD;AAClD,MAAM,UAAU,KAAK,CAAC,GAAG,UAA2B;IACnD,OAAO,KAAK,EAAE,KAAK,EAAE,EAAE;QACtB,KAAK,MAAM,SAAS,IAAI,UAAU,EAAE,CAAC;YACpC,IAAI,MAAM,SAAS,CAAC,KAAK,CAAC;gBAAE,OAAO,IAAI,CAAA;QACxC,CAAC;QACD,OAAO,KAAK,CAAA;IACb,CAAC,CAAA;AACF,CAAC"}