@harness-kernel/core 0.1.0-beta.0

package/dist/context-75mlon5x.d.ts

@@ -0,0 +1,394 @@
+import { c as HarnessRoleSelector } from './role-BN6KhQxx.js';
+import { E as EventCursor, J as JsonObject, a as HarnessEventClass, d as HarnessEventQuery, e as HarnessEventRecord, H as HarnessEvent, b as HarnessEventEmitOptions } from './events-D4xcDi53.js';
+import { b as HarnessLogClass, c as HarnessLogContext } from './types-BPmsw-mF.js';
+import { HarnessSandboxSession } from './runner/sandbox.js';
+
+type AgentMessageRole = "system" | "user" | "assistant" | "tool" | "event" | (string & {});
+interface AgentMessage {
+    id: string;
+    seq: number;
+    branchId: string;
+    parentMessageId?: string;
+    role: AgentMessageRole;
+    authorRole?: string;
+    roleType?: string;
+    content: unknown;
+    createdAt: string;
+    modeId?: string;
+    turnId?: string;
+    hidden?: boolean;
+    toolName?: string;
+    toolCallId?: string;
+    eventCursor?: EventCursor;
+    metadata?: JsonObject;
+}
+interface TranscriptQuery {
+    limit?: number;
+    includeHidden?: boolean;
+    includeInactive?: boolean;
+    beforeCurrentTurn?: boolean;
+    roles?: AgentMessageRole[];
+}
+interface TranscriptCursor {
+    id: string;
+    branchId: string;
+    headMessageId?: string;
+    seq: number;
+    updatedAt: string;
+}
+type TranscriptSeekTarget = "latest" | "start" | {
+    messageId: string;
+} | {
+    cursor: TranscriptCursor;
+};
+interface TranscriptBranch {
+    id: string;
+    createdAt: string;
+    parentBranchId?: string;
+    parentMessageId?: string;
+    parentMessageSeq?: number;
+    parentEventSeq?: number;
+    metadata?: JsonObject;
+}
+
+type HarnessContextProviderClass<TProvider extends HarnessContextProvider = HarnessContextProvider> = abstract new (...args: any[]) => TProvider;
+type HarnessContextProviderSelector<TOptions extends JsonObject = JsonObject> = HarnessContextProvider<TOptions> | HarnessContextProviderClass<HarnessContextProvider<TOptions>>;
+interface ContextProviderBinding<TOptions extends JsonObject = JsonObject> {
+    provider: HarnessContextProviderSelector<TOptions>;
+    options?: TOptions;
+}
+type ContextProviderReference<TOptions extends JsonObject = JsonObject> = HarnessContextProviderSelector<TOptions> | ContextProviderBinding<TOptions>;
+interface ContextProviderSummary {
+    type: string;
+    label?: string;
+    options?: JsonObject;
+}
+interface ContextContribution {
+    providerId?: string;
+    providerLabel?: string;
+    role: string;
+    authorRole?: string;
+    roleType?: string;
+    content: unknown;
+    metadata?: JsonObject;
+}
+declare enum ContextScopes {
+    Turn = "turn",
+    Run = "run",
+    Session = "session"
+}
+declare enum ContextConsume {
+    Once = "once",
+    WhileActive = "while_active"
+}
+interface ContextRegistrationOptions {
+    scope?: ContextScopes;
+    on?: HarnessEventClass;
+    consume?: ContextConsume;
+    id?: string;
+    replace?: boolean;
+    metadata?: JsonObject;
+}
+interface ContextEntry {
+    id: string;
+    scope: ContextScopes;
+    on: string;
+    consume: ContextConsume;
+    createdAt: string;
+    activatedAt?: string;
+    activatedByEventId?: string;
+    activatedByEventType?: string;
+    runId: string;
+    turnId?: string;
+    modeId: string;
+    contribution: ContextContribution;
+    metadata?: JsonObject;
+}
+interface ContextEntryFilter {
+    id?: string;
+    scope?: ContextScopes;
+    consume?: ContextConsume;
+    providerId?: string;
+    role?: string;
+    on?: HarnessEventClass;
+}
+type ContextProviderOutput = string | ContextContributionInput | Array<string | ContextContributionInput> | null | undefined;
+interface ContextContributionInput {
+    role?: HarnessRoleSelector;
+    content: unknown;
+    metadata?: JsonObject;
+}
+interface ContextProviderRenderResult {
+    providerId: string;
+    providerLabel?: string;
+    binding: ContextProviderSummary;
+    contributions: ContextContribution[];
+}
+interface ContextSnapshot {
+    id: string;
+    turnId?: string;
+    modeId: string;
+    createdAt: string;
+    providers: ContextProviderRenderResult[];
+    contributions: ContextContribution[];
+    systemPrompt: string;
+    messages: AgentMessage[];
+}
+declare abstract class HarnessContextProvider<TOptions extends JsonObject = JsonObject> {
+    protected readonly __harnessContextProviderBrand: true;
+    label?: string;
+    priority?: number;
+    role?: HarnessRoleSelector;
+    get type(): string;
+    with(options: TOptions): ContextProviderBinding<TOptions>;
+    abstract render(session: AgentReadSession, options?: TOptions): ContextProviderOutput | Promise<ContextProviderOutput>;
+}
+type AgentContextProvider<TOptions extends JsonObject = JsonObject> = HarnessContextProvider<TOptions>;
+
+interface HarnessModeSummary {
+    type: string;
+    label: string;
+}
+declare abstract class HarnessMode {
+    protected readonly __harnessModeBrand: true;
+    label?: string;
+    model?: string;
+    prompt?: string | ((session: AgentReadSession) => string | Promise<string>);
+    providers?: "all" | ContextProviderReference[];
+    excludeProviders?: string[];
+    tools?: AgentToolSource[];
+    maxTurns?: number;
+    toolApproval?: ToolApprovalMode;
+    get type(): string;
+    getPrompt?(session: AgentReadSession): string | Promise<string>;
+    onEnter?(session: AgentActionSession, input?: unknown): void | Promise<void>;
+    onExit?(session: AgentActionSession, nextMode: HarnessModeSummary): void | Promise<void>;
+}
+type HarnessModeClass<TMode extends HarnessMode = HarnessMode> = abstract new (...args: any[]) => TMode;
+type HarnessModeSelector<TMode extends HarnessMode = HarnessMode> = TMode | HarnessModeClass<TMode>;
+type AgentModeDefinition = HarnessMode;
+
+type AgentSharedState = JsonObject;
+interface AgentSharedStateDefinition {
+    initial?: AgentSharedState | (() => AgentSharedState);
+}
+
+interface HarnessSnapshotInput {
+    label?: string;
+    metadata?: JsonObject;
+}
+interface HarnessSnapshotSummary {
+    id: string;
+    label?: string;
+    createdAt: string;
+    agentKey: string;
+    runId?: string;
+    turnId?: string;
+    modeId: string;
+    model: string;
+    transcriptCursor: TranscriptCursor;
+    eventCursor: EventCursor;
+    metadata?: JsonObject;
+}
+interface HarnessSnapshot extends HarnessSnapshotSummary {
+    state: AgentSharedState;
+    contextEntries: ContextEntry[];
+    contextSnapshot?: ContextSnapshot;
+    branches: TranscriptBranch[];
+}
+interface HarnessSnapshotCreator {
+    create(input?: HarnessSnapshotInput): Promise<HarnessSnapshot>;
+}
+interface HarnessSnapshotSession extends HarnessSnapshotCreator {
+    list(): HarnessSnapshotSummary[];
+    get(id: string): HarnessSnapshot | undefined;
+    restore(id: string): Promise<HarnessSnapshot>;
+    delete(id: string): Promise<boolean>;
+}
+
+interface AgentStateReader<TState extends AgentSharedState = AgentSharedState> {
+    get(): TState;
+}
+interface AgentStateSession<TState extends AgentSharedState = AgentSharedState> extends AgentStateReader<TState> {
+    update(patch: Partial<TState>): void;
+    set(next: TState): void;
+}
+interface AgentHistorySession {
+    get(options?: TranscriptQuery): AgentMessage[];
+}
+interface AgentEventReader {
+    query<TPayload = unknown>(filter?: HarnessEventQuery<TPayload>): HarnessEventRecord<TPayload>[];
+}
+interface AgentEventSession extends AgentEventReader {
+    emit<TPayload, TEvent extends HarnessEvent<TPayload>>(eventClass: HarnessEventClass<TPayload, TEvent>, payload: TPayload, options?: HarnessEventEmitOptions): Promise<TEvent>;
+}
+interface AgentModeReader {
+    current(): HarnessModeSummary;
+}
+interface AgentModeSession extends AgentModeReader {
+    switch(mode: HarnessModeSelector, input?: unknown): Promise<void>;
+}
+interface AgentToolSession {
+    invoke(tool: HarnessToolSelector, args: unknown): Promise<AgentToolResult>;
+}
+interface AgentMessageInput {
+    content: string;
+    metadata?: JsonObject;
+    role?: HarnessRoleSelector;
+    id?: string;
+}
+interface AgentMessageEnqueueOptions {
+    metadata?: JsonObject;
+}
+interface AgentMessageSession {
+    enqueue(input: string | AgentMessageInput, options?: AgentMessageEnqueueOptions): Promise<void>;
+}
+interface HarnessTranscriptSession {
+    get(options?: TranscriptQuery): AgentMessage[];
+    getCursor(): TranscriptCursor;
+    seek(target: TranscriptSeekTarget): Promise<TranscriptCursor>;
+    latest(): Promise<TranscriptCursor>;
+}
+interface AgentLogSession {
+    debug(message: string, fields?: Record<string, unknown>): void;
+    info(message: string, fields?: Record<string, unknown>): void;
+    warn(message: string, fields?: Record<string, unknown>): void;
+    error(errorOrMessage: unknown, fields?: Record<string, unknown>): void;
+    emit<TFields>(logClass: HarnessLogClass<TFields>, fields: TFields): void;
+}
+interface AgentRuntimeLogger {
+    readonly modelDeltas: "none" | "summary" | "full";
+    emit<TFields>(logClass: HarnessLogClass<TFields>, fields: TFields, context?: HarnessLogContext): void;
+    agent(context: HarnessLogContext): AgentLogSession;
+}
+interface AgentContextReader {
+    get(filter?: ContextEntryFilter): ContextEntry[];
+    snapshot(): ContextSnapshot | undefined;
+}
+interface AgentContextSession extends AgentContextReader {
+    add(input: ContextContributionInput, options?: ContextRegistrationOptions): Promise<ContextEntry>;
+    render(binding: ContextProviderReference, options?: ContextRegistrationOptions): Promise<ContextEntry[]>;
+    remove(id: string): Promise<boolean>;
+    clear(filter?: ContextEntryFilter): Promise<number>;
+}
+interface AgentReadSession<TState extends AgentSharedState = AgentSharedState, TServices extends Record<string, unknown> = Record<string, unknown>> {
+    runId: string;
+    turnId?: string;
+    agentKey: string;
+    workDir: string;
+    outputDir?: string;
+    services: TServices;
+    state: AgentStateReader<TState>;
+    history: AgentHistorySession;
+    events: AgentEventReader;
+    mode: AgentModeReader;
+    context: AgentContextReader;
+    log: AgentLogSession;
+}
+interface AgentActionSession<TState extends AgentSharedState = AgentSharedState, TServices extends Record<string, unknown> = Record<string, unknown>> extends AgentReadSession<TState, TServices> {
+    sandbox: HarnessSandboxSession;
+    state: AgentStateSession<TState>;
+    events: AgentEventSession;
+    mode: AgentModeSession;
+    tools: AgentToolSession;
+    context: AgentContextSession;
+    messages: AgentMessageSession;
+    snapshots: HarnessSnapshotCreator;
+    toolCall?: {
+        id?: string;
+        name: string;
+    };
+}
+interface RunInfo {
+    runId: string;
+    agentKey: string;
+    workDir: string;
+    outputDir?: string;
+    started: boolean;
+    startedAt?: string;
+}
+interface TurnInfo {
+    turnId?: string;
+    turnCount: number;
+    modeId: string;
+}
+
+type ToolApprovalMode = "auto" | "ask" | "deny" | "tool-default";
+type ToolApprovalDecision = "approved" | "denied";
+type ToolRisk = "safe" | "read" | "write" | "execute" | "network" | "destructive";
+interface ToolPermission {
+    kind: "filesystem" | "shell" | "network" | "custom";
+    access?: "read" | "write" | "execute";
+    path?: string;
+    description?: string;
+}
+type ToolRef = {
+    kind: "file";
+    path: string;
+    role?: "created" | "modified" | "read" | "evidence";
+} | {
+    kind: "url";
+    url: string;
+    role?: string;
+} | {
+    kind: "command";
+    command: string;
+    exitCode?: number;
+    role?: string;
+} | {
+    kind: "tool_call";
+    toolName: string;
+    callId?: string;
+    role?: string;
+} | {
+    kind: "session";
+    sessionId: string;
+    role?: string;
+} | {
+    kind: "external";
+    label: string;
+    uri?: string;
+    role?: string;
+};
+interface ToolCatalogEntry {
+    name: string;
+    description: string;
+    risk?: ToolRisk;
+    permissions?: ToolPermission[];
+    requiresApproval?: boolean;
+}
+type ToolApprovalResolver = (args: unknown, session: AgentActionSession) => boolean | Promise<boolean>;
+interface AgentToolResult<TData = unknown> {
+    content: string;
+    data?: TData;
+    refs?: ToolRef[];
+    metadata?: JsonObject;
+    isError?: boolean;
+}
+declare abstract class HarnessTool<TInput = unknown, TData = unknown> {
+    protected readonly __harnessToolBrand: true;
+    label?: string;
+    abstract name: string;
+    abstract description: string;
+    schema?: unknown;
+    risk?: ToolRisk;
+    permissions?: ToolPermission[];
+    requiresApproval?: boolean | ToolApprovalResolver;
+    get type(): string;
+    get inputSchema(): unknown;
+    abstract execute(args: TInput, session: AgentActionSession): AgentToolResult<TData> | Promise<AgentToolResult<TData>>;
+}
+type HarnessToolClass<TTool extends HarnessTool = HarnessTool> = abstract new (...args: any[]) => TTool;
+type HarnessToolSelector<TTool extends HarnessTool = HarnessTool> = TTool | HarnessToolClass<TTool>;
+type AgentToolDefinition<TInput = unknown, TData = unknown> = HarnessTool<TInput, TData>;
+type AgentToolSource = HarnessTool;
+interface ToolApprovalRequest {
+    id: string;
+    name: string;
+    args: unknown;
+    modeId: string;
+    risk?: ToolRisk;
+    permissions?: ToolPermission[];
+}
+
+export { type HarnessToolSelector as $, type AgentActionSession as A, type ContextContributionInput as B, ContextConsume as C, type ContextEntry as D, type ContextEntryFilter as E, type ContextProviderBinding as F, type ContextProviderOutput as G, type ContextProviderReference as H, type ContextProviderRenderResult as I, type ContextProviderSummary as J, type ContextRegistrationOptions as K, ContextScopes as L, type ContextSnapshot as M, HarnessContextProvider as N, type HarnessContextProviderClass as O, type HarnessContextProviderSelector as P, HarnessMode as Q, type HarnessModeClass as R, type HarnessModeSelector as S, type HarnessModeSummary as T, type HarnessSnapshot as U, type HarnessSnapshotCreator as V, type HarnessSnapshotInput as W, type HarnessSnapshotSession as X, type HarnessSnapshotSummary as Y, HarnessTool as Z, type HarnessToolClass as _, type AgentContextProvider as a, type HarnessTranscriptSession as a0, type RunInfo as a1, type ToolApprovalDecision as a2, type ToolApprovalMode as a3, type ToolApprovalRequest as a4, type ToolApprovalResolver as a5, type ToolCatalogEntry as a6, type ToolPermission as a7, type ToolRef as a8, type ToolRisk as a9, type TranscriptBranch as aa, type TranscriptCursor as ab, type TranscriptQuery as ac, type TranscriptSeekTarget as ad, type TurnInfo as ae, type AgentContextReader as b, type AgentContextSession as c, type AgentEventReader as d, type AgentEventSession as e, type AgentHistorySession as f, type AgentLogSession as g, type AgentMessage as h, type AgentMessageEnqueueOptions as i, type AgentMessageInput as j, type AgentMessageRole as k, type AgentMessageSession as l, type AgentModeDefinition as m, type AgentModeReader as n, type AgentModeSession as o, type AgentReadSession as p, type AgentRuntimeLogger as q, type AgentSharedState as r, type AgentSharedStateDefinition as s, type AgentStateReader as t, type AgentStateSession as u, type AgentToolDefinition as v, type AgentToolResult as w, type AgentToolSession as x, type AgentToolSource as y, type ContextContribution as z };

package/dist/event-CKV4EeZ3.d.ts

@@ -0,0 +1,230 @@
+import { H as HarnessEvent } from './events-D4xcDi53.js';
+import { ObjectSchema, StringSchema, NumberSchema, OptionalSchema, LiteralSchema, UnknownSchema, EnumSchema } from './schema.js';
+
+declare class RunStartEvent extends HarnessEvent<{
+    agentKey: string;
+    modeId: string;
+    workDir: string;
+    outputDir?: string;
+}> {
+    static type: string;
+    static schema: ObjectSchema<{
+        agentKey: StringSchema;
+        modeId: StringSchema;
+        workDir: StringSchema;
+        outputDir: OptionalSchema<unknown, string | undefined>;
+    }>;
+}
+declare class TurnStartEvent extends HarnessEvent<{
+    turnId: string;
+    input: string;
+}> {
+    static type: string;
+    static schema: ObjectSchema<{
+        turnId: StringSchema;
+        input: StringSchema;
+    }>;
+}
+declare class ContextReadyEvent extends HarnessEvent<{
+    snapshotId: string;
+    providerCount: number;
+    contributionCount: number;
+}> {
+    static type: string;
+    static schema: ObjectSchema<{
+        snapshotId: StringSchema;
+        providerCount: NumberSchema;
+        contributionCount: NumberSchema;
+    }>;
+}
+declare class ModelBeforeEvent extends HarnessEvent<{
+    model: string;
+    messageCount: number;
+}> {
+    static type: string;
+    static schema: ObjectSchema<{
+        model: StringSchema;
+        messageCount: NumberSchema;
+    }>;
+}
+declare class ModelAfterEvent extends HarnessEvent<{
+    model: string;
+    content: string;
+    usage?: unknown;
+    finishReason?: string;
+}> {
+    static type: string;
+    static schema: ObjectSchema<{
+        model: StringSchema;
+        content: StringSchema;
+        usage: OptionalSchema<unknown, unknown>;
+        finishReason: OptionalSchema<unknown, string | undefined>;
+    }>;
+}
+declare class ToolStartEvent extends HarnessEvent<{
+    id: string;
+    name: string;
+    args: unknown;
+}> {
+    static type: string;
+    static schema: ObjectSchema<{
+        id: StringSchema;
+        name: StringSchema;
+        args: UnknownSchema;
+    }>;
+}
+declare class ToolEndEvent extends HarnessEvent<{
+    id: string;
+    name: string;
+    durationMs: number;
+    result: unknown;
+}> {
+    static type: string;
+    static schema: ObjectSchema<{
+        id: StringSchema;
+        name: StringSchema;
+        durationMs: NumberSchema;
+        result: UnknownSchema;
+    }>;
+}
+declare class TurnEndEvent extends HarnessEvent<{
+    turnId: string;
+    finalAnswer: string;
+}> {
+    static type: string;
+    static schema: ObjectSchema<{
+        turnId: StringSchema;
+        finalAnswer: StringSchema;
+    }>;
+}
+declare class RunEndEvent extends HarnessEvent<{
+    metrics: unknown;
+    finalAnswer: string;
+}> {
+    static type: string;
+    static schema: ObjectSchema<{
+        metrics: UnknownSchema;
+        finalAnswer: StringSchema;
+    }>;
+}
+declare class ErrorEvent extends HarnessEvent<{
+    message: string;
+    recoverable?: boolean;
+    details?: unknown;
+}> {
+    static type: string;
+    static schema: ObjectSchema<{
+        message: StringSchema;
+        recoverable: OptionalSchema<unknown, boolean | undefined>;
+        details: OptionalSchema<unknown, unknown>;
+    }>;
+}
+declare class MessageStartEvent extends HarnessEvent<{
+    role: string;
+}> {
+    static type: string;
+    static schema: ObjectSchema<{
+        role: StringSchema;
+    }>;
+}
+declare class MessageDeltaEvent extends HarnessEvent<{
+    role: "assistant";
+    text: string;
+}> {
+    static type: string;
+    static schema: ObjectSchema<{
+        role: LiteralSchema<"assistant">;
+        text: StringSchema;
+    }>;
+}
+declare class MessageEndEvent extends HarnessEvent<{
+    message: unknown;
+}> {
+    static type: string;
+    static schema: ObjectSchema<{
+        message: UnknownSchema;
+    }>;
+}
+declare class ToolApprovalRequestedEvent extends HarnessEvent<{
+    id: string;
+    name: string;
+    args: unknown;
+    modeId?: string;
+    risk?: string;
+    permissions?: unknown[];
+}> {
+    static type: string;
+    static schema: ObjectSchema<{
+        id: StringSchema;
+        name: StringSchema;
+        args: UnknownSchema;
+        modeId: OptionalSchema<unknown, string | undefined>;
+        risk: OptionalSchema<unknown, string | undefined>;
+        permissions: OptionalSchema<unknown[] | undefined, unknown[] | undefined>;
+    }>;
+}
+declare class ToolApprovalResolvedEvent extends HarnessEvent<{
+    id: string;
+    name: string;
+    args: unknown;
+    decision: "approved" | "denied";
+    modeId?: string;
+}> {
+    static type: string;
+    static schema: ObjectSchema<{
+        id: StringSchema;
+        name: StringSchema;
+        args: UnknownSchema;
+        decision: EnumSchema<readonly ["approved", "denied"]>;
+        modeId: OptionalSchema<unknown, string | undefined>;
+    }>;
+}
+declare class ModeChangedEvent extends HarnessEvent<{
+    previousMode: string;
+    mode: string;
+    input?: unknown;
+}> {
+    static type: string;
+    static schema: ObjectSchema<{
+        previousMode: StringSchema;
+        mode: StringSchema;
+        input: OptionalSchema<unknown, unknown>;
+    }>;
+}
+declare class SnapshotCreatedEvent extends HarnessEvent<{
+    snapshot: unknown;
+}> {
+    static type: string;
+    static schema: ObjectSchema<{
+        snapshot: UnknownSchema;
+    }>;
+}
+declare class SnapshotRestoredEvent extends HarnessEvent<{
+    snapshot: unknown;
+}> {
+    static type: string;
+    static schema: ObjectSchema<{
+        snapshot: UnknownSchema;
+    }>;
+}
+declare class SnapshotDeletedEvent extends HarnessEvent<{
+    snapshot: unknown;
+}> {
+    static type: string;
+    static schema: ObjectSchema<{
+        snapshot: UnknownSchema;
+    }>;
+}
+declare class TranscriptCursorChangedEvent extends HarnessEvent<{
+    previousCursor: unknown;
+    cursor: unknown;
+}> {
+    static type: string;
+    static schema: ObjectSchema<{
+        previousCursor: UnknownSchema;
+        cursor: UnknownSchema;
+    }>;
+}
+declare const runtimeEventClasses: (typeof RunStartEvent | typeof TurnStartEvent | typeof ContextReadyEvent | typeof ModelBeforeEvent | typeof ModelAfterEvent | typeof ToolStartEvent | typeof ToolEndEvent | typeof TurnEndEvent | typeof RunEndEvent | typeof MessageStartEvent | typeof MessageDeltaEvent | typeof MessageEndEvent | typeof ModeChangedEvent | typeof SnapshotCreatedEvent | typeof TranscriptCursorChangedEvent)[];
+
+export { ContextReadyEvent as C, ErrorEvent as E, MessageDeltaEvent as M, RunEndEvent as R, SnapshotCreatedEvent as S, ToolApprovalRequestedEvent as T, MessageEndEvent as a, MessageStartEvent as b, ModeChangedEvent as c, ModelAfterEvent as d, ModelBeforeEvent as e, RunStartEvent as f, SnapshotDeletedEvent as g, SnapshotRestoredEvent as h, ToolApprovalResolvedEvent as i, ToolEndEvent as j, ToolStartEvent as k, TranscriptCursorChangedEvent as l, TurnEndEvent as m, TurnStartEvent as n, runtimeEventClasses as r };

package/dist/events-D4xcDi53.d.ts

@@ -0,0 +1,69 @@
+type JsonObject = Record<string, unknown>;
+
+interface HarnessEventMetadata extends JsonObject {
+    label?: string;
+}
+interface HarnessEventSource {
+    kind: "runtime" | "model_provider" | "tool" | "hook" | "context_provider" | "mode" | "user" | "custom";
+    id?: string;
+    name?: string;
+}
+interface HarnessEventRecord<TPayload = unknown> {
+    id: string;
+    seq: number;
+    branchId: string;
+    type: string;
+    eventClassId: string;
+    at: string;
+    source: HarnessEventSource;
+    payload: TPayload;
+    runId: string;
+    turnId?: string;
+    modeId?: string;
+    correlationId?: string;
+    causationId?: string;
+    hidden: true;
+    metadata?: HarnessEventMetadata;
+}
+declare abstract class HarnessEvent<TPayload = unknown> {
+    readonly record: HarnessEventRecord<TPayload>;
+    static type?: string;
+    static schema?: unknown;
+    constructor(record: HarnessEventRecord<TPayload>);
+    get id(): string;
+    get type(): string;
+    get payload(): TPayload;
+    get at(): string;
+}
+type HarnessEventClass<TPayload = unknown, TEvent extends HarnessEvent<TPayload> = HarnessEvent<TPayload>> = {
+    readonly type?: string;
+    readonly schema?: unknown;
+    new (record: HarnessEventRecord<any>): TEvent;
+};
+interface HarnessEventEmitOptions {
+    source?: HarnessEventSource;
+    correlationId?: string;
+    causationId?: string;
+    metadata?: HarnessEventMetadata;
+    hiddenTranscript?: boolean;
+    skipHooks?: boolean;
+}
+interface HarnessEventQuery<TPayload = unknown> {
+    event?: HarnessEventClass<TPayload>;
+    type?: string;
+    sourceKind?: HarnessEventSource["kind"];
+    limit?: number;
+    since?: string;
+    until?: string;
+    includeInactive?: boolean;
+}
+interface EventCursor {
+    id: string;
+    branchId: string;
+    headEventId?: string;
+    seq: number;
+    updatedAt: string;
+}
+type RunnerEventListener = (event: HarnessEventRecord) => void | Promise<void>;
+
+export { type EventCursor as E, HarnessEvent as H, type JsonObject as J, type RunnerEventListener as R, type HarnessEventClass as a, type HarnessEventEmitOptions as b, type HarnessEventMetadata as c, type HarnessEventQuery as d, type HarnessEventRecord as e, type HarnessEventSource as f };