Skip to main content

lash/
lib.rs

1//! App-facing embedding facade for Lash.
2//!
3//! `lash` is intentionally a small layer above the lower-level
4//! `lash-core` runtime crate. Host applications own providers, persistence,
5//! app state, HTTP protocols, auth, and frontend streaming; this crate
6//! owns only the ergonomic core/session/turn API.
7//!
8//! Every public name has exactly one home. The crate root carries the daily
9//! core/session/turn path; each domain module ([`tools`], [`persistence`],
10//! [`plugins`], [`observe`], [`triggers`], ...) carries its own
11//! vocabulary. [`prelude`] is the curated daily-use subset of that root.
12
13pub mod admin;
14mod core;
15mod error;
16mod plugin_binding;
17pub(crate) mod process_admin;
18mod prompt_layer;
19#[cfg(feature = "rlm")]
20pub mod rlm;
21pub mod scenario_contracts;
22mod session;
23mod support;
24#[cfg(all(test, feature = "rlm"))]
25mod tests;
26pub mod turn;
27pub mod usage;
28
29pub use crate::admin::{
30    AdvancedToolAdmin, Completions, CoreTriggerAdmin, PluginOperations, SessionCommandAdmin,
31    SessionTriggerAdmin, ToolAdmin,
32};
33pub use crate::core::{LashCore, LashCoreBuilder, SessionDeleteReport};
34pub use crate::error::{EmbedError, Result};
35pub use crate::plugin_binding::PluginBinding;
36pub use crate::prompt_layer::PromptLayerSink;
37pub use crate::session::{
38    EnqueueTurnBuilder, LashSession, ObservableSession, ParkedSession, SessionBuilder,
39    SessionConfigPatch,
40};
41pub use crate::turn::{
42    QueuedTurnBuilder, TurnActivityFanout, TurnBuilder, TurnOutput, TurnResult, TurnStream,
43    message_role, message_text,
44};
45pub use lash_core::{
46    AwaitEventKey, AwaitEventWaitIdentity, ExecutionSummary, ExternalCompletionError, InputItem,
47    ModelLimits, ModelSpec, PendingTurnInput, PendingTurnInputCancelOutcome,
48    PendingTurnInputCancelResult, PendingTurnInputCancelTarget,
49    PendingTurnInputSuffixCancelOutcome, PluginStack, Resolution, ResolveOutcome, SessionCommand,
50    SessionCommandReceipt, SessionCreateRequest, SessionSpec, SessionStartPoint, TurnActivity,
51    TurnActivityId, TurnActivitySink, TurnCause, TurnEvent, TurnFinish, TurnInput, TurnOutcome,
52    TurnStop,
53};
54/// Cooperative cancellation handle accepted by
55/// [`TurnBuilder::cancel`](crate::TurnBuilder::cancel); re-exported so
56/// embedders cancel turns without depending on `tokio-util` themselves.
57pub use tokio_util::sync::CancellationToken;
58
59/// `use lash::prelude::*;` brings in the daily core/session/turn vocabulary
60/// without the lower-level integration types or domain modules also exposed
61/// from the crate root.
62pub mod prelude {
63    pub use crate::{
64        AdvancedToolAdmin, CoreTriggerAdmin, EmbedError, EnqueueTurnBuilder, ExecutionSummary,
65        InputItem, LashCore, LashCoreBuilder, LashSession, ModelLimits, ModelSpec,
66        ObservableSession, ParkedSession, PendingTurnInputCancelOutcome, PluginBinding,
67        PluginOperations, PluginStack, PromptLayerSink, QueuedTurnBuilder, Result, SessionBuilder,
68        SessionCommand, SessionCommandAdmin, SessionCommandReceipt, SessionConfigPatch,
69        SessionCreateRequest, SessionDeleteReport, SessionSpec, SessionStartPoint,
70        SessionTriggerAdmin, ToolAdmin, TurnActivity, TurnActivityFanout, TurnActivityId,
71        TurnActivitySink, TurnBuilder, TurnCause, TurnEvent, TurnFinish, TurnInput, TurnOutcome,
72        TurnOutput, TurnResult, TurnStop, TurnStream, message_role, message_text,
73    };
74}
75
76/// Session observation: cursors, resumable event streams, and live replay
77/// recovery for host frontends. Entry point: [`LashSession::observe`] /
78/// [`ObservableSession`].
79pub mod observe {
80    pub use crate::session::{
81        RemoteSessionObservationEventStream, RemoteSessionObservationStream,
82        RemoteSessionObservationStreamItem, RemoteSessionObservationSubscription,
83        SessionObservationStream, SessionObservationStreamItem,
84    };
85    pub use lash_core::{
86        InMemoryLiveReplayStore, InMemoryLiveReplayStoreConfig, LiveReplayGap, LiveReplayGapReason,
87        LiveReplayStore, SessionCursor, SessionObservation, SessionObservationEvent,
88        SessionObservationEventPayload, SessionObservationSubscription, SessionProcessEventKind,
89        SessionQueueEventKind, SessionResume, SessionRevision,
90    };
91}
92
93/// Triggers and subscriptions: declaring event sources, emitting occurrences,
94/// and inspecting trigger subscriptions. Entry points:
95/// [`LashCore::triggers`] and [`LashSession::triggers`].
96pub mod triggers {
97    pub use lash_core::{
98        LashSchema, TriggerDeliveryEmitOutcome, TriggerDeliveryEmitReport,
99        TriggerDeliveryReservation, TriggerDeliveryReservationStatus, TriggerEmitReport,
100        TriggerEvent, TriggerEventType, TriggerOccurrenceFilter, TriggerOccurrenceRecord,
101        TriggerOccurrenceRequest, TriggerRegistration, TriggerStore, TriggerSubscriptionDraft,
102        TriggerSubscriptionFilter, TriggerSubscriptionRecord, TriggerTargetSummary,
103        empty_trigger_source_key,
104    };
105}
106
107pub mod tools {
108    pub use lash_core::{
109        CancelHint, PendingCompletion, PreparedToolCall, TimeoutBehavior, ToolActivation,
110        ToolArgumentProjectionPolicy, ToolCall, ToolCallOutput, ToolCallRecord, ToolContext,
111        ToolContract, ToolDefinition, ToolDurableEffects, ToolExecutionGrant, ToolManifest,
112        ToolOutputContract, ToolPrepareCall, ToolPrepareContext, ToolProvider, ToolResult,
113        ToolScheduling, ToolSourceHandle, ToolTriggerClient,
114    };
115    pub use lash_core::{
116        PLUGIN_TOOL_SOURCE_ID, ToolId, ToolRestoreReport, ToolState, ToolStateEntry,
117    };
118    #[cfg(feature = "rlm")]
119    pub use lash_lashlang_runtime::{
120        CataloguePreviewEntry, CataloguePreviewOptions, DEFAULT_CATALOGUE_PREVIEW_CALL_NAME_LIMIT,
121        DEFAULT_CATALOGUE_PREVIEW_MODULE_LIMIT, LASHLANG_TOOL_BINDING_KEY, LashlangToolBinding,
122        RemoteToolGrantLashlangExt, ToolDefinitionLashlangExt, ToolManifestLashlangExt,
123        catalogue_preview_contribution, catalogue_preview_contribution_for_entries,
124        catalogue_preview_contribution_for_entries_with_options,
125        catalogue_preview_contribution_for_manifests, catalogue_preview_contribution_with_options,
126        catalogue_preview_entries_from_catalog_records, catalogue_preview_entries_from_manifests,
127        catalogue_preview_entry_from_catalog_record, catalogue_preview_entry_from_manifest,
128    };
129    #[cfg(feature = "rlm")]
130    pub use lash_lashlang_runtime::{
131        DeferredResolutionRecord, DeferredToolResolver, Resolution as DeferredToolResolution,
132        SharedDeferredToolResolver, ToolGrant as DeferredToolGrant,
133    };
134    /// Author a fixed-tool provider without hand-rolling `tool_manifests` /
135    /// `resolve_contract`: supply the [`ToolDefinition`]s once and an
136    /// [`StaticToolExecute`] for behavior.
137    pub use lash_tool_support::{StaticToolExecute, StaticToolProvider};
138}
139
140pub mod direct {
141    pub use lash_core::llm::types::{
142        LlmAttachment, LlmEventSender, LlmOutputPart, LlmTerminalReason, LlmUsage,
143    };
144    pub use lash_core::{
145        DirectCompletion, DirectJsonSchema, DirectLlmClient, DirectLlmCompletion, DirectLlmError,
146        DirectMessage, DirectOutputSpec, DirectPart, DirectRequest, DirectRole,
147    };
148}
149
150pub mod persistence {
151    pub use lash_core::CheckpointKind;
152    pub use lash_core::FileAttachmentStore;
153    pub use lash_core::runtime::{
154        DeliveryPolicy, InMemorySessionStore, InMemorySessionStoreFactory, MergeKey,
155        PendingTurnInputClaimDiagnostics, PendingTurnInputDraft, QueuedWorkBatch,
156        QueuedWorkBatchDraft, QueuedWorkClaim, QueuedWorkClaimBoundary, QueuedWorkClass,
157        QueuedWorkCompletion, QueuedWorkItem, QueuedWorkPayload, RuntimeSessionState,
158        SessionStoreCreateRequest, SessionStoreFactory, SlotPolicy, TurnInputClaim,
159        TurnInputCompletion,
160    };
161    pub use lash_core::store::queued_work;
162    pub use lash_core::store::{
163        GraphCommitDelta, HydratedSessionCheckpoint, PersistedSessionRead, RuntimeCommit,
164        RuntimeCommitResult, RuntimeTurnCommitStamp, SessionCheckpoint, SessionHead,
165        SessionHeadMeta, load_persisted_session_state, load_persisted_session_state_active_path,
166    };
167    pub use lash_core::{
168        AttachmentReclamationReport, AttachmentRootSet, AttachmentStore, InMemoryAttachmentStore,
169        InMemoryProcessExecutionEnvStore, ProcessExecutionEnvStore, SessionAttachmentStore,
170        StoredBlobRef, reclaim_unreferenced_attachments,
171    };
172    pub use lash_core::{
173        BlobRef, GcReport, LeaseOwnerIdentity, LeaseOwnerLiveness, PersistedSessionConfig,
174        PersistedTurnState, ProtocolEvent, QueuedWorkStore, RuntimePersistence, SessionCommitStore,
175        SessionEventRecord, SessionExecutionLease, SessionExecutionLeaseClaimOutcome,
176        SessionExecutionLeaseCompletion, SessionExecutionLeaseFence, SessionExecutionLeaseStore,
177        SessionGraph, SessionMeta, SessionNodeRecord, SessionReadScope, SessionReadView,
178        SessionRelation, StoreError, StoreMaintenance, TurnInputStore, VacuumReport,
179    };
180    #[cfg(feature = "rlm")]
181    pub use lash_lashlang_runtime::{InMemoryLashlangArtifactStore, LashlangArtifactStore};
182}
183
184pub mod plugins {
185    pub use lash_core::PluginDirective;
186    pub use lash_core::PluginOptions;
187    pub use lash_core::plugin::{
188        AfterToolCallHook, AfterTurnHook, AssistantResponseHook, AssistantResponseHookContext,
189        AssistantResponseTransform, AssistantStreamHook, AssistantStreamHookContext,
190        AssistantStreamTransform, BeforeToolCallHook, BeforeTurnHook, CheckpointHook,
191        CheckpointHookContext, CompactionContext, ContextCompaction, ContextCompactor,
192        ContextError, PluginExtensionContribution, PluginSpecBuilder, StaticPluginFactory,
193        ToolCallHookContext, ToolResultHookContext,
194    };
195    pub use lash_core::{
196        PluginError, PluginFactory, PluginHost, PluginMessage, PluginRegistrar, PluginRuntimeEvent,
197        PluginSession, PluginSessionContext, PluginSpec, PluginSpecFactory, PromptHookContext,
198        SessionPlugin, ToolCatalogContribution, TurnHookContext, TurnResultHookContext,
199    };
200    pub use lash_plugin_tool_output_budget::{
201        ToolOutputBudgetConfig, ToolOutputBudgetMode, ToolOutputBudgetPluginFactory,
202        tool_output_budget_stack as runtime_plugin_stack,
203    };
204}
205
206pub mod messages {
207    pub use lash_core::{Message, MessageRole};
208}
209
210/// Wire-format DTOs for driving lash across a process boundary, sub-namespaced
211/// by protocol domain. Only the cross-cutting handshake
212/// ([`REMOTE_PROTOCOL_VERSION`](remote::REMOTE_PROTOCOL_VERSION),
213/// [`ensure_protocol_version`](remote::ensure_protocol_version)) and the
214/// protocol error type live at this root; everything else has exactly one
215/// home in a domain sub-namespace.
216pub mod remote {
217    pub use lash_remote_protocol::{
218        REMOTE_PROTOCOL_VERSION, RemoteProtocolError, ensure_protocol_version,
219    };
220
221    /// LLM request/response envelopes: messages, attachments, tool specs,
222    /// output specs, and provider metadata.
223    pub mod llm {
224        pub use lash_remote_protocol::llm::{
225            RemoteAttachmentRef, RemoteDiagnostic, RemoteGenerationOptions, RemoteLlmAttachment,
226            RemoteLlmContentBlock, RemoteLlmMessage, RemoteLlmOutputPart, RemoteLlmOutputSpec,
227            RemoteLlmRequest, RemoteLlmRequestScope, RemoteLlmResponse, RemoteLlmRole,
228            RemoteLlmTerminalReason, RemoteLlmToolChoice, RemoteLlmToolSpec, RemoteModelIntent,
229            RemoteProviderFailureKind, RemoteProviderMetadata, RemoteProviderReasoningReplay,
230            RemoteProviderReplayMeta, RemoteResponseTextMeta, RemoteSchemaProjectionOverride,
231        };
232    }
233
234    /// Session observation: cursors, resumable observation events, and live
235    /// replay gaps.
236    pub mod observations {
237        pub use lash_remote_protocol::observations::{
238            RemoteLiveReplayGap, RemoteLiveReplayGapReason, RemoteSessionCursor,
239            RemoteSessionObservation, RemoteSessionObservationEvent,
240            RemoteSessionObservationEventPayload, RemoteSessionProcessEventKind,
241            RemoteSessionQueueEventKind,
242        };
243    }
244
245    /// Process lifecycle envelopes: start/cancel/signal/await/list requests
246    /// and results, process records, event semantics, and execution
247    /// environments.
248    pub mod processes {
249        pub use lash_remote_protocol::processes::{
250            RemoteAbandonEvidence, RemoteAbandonRequest, RemoteAbandonWriter,
251            RemoteObservedProcess, RemoteObservedProcessEvent, RemotePersistProcessEnvRequest,
252            RemotePersistProcessEnvResult, RemoteProcessAwaitOutput, RemoteProcessAwaitRequest,
253            RemoteProcessAwaitResult, RemoteProcessCancelRequest, RemoteProcessCancelResult,
254            RemoteProcessDefinitionIdentity, RemoteProcessEvent, RemoteProcessEventSemantics,
255            RemoteProcessEventSemanticsSpec, RemoteProcessEventType, RemoteProcessEventsRequest,
256            RemoteProcessEventsResponse, RemoteProcessExecutionEnvRef,
257            RemoteProcessExecutionEnvSpec, RemoteProcessExecutionPolicy, RemoteProcessExternalRef,
258            RemoteProcessHandleDescriptor, RemoteProcessInput, RemoteProcessLifecycleStatus,
259            RemoteProcessListFilter, RemoteProcessListResponse, RemoteProcessModelLimits,
260            RemoteProcessModelSpec, RemoteProcessOriginator, RemoteProcessPluginOptions,
261            RemoteProcessProvenance, RemoteProcessSignalRequest, RemoteProcessSignalResult,
262            RemoteProcessStartGrant, RemoteProcessStartRequest, RemoteProcessStartResult,
263            RemoteProcessStarted, RemoteProcessStatus, RemoteProcessStatusFilter,
264            RemoteProcessSummary, RemoteProcessTerminalSemantics, RemoteProcessTerminalSpec,
265            RemoteProcessTerminalState, RemoteProcessValueSelector, RemoteProcessWaitKind,
266            RemoteProcessWaitState, RemoteProcessWake, RemoteProcessWakeDedupeKey,
267            RemoteProcessWakeSpec, RemoteProcessWorkItem, RemoteProcessWorkSnapshot,
268            RemoteRecoveryDisposition, RemoteRuntimeEffectKind, RemoteRuntimeInvocation,
269            RemoteRuntimeReplay, RemoteRuntimeScope, RemoteRuntimeSubject, RemoteSessionScope,
270            RemoteToolFailureClass,
271        };
272    }
273
274    /// Prompt-layer envelopes: templates, slots, and contributions.
275    pub mod prompt {
276        pub use lash_remote_protocol::prompt::{
277            RemotePromptBuiltin, RemotePromptContribution, RemotePromptContributionGate,
278            RemotePromptLayer, RemotePromptSlot, RemotePromptSlotLayer, RemotePromptTemplate,
279            RemotePromptTemplateEntry, RemotePromptTemplateSection,
280        };
281    }
282
283    /// Tool grants and the remote tool-registry contract.
284    pub mod tools {
285        pub use lash_remote_protocol::registry_errors::{
286            RemoteToolRegistry, assert_remote_tool_registry_reopenable,
287        };
288        pub use lash_remote_protocol::tools::{
289            RemoteToolActivation, RemoteToolArgumentProjectionPolicy, RemoteToolGrant,
290            RemoteToolOutputContract, RemoteToolRetryPolicy, RemoteToolScheduling,
291        };
292    }
293
294    /// Trigger envelopes: occurrence emission, subscriptions, and
295    /// registrations.
296    pub mod triggers {
297        pub use lash_remote_protocol::triggers::{
298            RemoteTriggerCancelSubscriptionRequest, RemoteTriggerCancelSubscriptionResult,
299            RemoteTriggerDeliveryEmitOutcome, RemoteTriggerDeliveryEmitReport,
300            RemoteTriggerEmitReport, RemoteTriggerInputBinding, RemoteTriggerInputTemplate,
301            RemoteTriggerListSubscriptionsResponse, RemoteTriggerOccurrenceRecord,
302            RemoteTriggerOccurrenceRequest, RemoteTriggerRegisterSubscriptionRequest,
303            RemoteTriggerRegisterSubscriptionResult, RemoteTriggerRegistration,
304            RemoteTriggerSubscriptionDraft, RemoteTriggerSubscriptionFilter,
305            RemoteTriggerSubscriptionRecord, RemoteTriggerTargetSummary,
306        };
307    }
308
309    /// Turn input envelopes: items, per-turn protocol options, and the turn
310    /// request.
311    pub mod turn_input {
312        pub use lash_remote_protocol::turn_input::{
313            RemoteInputItem, RemoteProtocolTurnOptions, RemoteTurnInput, RemoteTurnRequest,
314        };
315    }
316
317    /// Turn result envelopes: outcomes, stops, assistant output, summaries,
318    /// issues, and causal references.
319    pub mod turn_result {
320        pub use lash_remote_protocol::turn_result::{
321            RemoteAssistantOutput, RemoteAssistantOutputState, RemoteCausalRef,
322            RemoteExecutionSummary, RemoteToolCallOutcome, RemoteToolCallSummary, RemoteTurnFinish,
323            RemoteTurnIssue, RemoteTurnOutcome, RemoteTurnResult, RemoteTurnStatus, RemoteTurnStop,
324            RemoteTurnUsageSummary,
325        };
326    }
327
328    /// Token usage accounting and the streaming turn-activity vocabulary.
329    pub mod usage {
330        pub use lash_remote_protocol::usage_activity::{
331            RemoteTokenLedgerEntry, RemoteTurnActivity, RemoteTurnEvent, RemoteUsage,
332        };
333    }
334}
335
336pub mod process {
337    pub use crate::admin::SessionProcessAdmin;
338    pub use crate::process_admin::Processes;
339    pub use lash_core::{
340        AbandonEvidence, AbandonRequest, AbandonWriter, ObservedProcess, ObservedProcessEvent,
341        ObservedWorkItem, ProcessAttach, ProcessAwaitOutput, ProcessAwaiter, ProcessCancelAbility,
342        ProcessCancelAllRequest, ProcessCancelRequest, ProcessCancelSource, ProcessCancelSummary,
343        ProcessChangeCursor, ProcessChangeHub, ProcessCompletionAuthority, ProcessEvent,
344        ProcessEventAppendRequest, ProcessEventAppendResult, ProcessEventSink, ProcessEventType,
345        ProcessExecutionContext, ProcessExecutionEnvRef, ProcessExecutionEnvSpec,
346        ProcessExternalRef, ProcessHandleDescriptor, ProcessHandleGrant, ProcessHandleSummary,
347        ProcessIdentity, ProcessInput, ProcessLease, ProcessLeaseClaimOutcome,
348        ProcessLeaseCompletion, ProcessLifecycleStatus, ProcessListFilter, ProcessListMode,
349        ProcessLiveReferenceSummary, ProcessOpScope, ProcessProvenance, ProcessPruneReport,
350        ProcessRecord, ProcessRegistration, ProcessRegistry, ProcessRunHandle, ProcessRuntimeHost,
351        ProcessService, ProcessSessionDeleteReport, ProcessStartOptions, ProcessStartRequest,
352        ProcessStarted, ProcessStatus, ProcessStatusFilter, ProcessTerminalState, ProcessWake,
353        ProcessWakeDedupeKey, ProcessWakeDelivery, ProcessWakeSpec, ProcessWorkDriver,
354        ProcessWorkObserver, ProcessWorkSnapshot, RecoveryDisposition, SessionScope,
355        SessionScopeId, ToolSessionProcessAdmin, watch_process_registry,
356        watch_process_registry_with_sink,
357    };
358    #[cfg(feature = "rlm")]
359    pub use lash_lashlang_runtime::{
360        LASHLANG_ENGINE_KIND, LashlangProcessInput, lashlang_process_event_types,
361        lashlang_process_signal_event_types,
362    };
363}
364
365pub mod durability {
366    pub use lash_core::{
367        DurableProcessWorker, DurableProcessWorkerConfig, EffectHost, InlineEffectHost,
368        LeaseTimings, LeaseTimingsError, ProcessDrainReport, Residency, RuntimeEnvironment,
369        RuntimeHostConfig, TerminationPolicy,
370    };
371}
372
373pub mod runtime {
374    pub use crate::core::AdvancedLashCoreBuilder;
375    pub use lash_core::runtime::{
376        AssembledTurn, AwaitEventResolver, DirectCompletionClient, EmbeddedRuntimeHost, EventSink,
377        ExecutionScope, InlineRuntimeEffectController, LashRuntime, LlmAttachmentSpec,
378        LlmRequestSpec, NoopEventSink, NoopTurnActivitySink, ProcessCommand, ProcessEffectOutcome,
379        QueuedWorkDriver, QueuedWorkRunHandle, QueuedWorkRunRequest, RuntimeEffectCommand,
380        RuntimeEffectController, RuntimeEffectControllerError, RuntimeEffectEnvelope,
381        RuntimeEffectKind, RuntimeEffectLocalExecutor, RuntimeEffectOutcome,
382        RuntimeEnvironmentBuilder, RuntimeError, RuntimeErrorCode, RuntimeHandle,
383        RuntimeInvocation, RuntimeObservation, RuntimeScope, RuntimeTurnPhase,
384        RuntimeTurnPhaseProbe, ScopedEffectController, TurnContext,
385    };
386    pub use lash_core::{
387        PersistentRuntimeServices, ProtocolSessionExtensionHandle, ProtocolTurnOptions,
388        SessionHandle, SessionPolicy, SessionSnapshot, render_turn_causes_prompt,
389    };
390}
391
392pub mod prompt {
393    pub use lash_core::{
394        PromptBuiltin, PromptContribution, PromptContributionGate, PromptLayer, PromptSlot,
395        PromptTemplate, PromptTemplateEntry, PromptTemplateSection, default_prompt_template,
396    };
397}
398
399pub mod tracing {
400    pub use lash_core::{
401        JsonlTraceSink, TraceAttachment, TraceBranchSelection, TraceContentBlock, TraceError,
402        TraceEvent, TraceLabelMetadata, TraceLlmMessage, TraceLlmRequest, TraceLlmResponse,
403        TracePromptComponent, TraceProviderStreamEvent, TraceRecord, TraceRuntimeScope,
404        TraceRuntimeStreamEvent, TraceRuntimeSubject, TraceSinkError, TraceTokenUsage,
405        TraceToolSpec,
406    };
407    #[cfg(feature = "otel-trace")]
408    pub use lash_core::{OtelTraceOptions, OtelTraceSink};
409    #[cfg(feature = "rlm")]
410    pub use lash_lashlang_runtime::{
411        TraceLashlangChildExecution, TraceLashlangEdgeSelection, TraceLashlangExecutionEvent,
412        TraceLashlangExecutionIdentity, TraceLashlangGraph, TraceLashlangGraphChildLink,
413        TraceLashlangGraphEdge, TraceLashlangGraphNode, TraceLashlangGraphStore, TraceLashlangMap,
414        TraceLashlangMapEdge, TraceLashlangMapNode, TraceLashlangNodeStatus, TraceLashlangStatus,
415    };
416    pub use lash_trace::{StderrTraceSink, TeeTraceSink, TraceContext, TraceLevel, TraceSink};
417}
418
419/// Test helpers for embedders. Enable with `lash = { ..., features = ["testing"] }`
420/// to script model responses in integration tests without a live provider.
421#[cfg(any(test, feature = "testing"))]
422pub mod testing;
423
424pub mod provider {
425    /// Typed provider-failure classification surfaced on
426    /// [`TurnIssue`](crate::turn::TurnIssue) and session error envelopes.
427    pub use lash_core::ProviderFailureKind;
428    pub use lash_core::provider::{
429        ProviderRateLimitPolicy, ProviderReliability, ProviderRetryPolicy,
430    };
431    /// Request/response/error vocabulary of [`Provider::complete`],
432    /// re-exported so hosts can implement provider decorators (admission
433    /// gates, metrics taps) against the facade alone.
434    pub use lash_core::{LlmRequest, LlmRequestScope, LlmResponse, LlmTransportError};
435    pub use lash_core::{
436        LlmTimeouts, ModelCapability, Provider, ProviderComponents, ProviderFactory,
437        ProviderHandle, ProviderOptions, ProviderSpec, ReasoningCapability, ReasoningEncoding,
438        RequestTimeout,
439    };
440}