@schlenkr/ragents 0.1.6 → 0.1.8

package/packages/agent/dist/core/defaults.d.ts

@@ -1,3 +0,0 @@
-import type { ThinkingLevel } from "../loop/index.ts";
-export declare const DEFAULT_THINKING_LEVEL: ThinkingLevel;
-//# sourceMappingURL=defaults.d.ts.map

package/packages/agent/dist/core/extensions/index.d.ts

@@ -1,11 +0,0 @@
-/**
- * Extension system for agent hooks and custom tools.
- */
-export type { SourceInfo } from "../source-info.ts";
-export { createExtensionRuntime, loadExtensionFromFactory } from "./loader.ts";
-export type { ExtensionContextSource, ExtensionErrorListener } from "./runner.ts";
-export { ExtensionRunner, STALE_EXTENSION_MESSAGE } from "./runner.ts";
-export type { AgentToolResult, AgentToolUpdateCallback, BeforeAgentStartEvent, BeforeAgentStartEventResult, BuildSystemPromptOptions, ContextEvent, ContextEventResult, Extension, ExtensionActions, ExtensionAPI, ExtensionContext, ExtensionError, ExtensionEvent, ExtensionFactory, ExtensionFactoryContext, ExtensionFactorySettlementObserver, ExtensionHandler, ExtensionRuntime, InlineExtension, LoadExtensionsResult, RegisteredTool, ToolDefinition, ToolExecutionMode, ToolInfo, ToolResultEvent, ToolResultEventResult, } from "./types.ts";
-export { defineTool } from "./types.ts";
-export { wrapRegisteredTools } from "./wrapper.ts";
-//# sourceMappingURL=index.d.ts.map

package/packages/agent/dist/core/extensions/loader.d.ts

@@ -1,12 +0,0 @@
-/**
- * Extension loader - creates extensions from inline factories.
- */
-import type { Extension, ExtensionFactory, ExtensionFactorySettlementObserver, ExtensionRuntime } from "./types.ts";
-/**
- * Create a runtime with throwing stubs for action methods.
- * Runner.bindCore() replaces these with real implementations.
- */
-export declare function createExtensionRuntime(): ExtensionRuntime;
-/** Create an Extension from an inline factory function. */
-export declare function loadExtensionFromFactory(factory: ExtensionFactory, runtime: ExtensionRuntime, extensionPath: string, signal?: AbortSignal, onFactorySettlement?: ExtensionFactorySettlementObserver): Promise<Extension>;
-//# sourceMappingURL=loader.d.ts.map

package/packages/agent/dist/core/extensions/runner.d.ts

@@ -1,39 +0,0 @@
-/**
- * Extension runner - executes extension handlers against one agent session.
- */
-import type { AgentMessage } from "../../loop/index.ts";
-import type { Model, UserAttachment } from "@ragents/ai";
-import type { SessionManager } from "../session-manager.ts";
-import type { BuildSystemPromptOptions } from "../system-prompt.ts";
-import type { Extension, ExtensionActions, ExtensionContext, ExtensionError, ExtensionRuntime, RegisteredTool, ToolResultEvent, ToolResultEventResult } from "./types.ts";
-export type ExtensionErrorListener = (error: ExtensionError) => void;
-/** What the runner reads from its session when it builds a handler context. */
-export interface ExtensionContextSource {
-    getModel: () => Model<any> | undefined;
-    getSignal: () => AbortSignal | undefined;
-}
-export declare const STALE_EXTENSION_MESSAGE = "This extension is stale: its agent session was disposed.";
-export declare class ExtensionRunner {
-    private readonly extensions;
-    private readonly runtime;
-    private readonly sessionManager;
-    private readonly errorListeners;
-    private contextSource;
-    private staleMessage;
-    constructor(extensions: Extension[], runtime: ExtensionRuntime, sessionManager: SessionManager);
-    bindCore(actions: ExtensionActions, contextSource: ExtensionContextSource): void;
-    /** Get all registered tools from all extensions (first registration per name wins). */
-    getAllRegisteredTools(): RegisteredTool[];
-    invalidate(message?: string): void;
-    private assertActive;
-    onError(listener: ExtensionErrorListener): () => void;
-    private emitError;
-    hasHandlers(eventType: string): boolean;
-    /** Context values are resolved at call time, so a disposed session is detected on every access. */
-    createContext(): ExtensionContext;
-    emitToolResult(event: ToolResultEvent): Promise<ToolResultEventResult | undefined>;
-    emitContext(messages: AgentMessage[]): Promise<AgentMessage[]>;
-    /** Chains the system prompt through all before_agent_start handlers; undefined when none changed it. */
-    emitBeforeAgentStart(prompt: string, systemPrompt: string, systemPromptOptions: BuildSystemPromptOptions, attachments?: UserAttachment[]): Promise<string | undefined>;
-}
-//# sourceMappingURL=runner.d.ts.map

package/packages/agent/dist/core/extensions/types.d.ts

@@ -1,156 +0,0 @@
-/** Extensions are inline factories: they adjust the system prompt, the messages of a model call and tool results, and register tools. */
-import type { AgentMessage, AgentToolResult, AgentToolUpdateCallback, ToolExecutionMode } from "../../loop/index.ts";
-import type { ImageContent, Model, TextContent, UserAttachment } from "@ragents/ai";
-import type { Static, TSchema } from "typebox";
-import type { ReadonlySessionManager } from "../session-manager.ts";
-import type { SourceInfo } from "../source-info.ts";
-import type { BuildSystemPromptOptions } from "../system-prompt.ts";
-export type { BuildSystemPromptOptions } from "../system-prompt.ts";
-export type { AgentToolResult, AgentToolUpdateCallback, ToolExecutionMode };
-/** Context passed to extension event handlers and tools. */
-export interface ExtensionContext {
-    /** Session manager (read-only) */
-    sessionManager: ReadonlySessionManager;
-    /** Current model (may be undefined) */
-    model: Model<any> | undefined;
-    /** The current abort signal, or undefined when the agent is not streaming. */
-    signal: AbortSignal | undefined;
-}
-/** Tool definition for registerTool(). */
-export interface ToolDefinition<TParams extends TSchema = TSchema, TDetails = unknown, TState = any> {
-    /** Tool name (used in LLM tool calls) */
-    name: string;
-    /** Human-readable label */
-    label: string;
-    /** Description for LLM */
-    description: string;
-    /** Optional one-line snippet for the Available tools section in the default system prompt. */
-    promptSnippet?: string;
-    /** Optional guideline bullets appended to the default system prompt Guidelines section when this tool is active. */
-    promptGuidelines?: string[];
-    /** Parameter schema (TypeBox) */
-    parameters: TParams;
-    /** Optional compatibility shim to prepare raw tool call arguments before schema validation. */
-    prepareArguments?: (args: unknown) => Static<TParams>;
-    /** Per-tool execution mode override; if omitted, the default execution mode applies. */
-    executionMode?: ToolExecutionMode;
-    /** Execute the tool. */
-    execute(toolCallId: string, params: Static<TParams>, signal: AbortSignal | undefined, onUpdate: AgentToolUpdateCallback<TDetails> | undefined, ctx: ExtensionContext): Promise<AgentToolResult<TDetails>>;
-}
-type AnyToolDefinition = ToolDefinition<any, any, any>;
-/** Preserve parameter inference for standalone tool definitions. */
-export declare function defineTool<TParams extends TSchema, TDetails = unknown, TState = any>(tool: ToolDefinition<TParams, TDetails, TState>): ToolDefinition<TParams, TDetails, TState> & AnyToolDefinition;
-/** Fired before each LLM call. Can modify messages. */
-export interface ContextEvent {
-    type: "context";
-    messages: AgentMessage[];
-}
-/** Fired after the user submits a prompt but before the agent loop. */
-export interface BeforeAgentStartEvent {
-    type: "before_agent_start";
-    /** The raw user prompt text. */
-    prompt: string;
-    attachments?: UserAttachment[];
-    /** The fully assembled system prompt string. */
-    systemPrompt: string;
-    /** Structured options used to build the system prompt. */
-    systemPromptOptions: BuildSystemPromptOptions;
-}
-/** Fired after a tool executes. Can modify the result. */
-export interface ToolResultEvent {
-    type: "tool_result";
-    toolCallId: string;
-    toolName: string;
-    input: Record<string, unknown>;
-    content: (TextContent | ImageContent)[];
-    details: unknown;
-    isError: boolean;
-}
-export type ExtensionEvent = ContextEvent | BeforeAgentStartEvent | ToolResultEvent;
-export interface ContextEventResult {
-    messages?: AgentMessage[];
-}
-export interface ToolResultEventResult {
-    content?: (TextContent | ImageContent)[];
-    details?: unknown;
-    isError?: boolean;
-}
-export interface BeforeAgentStartEventResult {
-    /** Replace the system prompt for this turn. If multiple extensions return this, they are chained. */
-    systemPrompt?: string;
-}
-/** Handler function type for events */
-export type ExtensionHandler<E, R = undefined> = (event: E, ctx: ExtensionContext) => Promise<R | void> | R | void;
-/** ExtensionAPI passed to extension factory functions. */
-export interface ExtensionAPI {
-    on(event: "before_agent_start", handler: ExtensionHandler<BeforeAgentStartEvent, BeforeAgentStartEventResult>): void;
-    on(event: "context", handler: ExtensionHandler<ContextEvent, ContextEventResult>): void;
-    on(event: "tool_result", handler: ExtensionHandler<ToolResultEvent, ToolResultEventResult>): void;
-    /** Register a tool that the LLM can call. */
-    registerTool<TParams extends TSchema = TSchema, TDetails = unknown, TState = any>(tool: ToolDefinition<TParams, TDetails, TState>): void;
-    /** Append a custom entry to the session for state persistence (not sent to LLM). */
-    appendEntry<T = unknown>(customType: string, data?: T): void;
-    /** Get all configured tools with parameter schema, prompt guidelines, and source metadata. */
-    getAllTools(): ToolInfo[];
-    /** Set the active tools by name. */
-    setActiveTools(toolNames: string[]): void;
-}
-export interface ExtensionFactoryContext {
-    readonly signal: AbortSignal;
-}
-/** Extension factory function type. Supports both sync and async initialization. */
-export type ExtensionFactory = (agent: ExtensionAPI, context: ExtensionFactoryContext) => void | Promise<void>;
-/** Observes the actual lifetime of an async extension factory, independently of an aborted loader wait. */
-export type ExtensionFactorySettlementObserver = (settlement: Promise<void>) => void;
-export type InlineExtension = ExtensionFactory | {
-    /** Display name shown as `<inline:name>`. */
-    name: string;
-    factory: ExtensionFactory;
-};
-export interface RegisteredTool {
-    definition: ToolDefinition;
-    sourceInfo: SourceInfo;
-}
-type HandlerFn = (...args: unknown[]) => Promise<unknown>;
-/** Tool info with name, description, parameter schema, prompt guidelines, and source metadata. */
-export type ToolInfo = Pick<ToolDefinition, "name" | "description" | "parameters" | "promptGuidelines"> & {
-    sourceInfo: SourceInfo;
-};
-/** Action implementations behind the ExtensionAPI, provided by the session. */
-export interface ExtensionActions {
-    appendEntry: <T = unknown>(customType: string, data?: T) => void;
-    getAllTools: () => ToolInfo[];
-    setActiveTools: (toolNames: string[]) => void;
-    refreshTools: () => void;
-}
-/** Shared state created by the loader; actions are throwing stubs until the runner binds the session. */
-export interface ExtensionRuntime extends ExtensionActions {
-    /** Throws when this extension instance is stale. */
-    assertActive: () => void;
-    /** Marks this extension instance as stale. */
-    invalidate: (message?: string) => void;
-}
-/** Loaded extension with all registered items. */
-export interface Extension {
-    path: string;
-    sourceInfo: SourceInfo;
-    handlers: Map<string, HandlerFn[]>;
-    tools: Map<string, RegisteredTool>;
-}
-/** Result of loading extensions. */
-export interface LoadExtensionsResult {
-    extensions: Extension[];
-    errors: Array<{
-        path: string;
-        error: string;
-    }>;
-    /** Shared runtime - actions are throwing stubs until the runner binds the session */
-    runtime: ExtensionRuntime;
-}
-export interface ExtensionError {
-    extensionPath: string;
-    event: string;
-    error: string;
-    stack?: string;
-}
-//# sourceMappingURL=types.d.ts.map

package/packages/agent/dist/core/extensions/wrapper.d.ts

@@ -1,12 +0,0 @@
-/**
- * Tool wrappers for extension-registered tools.
- *
- * These wrappers only adapt tool execution so extension tools receive the runner context.
- * Tool result interception is handled by AgentSession via the hooks of the agent loop.
- */
-import type { AgentTool } from "../../loop/index.ts";
-import type { ExtensionRunner } from "./runner.ts";
-import type { RegisteredTool } from "./types.ts";
-/** Wrap registered tools into AgentTools that receive the runner context on every call. */
-export declare function wrapRegisteredTools(registeredTools: RegisteredTool[], runner: ExtensionRunner): AgentTool[];
-//# sourceMappingURL=wrapper.d.ts.map

package/packages/agent/dist/core/resource-loader.d.ts

@@ -1,39 +0,0 @@
-import type { ExtensionFactorySettlementObserver, InlineExtension, LoadExtensionsResult } from "./extensions/types.ts";
-import type { Skill } from "./skills.ts";
-export interface ResourceLoaderReloadOptions {
-    signal?: AbortSignal;
-}
-export interface ResourceLoader {
-    getExtensions(): LoadExtensionsResult;
-    getSkills(): readonly Skill[];
-    getSystemPrompt(): string | undefined;
-    setSystemPrompt(value: string): void;
-    reload(options?: ResourceLoaderReloadOptions): Promise<void>;
-    waitForSettlement?(): Promise<void> | undefined;
-}
-export interface DefaultResourceLoaderOptions {
-    skills?: readonly Skill[];
-    extensionFactories?: InlineExtension[];
-    systemPrompt?: string;
-    onExtensionFactorySettlement?: ExtensionFactorySettlementObserver;
-}
-/** Extensions come only as inline factories and skills as given by the caller; nothing is discovered or installed. */
-export declare class DefaultResourceLoader implements ResourceLoader {
-    private readonly skills;
-    private readonly extensionFactories;
-    private readonly onExtensionFactorySettlement?;
-    private readonly extensionFactorySettlements;
-    private extensionsResult;
-    private systemPrompt?;
-    constructor(options: DefaultResourceLoaderOptions);
-    getExtensions(): LoadExtensionsResult;
-    waitForSettlement(): Promise<void> | undefined;
-    private readonly trackExtensionFactorySettlement;
-    getSkills(): readonly Skill[];
-    getSystemPrompt(): string | undefined;
-    setSystemPrompt(value: string): void;
-    reload(options?: ResourceLoaderReloadOptions): Promise<void>;
-    private loadExtensionFactories;
-    private detectToolConflicts;
-}
-//# sourceMappingURL=resource-loader.d.ts.map

package/packages/agent/dist/core/sdk.d.ts

@@ -1,38 +0,0 @@
-import { type ThinkingLevel } from "../loop/index.ts";
-import { type Model } from "@ragents/ai";
-import { AgentSession } from "./agent-session.ts";
-import type { LoadExtensionsResult, ToolDefinition } from "./extensions/index.ts";
-import type { ModelRuntime } from "./model-runtime.ts";
-import type { ResourceLoader } from "./resource-loader.ts";
-import type { SessionManager } from "./session-manager.ts";
-import { type AgentSettingsInput } from "./agent-settings.ts";
-export interface CreateAgentSessionOptions {
-    /** Working directory of the session. Default: the working directory of the session manager */
-    cwd?: string;
-    modelRuntime: ModelRuntime;
-    /** The model of the session; a session without one is an error. */
-    model: Model<any>;
-    /** Thinking level. Default: from the session, else settings, else 'medium' (clamped to model capabilities) */
-    thinkingLevel?: ThinkingLevel;
-    /** Optional allowlist of tool names; without it every registered tool is enabled. */
-    tools?: string[];
-    /** Custom tools to register besides the tools of extensions. */
-    customTools?: ToolDefinition[];
-    /** Loaded resources: extensions, skills and the system prompt. */
-    resourceLoader: ResourceLoader;
-    sessionManager: SessionManager;
-    settings?: AgentSettingsInput;
-}
-/** Result from createAgentSession */
-export interface CreateAgentSessionResult {
-    /** The created session */
-    session: AgentSession;
-    /** Extensions of the session, with the errors of their factories */
-    extensionsResult: LoadExtensionsResult;
-}
-export * from "./agent-session-runtime.ts";
-export type { ExtensionAPI, ExtensionContext, ExtensionFactory, InlineExtension, ToolDefinition } from "./extensions/index.ts";
-export type { Skill } from "./skills.ts";
-/** Create an AgentSession for the given model. */
-export declare function createAgentSession(options: CreateAgentSessionOptions): Promise<CreateAgentSessionResult>;
-//# sourceMappingURL=sdk.d.ts.map

package/packages/agent/dist/core/session-manager.d.ts

@@ -1,189 +0,0 @@
-import { type AgentMessage } from "../loop/index.ts";
-import type { Message } from "@ragents/ai";
-import { type CustomMessage } from "./messages.ts";
-export declare const CURRENT_SESSION_VERSION = 3;
-export interface SessionHeader {
-    type: "session";
-    version?: number;
-    id: string;
-    timestamp: string;
-    cwd: string;
-    parentSession?: string;
-}
-export interface NewSessionOptions {
-    id?: string;
-    parentSession?: string;
-}
-export interface SessionEntryBase {
-    type: string;
-    id: string;
-    parentId: string | null;
-    timestamp: string;
-}
-export interface SessionMessageEntry extends SessionEntryBase {
-    type: "message";
-    message: AgentMessage;
-}
-export interface ThinkingLevelChangeEntry extends SessionEntryBase {
-    type: "thinking_level_change";
-    thinkingLevel: string;
-}
-export interface ModelChangeEntry extends SessionEntryBase {
-    type: "model_change";
-    provider: string;
-    modelId: string;
-}
-export interface CompactionEntry<T = unknown> extends SessionEntryBase {
-    type: "compaction";
-    summary: string;
-    firstKeptEntryId: string;
-    tokensBefore: number;
-    /** Extension-specific data (e.g., ArtifactIndex, version markers for structured compaction) */
-    details?: T;
-    /** True if generated by an extension, undefined/false if agent-generated (backward compatible) */
-    fromHook?: boolean;
-}
-/**
- * Custom entry for extensions to store extension-specific data in the session.
- * Use customType to identify your extension's entries.
- *
- * Purpose: Persist extension state across session reloads. On reload, extensions can
- * scan entries for their customType and reconstruct internal state.
- *
- * Does NOT participate in LLM context (ignored by buildSessionContext).
- * For injecting content into context, see CustomMessageEntry.
- */
-export interface CustomEntry<T = unknown> extends SessionEntryBase {
-    type: "custom";
-    customType: string;
-    data?: T;
-}
-/** Session entry - has id/parentId for tree structure (returned by "read" methods in SessionManager) */
-export type SessionEntry = SessionMessageEntry | ThinkingLevelChangeEntry | ModelChangeEntry | CompactionEntry | CustomEntry;
-/** Raw file entry (includes header) */
-export type FileEntry = SessionHeader | SessionEntry;
-export interface SessionContext {
-    messages: AgentMessage[];
-    thinkingLevel: string;
-    model: {
-        provider: string;
-        modelId: string;
-    } | null;
-}
-export type ReadonlySessionManager = Pick<SessionManager, "getBranch">;
-export declare function assertValidSessionId(id: string): void;
-export declare function getLatestCompactionEntry(entries: SessionEntry[]): CompactionEntry | null;
-/**
- * Project one selected session entry into LLM/runtime messages.
- * Plain custom entries are display/state entries and do not participate in context.
- */
-export declare function sessionEntryToContextMessages(entry: SessionEntry): AgentMessage[];
-/**
- * Build the active, compaction-aware session entry list.
- *
- * This follows the current leaf path. If the path contains compaction entries,
- * the latest compaction is represented by the compaction entry itself, followed
- * by the kept entries starting at firstKeptEntryId and all entries after the
- * compaction entry. Older summarized entries are omitted.
- */
-export declare function buildContextEntries(entries: SessionEntry[], leafId?: string | null, byId?: Map<string, SessionEntry>): SessionEntry[];
-/**
- * Build the session context from entries using tree traversal.
- * If leafId is provided, walks from that entry to root.
- * Handles compaction and branch summaries along the path.
- */
-export declare function buildSessionContext(entries: SessionEntry[], leafId?: string | null, byId?: Map<string, SessionEntry>): SessionContext;
-/** Exported for testing */
-export declare function loadEntriesFromFile(filePath: string): FileEntry[];
-/**
- * Manages conversation sessions as append-only trees stored in JSONL files.
- *
- * Each session entry has an id and parentId forming a tree structure. The "leaf"
- * pointer tracks the current position. Appending creates a child of the current leaf.
- * Branching moves the leaf to an earlier entry, allowing new branches without
- * modifying history.
- *
- * Use buildSessionContext() to get the resolved message list for the LLM, which
- * handles compaction summaries and follows the path from root to current leaf.
- */
-export declare class SessionManager {
-    private sessionId;
-    private sessionFile;
-    private sessionDir;
-    private cwd;
-    private persist;
-    private flushed;
-    private fileEntries;
-    private byId;
-    private leafId;
-    private constructor();
-    /** Switch to a different session file (used for resume and branching) */
-    setSessionFile(sessionFile: string): void;
-    newSession(options?: NewSessionOptions): string | undefined;
-    private _buildIndex;
-    private _rewriteFile;
-    isPersisted(): boolean;
-    getCwd(): string;
-    getSessionDir(): string;
-    getSessionId(): string;
-    getSessionFile(): string | undefined;
-    _persist(entry: SessionEntry): void;
-    private _appendEntry;
-    /** Append a message as child of current leaf, then advance leaf. Returns entry id.
-     * Compaction summaries are top-level entries appended via appendCompaction(), not message entries.
-     */
-    appendMessage(message: Message | CustomMessage): string;
-    /** Append a thinking level change as child of current leaf, then advance leaf. Returns entry id. */
-    appendThinkingLevelChange(thinkingLevel: string): string;
-    /** Append a model change as child of current leaf, then advance leaf. Returns entry id. */
-    appendModelChange(provider: string, modelId: string): string;
-    /** Append a compaction summary as child of current leaf, then advance leaf. Returns entry id. */
-    appendCompaction<T = unknown>(summary: string, firstKeptEntryId: string, tokensBefore: number, details?: T, fromHook?: boolean): string;
-    /** Append a custom entry (for extensions) as child of current leaf, then advance leaf. Returns entry id. */
-    appendCustomEntry(customType: string, data?: unknown): string;
-    getLeafId(): string | null;
-    getLeafEntry(): SessionEntry | undefined;
-    getEntry(id: string): SessionEntry | undefined;
-    /**
-     * Walk from entry to root, returning all entries in path order.
-     * Includes all entry types (messages, compaction, model changes, etc.).
-     * Use buildSessionContext() to get the resolved messages for the LLM.
-     */
-    getBranch(fromId?: string): SessionEntry[];
-    /**
-     * Build the active, compaction-aware entry list for context/rendering.
-     * Uses tree traversal from current leaf.
-     */
-    buildContextEntries(): SessionEntry[];
-    /**
-     * Build the session context (what gets sent to the LLM).
-     * Uses tree traversal from current leaf.
-     */
-    buildSessionContext(): SessionContext;
-    /**
-     * Get session header.
-     */
-    getHeader(): SessionHeader | null;
-    /**
-     * Get all session entries (excludes header). Returns a shallow copy.
-     * The session is append-only: use appendXXX() to add entries, branch() to
-     * change the leaf pointer. Entries cannot be modified or deleted.
-     */
-    getEntries(): SessionEntry[];
-    /**
-     * Create a new session.
-     * @param cwd Working directory (stored in session header)
-     * @param sessionDir Session directory
-     */
-    static create(cwd: string, sessionDir: string, options?: NewSessionOptions): SessionManager;
-    /**
-     * Open a specific session file.
-     * @param path Path to session file
-     * @param sessionDir Optional session directory for /new or /branch. If omitted, derives from file's parent.
-     * @param cwdOverride Optional cwd override instead of the session header cwd.
-     */
-    static open(path: string, sessionDir?: string, cwdOverride?: string): SessionManager;
-    /** Create an in-memory session (no file persistence) */
-    static inMemory(cwd?: string, options?: NewSessionOptions): SessionManager;
-}
-//# sourceMappingURL=session-manager.d.ts.map

package/packages/agent/dist/core/source-info.d.ts

@@ -1,16 +0,0 @@
-export type SourceScope = "user" | "project" | "temporary";
-export type SourceOrigin = "package" | "top-level";
-export interface SourceInfo {
-    path: string;
-    source: string;
-    scope: SourceScope;
-    origin: SourceOrigin;
-    baseDir?: string;
-}
-export declare function createSyntheticSourceInfo(path: string, options: {
-    source: string;
-    scope?: SourceScope;
-    origin?: SourceOrigin;
-    baseDir?: string;
-}): SourceInfo;
-//# sourceMappingURL=source-info.d.ts.map

package/packages/agent/dist/core/system-prompt.d.ts

@@ -1,21 +0,0 @@
-/**
- * System prompt construction and project context loading
- */
-import { type Skill } from "./skills.ts";
-export interface BuildSystemPromptOptions {
-    /** Custom system prompt (replaces default). */
-    customPrompt?: string;
-    /** Tools to include in prompt. Default: [read, bash, edit, write] */
-    selectedTools?: string[];
-    /** Optional one-line tool snippets keyed by tool name. */
-    toolSnippets?: Record<string, string>;
-    /** Additional guideline bullets appended to the default system prompt guidelines. */
-    promptGuidelines?: string[];
-    /** Working directory; only the default prompt names it, a custom prompt stays as the caller wrote it. */
-    cwd: string;
-    /** Pre-loaded skills. */
-    skills?: readonly Skill[];
-}
-/** Build the system prompt with tools, guidelines, and context */
-export declare function buildSystemPrompt(options: BuildSystemPromptOptions): string;
-//# sourceMappingURL=system-prompt.d.ts.map

package/packages/agent/src/core/agent-session-runtime.ts

@@ -1,94 +0,0 @@
-import type { AgentSession } from "./agent-session.ts";
-import type { AgentSessionServices } from "./agent-session-services.ts";
-import type { ExtensionFactorySettlementObserver } from "./extensions/index.ts";
-import type { CreateAgentSessionResult } from "./sdk.ts";
-import type { SessionManager } from "./session-manager.ts";
-
-/** Result returned by runtime creation: the created session and its cwd-bound services. */
-export interface CreateAgentSessionRuntimeResult extends CreateAgentSessionResult {
-	services: AgentSessionServices;
-}
-
-/** Creates the services and the AgentSession for a target cwd and session manager. */
-export type CreateAgentSessionRuntimeFactory = (options: {
-	cwd: string;
-	sessionManager: SessionManager;
-	signal: AbortSignal;
-	onExtensionFactorySettlement?: ExtensionFactorySettlementObserver;
-}) => Promise<CreateAgentSessionRuntimeResult>;
-
-function abortReason(signal: AbortSignal): Error {
-	return signal.reason instanceof Error ? signal.reason : new Error("Agent session runtime creation was aborted.");
-}
-
-function awaitWithSignal<T>(operation: Promise<T>, signal: AbortSignal): Promise<T> {
-	if (signal.aborted) {
-		return Promise.reject(abortReason(signal));
-	}
-
-	return new Promise<T>((resolve, reject) => {
-		const abort = () => reject(abortReason(signal));
-		signal.addEventListener("abort", abort, { once: true });
-		operation.then(resolve, reject).finally(() => signal.removeEventListener("abort", abort));
-	});
-}
-
-/** Owns one AgentSession plus its cwd-bound services. */
-export class AgentSessionRuntime {
-	readonly session: AgentSession;
-	readonly services: AgentSessionServices;
-
-	constructor(session: AgentSession, services: AgentSessionServices) {
-		this.session = session;
-		this.services = services;
-	}
-
-	waitForSettlement(): Promise<void> {
-		return this.session.waitForSettlement();
-	}
-
-	async dispose(): Promise<void> {
-		this.session.dispose();
-	}
-}
-
-/** Create the runtime from a runtime factory; an abort during creation disposes the late session. */
-export async function createAgentSessionRuntime(
-	createRuntime: CreateAgentSessionRuntimeFactory,
-	options: {
-		cwd: string;
-		sessionManager: SessionManager;
-		signal?: AbortSignal;
-		onExtensionFactorySettlement?: ExtensionFactorySettlementObserver;
-	},
-): Promise<AgentSessionRuntime> {
-	const signal = options.signal ?? new AbortController().signal;
-	signal.throwIfAborted();
-	const creation = Promise.resolve().then(() => createRuntime({
-		cwd: options.cwd,
-		sessionManager: options.sessionManager,
-		signal,
-		...(options.onExtensionFactorySettlement
-			? { onExtensionFactorySettlement: options.onExtensionFactorySettlement }
-			: {}),
-	}));
-	let result: CreateAgentSessionRuntimeResult;
-
-	try {
-		result = await awaitWithSignal(creation, signal);
-	} catch (error) {
-		if (signal.aborted) {
-			void creation.then((lateResult) => lateResult.session.dispose(), () => undefined);
-		}
-		throw error;
-	}
-	return new AgentSessionRuntime(result.session, result.services);
-}
-
-export {
-	type AgentSessionServices,
-	type CreateAgentSessionFromServicesOptions,
-	type CreateAgentSessionServicesOptions,
-	createAgentSessionFromServices,
-	createAgentSessionServices,
-} from "./agent-session-services.ts";