@harness-kernel/core 0.1.0-beta.0

package/dist/hook-DMb9fw9Z.d.ts

@@ -0,0 +1,20 @@
+import { H as HarnessEvent, a as HarnessEventClass } from './events-D4xcDi53.js';
+import { A as AgentActionSession } from './context-75mlon5x.js';
+
+interface HarnessHookSummary {
+    type: string;
+    label: string;
+    eventType: string;
+    eventClassId: string;
+}
+declare abstract class HarnessHook<TEvent extends HarnessEvent = HarnessEvent> {
+    protected readonly __harnessHookBrand: true;
+    label?: string;
+    readonly eventClass?: HarnessEventClass<any, TEvent>;
+    static for<TPayload, TEvent extends HarnessEvent<TPayload>>(eventClass: HarnessEventClass<TPayload, TEvent>): abstract new () => HarnessHook<TEvent>;
+    get type(): string;
+    abstract onActive(session: AgentActionSession, event: TEvent): void | Promise<void>;
+}
+type HarnessHookEventClass<TEvent extends HarnessEvent = HarnessEvent> = abstract new () => HarnessHook<TEvent>;
+
+export { HarnessHook as H, type HarnessHookEventClass as a, type HarnessHookSummary as b };

package/dist/index.d.ts

@@ -0,0 +1,164 @@
+import { R as RunnerEventListener, J as JsonObject, d as HarnessEventQuery, e as HarnessEventRecord, b as HarnessEventEmitOptions } from './events-D4xcDi53.js';
+export { E as EventCursor, H as HarnessEvent, a as HarnessEventClass, c as HarnessEventMetadata, f as HarnessEventSource } from './events-D4xcDi53.js';
+import { a as HarnessAgentManifest } from './approval-DfvjpbFs.js';
+export { H as HarnessAgentInput, b as HarnessAppConfig, c as HarnessErrorShape, d as HarnessEventSummary, 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, n as HarnessStorageConfig, o as HarnessStreamEvent, p as HarnessUserInput, S as SendOptions, q as SendResult, r as StreamOptions, T as ToolApprovalHandle, W as WaitForEventOptions } from './approval-DfvjpbFs.js';
+import { ac as TranscriptQuery, h as AgentMessage, ab as TranscriptCursor, ad as TranscriptSeekTarget, r as AgentSharedState, W as HarnessSnapshotInput, U as HarnessSnapshot, Y as HarnessSnapshotSummary, M as ContextSnapshot, E as ContextEntryFilter, D as ContextEntry, S as HarnessModeSelector } from './context-75mlon5x.js';
+export { A as AgentActionSession, a as AgentContextProvider, b as AgentContextReader, c as AgentContextSession, d as AgentEventReader, e as AgentEventSession, f as AgentHistorySession, g as AgentLogSession, i as AgentMessageEnqueueOptions, j as AgentMessageInput, k as AgentMessageRole, l as AgentMessageSession, m as AgentModeDefinition, n as AgentModeReader, o as AgentModeSession, p as AgentReadSession, q as AgentRuntimeLogger, s as AgentSharedStateDefinition, t as AgentStateReader, u as AgentStateSession, v as AgentToolDefinition, w as AgentToolResult, x as AgentToolSession, y as AgentToolSource, C as ContextConsume, z as ContextContribution, B as ContextContributionInput, F as ContextProviderBinding, G as ContextProviderOutput, H as ContextProviderReference, I as ContextProviderRenderResult, J as ContextProviderSummary, K as ContextRegistrationOptions, L as ContextScopes, N as HarnessContextProvider, O as HarnessContextProviderClass, P as HarnessContextProviderSelector, Q as HarnessMode, R as HarnessModeClass, T as HarnessModeSummary, V as HarnessSnapshotCreator, X as HarnessSnapshotSession, Z as HarnessTool, _ as HarnessToolClass, $ as HarnessToolSelector, a0 as HarnessTranscriptSession, a1 as RunInfo, a2 as ToolApprovalDecision, a3 as ToolApprovalMode, a4 as ToolApprovalRequest, a5 as ToolApprovalResolver, a6 as ToolCatalogEntry, a7 as ToolPermission, a8 as ToolRef, a9 as ToolRisk, aa as TranscriptBranch, ae as TurnInfo } from './context-75mlon5x.js';
+export { A as AssistantRole, H as HarnessRole, a as HarnessRoleClass, b as HarnessRoleDefinition, c as HarnessRoleSelector, d as HarnessRoleSummary, N as NativeRoles, R as RoleTargets, S as SystemRole, T as ToolRole, U as UserRole, e as assistantRole, s as systemRole, t as toolRole, u as userRole } from './role-BN6KhQxx.js';
+export { H as HarnessHook, a as HarnessHookEventClass, b as HarnessHookSummary } from './hook-DMb9fw9Z.js';
+import { d as RunMetrics } from './storage-BmOEwW-p.js';
+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, T as ToolCallMetric } from './storage-BmOEwW-p.js';
+import { N as NormalizedAgentDefinition, c as AgentSessionRunnerOptions, b as AgentRunnerRunOptions, a as AgentRunResult, e as ModelProviderInfo } from './model-provider-BrZ2RRmS.js';
+export { A as AgentDefinition, H as HarnessModelProvider, d as HarnessModelProviderRegistry, M as ModelInfo, f as ModelProviderPreparedContext, g as ModelProviderRunInput, h as ModelProviderRunResult, R as ResolvedModelProvider, m as modelProviderId, p as parseModelRef } from './model-provider-BrZ2RRmS.js';
+export { C as ContextReadyEvent, E as ErrorEvent, M as MessageDeltaEvent, a as MessageEndEvent, b as MessageStartEvent, c as ModeChangedEvent, d as ModelAfterEvent, e as ModelBeforeEvent, R as RunEndEvent, f as RunStartEvent, S as SnapshotCreatedEvent, g as SnapshotDeletedEvent, h as SnapshotRestoredEvent, T as ToolApprovalRequestedEvent, i as ToolApprovalResolvedEvent, j as ToolEndEvent, k as ToolStartEvent, l as TranscriptCursorChangedEvent, m as TurnEndEvent, n as TurnStartEvent, r as runtimeEventClasses } from './event-CKV4EeZ3.js';
+export { defineAgent } from './agent.js';
+export { HarnessSandbox, HarnessSandboxOpenInput, HarnessSandboxSession, NoopSandbox, NoopSandboxSession, SandboxExecInput, SandboxExecResult } from './runner/sandbox.js';
+export { C as CreateHarnessSessionInternalOptions, H as HarnessSessionImpl, a as HarnessSessionStoreImpl, c as createHarnessSession, b as createHarnessSessionStore } from './runner-Dxo7ALtp.js';
+export { ArraySchema, BooleanSchema, DefaultSchema, EnumSchema, InferInput, InferOutput, JsonSchema, LiteralSchema, NormalizedSchema, NumberSchema, ObjectSchema, OptionalSchema, RecordSchema, SafeParseResult, Schema, SchemaError, SchemaIssue, SchemaIssueCode, SchemaSource, StringSchema, UnknownSchema, formatSchemaPath, normalizeSchema, s, schemaIssuesFromError } from './schema.js';
+export { T as ToolErrorCode, a as ToolErrorPayload, b as ToolInvalidField, c as createToolErrorPayload } from './tool-errors-CygY1Nba.js';
+import './types-BPmsw-mF.js';
+
+declare class AgentSessionRunner {
+    private readonly options;
+    readonly agent: NormalizedAgentDefinition;
+    readonly workDir: string;
+    readonly outputDir: string;
+    private readonly sessionIdValue;
+    private readonly storageCoordinator;
+    private readonly sandboxManager;
+    private runIdValue;
+    private readonly transcriptManager;
+    private readonly eventRecorder;
+    private readonly contextRegistry;
+    private readonly snapshotManager;
+    private readonly toolExecutor;
+    private readonly modelPipeline;
+    private readonly services;
+    private readonly roles;
+    private readonly roleResolver;
+    private readonly providerRegistry;
+    private readonly defaultModel;
+    private modelOverride;
+    private runModelOverride;
+    private currentMode;
+    private state;
+    private metrics;
+    private startedAtPerf;
+    private started;
+    private pendingInputs;
+    private finalAnswer;
+    private currentTurnId;
+    private providerStack;
+    private hookDepth;
+    private turnHandoffRequested;
+    constructor(options: AgentSessionRunnerOptions);
+    private logSource;
+    private logContext;
+    private log;
+    private logModelDelta;
+    get mode(): string;
+    get runId(): string;
+    subscribe(listener: RunnerEventListener): () => void;
+    requestTurnHandoff(): void;
+    private storeRunDir;
+    private ensureStoreInitialized;
+    private ensureSandboxOpen;
+    private closeSandbox;
+    private closeStore;
+    private applyStoredRuntimeState;
+    private persistCursors;
+    private beginNewRun;
+    run(message: string, options?: AgentRunnerRunOptions): Promise<AgentRunResult>;
+    prompt(message: string, options?: AgentRunnerRunOptions): Promise<AgentRunResult>;
+    close(): Promise<void>;
+    getTranscript(options?: TranscriptQuery): AgentMessage[];
+    getMetrics(): RunMetrics;
+    getRunInfo(): {
+        runId: string;
+        agentKey: string;
+        workDir: string;
+        outputDir: string | undefined;
+        started: boolean;
+        startedAt: string;
+    };
+    getModel(): string;
+    setModel(model: string): void;
+    clearModelOverride(): void;
+    getModelProviderInfo(): ModelProviderInfo;
+    getAvailableModels(): {
+        id: string;
+        provider: string;
+        label?: string;
+        metadata?: JsonObject;
+    }[];
+    getAgentManifest(): HarnessAgentManifest;
+    getEvents(filter?: HarnessEventQuery): HarnessEventRecord[];
+    getTranscriptCursor(): TranscriptCursor;
+    seekTranscript(target: TranscriptSeekTarget): Promise<TranscriptCursor>;
+    latestTranscript(): Promise<TranscriptCursor>;
+    getState(): AgentSharedState;
+    updateState(patch: unknown): void;
+    replaceState(next: AgentSharedState): void;
+    createSnapshot(input?: HarnessSnapshotInput, eventOptions?: HarnessEventEmitOptions): Promise<HarnessSnapshot>;
+    listSnapshots(): HarnessSnapshotSummary[];
+    getSnapshot(id: string): HarnessSnapshot | undefined;
+    restoreSnapshot(id: string, eventOptions?: HarnessEventEmitOptions): Promise<HarnessSnapshot>;
+    deleteSnapshot(id: string, eventOptions?: HarnessEventEmitOptions): Promise<boolean>;
+    getContextSnapshot(): ContextSnapshot | undefined;
+    getContextEntries(filter?: ContextEntryFilter): ContextEntry[];
+    switchMode(mode: HarnessModeSelector, input?: unknown): Promise<void>;
+    private start;
+    private runTurn;
+    private addMessage;
+    private addHiddenEventMessage;
+    private addToolCallMessage;
+    private addToolResultMessage;
+    private markMessageEventCursor;
+    private createInitialState;
+    private getModeDefinition;
+    private resolveModeType;
+    private buildReadSession;
+    private buildActionSession;
+    private withEmitDefaults;
+    private throwIfTurnHandoffRequested;
+    private normalizeModelOverride;
+    private getActiveModel;
+    private resolveModelProvider;
+    private modelProviderSource;
+    private filterTranscript;
+    private getActiveContextProviderBindings;
+    private getContextProviders;
+    private providerFromReference;
+    private bindingToSummary;
+    private dynamicContextEntriesFor;
+    private activateDynamicContextFor;
+    private consumeDynamicContext;
+    private addDynamicContext;
+    private addDynamicContextContribution;
+    private renderDynamicContext;
+    private removeDynamicContext;
+    private clearDynamicContext;
+    private buildContextSnapshot;
+    private loadContextProvider;
+    private normalizeContextContribution;
+    private normalizeContextOutput;
+    private resolveRole;
+    private assertModelProviderSupportsMessages;
+    private renderSystemContributions;
+    private contributionToMessage;
+    private resolveTools;
+    private getAllTools;
+    private toToolCatalogEntry;
+    private hookSummary;
+    private eventSummaries;
+    private invokeTool;
+    private executeTool;
+    private applyTranscriptSeek;
+    private emitInternal;
+    private emit;
+    private recordHarnessEvent;
+    private queryEvents;
+    private dispatchHooks;
+}
+
+export { AgentMessage, AgentRunResult, AgentRunnerRunOptions, AgentSessionRunner, AgentSessionRunnerOptions, AgentSharedState, ContextEntry, ContextEntryFilter, ContextSnapshot, HarnessAgentManifest, HarnessEventEmitOptions, HarnessEventQuery, HarnessEventRecord, HarnessModeSelector, HarnessSnapshot, HarnessSnapshotInput, HarnessSnapshotSummary, JsonObject, ModelProviderInfo, NormalizedAgentDefinition, RunMetrics, RunnerEventListener, TranscriptCursor, TranscriptQuery, TranscriptSeekTarget };

package/dist/index.js

@@ -0,0 +1,174 @@
+import {
+  AgentSessionRunner,
+  HarnessSessionImpl,
+  HarnessSessionPhase,
+  HarnessSessionStoreImpl,
+  createHarnessSession,
+  createHarnessSessionStore,
+  createToolErrorPayload
+} from "./chunk-4WWSQAWA.js";
+import {
+  HarnessModelProviderRegistry,
+  modelProviderId,
+  parseModelRef
+} from "./chunk-Q73WH5D7.js";
+import "./chunk-Q44U2CMM.js";
+import {
+  HarnessSandbox,
+  HarnessSandboxSession,
+  NoopSandbox,
+  NoopSandboxSession
+} from "./chunk-AD3BCYWU.js";
+import {
+  HarnessRunStorage,
+  HarnessRunStore,
+  MemoryRunStorage,
+  MemoryRunStore,
+  NoopRunStorage,
+  NoopRunStore
+} from "./chunk-AZVA22HW.js";
+import {
+  defineAgent
+} from "./chunk-RRWJUHJG.js";
+import {
+  ContextReadyEvent,
+  ErrorEvent,
+  MessageDeltaEvent,
+  MessageEndEvent,
+  MessageStartEvent,
+  ModeChangedEvent,
+  ModelAfterEvent,
+  ModelBeforeEvent,
+  RunEndEvent,
+  RunStartEvent,
+  SnapshotCreatedEvent,
+  SnapshotDeletedEvent,
+  SnapshotRestoredEvent,
+  ToolApprovalRequestedEvent,
+  ToolApprovalResolvedEvent,
+  ToolEndEvent,
+  ToolStartEvent,
+  TranscriptCursorChangedEvent,
+  TurnEndEvent,
+  TurnStartEvent,
+  runtimeEventClasses
+} from "./chunk-4SYLFKIX.js";
+import {
+  ArraySchema,
+  BooleanSchema,
+  DefaultSchema,
+  EnumSchema,
+  LiteralSchema,
+  NumberSchema,
+  ObjectSchema,
+  OptionalSchema,
+  RecordSchema,
+  Schema,
+  SchemaError,
+  StringSchema,
+  UnknownSchema,
+  formatSchemaPath,
+  normalizeSchema,
+  s,
+  schemaIssuesFromError
+} from "./chunk-OBKS4AJR.js";
+import {
+  AssistantRole,
+  ContextConsume,
+  ContextScopes,
+  HarnessContextProvider,
+  HarnessEvent,
+  HarnessHook,
+  HarnessMode,
+  HarnessRole,
+  HarnessTool,
+  NativeRoles,
+  RoleTargets,
+  SystemRole,
+  ToolRole,
+  UserRole,
+  assistantRole,
+  systemRole,
+  toolRole,
+  userRole
+} from "./chunk-4A2P4QU5.js";
+export {
+  AgentSessionRunner,
+  ArraySchema,
+  AssistantRole,
+  BooleanSchema,
+  ContextConsume,
+  ContextReadyEvent,
+  ContextScopes,
+  DefaultSchema,
+  EnumSchema,
+  ErrorEvent,
+  HarnessContextProvider,
+  HarnessEvent,
+  HarnessHook,
+  HarnessMode,
+  HarnessModelProviderRegistry,
+  HarnessRole,
+  HarnessRunStorage,
+  HarnessRunStore,
+  HarnessSandbox,
+  HarnessSandboxSession,
+  HarnessSessionImpl,
+  HarnessSessionPhase,
+  HarnessSessionStoreImpl,
+  HarnessTool,
+  LiteralSchema,
+  MemoryRunStorage,
+  MemoryRunStore,
+  MessageDeltaEvent,
+  MessageEndEvent,
+  MessageStartEvent,
+  ModeChangedEvent,
+  ModelAfterEvent,
+  ModelBeforeEvent,
+  NativeRoles,
+  NoopRunStorage,
+  NoopRunStore,
+  NoopSandbox,
+  NoopSandboxSession,
+  NumberSchema,
+  ObjectSchema,
+  OptionalSchema,
+  RecordSchema,
+  RoleTargets,
+  RunEndEvent,
+  RunStartEvent,
+  Schema,
+  SchemaError,
+  SnapshotCreatedEvent,
+  SnapshotDeletedEvent,
+  SnapshotRestoredEvent,
+  StringSchema,
+  SystemRole,
+  ToolApprovalRequestedEvent,
+  ToolApprovalResolvedEvent,
+  ToolEndEvent,
+  ToolRole,
+  ToolStartEvent,
+  TranscriptCursorChangedEvent,
+  TurnEndEvent,
+  TurnStartEvent,
+  UnknownSchema,
+  UserRole,
+  assistantRole,
+  createHarnessSession,
+  createHarnessSessionStore,
+  createToolErrorPayload,
+  defineAgent,
+  formatSchemaPath,
+  modelProviderId,
+  normalizeSchema,
+  parseModelRef,
+  runtimeEventClasses,
+  s,
+  schemaIssuesFromError,
+  systemRole,
+  toolRole,
+  userRole
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

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

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

@@ -0,0 +1,130 @@
+import { H as HarnessEvent, a as HarnessEventClass, b as HarnessEventEmitOptions, e as HarnessEventRecord, J as JsonObject } from './events-D4xcDi53.js';
+import { h as AgentMessage, v as AgentToolDefinition, w as AgentToolResult, M as ContextSnapshot, S as HarnessModeSelector, Q as HarnessMode, s as AgentSharedStateDefinition, a3 as ToolApprovalMode, a4 as ToolApprovalRequest, a2 as ToolApprovalDecision, q as AgentRuntimeLogger } from './context-75mlon5x.js';
+import { b as HarnessRoleDefinition, c as HarnessRoleSelector } from './role-BN6KhQxx.js';
+import { HarnessSandbox } from './runner/sandbox.js';
+import { d as RunMetrics, H as HarnessRunStorage } from './storage-BmOEwW-p.js';
+import { H as HarnessHook } from './hook-DMb9fw9Z.js';
+
+interface ModelProviderRunInput {
+    runId: string;
+    turnId?: string;
+    modeId: string;
+    modelRef: string;
+    provider: string;
+    model: string;
+    systemPrompt: string;
+    messages: AgentMessage[];
+    roles: HarnessRoleDefinition[];
+    tools: AgentToolDefinition[];
+    maxTurns: number;
+    signal?: AbortSignal;
+    emit<TPayload, TEvent extends HarnessEvent<TPayload>>(eventClass: HarnessEventClass<TPayload, TEvent>, payload: TPayload, options?: HarnessEventEmitOptions): Promise<TEvent>;
+    executeTool(tool: AgentToolDefinition, args: unknown, callId?: string): Promise<AgentToolResult>;
+    prepareContext(): Promise<ModelProviderPreparedContext>;
+}
+interface ModelProviderPreparedContext {
+    systemPrompt: string;
+    messages: AgentMessage[];
+    snapshot: ContextSnapshot;
+}
+interface ModelProviderRunResult {
+    content: string;
+    usage?: unknown;
+    finishReason?: string;
+    raw?: unknown;
+}
+interface HarnessModelProvider {
+    readonly namespace: string;
+    readonly id?: string;
+    readonly configSchema?: unknown;
+    run(input: ModelProviderRunInput): Promise<ModelProviderRunResult>;
+    getInfo?(): ModelProviderInfo;
+    getModels?(): ModelInfo[];
+    supportsRole?(roleId: string): boolean;
+}
+interface ResolvedModelProvider {
+    provider: HarnessModelProvider;
+    namespace: string;
+    modelId: string;
+    modelRef: string;
+}
+declare function modelProviderId(provider: HarnessModelProvider): string;
+declare function parseModelRef(modelRef: string): {
+    namespace: string;
+    modelId: string;
+};
+declare class HarnessModelProviderRegistry {
+    private readonly providers;
+    constructor(providers: HarnessModelProvider[]);
+    register(provider: HarnessModelProvider): void;
+    resolve(modelRef: string): ResolvedModelProvider;
+    list(): HarnessModelProvider[];
+}
+
+interface AgentDefinition {
+    key?: string;
+    label: string;
+    initialMode: HarnessModeSelector;
+    modes: HarnessMode[];
+    sharedState?: AgentSharedStateDefinition;
+    roles?: HarnessRoleDefinition[];
+    hooks?: HarnessHook[];
+    declaredEvents?: HarnessEventClass[];
+}
+interface NormalizedAgentDefinition {
+    key: string;
+    label: string;
+    initialMode: string;
+    modes: Record<string, HarnessMode>;
+    sharedState?: AgentSharedStateDefinition;
+    roles?: HarnessRoleDefinition[];
+    hooks?: HarnessHook[];
+    declaredEvents?: HarnessEventClass[];
+}
+interface ModelProviderInfo {
+    id: string;
+    label?: string;
+    provider?: string;
+    metadata?: JsonObject;
+}
+interface ModelInfo {
+    id: string;
+    label?: string;
+    provider?: string;
+    metadata?: JsonObject;
+}
+interface AgentRunnerRunOptions {
+    signal?: AbortSignal;
+    model?: string;
+    userInputId?: string;
+    userMetadata?: JsonObject;
+    userRole?: HarnessRoleSelector;
+}
+interface AgentSessionRunnerOptions {
+    sessionId?: string;
+    agent: AgentDefinition;
+    providers: HarnessModelProvider[];
+    defaultModel: string;
+    sandbox?: HarnessSandbox;
+    roles?: HarnessRoleDefinition[];
+    workDir?: string;
+    outputDir?: string;
+    storage?: HarnessRunStorage;
+    initialMode?: HarnessModeSelector;
+    toolApproval?: ToolApprovalMode;
+    maxTurns?: number;
+    services?: JsonObject;
+    approveTool?(request: ToolApprovalRequest): boolean | ToolApprovalDecision | Promise<boolean | ToolApprovalDecision>;
+    logger?: AgentRuntimeLogger;
+}
+interface AgentRunResult {
+    runId: string;
+    agentKey: string;
+    finalAnswer: string;
+    transcript: AgentMessage[];
+    events: HarnessEventRecord[];
+    metrics: RunMetrics;
+    outputDir?: string;
+}
+
+export { type AgentDefinition as A, type HarnessModelProvider as H, type ModelInfo as M, type NormalizedAgentDefinition as N, type ResolvedModelProvider as R, type AgentRunResult as a, type AgentRunnerRunOptions as b, type AgentSessionRunnerOptions as c, HarnessModelProviderRegistry as d, type ModelProviderInfo as e, type ModelProviderPreparedContext as f, type ModelProviderRunInput as g, type ModelProviderRunResult as h, modelProviderId as m, parseModelRef as p };

package/dist/role-BN6KhQxx.d.ts

@@ -0,0 +1,68 @@
+interface HarnessRoleSummary {
+    type: string;
+    name: string;
+    label?: string;
+    target: string;
+    nativeRole?: string;
+    default?: boolean;
+    description?: string;
+}
+declare enum RoleTargets {
+    System = "system",
+    Messages = "messages",
+    Hidden = "hidden"
+}
+declare enum NativeRoles {
+    System = "system",
+    User = "user",
+    Assistant = "assistant",
+    Tool = "tool"
+}
+declare abstract class HarnessRole {
+    protected readonly __harnessRoleBrand: true;
+    label?: string;
+    name?: string;
+    abstract target: RoleTargets | (string & {});
+    nativeRole?: NativeRoles | (string & {});
+    default?: boolean;
+    description?: string;
+    get type(): string;
+}
+type HarnessRoleClass<TRole extends HarnessRole = HarnessRole> = abstract new (...args: any[]) => TRole;
+type HarnessRoleDefinition = HarnessRole;
+type HarnessRoleSelector<TRole extends HarnessRole = HarnessRole> = TRole | HarnessRoleClass<TRole>;
+declare class SystemRole extends HarnessRole {
+    static type: string;
+    label: string;
+    name: string;
+    target: RoleTargets;
+    nativeRole: NativeRoles;
+    default: boolean;
+}
+declare class UserRole extends HarnessRole {
+    static type: string;
+    label: string;
+    name: string;
+    target: RoleTargets;
+    nativeRole: NativeRoles;
+}
+declare class AssistantRole extends HarnessRole {
+    static type: string;
+    label: string;
+    name: string;
+    target: RoleTargets;
+    nativeRole: NativeRoles;
+}
+declare class ToolRole extends HarnessRole {
+    static type: string;
+    label: string;
+    name: string;
+    target: RoleTargets;
+    nativeRole: NativeRoles;
+}
+declare const systemRole: SystemRole;
+declare const userRole: UserRole;
+declare const assistantRole: AssistantRole;
+declare const toolRole: ToolRole;
+
+export { AssistantRole as A, HarnessRole as H, NativeRoles as N, RoleTargets as R, SystemRole as S, ToolRole as T, UserRole as U, type HarnessRoleClass as a, type HarnessRoleDefinition as b, type HarnessRoleSelector as c, type HarnessRoleSummary as d, assistantRole as e, systemRole as s, toolRole as t, userRole as u };

package/dist/runner/approval.d.ts

@@ -0,0 +1,9 @@
+export { T as ToolApprovalHandle } from '../approval-DfvjpbFs.js';
+export { a2 as ToolApprovalDecision, a3 as ToolApprovalMode, a4 as ToolApprovalRequest } from '../context-75mlon5x.js';
+import '../model-provider-BrZ2RRmS.js';
+import '../events-D4xcDi53.js';
+import '../role-BN6KhQxx.js';
+import './sandbox.js';
+import '../storage-BmOEwW-p.js';
+import '../hook-DMb9fw9Z.js';
+import '../types-BPmsw-mF.js';

package/dist/runner/approval.js

@@ -0,0 +1 @@
+//# sourceMappingURL=approval.js.map

package/dist/runner/approval.js.map

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

package/dist/runner/event.d.ts

@@ -0,0 +1,3 @@
+export { H as HarnessEvent, a as HarnessEventClass, b as HarnessEventEmitOptions, d as HarnessEventQuery, e as HarnessEventRecord, f as HarnessEventSource } from '../events-D4xcDi53.js';
+export { C as ContextReadyEvent, E as ErrorEvent, M as MessageDeltaEvent, a as MessageEndEvent, b as MessageStartEvent, c as ModeChangedEvent, d as ModelAfterEvent, e as ModelBeforeEvent, R as RunEndEvent, f as RunStartEvent, S as SnapshotCreatedEvent, g as SnapshotDeletedEvent, h as SnapshotRestoredEvent, T as ToolApprovalRequestedEvent, i as ToolApprovalResolvedEvent, j as ToolEndEvent, k as ToolStartEvent, l as TranscriptCursorChangedEvent, m as TurnEndEvent, n as TurnStartEvent } from '../event-CKV4EeZ3.js';
+import '../schema.js';

package/dist/runner/event.js

@@ -0,0 +1,50 @@
+import {
+  ContextReadyEvent,
+  ErrorEvent,
+  MessageDeltaEvent,
+  MessageEndEvent,
+  MessageStartEvent,
+  ModeChangedEvent,
+  ModelAfterEvent,
+  ModelBeforeEvent,
+  RunEndEvent,
+  RunStartEvent,
+  SnapshotCreatedEvent,
+  SnapshotDeletedEvent,
+  SnapshotRestoredEvent,
+  ToolApprovalRequestedEvent,
+  ToolApprovalResolvedEvent,
+  ToolEndEvent,
+  ToolStartEvent,
+  TranscriptCursorChangedEvent,
+  TurnEndEvent,
+  TurnStartEvent
+} from "../chunk-4SYLFKIX.js";
+import "../chunk-OBKS4AJR.js";
+import {
+  HarnessEvent
+} from "../chunk-4A2P4QU5.js";
+export {
+  ContextReadyEvent,
+  ErrorEvent,
+  HarnessEvent,
+  MessageDeltaEvent,
+  MessageEndEvent,
+  MessageStartEvent,
+  ModeChangedEvent,
+  ModelAfterEvent,
+  ModelBeforeEvent,
+  RunEndEvent,
+  RunStartEvent,
+  SnapshotCreatedEvent,
+  SnapshotDeletedEvent,
+  SnapshotRestoredEvent,
+  ToolApprovalRequestedEvent,
+  ToolApprovalResolvedEvent,
+  ToolEndEvent,
+  ToolStartEvent,
+  TranscriptCursorChangedEvent,
+  TurnEndEvent,
+  TurnStartEvent
+};
+//# sourceMappingURL=event.js.map

package/dist/runner/event.js.map

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

package/dist/runner/logging.d.ts

@@ -0,0 +1,31 @@
+import { g as HarnessLogSink, k as HarnessLoggingLevel, f as HarnessLogRecord, e as HarnessLogLevel } from '../types-BPmsw-mF.js';
+export { H as HarnessLog, a as HarnessLogCategory, b as HarnessLogClass, c as HarnessLogContext, d as HarnessLogError, h as HarnessLogSource, i as HarnessLogSourceKind, j as HarnessLoggingConfig, l as HarnessRedactionConfig } from '../types-BPmsw-mF.js';
+export { T as ToolErrorCode, a as ToolErrorPayload, b as ToolInvalidField } from '../tool-errors-CygY1Nba.js';
+
+interface ConsoleLogSinkOptions {
+    format?: "pretty" | "json";
+    level?: HarnessLoggingLevel;
+    console?: Pick<Console, "log" | "warn" | "error">;
+}
+declare class ConsoleLogSink extends HarnessLogSink {
+    private readonly format;
+    private readonly level?;
+    private readonly target;
+    constructor(options?: ConsoleLogSinkOptions);
+    write(record: HarnessLogRecord): void;
+}
+
+interface MemoryLogSinkOptions {
+    level?: HarnessLoggingLevel;
+}
+declare class MemoryLogSink extends HarnessLogSink {
+    readonly records: HarnessLogRecord[];
+    private readonly level?;
+    constructor(options?: MemoryLogSinkOptions);
+    write(record: HarnessLogRecord): void;
+    clear(): void;
+}
+
+declare function shouldWriteLog(recordLevel: HarnessLogLevel, configuredLevel: HarnessLoggingLevel | undefined): boolean;
+
+export { ConsoleLogSink, HarnessLogLevel, HarnessLogRecord, HarnessLogSink, HarnessLoggingLevel, MemoryLogSink, shouldWriteLog };

package/dist/runner/logging.js

@@ -0,0 +1,15 @@
+import {
+  ConsoleLogSink,
+  HarnessLog,
+  HarnessLogSink,
+  MemoryLogSink,
+  shouldWriteLog
+} from "../chunk-Q44U2CMM.js";
+export {
+  ConsoleLogSink,
+  HarnessLog,
+  HarnessLogSink,
+  MemoryLogSink,
+  shouldWriteLog
+};
+//# sourceMappingURL=logging.js.map