@harness-kernel/core 0.1.0-beta.0

package/NOTICE

@@ -0,0 +1,3 @@
+Harness Kernel
+
+Copyright 2026 Ducks Software and Harness Kernel contributors

package/README.md

@@ -0,0 +1,12 @@
+# @harness-kernel/core
+
+Zero-dependency runtime contracts and session kernel for Harness Kernel.
+
+Use this package for agent definitions, modes, tools, roles, hooks, context
+providers, events, schemas, session stores, and runtime contracts.
+
+```sh
+pnpm add @harness-kernel/core
+```
+
+Docs: <https://ducks-software-ai-infrastructure.github.io/harness-kernel/docs/packages/core/>

package/dist/agent/context.d.ts

@@ -0,0 +1,5 @@
+export { c as HarnessRoleSelector } from '../role-BN6KhQxx.js';
+export { a as AgentContextProvider, b as AgentContextReader, c as AgentContextSession, C as ContextConsume, z as ContextContribution, B as ContextContributionInput, D as ContextEntry, E as ContextEntryFilter, F as ContextProviderBinding, G as ContextProviderOutput, H as ContextProviderReference, I as ContextProviderRenderResult, J as ContextProviderSummary, K as ContextRegistrationOptions, L as ContextScopes, M as ContextSnapshot, N as HarnessContextProvider, O as HarnessContextProviderClass, P as HarnessContextProviderSelector } from '../context-75mlon5x.js';
+import '../events-D4xcDi53.js';
+import '../types-BPmsw-mF.js';
+import '../runner/sandbox.js';

package/dist/agent/context.js

@@ -0,0 +1,11 @@
+import {
+  ContextConsume,
+  ContextScopes,
+  HarnessContextProvider
+} from "../chunk-4A2P4QU5.js";
+export {
+  ContextConsume,
+  ContextScopes,
+  HarnessContextProvider
+};
+//# sourceMappingURL=context.js.map

package/dist/agent/context.js.map

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

package/dist/agent/event.d.ts

@@ -0,0 +1,3 @@
+export { H as HarnessEvent, a as HarnessEventClass, b as HarnessEventEmitOptions, c as HarnessEventMetadata, 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/agent/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/agent/event.js.map

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

package/dist/agent/hook.d.ts

@@ -0,0 +1,6 @@
+export { H as HarnessEvent, a as HarnessEventClass } from '../events-D4xcDi53.js';
+export { H as HarnessHook, a as HarnessHookEventClass } from '../hook-DMb9fw9Z.js';
+import '../context-75mlon5x.js';
+import '../role-BN6KhQxx.js';
+import '../types-BPmsw-mF.js';
+import '../runner/sandbox.js';

package/dist/agent/hook.js

@@ -0,0 +1,7 @@
+import {
+  HarnessHook
+} from "../chunk-4A2P4QU5.js";
+export {
+  HarnessHook
+};
+//# sourceMappingURL=hook.js.map

package/dist/agent/hook.js.map

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

package/dist/agent/mode.d.ts

@@ -0,0 +1,5 @@
+export { m as AgentModeDefinition, H as ContextProviderReference, Q as HarnessMode, R as HarnessModeClass, S as HarnessModeSelector, T as HarnessModeSummary, a3 as ToolApprovalMode } from '../context-75mlon5x.js';
+import '../role-BN6KhQxx.js';
+import '../events-D4xcDi53.js';
+import '../types-BPmsw-mF.js';
+import '../runner/sandbox.js';

package/dist/agent/mode.js

@@ -0,0 +1,7 @@
+import {
+  HarnessMode
+} from "../chunk-4A2P4QU5.js";
+export {
+  HarnessMode
+};
+//# sourceMappingURL=mode.js.map

package/dist/agent/mode.js.map

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

package/dist/agent/role.d.ts

@@ -0,0 +1 @@
+export { A as AssistantRole, H as HarnessRole, a as HarnessRoleClass, b as HarnessRoleDefinition, c as HarnessRoleSelector, 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';

package/dist/agent/role.js

@@ -0,0 +1,27 @@
+import {
+  AssistantRole,
+  HarnessRole,
+  NativeRoles,
+  RoleTargets,
+  SystemRole,
+  ToolRole,
+  UserRole,
+  assistantRole,
+  systemRole,
+  toolRole,
+  userRole
+} from "../chunk-4A2P4QU5.js";
+export {
+  AssistantRole,
+  HarnessRole,
+  NativeRoles,
+  RoleTargets,
+  SystemRole,
+  ToolRole,
+  UserRole,
+  assistantRole,
+  systemRole,
+  toolRole,
+  userRole
+};
+//# sourceMappingURL=role.js.map

package/dist/agent/role.js.map

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

package/dist/agent/session.d.ts

@@ -0,0 +1,6 @@
+export { E as EventCursor, d as HarnessEventQuery, e as HarnessEventRecord } from '../events-D4xcDi53.js';
+export { A as AgentActionSession, b as AgentContextReader, c as AgentContextSession, d as AgentEventReader, e as AgentEventSession, f as AgentHistorySession, g as AgentLogSession, h as AgentMessage, i as AgentMessageEnqueueOptions, j as AgentMessageInput, l as AgentMessageSession, n as AgentModeReader, o as AgentModeSession, p as AgentReadSession, t as AgentStateReader, u as AgentStateSession, w as AgentToolResult, x as AgentToolSession, C as ContextConsume, D as ContextEntry, E as ContextEntryFilter, K as ContextRegistrationOptions, L as ContextScopes, T as HarnessModeSummary, 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';
+export { c as HarnessRoleSelector, N as NativeRoles, R as RoleTargets } from '../role-BN6KhQxx.js';
+export { T as ToolErrorCode, a as ToolErrorPayload, b as ToolInvalidField } from '../tool-errors-CygY1Nba.js';
+import '../types-BPmsw-mF.js';
+import '../runner/sandbox.js';

package/dist/agent/session.js

@@ -0,0 +1,13 @@
+import {
+  ContextConsume,
+  ContextScopes,
+  NativeRoles,
+  RoleTargets
+} from "../chunk-4A2P4QU5.js";
+export {
+  ContextConsume,
+  ContextScopes,
+  NativeRoles,
+  RoleTargets
+};
+//# sourceMappingURL=session.js.map

package/dist/agent/session.js.map

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

package/dist/agent/tool.d.ts

@@ -0,0 +1,5 @@
+export { v as AgentToolDefinition, w as AgentToolResult, y as AgentToolSource, Z as HarnessTool, _ as HarnessToolClass, $ as HarnessToolSelector, a5 as ToolApprovalResolver, a6 as ToolCatalogEntry, a7 as ToolPermission, a8 as ToolRef, a9 as ToolRisk } from '../context-75mlon5x.js';
+import '../role-BN6KhQxx.js';
+import '../events-D4xcDi53.js';
+import '../types-BPmsw-mF.js';
+import '../runner/sandbox.js';

package/dist/agent/tool.js

@@ -0,0 +1,7 @@
+import {
+  HarnessTool
+} from "../chunk-4A2P4QU5.js";
+export {
+  HarnessTool
+};
+//# sourceMappingURL=tool.js.map

package/dist/agent/tool.js.map

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

package/dist/agent.d.ts

@@ -0,0 +1,12 @@
+import { A as AgentDefinition } from './model-provider-BrZ2RRmS.js';
+export { J as JsonObject } from './events-D4xcDi53.js';
+export { r as AgentSharedState, s as AgentSharedStateDefinition } from './context-75mlon5x.js';
+import './role-BN6KhQxx.js';
+import './runner/sandbox.js';
+import './storage-BmOEwW-p.js';
+import './hook-DMb9fw9Z.js';
+import './types-BPmsw-mF.js';
+
+declare function defineAgent(definition: AgentDefinition): AgentDefinition;
+
+export { AgentDefinition, defineAgent };

package/dist/agent.js

@@ -0,0 +1,7 @@
+import {
+  defineAgent
+} from "./chunk-RRWJUHJG.js";
+export {
+  defineAgent
+};
+//# sourceMappingURL=agent.js.map

package/dist/agent.js.map

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

package/dist/approval-DfvjpbFs.d.ts

@@ -0,0 +1,247 @@
+import { A as AgentDefinition, H as HarnessModelProvider, e as ModelProviderInfo } from './model-provider-BrZ2RRmS.js';
+import { j as HarnessLoggingConfig } from './types-BPmsw-mF.js';
+import { e as HarnessEventRecord, a as HarnessEventClass, d as HarnessEventQuery, H as HarnessEvent } from './events-D4xcDi53.js';
+import { T as HarnessModeSummary, J as ContextProviderSummary, a6 as ToolCatalogEntry, S as HarnessModeSelector, a3 as ToolApprovalMode, h as AgentMessage, a9 as ToolRisk, a7 as ToolPermission, w as AgentToolResult, r as AgentSharedState, a0 as HarnessTranscriptSession, X as HarnessSnapshotSession, M as ContextSnapshot } from './context-75mlon5x.js';
+import { d as HarnessRoleSummary, c as HarnessRoleSelector } from './role-BN6KhQxx.js';
+import { H as HarnessRunStorage, d as RunMetrics } from './storage-BmOEwW-p.js';
+import { b as HarnessHookSummary } from './hook-DMb9fw9Z.js';
+import { HarnessSandbox } from './runner/sandbox.js';
+
+interface HarnessEventSummary {
+    type: string;
+    label: string;
+    className: string;
+    builtIn?: boolean;
+}
+
+interface HarnessAgentManifest {
+    key: string;
+    label: string;
+    initialMode: string;
+    currentMode?: string;
+    modes: HarnessModeSummary[];
+    roles: HarnessRoleSummary[];
+    hooks: HarnessHookSummary[];
+    contextProviders: ContextProviderSummary[];
+    tools: ToolCatalogEntry[];
+    events: HarnessEventSummary[];
+}
+
+type HarnessAgentInput = {
+    definition: AgentDefinition;
+};
+type HarnessStorageConfig = HarnessRunStorage;
+interface HarnessAppConfig {
+    agent: HarnessAgentInput;
+    providers: HarnessModelProvider[];
+    defaultModel: string;
+    workDir?: string;
+    storage?: HarnessStorageConfig;
+    sandbox?: HarnessSandbox;
+    initialMode?: HarnessModeSelector | string;
+    toolApproval?: ToolApprovalMode;
+    maxTurns?: number;
+    services?: Record<string, unknown>;
+    logging?: HarnessLoggingConfig;
+    sessionTtlMs?: number;
+    toolApprovalTimeoutMs?: number;
+}
+interface HarnessUserInput {
+    id?: string;
+    content: string;
+    metadata?: Record<string, unknown>;
+    role?: HarnessRoleSelector;
+}
+interface SendOptions {
+    signal?: AbortSignal;
+    model?: string;
+    after?: HarnessEventClass;
+}
+interface StreamOptions extends SendOptions {
+}
+interface WaitForEventOptions {
+    signal?: AbortSignal;
+    timeoutMs?: number;
+}
+interface SendResult {
+    sessionId: string;
+    runId: string;
+    answer: string;
+    agentKey: string;
+    mode: string;
+    outputDir?: string;
+    metrics: RunMetrics;
+    transcript: AgentMessage[];
+    events: HarnessEventRecord[];
+}
+interface ToolApprovalHandle {
+    id: string;
+    sessionId: string;
+    runId: string;
+    toolCallId: string;
+    name: string;
+    args: unknown;
+    modeId: string;
+    risk?: ToolRisk;
+    permissions?: ToolPermission[];
+    createdAt: string;
+    expiresAt?: string;
+    approve(): Promise<void>;
+    deny(reason?: string): Promise<void>;
+}
+interface HarnessErrorShape {
+    name?: string;
+    message: string;
+    stack?: string;
+    cause?: unknown;
+}
+type HarnessStreamEvent = {
+    type: "run.started";
+    sessionId: string;
+    runId: string;
+    mode: string;
+} | {
+    type: "session.status";
+    status: HarnessSessionStatus;
+} | {
+    type: "user.message";
+    message: AgentMessage;
+} | {
+    type: "assistant.delta";
+    text: string;
+    event: HarnessEventRecord;
+} | {
+    type: "assistant.message";
+    message: AgentMessage;
+} | {
+    type: "tool.started";
+    toolCallId: string;
+    name: string;
+    args: unknown;
+} | {
+    type: "tool.approval.requested";
+    approval: ToolApprovalHandle;
+} | {
+    type: "tool.approval.resolved";
+    approvalId: string;
+    approved: boolean;
+} | {
+    type: "tool.ended";
+    toolCallId: string;
+    name: string;
+    result: AgentToolResult;
+} | {
+    type: "mode.changed";
+    previousMode: string;
+    mode: string;
+} | {
+    type: "event";
+    event: HarnessEventRecord;
+} | {
+    type: "run.completed";
+    result: SendResult;
+} | {
+    type: "error";
+    error: HarnessErrorShape;
+};
+interface HarnessRunStream extends AsyncIterable<HarnessStreamEvent> {
+    readonly id: string;
+    readonly result: Promise<SendResult>;
+    cancel(reason?: string): Promise<void>;
+}
+type HarnessSessionListener = (event: HarnessStreamEvent) => void | Promise<void>;
+type HarnessSessionEventListener<TEvent extends HarnessEvent = HarnessEvent> = (event: TEvent) => void | Promise<void>;
+declare enum HarnessSessionPhase {
+    Idle = "idle",
+    Queued = "queued",
+    Starting = "starting",
+    BuildingContext = "building_context",
+    WaitingModel = "waiting_model",
+    RunningTool = "running_tool",
+    WaitingApproval = "waiting_approval",
+    ClosingTurn = "closing_turn",
+    Completed = "completed",
+    Error = "error",
+    Closed = "closed"
+}
+interface HarnessSessionStatus {
+    sessionId: string;
+    agentKey: string;
+    mode: string;
+    model: string;
+    provider: ModelProviderInfo | undefined;
+    createdAt: string;
+    lastActiveAt: string;
+    running: boolean;
+    phase: HarnessSessionPhase;
+    queuedInputCount: number;
+    currentTurnId?: string;
+    activeTool?: {
+        id: string;
+        name: string;
+    };
+    lastEventAt?: string;
+    lastError?: HarnessErrorShape;
+    pendingApprovalCount: number;
+    runId?: string;
+    outputDir?: string;
+    metrics?: RunMetrics;
+}
+interface HarnessSession {
+    readonly id: string;
+    send(input: string | HarnessUserInput, options?: SendOptions): Promise<SendResult>;
+    stream(input: string | HarnessUserInput, options?: StreamOptions): HarnessRunStream;
+    getStatus(): HarnessSessionStatus;
+    getModel(): string;
+    setModel(model: string): void;
+    clearModelOverride(): void;
+    getMode(): string;
+    switchMode(mode: HarnessModeSelector | string, input?: unknown): Promise<void>;
+    getState(): AgentSharedState;
+    updateState(patch: unknown): void;
+    replaceState(next: AgentSharedState): void;
+    transcript: HarnessTranscriptSession;
+    snapshots: HarnessSnapshotSession;
+    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>;
+}
+type HarnessSessionStoreEvent = {
+    type: "session.created";
+    sessionId: string;
+    status: HarnessSessionStatus;
+} | {
+    type: "session.deleted";
+    sessionId: string;
+} | {
+    type: "session.cleared";
+} | {
+    type: "session.event";
+    sessionId: string;
+    event: HarnessStreamEvent;
+};
+type HarnessSessionStoreListener = (event: HarnessSessionStoreEvent) => void | Promise<void>;
+interface HarnessSessionStore {
+    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>;
+}
+
+export { type HarnessAgentInput as H, type SendOptions as S, type ToolApprovalHandle as T, type WaitForEventOptions as W, type HarnessAgentManifest as a, type HarnessAppConfig as b, type HarnessErrorShape as c, type HarnessEventSummary as d, type HarnessRunStream as e, type HarnessSession as f, type HarnessSessionEventListener as g, type HarnessSessionListener as h, HarnessSessionPhase as i, type HarnessSessionStatus as j, type HarnessSessionStore as k, type HarnessSessionStoreEvent as l, type HarnessSessionStoreListener as m, type HarnessStorageConfig as n, type HarnessStreamEvent as o, type HarnessUserInput as p, type SendResult as q, type StreamOptions as r };

package/dist/chunk-4A2P4QU5.js

@@ -0,0 +1,179 @@
+// src/runtime/types/events.ts
+var HarnessEvent = class {
+  constructor(record) {
+    this.record = record;
+  }
+  record;
+  static type;
+  static schema;
+  get id() {
+    return this.record.id;
+  }
+  get type() {
+    return this.record.type;
+  }
+  get payload() {
+    return this.record.payload;
+  }
+  get at() {
+    return this.record.at;
+  }
+};
+
+// src/runtime/types/naming.ts
+function constructorOf(value) {
+  return value.constructor;
+}
+function constructTypeOf(value) {
+  const ctor = constructorOf(value);
+  return ctor.type ?? ctor.name ?? "AnonymousConstruct";
+}
+
+// src/runtime/types/roles.ts
+var RoleTargets = /* @__PURE__ */ ((RoleTargets2) => {
+  RoleTargets2["System"] = "system";
+  RoleTargets2["Messages"] = "messages";
+  RoleTargets2["Hidden"] = "hidden";
+  return RoleTargets2;
+})(RoleTargets || {});
+var NativeRoles = /* @__PURE__ */ ((NativeRoles2) => {
+  NativeRoles2["System"] = "system";
+  NativeRoles2["User"] = "user";
+  NativeRoles2["Assistant"] = "assistant";
+  NativeRoles2["Tool"] = "tool";
+  return NativeRoles2;
+})(NativeRoles || {});
+var HarnessRole = class {
+  label;
+  name;
+  nativeRole;
+  default;
+  description;
+  get type() {
+    return constructTypeOf(this);
+  }
+};
+var SystemRole = class extends HarnessRole {
+  static type = "system";
+  label = "System";
+  name = "system";
+  target = "system" /* System */;
+  nativeRole = "system" /* System */;
+  default = true;
+};
+var UserRole = class extends HarnessRole {
+  static type = "user";
+  label = "User";
+  name = "user";
+  target = "messages" /* Messages */;
+  nativeRole = "user" /* User */;
+};
+var AssistantRole = class extends HarnessRole {
+  static type = "assistant";
+  label = "Assistant";
+  name = "assistant";
+  target = "messages" /* Messages */;
+  nativeRole = "assistant" /* Assistant */;
+};
+var ToolRole = class extends HarnessRole {
+  static type = "tool";
+  label = "Tool";
+  name = "tool";
+  target = "messages" /* Messages */;
+  nativeRole = "tool" /* Tool */;
+};
+var systemRole = new SystemRole();
+var userRole = new UserRole();
+var assistantRole = new AssistantRole();
+var toolRole = new ToolRole();
+
+// src/runtime/types/tools.ts
+var HarnessTool = class {
+  label;
+  schema;
+  risk;
+  permissions;
+  requiresApproval;
+  get type() {
+    return constructTypeOf(this);
+  }
+  get inputSchema() {
+    return this.schema;
+  }
+};
+
+// src/runtime/types/context.ts
+var ContextScopes = /* @__PURE__ */ ((ContextScopes2) => {
+  ContextScopes2["Turn"] = "turn";
+  ContextScopes2["Run"] = "run";
+  ContextScopes2["Session"] = "session";
+  return ContextScopes2;
+})(ContextScopes || {});
+var ContextConsume = /* @__PURE__ */ ((ContextConsume2) => {
+  ContextConsume2["Once"] = "once";
+  ContextConsume2["WhileActive"] = "while_active";
+  return ContextConsume2;
+})(ContextConsume || {});
+var HarnessContextProvider = class {
+  label;
+  priority;
+  role;
+  get type() {
+    return constructTypeOf(this);
+  }
+  with(options) {
+    return { provider: this, options };
+  }
+};
+
+// src/runtime/types/modes.ts
+var HarnessMode = class {
+  label;
+  model;
+  prompt;
+  providers;
+  excludeProviders;
+  tools;
+  maxTurns;
+  toolApproval;
+  get type() {
+    return constructTypeOf(this);
+  }
+};
+
+// src/runtime/types/hooks.ts
+var HarnessHook = class _HarnessHook {
+  label;
+  eventClass;
+  static for(eventClass) {
+    class BoundHarnessHook extends _HarnessHook {
+      eventClass = eventClass;
+    }
+    return BoundHarnessHook;
+  }
+  get type() {
+    return constructTypeOf(this);
+  }
+};
+
+export {
+  HarnessEvent,
+  RoleTargets,
+  NativeRoles,
+  HarnessRole,
+  SystemRole,
+  UserRole,
+  AssistantRole,
+  ToolRole,
+  systemRole,
+  userRole,
+  assistantRole,
+  toolRole,
+  HarnessTool,
+  ContextScopes,
+  ContextConsume,
+  HarnessContextProvider,
+  HarnessMode,
+  HarnessHook
+};
+//# sourceMappingURL=chunk-4A2P4QU5.js.map