@agimon-ai/po-core 0.0.0-alpha.0

package/dist/src/types/remote.d.mts

@@ -0,0 +1,152 @@
+//#region src/types/remote.d.ts
+export type RemoteChannelScope = 'session' | 'protocol' | 'http';
+/**
+ * How the tunnel is established.
+ *
+ * `named` carries a hostname rather than discovering one, which is why it is
+ * the mode that supports passkeys, a service worker, and durable pairing: all
+ * three are bound to the origin, and a quick tunnel's hostname rotates on every
+ * start. The token is referenced by path, never stored inline, because it is a
+ * Cloudflare account credential and an inlined one ends up in a bug report.
+ */
+export type TunnelConfig = {
+  kind: 'quick';
+} | {
+  kind: 'named';
+  hostname: string;
+  name?: string;
+  tokenFile?: string;
+  configFile?: string;
+};
+/**
+ * Running the cockpit in a container.
+ *
+ * Tied to remote access rather than offered separately: the reason to contain
+ * the cockpit is that a paired device drives an agent holding a shell, and the
+ * containment only means anything if it is in place before the tunnel is.
+ *
+ * The workspace list is the boundary. A hub inside the container cannot create
+ * a session in a path that is not mounted, so arbitrary-directory spawning is
+ * closed by construction rather than by a check.
+ */
+export interface SandboxSettings {
+  enabled: boolean;
+  /** Absolute host directories the contained cockpit may work in. */
+  workspaces: string[];
+}
+/** Nullable numbers are not used: a disabled toggle keeps its value so flipping it back restores it. */
+export interface RemoteAccessSettings {
+  /** Close the tunnel on a timer. */
+  autoCloseEnabled: boolean;
+  autoCloseMinutes: number;
+  /** Expire paired sessions on idle and on total age. */
+  sessionExpiryEnabled: boolean;
+  idleMinutes: number;
+  absoluteHours: number;
+  tunnel: TunnelConfig;
+  sandbox: SandboxSettings;
+}
+export interface BundlePairingTrust {
+  publicKey: string;
+  fingerprint: string;
+  revision: number;
+}
+export type RemoteAccessStatus = 'off' | 'starting' | 'on' | 'failed';
+export interface PairedDeviceView {
+  id: string;
+  label: string;
+  userAgent: string;
+  /** ISO 8601. */
+  createdAt: string;
+  /** ISO 8601. */
+  lastSeenAt: string;
+  /** True for the device making the request, so the UI can say "this device". */
+  self: boolean;
+}
+/**
+ * How a live session earned its cookie. Only a `pairing` session approved by QR may register a native
+ * device, and a `device-key` session always needs a biometric step-up signature for gated actions.
+ */
+export type DeviceTrustKind = 'pairing' | 'passkey' | 'device-key';
+export type DeviceTrust = {
+  kind: 'pairing';
+} | {
+  kind: 'passkey';
+} | {
+  kind: 'device-key';
+  trustedDeviceId: string;
+};
+export type TrustedDevicePlatform = 'ios' | 'android';
+/** What local and remote callers see of a trusted device: no keys. */
+export interface TrustedDeviceView {
+  id: string;
+  label: string;
+  platform: TrustedDevicePlatform;
+  /** ISO 8601. */
+  createdAt: string;
+  /** ISO 8601. */
+  lastSeenAt: string;
+  /** True when the calling session signed in with this device's key. */
+  self: boolean;
+}
+export interface PairingRequestView {
+  id: string;
+  userAgent: string;
+  /**
+   * The address Cloudflare's edge reported. Display only: any local process can
+   * reach the tunnel listener directly and set this header to anything, so it
+   * never gates a decision. The UI labels it "reported by the edge".
+   */
+  edgeIp: string;
+  /** ISO 8601. */
+  createdAt: string;
+  /** ISO 8601. */
+  expiresAt: string;
+}
+export interface RemoteAccessStateView {
+  status: RemoteAccessStatus;
+  /** Present once the tunnel reports its hostname. */
+  publicUrl?: string;
+  /** ISO 8601, present while the tunnel is up. */
+  startedAt?: string;
+  /** ISO 8601, absent when auto-close is switched off. */
+  closesAt?: string;
+  /** Why the tunnel failed, once it has. */
+  error?: string;
+  devices: PairedDeviceView[];
+  /** Populated for local callers only; a paired phone must not see approval prompts. */
+  pending: PairingRequestView[];
+  /** Shown to local and remote callers, so a paired device can revoke a lost one. */
+  trustedDevices: TrustedDeviceView[];
+  settings: RemoteAccessSettings;
+}
+export type PairingStatus = 'pending' | 'approved' | 'denied' | 'expired' | 'consumed';
+export type TunnelFailure = 'not_installed' | 'spawn_failed' | 'timeout' | 'self_test_failed' | 'exited';
+export interface TunnelStartInput {
+  /** The loopback port the tunnel should publish. */
+  port: number;
+  config: TunnelConfig;
+  /** Arms the exact public origin before the launcher probes through it. */
+  acceptOrigin?: (origin: string) => void;
+  /** Cancels startup and asks the launcher to stop any process it has spawned. */
+  signal?: AbortSignal;
+}
+export type TunnelStartResult = {
+  ok: true;
+  publicOrigin: string;
+  stop: () => Promise<void>;
+} | {
+  ok: false;
+  failure: TunnelFailure;
+  message: string;
+};
+/**
+ * Starting a tunnel, as a port rather than a concrete process.
+ *
+ * Declared here so a test can inject a fake without pulling in the cloudflared
+ * adapter, and so `WebServerOptions` can name the seam without reaching across
+ * a layer to do it.
+ */
+export type TunnelLauncher = (input: TunnelStartInput) => Promise<TunnelStartResult>;
+//#endregion
+//# sourceMappingURL=remote.d.mts.map

package/dist/src/types/remote.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"remote.d.mts","names":[],"sources":["../../../src/types/remote.ts"],"mappings":";YACY;;;;;;;;;;YAWA;EACN;;EACA;EAAe;EAAkB;EAAe;EAAoB;;;;;;;;;;;;;iBAazD;EACf;;EAEA;;;iBAgBe;;EAEf;EACA;;EAEA;EACA;EACA;EACA,QAAQ;EACR,SAAS;;iBAGM;EACf;EACA;EACA;;YAGU;iBAEK;EACf;EACA;EACA;;EAEA;;EAEA;;EAEA;;;;;;YAOU;YAEA;EAAgB;;EAAsB;;EAAsB;EAAoB;;YAEhF;;iBAkBK;EACf;EACA;EACA,UAAU;;EAEV;;EAEA;;EAEA;;iBAGe;EACf;EACA;;;;;;EAMA;;EAEA;;EAEA;;iBAGe;EACf,QAAQ;;EAER;;EAEA;;EAEA;;EAEA;EACA,SAAS;;EAET,SAAS;;EAET,gBAAgB;EAChB,UAAU;;YAGA;YAEA;iBAEK;;EAEf;EACA,QAAQ;;EAER,gBAAgB;;EAEhB,SAAS;;YAGC;EACN;EAAU;EAAsB,YAAY;;EAC5C;EAAW,SAAS;EAAe;;;;;;;;;YAS7B,kBAAkB,OAAO,qBAAqB,QAAQ"}

package/dist/src/types/server/directHarnessRuntime.d.mts

@@ -0,0 +1,526 @@
+import { HistoryOwnership } from "../../services/historyImport/index.mjs";
+import { Static, TSchema } from "typebox";
+import { CompactionPolicy, Conversation, ConversationStreamOptions, Harness, QueueMode, Session, Storage } from "@earendil-works/pi-durable";
+import { Context, JsonValue } from "@earendil-works/chord";
+import { Api, CredentialStore, ImageContent, Message, Model, ModelThinkingLevel, Models, MutableModels, Provider, RetryPolicy, Tool, ToolResultMessage, Usage } from "@earendil-works/pi-ai";
+//#region src/types/server/directHarnessRuntime.d.ts
+export type AgentMessage = Message | import('@earendil-works/pi-coding-agent').SessionMessageEntry['message'];
+export type ThinkingLevel = ModelThinkingLevel;
+export type CompactionSettings = Partial<CompactionPolicy>;
+export interface Skill {
+  name: string;
+  description: string;
+  content: string;
+  filePath: string;
+  disableModelInvocation?: boolean;
+}
+export interface AgentHarnessResources {
+  skills?: Skill[];
+  promptTemplates?: {
+    name: string;
+    description?: string;
+    content: string;
+  }[];
+}
+export interface AgentHarnessToolInvocation {
+  invocationId: string;
+  operationId: string;
+  turnId: string;
+  getMemo(name: string): Promise<JsonValue | undefined>;
+  setMemo(name: string, value: JsonValue | undefined): Promise<void>;
+}
+export type AgentHarnessTool<TContext extends object | undefined = object | undefined, TParameters extends TSchema = TSchema, TDetails = unknown> = Tool<TParameters> & {
+  label?: string;
+  replay?: 'safe' | 'unsafe';
+  executionMode?: 'parallel' | 'sequential';
+  prepareArguments?(args: unknown): Static<TParameters>;
+  execute(callId: string, params: Static<TParameters>, update: (result: {
+    content: ToolResultMessage['content'];
+    details?: TDetails;
+  }) => void, toolContext: TContext, invocation: AgentHarnessToolInvocation, context: Context): Promise<{
+    content: ToolResultMessage['content'];
+    details?: TDetails;
+    isError?: boolean;
+  }>;
+};
+export type Entry = {
+  id: string;
+  parentId: string | null;
+  timestamp: number;
+  seq: number;
+} & ({
+  type: 'message';
+  message: AgentMessage;
+} | {
+  type: 'custom';
+  customType: string;
+  data?: JsonValue;
+} | {
+  type: 'compaction';
+  summary: string;
+  tokensBefore: number;
+  retainedTail: AgentMessage[];
+  fromHook: boolean;
+  details?: JsonValue;
+  usage?: Usage;
+} | {
+  type: 'branch_summary';
+  summary: string;
+  fromId?: string | null;
+  fromHook: boolean;
+  details?: JsonValue;
+  usage?: Usage;
+});
+export interface SessionStats {
+  messageCount: number;
+  userMessages: number;
+  assistantMessages: number;
+  toolCalls: number;
+  toolResults: number;
+  tokens: {
+    input: number;
+    output: number;
+    cacheRead: number;
+    cacheWrite: number;
+    total: number;
+  };
+  cost: number;
+  usage: Usage;
+  sessionId?: string;
+  sessionFile?: string;
+  totalMessages?: number;
+  totalCost?: number;
+  contextUsage?: import('@earendil-works/pi-coding-agent').ContextUsage;
+}
+export interface CompactionPreparation {
+  entries: Entry[];
+  messages: AgentMessage[];
+  tokensBefore: number;
+  retainedTail: AgentMessage[];
+  firstKeptEntryId?: string;
+  messagesToSummarize: AgentMessage[];
+  turnPrefixMessages: AgentMessage[];
+  isSplitTurn: boolean;
+  previousSummary?: string;
+  fileOps: import('@earendil-works/pi-coding-agent').FileOperations;
+  settings: {
+    enabled: boolean;
+    reserveTokens: number;
+    keepRecentTokens: number;
+  };
+}
+export interface CompactResult {
+  summary: string;
+  tokensBefore: number;
+  retainedTail: AgentMessage[];
+  details?: JsonValue;
+  usage?: Usage;
+}
+export interface HookMap {
+  transform_context: {
+    event: {
+      messages: AgentMessage[];
+      systemPrompt: string;
+    };
+    result: {
+      messages?: AgentMessage[];
+      systemPrompt?: string;
+    } | undefined;
+  };
+  before_payload: {
+    event: {
+      model: Model<Api>;
+      payload: unknown;
+    };
+    result: {
+      payload: unknown;
+    } | undefined;
+  };
+  before_tool: {
+    event: {
+      toolCallId: string;
+      toolName: string;
+      args: Record<string, JsonValue>;
+    };
+    result: {
+      args?: Record<string, JsonValue>;
+      block?: {
+        reason: string;
+        terminate?: boolean;
+      };
+    } | undefined;
+  };
+  after_tool: {
+    event: {
+      toolCallId: string;
+      toolName: string;
+      args: Record<string, JsonValue>;
+      content: ToolResultMessage['content'];
+      details?: JsonValue;
+      isError: boolean;
+      usage?: Usage;
+    };
+    result: {
+      content?: ToolResultMessage['content'];
+      details?: JsonValue;
+      isError?: boolean;
+      usage?: Usage;
+      terminate?: boolean;
+    } | undefined;
+  };
+  before_compaction: {
+    event: {
+      reason: 'manual' | 'threshold' | 'overflow';
+      preparation: CompactionPreparation;
+      customInstructions?: string;
+    };
+    result: {
+      decline?: boolean;
+      compaction?: CompactResult;
+    } | undefined;
+  };
+}
+export type HarnessEvent = ({
+  type: 'run_start' | 'run_resume' | 'turn_start' | 'compaction_start' | 'navigation_start';
+} | {
+  type: 'run_end';
+  runId?: string;
+  successorActive?: boolean;
+} | {
+  type: 'message_start' | 'message_end';
+  message: AgentMessage;
+  runId?: string;
+  entryId?: string;
+} | {
+  type: 'message_update';
+  message: import('@earendil-works/pi-ai').AssistantMessage;
+  event: import('@earendil-works/pi-ai').AssistantMessageEvent;
+} | {
+  type: 'tool_start';
+  toolCallId: string;
+  toolName: string;
+  args: Record<string, JsonValue>;
+} | {
+  type: 'tool_update';
+  toolCallId: string;
+  toolName: string;
+  partialResult: {
+    content: ToolResultMessage['content'];
+    details?: JsonValue;
+  };
+} | {
+  type: 'tool_end';
+  toolCallId: string;
+  toolName: string;
+  result: {
+    content: ToolResultMessage['content'];
+    details?: JsonValue;
+  };
+  isError: boolean;
+} | {
+  type: 'entry_added';
+  entry: Entry;
+} | {
+  type: 'queue_update';
+  queues: {
+    kind: string;
+  }[];
+} | {
+  type: 'turn_end';
+  message: import('@earendil-works/pi-ai').AssistantMessage;
+  toolResults: ToolResultMessage[];
+} | {
+  type: 'compaction_end';
+  status: 'completed' | 'failed' | 'aborted';
+  reason: 'manual' | 'threshold' | 'overflow';
+  entryId?: string;
+  error?: Error;
+} | {
+  type: 'navigation_end';
+  status: 'completed' | 'failed' | 'aborted';
+  tipId: string | null;
+  fromTipId: string | null;
+} | {
+  type: 'value_update';
+  value: 'session_name';
+  name: string;
+} | {
+  type: 'config_update';
+  property: 'model';
+  value: {
+    provider: string;
+    modelId: string;
+  };
+  previous?: {
+    provider: string;
+    modelId: string;
+  };
+} | {
+  type: 'config_update';
+  property: 'thinkingLevel';
+  value: ThinkingLevel;
+  previous: ThinkingLevel;
+} | {
+  type: 'usage';
+  row: {
+    id: string;
+    usage: Usage;
+  };
+} | {
+  type: 'run_suspend' | 'run_abort' | 'operation_abort';
+} | {
+  type: 'handler_error' | 'error';
+  error: string;
+}) & {
+  [key: string]: unknown;
+  lane?: string;
+  runId?: string;
+};
+export type EntryProjector = (entry: Entry) => AgentMessage[];
+export interface AgentHarnessOptions<TContext extends object | undefined> {
+  toolContext?: TContext | ((context: Context) => TContext | Promise<TContext>);
+  systemPrompt?: string | ((toolContext: TContext, context: Context) => string | Promise<string>);
+  streamOptions?: ConversationStreamOptions;
+  toProviderMessages?: (messages: AgentMessage[], context: Context) => Message[] | Promise<Message[]>;
+}
+/** The opaque frame shape consumed by the existing server compatibility facade. */
+export type DirectHarnessFrame = Record<string, unknown>;
+export type DirectHarnessModel = Model<Api> | {
+  provider: string;
+  id: string;
+};
+export interface DirectHarnessModelBoundary {
+  phase: 'turn' | 'request';
+  model?: Model<Api>;
+  prompt?: AgentMessage[];
+  resources: AgentHarnessResources;
+}
+export interface DirectHarnessRuntimeOptions<TContext extends object | undefined = object | undefined> {
+  /** Stable session identity. Existing session files are authoritative when omitted. */
+  sessionId?: string;
+  /** Working directory used by NodeExecutionEnv and newly-created sessions. */
+  cwd: string;
+  /** Stable lane identity. Defaults to `main`. */
+  lane?: string;
+  /** Stable host identity exposed to the parent orchestrator. */
+  harnessId?: string;
+  sessionName?: string;
+  /** Injecting a Session is supported for tests and hosts that already own storage. */
+  session?: Session;
+  durableStorage?: Storage;
+  /** Durable hosts write SQLite. The legacy JSONL selector is rejected. */
+  storage?: 'jsonl' | 'sqlite';
+  /** Existing durable-v1 SQLite session path. Requires historyOwnership for its lifetime. */
+  sessionPath?: string;
+  /** Existing v3 JSONL path. It is never opened for writing. */
+  legacySessionPath?: string;
+  /** Parent identity recorded on newly-created sessions. */
+  parentSessionId?: string;
+  sessionsRoot?: string;
+  /** Required when opening any existing session or importing legacy history. */
+  historyOwnership?: HistoryOwnership;
+  historyOriginalPath?: string;
+  historyStatePath?: string;
+  /** Public pi-ai model/provider/credential registries. */
+  models?: Models | MutableModels;
+  providers?: readonly Provider[];
+  credentials?: CredentialStore;
+  model?: DirectHarnessModel;
+  /** Public AgentHarness tools and resources are explicit, replaceable inputs. */
+  tools?: AgentHarnessTool<TContext>[];
+  resources?: AgentHarnessResources;
+  toolContext?: AgentHarnessOptions<TContext>['toolContext'];
+  systemPrompt?: AgentHarnessOptions<TContext>['systemPrompt'];
+  streamOptions?: AgentHarnessOptions<TContext>['streamOptions'];
+  retry?: RetryPolicy;
+  compaction?: CompactionSettings;
+  thinkingLevel?: ThinkingLevel;
+  /** Creation-time inherited intent. Persisted child state wins on reopen; requests remain Codex-only. */
+  initialFastMode?: boolean;
+  /** Creation-time lock. Persisted lock state wins on reopen. */
+  initialAgentLocked?: boolean;
+  activeToolNames?: string[];
+  steeringMode?: QueueMode;
+  followUpMode?: QueueMode;
+  toolExecution?: 'sequential' | 'parallel';
+  toProviderMessages?: AgentHarnessOptions<TContext>['toProviderMessages'];
+  entryProjectors?: Record<string, EntryProjector>;
+  context?: Context;
+  /** Synchronous admission check at the public Models dispatch boundary, before auth/provider work starts. */
+  guardModelRequest?: () => void;
+  beforeModelRequest?: (boundary: DirectHarnessModelBoundary, context: Context) => void | Promise<void>;
+  /** Active AgentHarness execution-hook bridges. */
+  transformContext?: (event: HookMap['transform_context']['event'], context: Context) => HookMap['transform_context']['result'] | Promise<HookMap['transform_context']['result']>;
+  beforePayload?: (event: HookMap['before_payload']['event'], context: Context) => HookMap['before_payload']['result'] | Promise<HookMap['before_payload']['result']>;
+  beforeTool?: (event: HookMap['before_tool']['event'], context: Context) => HookMap['before_tool']['result'] | Promise<HookMap['before_tool']['result']>;
+  afterTool?: (event: HookMap['after_tool']['event'], context: Context) => HookMap['after_tool']['result'] | Promise<HookMap['after_tool']['result']>;
+  beforeCompaction?: (event: HookMap['before_compaction']['event'], context: Context) => HookMap['before_compaction']['result'] | Promise<HookMap['before_compaction']['result']>;
+  /** Active package commands advertised through the compatibility protocol. */
+  listCommands?: () => readonly {
+    name: string;
+    description: string;
+  }[];
+  /** Returns false when the text is not an active package command, preserving normal prompt handling. */
+  dispatchCommand?: (text: string) => Promise<boolean>;
+}
+export interface DirectHarnessEventListener {
+  (event: HarnessEvent, context: Context): void | Promise<void>;
+}
+export interface DirectHarnessQueuedInput {
+  id: string;
+  text: string;
+  images?: ImageContent[];
+  delivery: 'steer' | 'followUp' | 'nextRun';
+  scheduling: 'automatic' | 'held';
+  disposition: 'pending' | 'handoff' | 'uncertain';
+}
+export interface DirectHarnessLifecycle {
+  revision: number;
+  operation: {
+    id: string;
+    kind: 'run' | 'compaction' | 'navigation';
+    status: 'open' | 'aborting';
+  } | null;
+  paused: boolean;
+  queue: DirectHarnessQueuedInput[];
+}
+/** Direct, same-process AgentHarness runtime owned by one session host. */
+export interface DirectHarnessRuntime<TContext extends object | undefined = object | undefined> {
+  readonly sessionId: string;
+  readonly sessionFile?: string;
+  readonly laneName: string;
+  readonly harnessId: string;
+  readonly session: Session;
+  readonly harness: Harness;
+  readonly lane: Conversation;
+  readonly exited: Promise<number>;
+  readonly storageQuarantined: boolean;
+  onPresentationFrame(listener: (frame: DirectHarnessFrame) => void): () => void;
+  onEvent(listener: DirectHarnessEventListener): () => void;
+  stop(): void;
+  readState(): Promise<Record<string, unknown>>;
+  readLifecycle(): Promise<DirectHarnessLifecycle>;
+  enqueueAutomatic(text: string, images?: ImageContent[]): Promise<{
+    id: string;
+  }>;
+  removeQueued(id: string): Promise<'removed' | 'in_flight' | 'already_consumed' | 'not_found'>;
+  promoteQueued(id: string, operationId?: string): Promise<'promoted' | 'in_flight' | 'target_changed' | 'not_found'>;
+  resumeQueue(): Promise<void>;
+  /** Reconciles persisted cancellation intent before the host resumes an interrupted native drive. */
+  recover(): Promise<void>;
+  readEntries(): Promise<{
+    entries: Entry[];
+    leafId: string | null;
+  }>;
+  /** Detached canonical context, before facet hooks, with unchanged custom metadata restored and no system message. */
+  getContextMessages(): Promise<AgentMessage[]>;
+  listCommands(): readonly {
+    name: string;
+    description: string;
+  }[];
+  /** Dispatches a registered command without admitting a model turn. */
+  dispatchCommand(text: string): Promise<boolean>;
+  setFastMode(enabled: boolean): Promise<void>;
+  /** True while local agent turns are blocked. Remote MCP operations still run. */
+  agentLocked(): boolean;
+  /** Persists the lock; locking aborts a running local agent turn. */
+  setAgentLock(locked: boolean): Promise<void>;
+  setModel(model: {
+    provider: string;
+    id: string;
+  }): Promise<void>;
+  availableModels(): Promise<readonly Model<Api>[]>;
+  /** Shares the harness dispatch guards with host-owned auxiliary model requests. */
+  completeModel?: Models['complete'];
+  availableThinkingLevels(): Promise<ThinkingLevel[]>;
+  setThinkingLevel(level: ThinkingLevel): Promise<void>;
+  setSteeringMode(mode: QueueMode): Promise<void>;
+  setFollowUpMode(mode: QueueMode): Promise<void>;
+  navigateTree(targetId: string | null, options?: Record<string, unknown>): Promise<{
+    cancelled: boolean;
+    entries: Entry[];
+  }>;
+  clearQueue(): Promise<{
+    steering: never[];
+    followUp: never[];
+  }>;
+  setName(name: string): Promise<void>;
+  getSessionStats(): Promise<SessionStats>;
+  replaceTools(tools: AgentHarnessTool<TContext>[]): Promise<void>;
+  replaceResources(resources: AgentHarnessResources): Promise<void>;
+  readResources(): Promise<AgentHarnessResources>;
+  /** Runs one non-agent operation while idle. Waiting is opt-in and does not guarantee ordering. */
+  runExternalOperation<T>(operation: () => Promise<T>, options?: {
+    signal?: AbortSignal;
+    waitMs?: number;
+  }): Promise<T>;
+  appendCustomEntry(customType: string, data?: unknown): Promise<string>;
+  /**
+   * Records a message without waking the agent.
+   *
+   * The lane defers the write while an operation runs, so a message appended
+   * mid-turn lands after the turn's tool results rather than between a tool
+   * call and its result, which providers reject on replay.
+   */
+  appendMessage(message: AgentMessage): Promise<string>;
+  /** Passive checkpoint writes: idle commits never queue; tool-boundary writers expire on callback exit. */
+  registerCheckpointBoundary?(callback: (boundary: {
+    signal?: AbortSignal;
+    appendMessage(message: AgentMessage): Promise<string | undefined>;
+  }) => Promise<void>): {
+    appendMessage(message: AgentMessage): Promise<string | undefined>;
+    dispose(): void;
+  };
+  /** Names an entry in the session tree. */
+  setLabel(targetId: string, label: string | undefined): Promise<void>;
+  recordUsage(usage: Usage, options?: {
+    entryId?: string;
+    details?: JsonValue;
+  }): Promise<string>;
+  submitPrompt(text: string, images?: ImageContent[], streamingBehavior?: 'steer' | 'followUp'): Promise<{
+    settled: Promise<void>;
+    handledCommand?: boolean;
+  }>;
+  /** Cancels an active run and directly admits one user message, preserving paused retained inputs. */
+  submitUserPrompt(text: string | Extract<AgentMessage, {
+    role: 'user';
+  }>, images?: ImageContent[]): Promise<{
+    settled: Promise<void>;
+    handledCommand?: boolean;
+  }>;
+  prompt(text: string, images?: ImageContent[]): Promise<void>;
+  /** Starts a run from an already-composed message, without awaiting the run. */
+  admitMessage(message: AgentMessage): Promise<{
+    settled: Promise<void>;
+  }>;
+  /**
+   * Admits host-generated input through Durable, never through the operator queue.
+   * `nextTurn` stages without writing or waking the agent and returns resolved settled.
+   * Only the next ordinary user prompt admission flushes it, not automatic or internal runs.
+   * Reuse requestId to deduplicate retries of steer/followUp admission.
+   */
+  submitInternalMessage(message: string | AgentMessage, delivery?: 'steer' | 'followUp' | 'nextTurn', requestId?: string): Promise<{
+    settled: Promise<void>;
+  }>;
+  steer(message: string | AgentMessage, images?: ImageContent[], targetOperationId?: string): Promise<void>;
+  followUp(message: string | AgentMessage, images?: ImageContent[]): Promise<void>;
+  /** Queues for the run after the current one, rather than into it. */
+  nextRun(message: string | AgentMessage, images?: ImageContent[]): Promise<void>;
+  abort(operationId?: string): Promise<void>;
+  /**
+   * Cancels the current operation and waits for the lane to go idle. Unlike abort, it does not
+   * wait on an external tool invocation, so session teardown can always stop a running turn.
+   */
+  interrupt(): Promise<void>;
+  compact(customInstructions?: string): Promise<void>;
+  /** Admits a persisted continuation without waiting for its provider/tool work. */
+  admitResume(): Promise<{
+    resumed: boolean;
+    settled: Promise<void>;
+  }>;
+  /** Continues a persisted in-flight operation; false when the lane had none. */
+  resume(): Promise<boolean>;
+  dispose(): Promise<void>;
+}
+//#endregion
+//# sourceMappingURL=directHarnessRuntime.d.mts.map

package/dist/src/types/server/directHarnessRuntime.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"directHarnessRuntime.d.mts","names":[],"sources":["../../../../src/types/server/directHarnessRuntime.ts"],"mappings":"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"}