@harness-kernel/core 0.1.0-beta.0

package/dist/runner/logging.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/runner/model-provider.d.ts

@@ -0,0 +1,8 @@
+export { H as HarnessModelProvider, d as HarnessModelProviderRegistry, M as ModelInfo, e as ModelProviderInfo, f as ModelProviderPreparedContext, g as ModelProviderRunInput, h as ModelProviderRunResult, R as ResolvedModelProvider, m as modelProviderId, p as parseModelRef } from '../model-provider-BrZ2RRmS.js';
+import '../events-D4xcDi53.js';
+import '../context-75mlon5x.js';
+import '../role-BN6KhQxx.js';
+import '../types-BPmsw-mF.js';
+import './sandbox.js';
+import '../storage-BmOEwW-p.js';
+import '../hook-DMb9fw9Z.js';

package/dist/runner/model-provider.js

@@ -0,0 +1,11 @@
+import {
+  HarnessModelProviderRegistry,
+  modelProviderId,
+  parseModelRef
+} from "../chunk-Q73WH5D7.js";
+export {
+  HarnessModelProviderRegistry,
+  modelProviderId,
+  parseModelRef
+};
+//# sourceMappingURL=model-provider.js.map

package/dist/runner/model-provider.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/runner/sandbox.d.ts

@@ -0,0 +1,47 @@
+interface HarnessSandboxOpenInput {
+    sessionId: string;
+    runId: string;
+    agentKey: string;
+    workDir: string;
+    outputDir?: string;
+    services: Record<string, unknown>;
+}
+interface SandboxExecInput {
+    command: string;
+    cwd?: string;
+    timeoutMs?: number;
+    env?: Record<string, string>;
+    stdin?: string;
+}
+interface SandboxExecResult {
+    stdout: string;
+    stderr: string;
+    exitCode: number | null;
+    signal?: string;
+    durationMs: number;
+    timedOut?: boolean;
+}
+declare abstract class HarnessSandbox {
+    abstract readonly id: string;
+    label?: string;
+    abstract open(input: HarnessSandboxOpenInput): Promise<HarnessSandboxSession> | HarnessSandboxSession;
+}
+declare abstract class HarnessSandboxSession {
+    abstract readonly id: string;
+    abstract readonly workDir: string;
+    abstract exec(input: SandboxExecInput): Promise<SandboxExecResult>;
+    close?(): Promise<void>;
+}
+declare class NoopSandbox extends HarnessSandbox {
+    readonly id = "noop";
+    label: string;
+    open(input: HarnessSandboxOpenInput): HarnessSandboxSession;
+}
+declare class NoopSandboxSession extends HarnessSandboxSession {
+    readonly workDir: string;
+    readonly id = "noop";
+    constructor(workDir: string);
+    exec(input: SandboxExecInput): Promise<SandboxExecResult>;
+}
+
+export { HarnessSandbox, type HarnessSandboxOpenInput, HarnessSandboxSession, NoopSandbox, NoopSandboxSession, type SandboxExecInput, type SandboxExecResult };

package/dist/runner/sandbox.js

@@ -0,0 +1,13 @@
+import {
+  HarnessSandbox,
+  HarnessSandboxSession,
+  NoopSandbox,
+  NoopSandboxSession
+} from "../chunk-AD3BCYWU.js";
+export {
+  HarnessSandbox,
+  HarnessSandboxSession,
+  NoopSandbox,
+  NoopSandboxSession
+};
+//# sourceMappingURL=sandbox.js.map

package/dist/runner/sandbox.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/runner/storage.d.ts

@@ -0,0 +1,6 @@
+export { H as HarnessRunStorage, a as HarnessRunStore, M as MemoryRunStorage, b as MemoryRunStore, N as NoopRunStorage, c as NoopRunStore, O as OpenRunStoreInput, R as RunCursorState } from '../storage-BmOEwW-p.js';
+import '../events-D4xcDi53.js';
+import '../context-75mlon5x.js';
+import '../role-BN6KhQxx.js';
+import '../types-BPmsw-mF.js';
+import './sandbox.js';

package/dist/runner/storage.js

@@ -0,0 +1,17 @@
+import {
+  HarnessRunStorage,
+  HarnessRunStore,
+  MemoryRunStorage,
+  MemoryRunStore,
+  NoopRunStorage,
+  NoopRunStore
+} from "../chunk-AZVA22HW.js";
+export {
+  HarnessRunStorage,
+  HarnessRunStore,
+  MemoryRunStorage,
+  MemoryRunStore,
+  NoopRunStorage,
+  NoopRunStore
+};
+//# sourceMappingURL=storage.js.map

package/dist/runner/storage.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/runner-Dxo7ALtp.d.ts

@@ -0,0 +1,87 @@
+import { d as HarnessEventQuery, e as HarnessEventRecord, H as HarnessEvent, a as HarnessEventClass } from './events-D4xcDi53.js';
+import { a0 as HarnessTranscriptSession, X as HarnessSnapshotSession, S as HarnessModeSelector, r as AgentSharedState, M as ContextSnapshot } from './context-75mlon5x.js';
+import { f as HarnessSession, b as HarnessAppConfig, p as HarnessUserInput, S as SendOptions, q as SendResult, r as StreamOptions, e as HarnessRunStream, j as HarnessSessionStatus, a as HarnessAgentManifest, T as ToolApprovalHandle, h as HarnessSessionListener, g as HarnessSessionEventListener, W as WaitForEventOptions, k as HarnessSessionStore, m as HarnessSessionStoreListener } from './approval-DfvjpbFs.js';
+import { A as AgentDefinition } from './model-provider-BrZ2RRmS.js';
+
+interface CreateHarnessSessionInternalOptions {
+    sessionId?: string;
+}
+declare class HarnessSessionImpl implements HarnessSession {
+    private readonly config;
+    readonly id: string;
+    readonly transcript: HarnessTranscriptSession;
+    readonly snapshots: HarnessSnapshotSession;
+    private readonly runner;
+    private readonly events;
+    private readonly approvals;
+    private readonly queue;
+    private readonly status;
+    private readonly createdAt;
+    private readonly logger;
+    private lastActiveAt;
+    private closed;
+    private activeAbort?;
+    private lastResult?;
+    private unsubscribeRunner;
+    constructor(config: HarnessAppConfig, input: {
+        sessionId?: string;
+        agent: AgentDefinition;
+        workDir: string;
+    });
+    send(input: string | HarnessUserInput, options?: SendOptions): Promise<SendResult>;
+    stream(input: string | HarnessUserInput, options?: StreamOptions): HarnessRunStream;
+    getStatus(): HarnessSessionStatus;
+    getMode(): string;
+    getModel(): string;
+    setModel(model: string): void;
+    clearModelOverride(): void;
+    switchMode(mode: HarnessModeSelector | string, input?: unknown): Promise<void>;
+    getState(): AgentSharedState;
+    updateState(patch: unknown): void;
+    replaceState(next: AgentSharedState): void;
+    getEvents(filter?: HarnessEventQuery): HarnessEventRecord[];
+    getContextSnapshot(): ContextSnapshot | undefined;
+    getAgentManifest(): HarnessAgentManifest;
+    getPendingApprovals(): ToolApprovalHandle[];
+    approveTool(approvalId: string): Promise<void>;
+    denyTool(approvalId: string, _reason?: string): Promise<void>;
+    on(listener: HarnessSessionListener): () => void;
+    onEvent<TPayload, TEvent extends HarnessEvent<TPayload>>(eventClass: HarnessEventClass<TPayload, TEvent>, listener: HarnessSessionEventListener<TEvent>): () => void;
+    waitForEvent<TPayload, TEvent extends HarnessEvent<TPayload>>(eventClass: HarnessEventClass<TPayload, TEvent>, options?: WaitForEventOptions): Promise<TEvent>;
+    close(): Promise<void>;
+    private notify;
+    private notifyStatus;
+    private assertSnapshotRestoreAllowed;
+    private applyPendingSendTrigger;
+    private resolveModeSelector;
+    private requestToolApproval;
+    private cancelActiveRun;
+}
+declare function createHarnessSession(config: HarnessAppConfig, options?: CreateHarnessSessionInternalOptions): Promise<HarnessSession>;
+
+declare class HarnessSessionStoreImpl implements HarnessSessionStore {
+    private readonly config;
+    private readonly sessions;
+    private readonly unsubscriptions;
+    private readonly listeners;
+    private closed;
+    constructor(config: HarnessAppConfig);
+    getOrCreate(sessionId?: string, overrides?: Partial<HarnessAppConfig>): Promise<HarnessSession>;
+    get(sessionId: string): HarnessSession | undefined;
+    list(): HarnessSessionStatus[];
+    delete(sessionId: string): Promise<boolean>;
+    clear(): Promise<void>;
+    send(sessionId: string | undefined, input: string | HarnessUserInput, options?: SendOptions): Promise<SendResult>;
+    stream(sessionId: string | undefined, input: string | HarnessUserInput, options?: StreamOptions): Promise<HarnessRunStream>;
+    getPendingApprovals(sessionId?: string): ToolApprovalHandle[];
+    approveTool(sessionId: string, approvalId: string): Promise<void>;
+    denyTool(sessionId: string, approvalId: string, reason?: string): Promise<void>;
+    getAgentManifest(sessionId: string): HarnessAgentManifest | undefined;
+    on(listener: HarnessSessionStoreListener): () => void;
+    close(): Promise<void>;
+    private notify;
+    private cleanupExpired;
+}
+declare function createHarnessSessionStore(config: HarnessAppConfig): Promise<HarnessSessionStore>;
+
+export { type CreateHarnessSessionInternalOptions as C, HarnessSessionImpl as H, HarnessSessionStoreImpl as a, createHarnessSessionStore as b, createHarnessSession as c };

package/dist/runner.d.ts

@@ -0,0 +1,10 @@
+export { c as createHarnessSession, b as createHarnessSessionStore } from './runner-Dxo7ALtp.js';
+export { a as HarnessAgentManifest, b as HarnessAppConfig, e as HarnessRunStream, f as HarnessSession, g as HarnessSessionEventListener, h as HarnessSessionListener, i as HarnessSessionPhase, j as HarnessSessionStatus, k as HarnessSessionStore, l as HarnessSessionStoreEvent, m as HarnessSessionStoreListener, o as HarnessStreamEvent, p as HarnessUserInput, S as SendOptions, q as SendResult, r as StreamOptions, W as WaitForEventOptions } from './approval-DfvjpbFs.js';
+export { E as EventCursor } from './events-D4xcDi53.js';
+export { U as HarnessSnapshot, V as HarnessSnapshotCreator, W as HarnessSnapshotInput, X as HarnessSnapshotSession, Y as HarnessSnapshotSummary, a0 as HarnessTranscriptSession, aa as TranscriptBranch, ab as TranscriptCursor, ac as TranscriptQuery, ad as TranscriptSeekTarget } from './context-75mlon5x.js';
+import './model-provider-BrZ2RRmS.js';
+import './role-BN6KhQxx.js';
+import './runner/sandbox.js';
+import './storage-BmOEwW-p.js';
+import './hook-DMb9fw9Z.js';
+import './types-BPmsw-mF.js';

package/dist/runner.js

@@ -0,0 +1,18 @@
+import {
+  HarnessSessionPhase,
+  createHarnessSession,
+  createHarnessSessionStore
+} from "./chunk-4WWSQAWA.js";
+import "./chunk-Q73WH5D7.js";
+import "./chunk-Q44U2CMM.js";
+import "./chunk-AD3BCYWU.js";
+import "./chunk-AZVA22HW.js";
+import "./chunk-4SYLFKIX.js";
+import "./chunk-OBKS4AJR.js";
+import "./chunk-4A2P4QU5.js";
+export {
+  HarnessSessionPhase,
+  createHarnessSession,
+  createHarnessSessionStore
+};
+//# sourceMappingURL=runner.js.map

package/dist/runner.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/schema.d.ts

@@ -0,0 +1,146 @@
+type SchemaIssueCode = "invalid_type" | "invalid_literal" | "invalid_enum" | "too_small" | "too_big" | "custom";
+type SchemaSource = "harness" | "zod" | "standard" | "json-schema" | "custom";
+interface SchemaIssue {
+    path: string;
+    code: string;
+    message: string;
+    expected?: string;
+    received?: string;
+}
+declare class SchemaError extends Error {
+    readonly issues: SchemaIssue[];
+    constructor(issues: SchemaIssue[]);
+}
+type SafeParseResult<T> = {
+    success: true;
+    data: T;
+} | {
+    success: false;
+    error: SchemaError;
+};
+type JsonSchema = Record<string, unknown>;
+type SchemaPathInput = string | number | Array<string | number> | undefined;
+declare function formatSchemaPath(path: SchemaPathInput): string;
+declare function schemaIssuesFromError(error: unknown): SchemaIssue[];
+declare abstract class Schema<TInput = unknown, TOutput = TInput> {
+    readonly isHarnessSchema = true;
+    private schemaDescription?;
+    abstract safeParse(input: unknown): SafeParseResult<TOutput>;
+    abstract toJsonSchema(): JsonSchema;
+    parse(input: TInput): TOutput;
+    optional(): OptionalSchema<TInput | undefined, TOutput | undefined>;
+    default(value: TOutput | (() => TOutput)): DefaultSchema<TInput | undefined, TOutput>;
+    describe(description: string): this;
+    protected withDescription<TJson extends JsonSchema>(json: TJson): TJson;
+}
+type InferInput<TSchema> = TSchema extends Schema<infer TInput, any> ? TInput : unknown;
+type InferOutput<TSchema> = TSchema extends Schema<any, infer TOutput> ? TOutput : unknown;
+declare class StringSchema extends Schema<unknown, string> {
+    private minLength?;
+    private maxLength?;
+    min(length: number): this;
+    max(length: number): this;
+    safeParse(input: unknown): SafeParseResult<string>;
+    toJsonSchema(): JsonSchema;
+}
+declare class NumberSchema extends Schema<unknown, number> {
+    private integerOnly;
+    private minValue?;
+    private maxValue?;
+    private exclusiveMin?;
+    int(): this;
+    min(value: number): this;
+    max(value: number): this;
+    positive(): this;
+    safeParse(input: unknown): SafeParseResult<number>;
+    toJsonSchema(): JsonSchema;
+}
+declare class BooleanSchema extends Schema<unknown, boolean> {
+    safeParse(input: unknown): SafeParseResult<boolean>;
+    toJsonSchema(): JsonSchema;
+}
+declare class ArraySchema<TItem extends Schema<any, any>> extends Schema<InferInput<TItem>[], InferOutput<TItem>[]> {
+    private readonly item;
+    constructor(item: TItem);
+    safeParse(input: unknown): SafeParseResult<InferOutput<TItem>[]>;
+    toJsonSchema(): JsonSchema;
+}
+type ObjectShape = Record<string, Schema<any, any>>;
+type OptionalInputKeys<TShape extends ObjectShape> = {
+    [K in keyof TShape]: undefined extends InferInput<TShape[K]> ? K : never;
+}[keyof TShape];
+type ObjectInput<TShape extends ObjectShape> = {
+    [K in Exclude<keyof TShape, OptionalInputKeys<TShape>>]: InferInput<TShape[K]>;
+} & {
+    [K in OptionalInputKeys<TShape>]?: InferInput<TShape[K]>;
+};
+type OptionalOutputKeys<TShape extends ObjectShape> = {
+    [K in keyof TShape]: undefined extends InferOutput<TShape[K]> ? K : never;
+}[keyof TShape];
+type ObjectOutput<TShape extends ObjectShape> = {
+    [K in Exclude<keyof TShape, OptionalOutputKeys<TShape>>]: InferOutput<TShape[K]>;
+} & {
+    [K in OptionalOutputKeys<TShape>]?: InferOutput<TShape[K]>;
+};
+declare class ObjectSchema<TShape extends ObjectShape> extends Schema<ObjectInput<TShape>, ObjectOutput<TShape>> {
+    private readonly shape;
+    constructor(shape: TShape);
+    safeParse(input: unknown): SafeParseResult<ObjectOutput<TShape>>;
+    toJsonSchema(): JsonSchema;
+}
+declare class RecordSchema<TValue extends Schema<any, any>> extends Schema<Record<string, InferInput<TValue>>, Record<string, InferOutput<TValue>>> {
+    private readonly valueSchema;
+    constructor(valueSchema: TValue);
+    safeParse(input: unknown): SafeParseResult<Record<string, InferOutput<TValue>>>;
+    toJsonSchema(): JsonSchema;
+}
+declare class EnumSchema<const TValues extends readonly [string, ...string[]]> extends Schema<unknown, TValues[number]> {
+    private readonly values;
+    constructor(values: TValues);
+    safeParse(input: unknown): SafeParseResult<TValues[number]>;
+    toJsonSchema(): JsonSchema;
+}
+declare class LiteralSchema<const TValue> extends Schema<unknown, TValue> {
+    private readonly value;
+    constructor(value: TValue);
+    safeParse(input: unknown): SafeParseResult<TValue>;
+    toJsonSchema(): JsonSchema;
+}
+declare class OptionalSchema<TInput, TOutput> extends Schema<TInput | undefined, TOutput | undefined> {
+    private readonly inner;
+    constructor(inner: Schema<TInput, TOutput>);
+    safeParse(input: unknown): SafeParseResult<TOutput | undefined>;
+    toJsonSchema(): JsonSchema;
+}
+declare class DefaultSchema<TInput, TOutput> extends Schema<TInput | undefined, TOutput> {
+    private readonly inner;
+    private readonly value;
+    constructor(inner: Schema<TInput, TOutput>, value: TOutput | (() => TOutput));
+    safeParse(input: unknown): SafeParseResult<TOutput>;
+    toJsonSchema(): JsonSchema;
+}
+declare class UnknownSchema extends Schema<unknown, unknown> {
+    safeParse(input: unknown): SafeParseResult<unknown>;
+    toJsonSchema(): JsonSchema;
+}
+declare const s: {
+    string: () => StringSchema;
+    number: () => NumberSchema;
+    boolean: () => BooleanSchema;
+    array: <TItem extends Schema<any, any>>(item: TItem) => ArraySchema<TItem>;
+    object: <TShape extends ObjectShape>(shape: TShape) => ObjectSchema<TShape>;
+    record: <TValue extends Schema<any, any>>(value: TValue) => RecordSchema<TValue>;
+    enum: <const TValues extends readonly [string, ...string[]]>(values: TValues) => EnumSchema<TValues>;
+    literal: <const TValue>(value: TValue) => LiteralSchema<TValue>;
+    unknown: () => UnknownSchema;
+};
+interface NormalizedSchema<TInput = unknown, TOutput = unknown> {
+    source: SchemaSource;
+    parse(input: TInput): TOutput;
+    safeParse(input: TInput): SafeParseResult<TOutput>;
+    issuesFromError(error: unknown): SchemaIssue[];
+    toJsonSchema?: () => JsonSchema;
+}
+declare function normalizeSchema<TInput = unknown, TOutput = unknown>(schema: unknown): NormalizedSchema<TInput, TOutput>;
+
+export { ArraySchema, BooleanSchema, DefaultSchema, EnumSchema, type InferInput, type InferOutput, type JsonSchema, LiteralSchema, type NormalizedSchema, NumberSchema, ObjectSchema, OptionalSchema, RecordSchema, type SafeParseResult, Schema, SchemaError, type SchemaIssue, type SchemaIssueCode, type SchemaSource, StringSchema, UnknownSchema, formatSchemaPath, normalizeSchema, s, schemaIssuesFromError };

package/dist/schema.js

@@ -0,0 +1,39 @@
+import {
+  ArraySchema,
+  BooleanSchema,
+  DefaultSchema,
+  EnumSchema,
+  LiteralSchema,
+  NumberSchema,
+  ObjectSchema,
+  OptionalSchema,
+  RecordSchema,
+  Schema,
+  SchemaError,
+  StringSchema,
+  UnknownSchema,
+  formatSchemaPath,
+  normalizeSchema,
+  s,
+  schemaIssuesFromError
+} from "./chunk-OBKS4AJR.js";
+export {
+  ArraySchema,
+  BooleanSchema,
+  DefaultSchema,
+  EnumSchema,
+  LiteralSchema,
+  NumberSchema,
+  ObjectSchema,
+  OptionalSchema,
+  RecordSchema,
+  Schema,
+  SchemaError,
+  StringSchema,
+  UnknownSchema,
+  formatSchemaPath,
+  normalizeSchema,
+  s,
+  schemaIssuesFromError
+};
+//# sourceMappingURL=schema.js.map

package/dist/schema.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/storage-BmOEwW-p.d.ts

@@ -0,0 +1,118 @@
+import { e as HarnessEventRecord, E as EventCursor } from './events-D4xcDi53.js';
+import { h as AgentMessage, U as HarnessSnapshot, ab as TranscriptCursor, aa as TranscriptBranch, M as ContextSnapshot } from './context-75mlon5x.js';
+
+interface ToolCallMetric {
+    name: string;
+    count: number;
+    errorCount: number;
+    totalDurationMs: number;
+}
+interface RunMetrics {
+    startedAt: string;
+    completedAt?: string;
+    durationMs: number;
+    turnCount: number;
+    messageCount: number;
+    eventCount: number;
+    toolCallCount: number;
+    finalMode?: string;
+    tools: Record<string, ToolCallMetric>;
+    errors: string[];
+    usage?: unknown;
+}
+
+interface RunCursorState {
+    transcriptCursor: TranscriptCursor;
+    eventCursor: EventCursor;
+    branches?: TranscriptBranch[];
+}
+interface OpenRunStoreInput {
+    runId: string;
+    sessionId: string;
+    agentKey: string;
+    outputDir?: string;
+}
+declare abstract class HarnessRunStorage {
+    abstract readonly id: string;
+    label?: string;
+    abstract openRun(input: OpenRunStoreInput): Promise<HarnessRunStore> | HarnessRunStore;
+}
+declare abstract class HarnessRunStore {
+    abstract readonly runId: string;
+    readonly outputDir?: string;
+    readonly runDir?: string;
+    abstract init(): Promise<void> | void;
+    abstract recordEvent(event: HarnessEventRecord): Promise<void> | void;
+    abstract loadEvents(): Promise<HarnessEventRecord[]> | HarnessEventRecord[];
+    abstract saveTranscript(messages: AgentMessage[]): Promise<void> | void;
+    abstract loadTranscript(): Promise<AgentMessage[]> | AgentMessage[];
+    abstract saveMetrics(metrics: RunMetrics): Promise<void> | void;
+    abstract saveSnapshot(snapshot: HarnessSnapshot): Promise<void> | void;
+    abstract loadSnapshots(): Promise<HarnessSnapshot[]> | HarnessSnapshot[];
+    abstract deleteSnapshot(id: string): Promise<void> | void;
+    abstract saveCursors(cursors: RunCursorState): Promise<void> | void;
+    abstract loadCursors(): Promise<RunCursorState | undefined> | RunCursorState | undefined;
+    abstract saveContextSnapshot(snapshot: ContextSnapshot): Promise<void> | void;
+    abstract loadContextSnapshots(): Promise<ContextSnapshot[]> | ContextSnapshot[];
+    close?(): Promise<void>;
+}
+declare class NoopRunStorage extends HarnessRunStorage {
+    readonly id = "noop";
+    label: string;
+    openRun(input: OpenRunStoreInput): HarnessRunStore;
+}
+declare class NoopRunStore extends HarnessRunStore {
+    readonly runId: string;
+    readonly outputDir: undefined;
+    readonly runDir: undefined;
+    constructor(runId: string);
+    init(): void;
+    recordEvent(_event: HarnessEventRecord): void;
+    loadEvents(): HarnessEventRecord[];
+    saveTranscript(_messages: AgentMessage[]): void;
+    loadTranscript(): AgentMessage[];
+    saveMetrics(_metrics: RunMetrics): void;
+    saveSnapshot(_snapshot: HarnessSnapshot): void;
+    loadSnapshots(): HarnessSnapshot[];
+    deleteSnapshot(_id: string): void;
+    saveCursors(_cursors: RunCursorState): void;
+    loadCursors(): RunCursorState | undefined;
+    saveContextSnapshot(_snapshot: ContextSnapshot): void;
+    loadContextSnapshots(): ContextSnapshot[];
+}
+interface MemoryRunState {
+    events: HarnessEventRecord[];
+    transcript: AgentMessage[];
+    metrics?: RunMetrics;
+    snapshots: Map<string, HarnessSnapshot>;
+    cursors?: RunCursorState;
+    contextSnapshots: Map<string, ContextSnapshot>;
+}
+declare class MemoryRunStorage extends HarnessRunStorage {
+    readonly id = "memory";
+    label: string;
+    private readonly runs;
+    openRun(input: OpenRunStoreInput): HarnessRunStore;
+}
+declare class MemoryRunStore extends HarnessRunStore {
+    readonly runId: string;
+    private readonly state;
+    readonly outputDir: undefined;
+    readonly runDir: undefined;
+    constructor(runId: string, state: MemoryRunState);
+    init(): void;
+    recordEvent(event: HarnessEventRecord): void;
+    loadEvents(): HarnessEventRecord[];
+    saveTranscript(messages: AgentMessage[]): void;
+    loadTranscript(): AgentMessage[];
+    saveMetrics(metrics: RunMetrics): void;
+    saveSnapshot(snapshot: HarnessSnapshot): void;
+    loadSnapshots(): HarnessSnapshot[];
+    deleteSnapshot(id: string): void;
+    saveCursors(cursors: RunCursorState): void;
+    loadCursors(): RunCursorState | undefined;
+    saveContextSnapshot(snapshot: ContextSnapshot): void;
+    loadContextSnapshots(): ContextSnapshot[];
+}
+
+export { HarnessRunStorage as H, MemoryRunStorage as M, NoopRunStorage as N, type OpenRunStoreInput as O, type RunCursorState as R, type ToolCallMetric as T, HarnessRunStore as a, MemoryRunStore as b, NoopRunStore as c, type RunMetrics as d };

package/dist/tool-errors-CygY1Nba.d.ts

@@ -0,0 +1,27 @@
+type ToolErrorCode = "tool.args.invalid_schema" | "tool.approval.denied" | "sandbox.exec.failed" | "tool.failed";
+interface ToolInvalidField {
+    path: string;
+    code?: string;
+    expected?: string;
+    received?: string;
+    message: string;
+}
+interface ToolErrorPayload {
+    ok: false;
+    error: {
+        code: ToolErrorCode;
+        message: string;
+        toolName: string;
+        invalidFields?: ToolInvalidField[];
+        metadata?: Record<string, unknown>;
+    };
+}
+declare function createToolErrorPayload(input: {
+    code: ToolErrorCode;
+    message: string;
+    toolName: string;
+    invalidFields?: ToolInvalidField[];
+    metadata?: Record<string, unknown>;
+}): ToolErrorPayload;
+
+export { type ToolErrorCode as T, type ToolErrorPayload as a, type ToolInvalidField as b, createToolErrorPayload as c };

package/dist/types-BPmsw-mF.d.ts

@@ -0,0 +1,80 @@
+type HarnessLogLevel = "debug" | "info" | "warn" | "error";
+type HarnessLoggingLevel = "silent" | HarnessLogLevel;
+type HarnessLogCategory = "session" | "run" | "turn" | "context" | "model" | "tool" | "approval" | "snapshot" | "transcript" | "storage" | "agent";
+type HarnessLogSourceKind = "runtime" | "model_provider" | "tool" | "hook" | "context_provider" | "mode" | "user" | "custom";
+interface HarnessLogSource {
+    kind: HarnessLogSourceKind;
+    id?: string;
+    type?: string;
+    name?: string;
+    label?: string;
+}
+interface HarnessLogError {
+    name?: string;
+    message: string;
+    stack?: string;
+}
+interface HarnessLogRecord {
+    id: string;
+    at: string;
+    level: HarnessLogLevel;
+    category: HarnessLogCategory;
+    type: string;
+    message: string;
+    sessionId?: string;
+    runId?: string;
+    turnId?: string;
+    modeId?: string;
+    branchId?: string;
+    source: HarnessLogSource;
+    correlationId?: string;
+    causationId?: string;
+    spanId?: string;
+    parentSpanId?: string;
+    durationMs?: number;
+    fields?: Record<string, unknown>;
+    error?: HarnessLogError;
+}
+declare abstract class HarnessLog<TFields = Record<string, unknown>> {
+    abstract level: HarnessLogLevel;
+    abstract category: HarnessLogCategory;
+    abstract message(fields: TFields): string;
+    levelFor?(fields: TFields): HarnessLogLevel;
+    redact?(fields: TFields): TFields;
+}
+type HarnessLogClass<TFields = Record<string, unknown>> = new () => HarnessLog<TFields>;
+declare abstract class HarnessLogSink {
+    abstract write(record: HarnessLogRecord): void | Promise<void>;
+    flush?(): void | Promise<void>;
+    close?(): void | Promise<void>;
+}
+interface HarnessLoggingConfig {
+    level?: HarnessLoggingLevel;
+    sinks?: HarnessLogSink[];
+    format?: "pretty" | "json";
+    modelDeltas?: "none" | "summary" | "full" | boolean;
+    events?: boolean;
+    redact?: {
+        keys?: string[];
+        replacement?: string;
+    };
+}
+interface HarnessRedactionConfig {
+    keys?: string[];
+    replacement?: string;
+}
+interface HarnessLogContext {
+    sessionId?: string;
+    runId?: string;
+    turnId?: string;
+    modeId?: string;
+    branchId?: string;
+    source?: HarnessLogSource;
+    correlationId?: string;
+    causationId?: string;
+    spanId?: string;
+    parentSpanId?: string;
+    durationMs?: number;
+}
+
+export { HarnessLog as H, type HarnessLogCategory as a, type HarnessLogClass as b, type HarnessLogContext as c, type HarnessLogError as d, type HarnessLogLevel as e, type HarnessLogRecord as f, HarnessLogSink as g, type HarnessLogSource as h, type HarnessLogSourceKind as i, type HarnessLoggingConfig as j, type HarnessLoggingLevel as k, type HarnessRedactionConfig as l };