@nylorun/harness 0.12.0-beta → 0.15.0-beta

package/dist/turn/runner.js

@@ -1,159 +0,0 @@
-import { beginTurn, commitCandidate, commitFinal, commitToolResults, withStatus, } from "../session/state.js";
-import { runStep } from "../step/run.js";
-import { createId } from "../utils/ids.js";
-import { copyJson } from "../utils/immutable.js";
-import { ToolPlanRunner } from "./plan-runner.js";
-/** Advances one Turn until it finalizes, trips policy, or reaches a waiting barrier. */
-export class TurnRunner {
-    agent;
-    sessionId;
-    session;
-    constructor(agent, sessionId, session) {
-        this.agent = agent;
-        this.sessionId = sessionId;
-        this.session = session;
-    }
-    async start(state, event, context, output) {
-        const turnId = createId("turn");
-        state = await context.commit(beginTurn(state, turnId, event), "input");
-        context.onConversation({ type: "input", event, turnId });
-        return this.advance(state, turnId, 1, [event], [], context, output);
-    }
-    async continue(state, context) {
-        const turnId = createId("turn");
-        return this.advance(beginTurn(state, turnId), turnId, 1, [], [], context);
-    }
-    async resume(state, pending, event, context) {
-        const resume = pending.plan.interactionResume(event);
-        const active = pending.plan.activeInteractionRecord(pending.turnId, pending.stepId, resume);
-        state = await context.commit(withStatus(state, "running", undefined, active), "input", active);
-        context.onConversation({ type: "input", event, turnId: pending.turnId });
-        const progress = await this.runPlan(pending, context, event);
-        if (progress.kind === "interaction-required")
-            return this.waitForInteraction(state, pending, progress.interaction, context);
-        if (progress.kind === "deferred")
-            return this.waitForDeferred(state, pending, pending.plan.activeToolsRecord(pending.turnId, pending.stepId), context);
-        state = await context.commit(commitToolResults(state, pending.turnId, pending.stepId, progress.results), "tool-results");
-        pending.plan.publishSettlements(context.observe);
-        const claimed = await context.claimInterrupts(state, pending.turnId);
-        return this.advance(claimed.state, pending.turnId, pending.stepNumber + 1, claimed.arrivals, progress.results, context, pending.output);
-    }
-    async advance(initialState, turnId, firstStep, arrivals, initialResults, context, output) {
-        let state = initialState;
-        let stepArrivals = arrivals;
-        let toolResults = initialResults;
-        for (let stepNumber = firstStep;; stepNumber += 1) {
-            const stepId = createId("step");
-            const run = await runStep({
-                agent: this.agent,
-                observe: context.observe,
-                state,
-                sessionId: this.sessionId,
-                turnId,
-                stepId,
-                turnNumber: state.turnCount,
-                stepNumber,
-                arrivals: stepArrivals,
-                toolResults,
-                signal: context.signal,
-                session: this.session,
-                states: context.states,
-                output,
-                recordModelRequested: (next, active) => context.commit(next, "model-requested", active),
-            });
-            context.assertCurrent();
-            state = run.state;
-            const pending = run.output.kind === "tools"
-                ? {
-                    plan: new ToolPlanRunner(run.output.plan),
-                    turnId,
-                    stepId,
-                    stepNumber,
-                    ...(output === undefined ? {} : { output }),
-                }
-                : undefined;
-            if (run.candidate) {
-                const active = pending?.plan.activeToolsRecord(turnId, stepId);
-                state = await context.commit(commitCandidate(state, turnId, stepId, run.candidate), "candidate", active);
-                context.observe({
-                    type: "model.completed",
-                    turnId,
-                    stepId,
-                    ...(run.requestedModelId === undefined ? {} : { requestedModelId: run.requestedModelId }),
-                    attributes: run.candidate,
-                });
-                context.onConversation({ type: "candidate", turnId, stepId, candidate: run.candidate });
-            }
-            if (run.output.kind === "tripwire")
-                return { kind: "tripwire", state, turnId, stepId, tripwire: run.output.tripwire };
-            if (run.output.kind === "deferred-model") {
-                state = await context.commit(withStatus(state, "waiting", undefined, run.output.active), "waiting", run.output.active);
-                return { kind: "deferred", state, turnId, stepId, active: run.output.active };
-            }
-            if (run.output.kind === "final") {
-                state = await context.commit(withStatus(commitFinal(state, turnId, stepId, run.output.output), "idle"), "final");
-                return { kind: "final", state, turnId, stepId, output: run.output.output };
-            }
-            const toolPlan = run.output.plan;
-            context.observe(() => ({
-                type: "tool.sealed",
-                turnId,
-                stepId,
-                attributes: {
-                    executable: Object.freeze(toolPlan.executable.map((entry) => Object.freeze({
-                        callId: entry.call.callId,
-                        toolName: entry.call.toolName,
-                        args: copyJson(entry.call.args),
-                        invocationId: entry.invocationId,
-                        owner: entry.owner,
-                        ...(entry.interaction === undefined
-                            ? {}
-                            : { interaction: copyJson(entry.interaction) }),
-                    }))),
-                    immediate: copyJson(toolPlan.immediateResults),
-                },
-            }));
-            const progress = await this.runPlan(pending, context);
-            if (progress.kind === "interaction-required")
-                return this.waitForInteraction(state, pending, progress.interaction, context);
-            if (progress.kind === "deferred")
-                return this.waitForDeferred(state, pending, pending.plan.activeToolsRecord(turnId, stepId), context);
-            state = await context.commit(commitToolResults(state, turnId, stepId, progress.results), "tool-results");
-            pending.plan.publishSettlements(context.observe);
-            const claimed = await context.claimInterrupts(state, turnId);
-            state = claimed.state;
-            stepArrivals = claimed.arrivals;
-            toolResults = progress.results;
-        }
-    }
-    async waitForInteraction(state, pending, interaction, context) {
-        const active = pending.plan.activeInteractionRecord(pending.turnId, pending.stepId);
-        state = await context.commit(withStatus(state, "waiting", interaction, active), "waiting", active);
-        pending.plan.publishSettlements(context.observe);
-        return { kind: "interaction-required", state, pending, interaction };
-    }
-    async waitForDeferred(state, pending, active, context) {
-        state = await context.commit(withStatus(state, "waiting", undefined, active), "waiting", active);
-        pending.plan.publishSettlements(context.observe);
-        return {
-            kind: "deferred",
-            state,
-            turnId: pending.turnId,
-            stepId: pending.stepId,
-            active,
-        };
-    }
-    async runPlan(pending, context, resume) {
-        context.onPlanActive(pending);
-        const progress = await pending.plan.run({
-            signal: context.signal,
-            observe: context.observe,
-            ids: { sessionId: this.sessionId, turnId: pending.turnId, stepId: pending.stepId },
-            states: context.states,
-            onModelCall: this.agent.invoke,
-        }, resume);
-        context.assertCurrent();
-        context.onPlanActive(undefined);
-        return progress;
-    }
-}

package/dist/types/manifest.d.ts

@@ -1,19 +0,0 @@
-import type { BoundMiddleware, MiddlewareContributions } from "./middleware.js";
-import type { BuildDiagnostic } from "./shared.js";
-export interface MiddlewareManifest extends MiddlewareContributions {
-    readonly id: string;
-}
-export interface AgentManifest {
-    readonly id: string;
-    readonly name: string;
-    readonly middleware: readonly MiddlewareManifest[];
-}
-export type BuildResult<Agent> = {
-    readonly ok: true;
-    readonly agent: Agent;
-    readonly manifest: AgentManifest;
-} | {
-    readonly ok: false;
-    readonly diagnostics: readonly BuildDiagnostic[];
-};
-export type { BoundMiddleware };

package/dist/types/middleware.d.ts

@@ -1,95 +0,0 @@
-import type { ContextMutationOptions, ModelCandidate, ModelDirective, ModelToolCall, ModelConfigurationMutationOptions } from "./model.js";
-import type { InputEvent, SessionIdentity, TranscriptEntry } from "./session.js";
-import type { ContextItem, JsonObject, Tripwire } from "./shared.js";
-import type { Interaction, ToolDefinition, ToolResult } from "./tool.js";
-export interface StepInput {
-    readonly sessionId: string;
-    readonly turnId: string;
-    readonly stepId: string;
-    /** One-based position of this turn within the Session. */
-    readonly turnNumber: number;
-    /** One-based position of this Model Step within the Turn. */
-    readonly stepNumber: number;
-    readonly session: Readonly<{
-        readonly userId?: string;
-        readonly context?: JsonObject;
-    }>;
-    readonly arrivals: readonly InputEvent[];
-    readonly toolResults: readonly ToolResult[];
-    readonly transcript: readonly TranscriptEntry[];
-}
-interface StepRequestBase {
-    /** Opaque identity of the Session that owns this Step. */
-    readonly sessionId: string;
-    /** Opaque identity of the Turn that owns this Step. */
-    readonly turnId: string;
-    /** Opaque identity of this Model Step. */
-    readonly stepId: string;
-    readonly session: StepInput["session"];
-    readonly turnNumber: number;
-    readonly stepNumber: number;
-    readonly arrivals: readonly InputEvent[];
-    readonly toolResults: readonly ToolResult[];
-    readonly transcript: readonly TranscriptEntry[];
-    readonly context: {
-        set(slot: string, items: readonly ContextItem[], options?: ContextMutationOptions): void;
-    };
-    readonly configuration: {
-        readonly instructions: {
-            set(slot: string, items: readonly string[], options?: ModelConfigurationMutationOptions): void;
-        };
-        readonly tools: {
-            set(slot: string, tools: readonly ToolDefinition[], options?: ModelConfigurationMutationOptions): void;
-        };
-        readonly model: {
-            select(directive: ModelDirective, options?: Omit<ModelConfigurationMutationOptions, "order">): void;
-            replace(directive: ModelDirective, options?: Omit<ModelConfigurationMutationOptions, "order">): void;
-            clear(options?: Omit<ModelConfigurationMutationOptions, "order">): void;
-        };
-    };
-    tripwire(error: Tripwire): StepResponse;
-}
-export type StepRequest<State = never> = StepRequestBase & ([State] extends [never] ? object : {
-    readonly state: Promise<State>;
-});
-export interface StepResponse {
-    candidate(): Readonly<ModelCandidate> | undefined;
-    toolCalls(): readonly ModelToolCall[];
-    replace(candidate: ModelCandidate): void;
-    deny(callId: string, reason: string): void;
-    requireInteraction(callId: string, interaction: Interaction): void;
-    tripwire(error: Tripwire): StepResponse;
-}
-export type StepMiddleware<State = never> = (request: StepRequest<State>, next: () => Promise<StepResponse>) => Promise<StepResponse>;
-export interface CapabilityState<State> {
-    create(session: SessionIdentity, signal: AbortSignal): State | Promise<State>;
-    dispose?(value: State): void | Promise<void>;
-}
-export type CapabilityItems<Item> = readonly Item[] | Readonly<{
-    readonly slot: string;
-    readonly items: readonly Item[];
-}>;
-/** A named capability that may supply static model surface and one typed middleware handler. */
-export interface CapabilityDeclaration<State = never> {
-    readonly id: string;
-    readonly tools?: CapabilityItems<ToolDefinition<ToolDefinition["inputSchema"], State>>;
-    readonly instructions?: CapabilityItems<string>;
-    readonly model?: ModelDirective;
-    readonly state?: CapabilityState<State>;
-    readonly middleware?: StepMiddleware<State>;
-}
-export interface MiddlewareContributions {
-    readonly instructions?: readonly string[];
-    readonly tools?: readonly {
-        readonly name: string;
-        readonly description?: string;
-    }[];
-    readonly model?: Pick<ModelDirective, "id" | "controls">;
-}
-export interface BoundMiddleware {
-    readonly id: string;
-    readonly handle: StepMiddleware;
-    readonly state?: CapabilityState<unknown>;
-    readonly contributions?: MiddlewareContributions;
-}
-export {};

package/dist/types/model.d.ts

@@ -1,184 +0,0 @@
-import type { ContextItem, DeferredOutcome, JsonObject, JsonValue } from "./shared.js";
-import type { InputEvent, TranscriptEntry } from "./session.js";
-import type { BoundToolDefinition, ToolResult } from "./tool.js";
-export interface ModelToolCall {
-    readonly id: string;
-    readonly name: string;
-    readonly args: JsonObject;
-}
-export type ModelOutputBlock = {
-    readonly type: "text";
-    readonly text: string;
-    readonly providerMetadata?: JsonObject;
-} | {
-    readonly type: "reasoning";
-    readonly text: string;
-    readonly providerMetadata?: JsonObject;
-} | {
-    readonly type: "json";
-    readonly value: JsonValue;
-} | {
-    readonly type: "tool-call";
-    readonly providerMetadata?: JsonObject;
-    readonly id: string;
-    readonly name: string;
-    readonly args: JsonObject;
-    readonly raw?: string;
-};
-export interface ModelUsage {
-    readonly inputTokens?: number;
-    readonly outputTokens?: number;
-    readonly totalTokens?: number;
-    readonly cachedTokens?: number;
-    readonly reasoningTokens?: number;
-    readonly costUsd?: number;
-}
-export type ModelFinishReason = "stop" | "length" | "tool-calls" | "content-filter" | "other";
-export interface ModelEvidence {
-    readonly requestId?: string;
-    readonly resolvedModel?: string;
-    readonly warnings?: readonly string[];
-    readonly extras?: JsonObject;
-}
-export interface ModelCandidate {
-    readonly output: readonly ModelOutputBlock[];
-    readonly finishReason?: ModelFinishReason;
-    readonly usage?: ModelUsage;
-    readonly evidence?: ModelEvidence;
-}
-export interface ModelControls {
-    readonly temperature?: number;
-    readonly maxOutputTokens?: number;
-}
-export interface ModelDirective {
-    readonly id?: string;
-    readonly controls?: ModelControls;
-    readonly config?: JsonObject;
-}
-/** A middleware-owned declaration for the model-visible configuration. */
-export interface ModelConfigurationMutationOptions {
-    readonly order?: number;
-    readonly reason?: string;
-}
-export interface ModelConfigurationContributor {
-    readonly middlewareId: string;
-    readonly slot: string;
-    readonly order: number;
-    readonly reason?: string;
-}
-export interface ModelConfigurationTool {
-    readonly name: string;
-    readonly description?: string;
-    readonly inputSchema: JsonObject;
-    readonly outputSchema?: JsonObject;
-    readonly contributor: ModelConfigurationContributor;
-}
-export interface ModelConfigurationInstruction {
-    readonly text: string;
-    readonly contributor: ModelConfigurationContributor;
-}
-export interface ModelConfigurationSnapshot {
-    readonly version: 1;
-    readonly model?: ModelDirective;
-    readonly instructions: readonly ModelConfigurationInstruction[];
-    /** Bound tools are retained for execution. */
-    readonly tools: readonly BoundToolDefinition[];
-    readonly toolContracts: readonly ModelConfigurationTool[];
-    readonly contributors: readonly ModelConfigurationContributor[];
-}
-/** A middleware-owned declaration for this model call's runtime context. */
-export interface ContextMutationOptions {
-    readonly order?: number;
-    readonly reason?: string;
-}
-export interface ContextContributor {
-    readonly middlewareId: string;
-    readonly slot: string;
-    readonly order: number;
-    readonly reason?: string;
-}
-/** Canonical runtime context for one model call. */
-export interface ContextSnapshot {
-    readonly items: readonly ContextItem[];
-    readonly contributors: readonly ContextContributor[];
-}
-export interface ModelRequest {
-    readonly sessionId: string;
-    readonly turnId: string;
-    readonly stepId: string;
-    readonly model?: ModelDirective;
-    /** Canonical, immutable Harness-owned model configuration for this call. */
-    readonly configuration: ModelConfigurationSnapshot;
-    readonly instructions: readonly string[];
-    readonly context: ContextSnapshot;
-    readonly transcript: readonly TranscriptEntry[];
-    readonly arrivals: readonly InputEvent[];
-    readonly toolResults: readonly ToolResult[];
-    /** Tools are normalized and immutable by the time a Model sees them. */
-    readonly tools: readonly BoundToolDefinition[];
-    /** Optional portable contract for this turn's terminal JSON result. */
-    readonly outputSchema?: JsonObject;
-}
-export type PromptContentPart = {
-    readonly type: "reasoning";
-    readonly text: string;
-    readonly providerMetadata?: JsonObject;
-} | {
-    readonly type: "text";
-    readonly text: string;
-    readonly providerMetadata?: JsonObject;
-} | {
-    readonly type: "media";
-    readonly mediaType: string;
-    readonly reference: JsonValue;
-} | {
-    readonly type: "tool-call";
-    readonly providerMetadata?: JsonObject;
-    readonly id: string;
-    readonly name: string;
-    readonly args: JsonObject;
-};
-export type PromptItem = {
-    readonly kind: "instructions";
-    readonly role: "system";
-    readonly content: readonly PromptContentPart[];
-} | {
-    readonly kind: "message";
-    readonly role: "user" | "assistant";
-    readonly content: readonly PromptContentPart[];
-} | {
-    readonly kind: "tool-result";
-    readonly toolCallId: string;
-    readonly toolName: string;
-    readonly status: "completed" | "denied" | "failed";
-    readonly content: readonly PromptContentPart[];
-} | {
-    readonly kind: "context";
-    readonly role: "user";
-    readonly content: readonly PromptContentPart[];
-};
-export interface ModelCallTool {
-    readonly name: string;
-    readonly description?: string;
-    readonly inputSchema: JsonObject;
-}
-export interface ModelCall {
-    readonly model?: ModelDirective;
-    readonly prompt: readonly PromptItem[];
-    readonly tools: readonly ModelCallTool[];
-    /** Optional portable contract for this turn's terminal JSON result. */
-    readonly outputSchema?: JsonObject;
-    readonly sessionId: string;
-}
-export interface ModelAdapterContext {
-    readonly request: ModelRequest;
-    readonly invocationId: string;
-    readonly signal: AbortSignal;
-    /** Publishes one JSON-safe provider request derived from the canonical ModelCall. */
-    reportPreparedCall(prepared: ModelPreparedCall): void;
-}
-export interface ModelPreparedCall {
-    readonly adapter: string;
-    readonly call: JsonValue;
-}
-export type ModelAdapter = (call: ModelCall, context: ModelAdapterContext) => Promise<ModelCandidate | string | DeferredOutcome>;

package/dist/types/session.d.ts

@@ -1,230 +0,0 @@
-import type { ModelAdapter, ModelCall, ModelCandidate } from "./model.js";
-import type { JsonObject, JsonValue, Observer, Tripwire } from "./shared.js";
-import type { RequiredInteraction, SchemaOutput, ToolExecutionResume, ToolOwner, ToolResult, ToolSchemaSource } from "./tool.js";
-export type InputEvent = {
-    readonly kind: "user-message" | "interrupt";
-    readonly text: string;
-    readonly metadata?: JsonObject;
-} | {
-    readonly kind: "user-message" | "interrupt";
-    readonly content: readonly UserContentPart[];
-    /** Undefined for content-bearing events; retained for text-event narrowing compatibility. */
-    readonly text?: undefined;
-    readonly metadata?: JsonObject;
-} | {
-    readonly kind: "approve";
-    readonly interactionId: string;
-    readonly approved: boolean;
-} | {
-    readonly kind: "respond";
-    readonly interactionId: string;
-    readonly value: JsonValue;
-};
-export type SessionEvent<Output = string> = {
-    readonly type: "input";
-    readonly event: InputEvent;
-    readonly turnId: string;
-} | {
-    readonly type: "candidate";
-    readonly turnId: string;
-    readonly stepId: string;
-    readonly candidate: ModelCandidate;
-} | {
-    readonly type: "final";
-    readonly output: Output;
-    readonly turnId: string;
-} | {
-    readonly type: "interaction.required";
-    readonly interaction: RequiredInteraction;
-    readonly turnId: string;
-} | {
-    readonly type: "tripwire";
-    readonly tripwire: Tripwire;
-    readonly turnId: string;
-} | {
-    readonly type: "execution.deferred";
-    readonly active: ActiveExecutionRecord;
-    readonly turnId: string;
-} | {
-    readonly type: "input.queued";
-    readonly inputId: string;
-} | {
-    readonly type: "input.rejected";
-    readonly inputId: string;
-    readonly reason: string;
-} | {
-    readonly type: "input.cancelled";
-    readonly inputId: string;
-    readonly reason: string;
-} | {
-    readonly type: "session.stopped";
-    readonly sessionId: string;
-};
-export interface InputCompletion<Output = string> {
-    readonly inputId: string;
-    readonly status: "completed" | "waiting" | "rejected" | "cancelled" | "stopped";
-    readonly events: readonly SessionEvent<Output>[];
-}
-export interface InputHandle<Output = string> {
-    readonly inputId: string;
-    readonly completed: Promise<InputCompletion<Output>>;
-}
-export interface SessionOptions {
-    readonly onModelCall: ModelAdapter;
-    readonly id?: string;
-    readonly userId?: string;
-    readonly context?: JsonObject;
-    readonly seed?: never;
-    readonly recorder?: SessionRecorder;
-    readonly observer?: Observer;
-}
-/** Stable host-owned facts available while a capability creates session-local state. */
-export interface SessionIdentity {
-    readonly id: string;
-    readonly userId?: string;
-    readonly context?: JsonObject;
-}
-export interface SeededSessionOptions {
-    readonly onModelCall: ModelAdapter;
-    readonly seed: SessionSeed;
-    readonly recorder?: SessionRecorder;
-    readonly observer?: Observer;
-    readonly id?: never;
-    readonly userId?: never;
-    readonly context?: never;
-}
-export type SessionRunOptions = SessionOptions | SeededSessionOptions;
-export interface InputOptions {
-    readonly signal?: AbortSignal;
-}
-/** Per-turn, locally-enforced terminal JSON contract. */
-export interface OutputInputOptions<Schema extends ToolSchemaSource = ToolSchemaSource> extends InputOptions {
-    readonly outputSchema?: Schema;
-}
-/** Ordered, model-visible user content. Media references stay host-owned JSON values. */
-export type UserContentPart = {
-    readonly type: "text";
-    readonly text: string;
-} | {
-    readonly type: "media";
-    readonly mediaType: string;
-    readonly reference: JsonValue;
-};
-export type MessageInput = string | {
-    readonly text: string;
-    readonly metadata?: JsonObject;
-} | {
-    readonly content: readonly UserContentPart[];
-    readonly metadata?: JsonObject;
-};
-export type InteractionReply = Extract<InputEvent, {
-    kind: "approve" | "respond";
-}>;
-/** Ordinary user text or an interaction reply. Use `Session.interrupt()` for barge-in text. */
-export type SessionInput = MessageInput | InteractionReply;
-export interface TranscriptInputEntry {
-    readonly kind: "input";
-    readonly turnId: string;
-    readonly event: InputEvent;
-}
-export interface TranscriptCandidateEntry {
-    readonly kind: "candidate";
-    readonly turnId: string;
-    readonly stepId: string;
-    readonly candidate: ModelCandidate;
-}
-export interface TranscriptToolsEntry {
-    readonly kind: "tool-results";
-    readonly turnId: string;
-    readonly stepId: string;
-    readonly results: readonly ToolResult[];
-}
-export interface TranscriptFinalEntry {
-    readonly kind: "final";
-    readonly turnId: string;
-    readonly stepId: string;
-    readonly output: JsonValue;
-}
-export type TranscriptEntry = TranscriptInputEntry | TranscriptCandidateEntry | TranscriptToolsEntry | TranscriptFinalEntry;
-export interface SessionSnapshot {
-    readonly id: string;
-    readonly status: "idle" | "running" | "waiting" | "stopped";
-    readonly turnCount: number;
-    readonly revision: number;
-    readonly transcript: readonly TranscriptEntry[];
-    readonly pendingInteraction?: RequiredInteraction;
-    readonly active?: ActiveExecutionRecord;
-}
-export interface SessionSeed {
-    readonly id?: string;
-    readonly userId?: string;
-    readonly context?: JsonObject;
-    readonly turnCount?: number;
-    readonly revision?: number;
-    readonly transcript: readonly TranscriptEntry[];
-}
-export interface ActiveModelExecutionRecord {
-    readonly kind: "model";
-    readonly turnId: string;
-    readonly stepId: string;
-    readonly invocationId: string;
-    readonly call: ModelCall;
-    readonly token?: JsonValue;
-}
-export interface ActiveToolCallRecord {
-    readonly callId: string;
-    readonly toolName: string;
-    readonly args: JsonValue;
-    readonly invocationId: string;
-    readonly owner: ToolOwner;
-    readonly status: "pending" | "settled" | "deferred";
-    readonly result?: ToolResult;
-    readonly token?: JsonValue;
-}
-export interface ActiveToolsExecutionRecord {
-    readonly kind: "tools";
-    readonly turnId: string;
-    readonly stepId: string;
-    readonly calls: readonly ActiveToolCallRecord[];
-}
-export interface ActiveInteractionExecutionRecord {
-    readonly kind: "interaction";
-    readonly turnId: string;
-    readonly stepId: string;
-    readonly callId: string;
-    readonly toolName: string;
-    readonly interaction: RequiredInteraction;
-    readonly token?: JsonValue;
-    readonly resume?: ToolExecutionResume;
-    readonly tools: ActiveToolsExecutionRecord;
-}
-export type ActiveExecutionRecord = ActiveModelExecutionRecord | ActiveToolsExecutionRecord | ActiveInteractionExecutionRecord;
-export interface SessionRecord {
-    readonly version: 1;
-    readonly revision: number;
-    readonly transition: "input" | "model-requested" | "candidate" | "tool-results" | "waiting" | "final" | "stopped";
-    readonly session: {
-        readonly id: string;
-        readonly userId?: string;
-        readonly context?: JsonObject;
-        readonly turnCount: number;
-        readonly status: SessionSnapshot["status"];
-    };
-    readonly transcript: readonly TranscriptEntry[];
-    readonly active?: ActiveExecutionRecord;
-}
-export interface SessionRecorder {
-    record(value: SessionRecord): Promise<void>;
-}
-export interface Session {
-    readonly id: string;
-    readonly state: SessionSnapshot;
-    input<Schema extends ToolSchemaSource>(event: MessageInput, options: OutputInputOptions<Schema> & {
-        readonly outputSchema: Schema;
-    }): InputHandle<SchemaOutput<Schema>>;
-    input(event: SessionInput, options?: InputOptions): InputHandle<string>;
-    interrupt(event: MessageInput, options?: InputOptions): InputHandle;
-    continue(options?: InputOptions): InputHandle;
-    stream(): AsyncIterable<SessionEvent<JsonValue>>;
-    stop(reason?: string): Promise<void>;
-}

package/dist/types/session.js

@@ -1 +0,0 @@
-export {};