@clinebot/core 0.0.7 → 0.0.10

package/dist/input/mention-enricher.d.ts

@@ -6,6 +6,7 @@ export interface MentionEnricherOptions extends FastFileIndexOptions {
 }
 export interface MentionEnrichmentResult {
     prompt: string;
+    mentions: string[];
     matchedFiles: string[];
     ignoredMentions: string[];
 }

package/dist/providers/local-provider-service.d.ts

@@ -1,4 +1,4 @@
-import type { providers as LlmsProviders } from "@clinebot/llms";
+import { type LlmsProviders } from "@clinebot/llms";
 import type { RpcAddProviderActionRequest, RpcOAuthProviderId, RpcProviderListItem, RpcProviderModel, RpcSaveProviderSettingsActionRequest } from "@clinebot/shared";
 import type { ProviderSettingsManager } from "../storage/provider-settings-manager";
 export declare function ensureCustomProvidersLoaded(manager: ProviderSettingsManager): Promise<void>;

package/dist/runtime/session-runtime.d.ts

@@ -32,7 +32,7 @@ export interface SessionRuntime {
         sessionId: string;
     }>;
     send(sessionId: string, prompt: string): Promise<AgentResult | undefined>;
-    abort(sessionId: string): Promise<void>;
+    abort(sessionId: string, reason?: unknown): Promise<void>;
     stop(sessionId: string): Promise<void>;
     poll(): Promise<string[]>;
 }

package/dist/session/default-session-manager.d.ts

@@ -1,5 +1,5 @@
 import { Agent, type AgentConfig, type AgentResult, type ToolApprovalRequest, type ToolApprovalResult } from "@clinebot/agents";
-import type { providers as LlmsProviders } from "@clinebot/llms";
+import type { LlmsProviders } from "@clinebot/llms";
 import { type ITelemetryService } from "@clinebot/shared";
 import type { RuntimeBuilder } from "../runtime/session-runtime";
 import { ProviderSettingsManager } from "../storage/provider-settings-manager";
@@ -36,13 +36,12 @@ export declare class DefaultSessionManager implements SessionManager {
     private readonly listeners;
     private readonly sessions;
     private readonly usageBySession;
+    private readonly subAgentStarts;
     constructor(options: DefaultSessionManagerOptions);
-    private resolveStoredProviderSettings;
-    private buildResolvedProviderConfig;
     start(input: StartSessionInput): Promise<StartSessionResult>;
     send(input: SendSessionInput): Promise<AgentResult | undefined>;
     getAccumulatedUsage(sessionId: string): Promise<SessionAccumulatedUsage | undefined>;
-    abort(sessionId: string): Promise<void>;
+    abort(sessionId: string, reason?: unknown): Promise<void>;
     stop(sessionId: string): Promise<void>;
     dispose(reason?: string): Promise<void>;
     get(sessionId: string): Promise<SessionRecord | undefined>;
@@ -52,32 +51,29 @@ export declare class DefaultSessionManager implements SessionManager {
     readMessages(sessionId: string): Promise<LlmsProviders.Message[]>;
     readHooks(sessionId: string, limit?: number): Promise<unknown[]>;
     subscribe(listener: (event: CoreSessionEvent) => void): () => void;
+    updateSessionModel(sessionId: string, modelId: string): Promise<void>;
     private runTurn;
     private executeAgentTurn;
     private prepareTurnInput;
-    private resolveAbsoluteFilePaths;
     private ensureSessionPersisted;
     private finalizeSingleRun;
     private failSession;
     private shutdownSession;
     private updateStatus;
-    private emitStatus;
-    private listRows;
-    private getRow;
+    private onAgentEvent;
     private createSpawnTool;
     private handleTeamEvent;
-    private hasPendingTeamRunWork;
-    private shouldAutoContinueTeamRuns;
-    private notifyTeamRunWaiters;
-    private waitForTeamRunUpdates;
-    private buildTeamRunContinuationPrompt;
+    private runWithAuthRetry;
+    private syncOAuthCredentials;
+    private getSessionOrThrow;
+    private resolveAbsoluteFilePaths;
+    private updateAgentConnection;
+    private emitStatus;
     private emit;
+    private listRows;
+    private getRow;
     private invoke;
     private invokeOptional;
     private invokeOptionalValue;
-    private runWithAuthRetry;
-    private isLikelyAuthError;
-    private syncOAuthCredentials;
-    updateSessionModel(sessionId: string, modelId: string): Promise<void>;
 }
 export {};

package/dist/session/runtime-oauth-token-manager.d.ts

@@ -1,6 +1,6 @@
+import { type ITelemetryService, type OAuthProviderId } from "@clinebot/shared";
 import { ProviderSettingsManager } from "../storage/provider-settings-manager";
-declare const MANAGED_OAUTH_PROVIDERS: readonly ["cline", "oca", "openai-codex"];
-type ManagedOAuthProviderId = (typeof MANAGED_OAUTH_PROVIDERS)[number];
+type ManagedOAuthProviderId = OAuthProviderId;
 export declare class OAuthReauthRequiredError extends Error {
     readonly providerId: ManagedOAuthProviderId;
     constructor(providerId: ManagedOAuthProviderId);
@@ -13,9 +13,11 @@ export type RuntimeOAuthResolution = {
 };
 export declare class RuntimeOAuthTokenManager {
     private readonly providerSettingsManager;
+    private readonly telemetry?;
     private readonly refreshInFlight;
     constructor(options?: {
         providerSettingsManager?: ProviderSettingsManager;
+        telemetry?: ITelemetryService;
     });
     resolveProviderApiKey(input: {
         providerId: string;

package/dist/session/session-agent-events.d.ts

@@ -0,0 +1,15 @@
+import type { AgentEvent } from "@clinebot/agents";
+import type { CoreSessionConfig } from "../types/config";
+import type { CoreSessionEvent } from "../types/events";
+import type { SessionAccumulatedUsage } from "./session-manager";
+import type { ActiveSession } from "./utils/types";
+export declare function extractSkillNameFromToolInput(input: unknown): string | undefined;
+export interface AgentEventContext {
+    sessionId: string;
+    config: CoreSessionConfig;
+    liveSession: ActiveSession | undefined;
+    usageBySession: Map<string, SessionAccumulatedUsage>;
+    persistMessages: (sessionId: string, messages: unknown[], systemPrompt?: string) => void;
+    emit: (event: CoreSessionEvent) => void;
+}
+export declare function handleAgentEvent(ctx: AgentEventContext, event: AgentEvent): void;

package/dist/session/session-config-builder.d.ts

@@ -0,0 +1,13 @@
+import type { LlmsProviders } from "@clinebot/llms";
+import type { ITelemetryService } from "@clinebot/shared";
+import type { ProviderSettingsManager } from "../storage/provider-settings-manager";
+import type { CoreSessionConfig } from "../types/config";
+import { type ProviderSettings } from "../types/provider-settings";
+import type { StartSessionInput } from "./session-manager";
+export declare function resolveWorkspacePath(config: CoreSessionConfig): string;
+export declare function buildEffectiveConfig(input: StartSessionInput, hookPath: string, sessionId: string, defaultTelemetry: ITelemetryService | undefined): Promise<{
+    config: CoreSessionConfig;
+    pluginSandboxShutdown?: () => Promise<void>;
+}>;
+export declare function buildResolvedProviderConfig(config: CoreSessionConfig, providerSettingsManager: ProviderSettingsManager, resolveReasoningFn: (config: CoreSessionConfig, storedReasoning: ProviderSettings["reasoning"]) => ProviderSettings["reasoning"]): LlmsProviders.ProviderConfig;
+export declare function resolveReasoningSettings(config: CoreSessionConfig, storedReasoning: ProviderSettings["reasoning"]): ProviderSettings["reasoning"];

package/dist/session/session-manager.d.ts

@@ -1,5 +1,5 @@
 import type { AgentResult } from "@clinebot/agents";
-import type { providers as LlmsProviders } from "@clinebot/llms";
+import type { LlmsProviders } from "@clinebot/llms";
 import type { SessionSource } from "../types/common";
 import type { CoreSessionConfig } from "../types/config";
 import type { CoreSessionEvent } from "../types/events";
@@ -45,7 +45,7 @@ export interface SessionManager {
     start(input: StartSessionInput): Promise<StartSessionResult>;
     send(input: SendSessionInput): Promise<AgentResult | undefined>;
     getAccumulatedUsage(sessionId: string): Promise<SessionAccumulatedUsage | undefined>;
-    abort(sessionId: string): Promise<void>;
+    abort(sessionId: string, reason?: unknown): Promise<void>;
     stop(sessionId: string): Promise<void>;
     dispose(reason?: string): Promise<void>;
     get(sessionId: string): Promise<SessionRecord | undefined>;

package/dist/session/session-team-coordination.d.ts

@@ -0,0 +1,12 @@
+import type { AgentResult, TeamEvent } from "@clinebot/agents";
+import type { CoreSessionEvent } from "../types/events";
+import type { ActiveSession, TeamRunUpdate } from "./utils/types";
+export declare function trackTeamRunState(session: ActiveSession, event: TeamEvent): void;
+export declare function dispatchTeamEventToBackend(rootSessionId: string, event: TeamEvent, invokeOptional: (method: string, ...args: unknown[]) => Promise<void>): Promise<void>;
+export declare function emitTeamProgress(session: ActiveSession, rootSessionId: string, event: TeamEvent, emit: (event: CoreSessionEvent) => void): void;
+export declare function hasPendingTeamRunWork(session: ActiveSession): boolean;
+export declare function shouldAutoContinueTeamRuns(session: ActiveSession, finishReason: AgentResult["finishReason"]): boolean;
+export declare function notifyTeamRunWaiters(session: ActiveSession): void;
+export declare function waitForTeamRunUpdates(session: ActiveSession): Promise<TeamRunUpdate[]>;
+export declare function buildTeamRunContinuationPrompt(session: ActiveSession, updates: TeamRunUpdate[]): string;
+export declare function formatModePrompt(prompt: string, mode: "act" | "plan" | undefined): string;

package/dist/session/session-telemetry.d.ts

@@ -0,0 +1,9 @@
+import type { ITelemetryService } from "@clinebot/shared";
+import type { enrichPromptWithMentions } from "../input";
+import type { SessionSource } from "../types/common";
+import type { CoreSessionConfig } from "../types/config";
+export declare function emitSessionCreationTelemetry(config: CoreSessionConfig, sessionId: string, source: SessionSource, isRestart: boolean, workspacePath: string): void;
+export declare function captureHookDiscoveryTelemetry(telemetry: ITelemetryService | undefined, options: {
+    workspacePath: string;
+}): void;
+export declare function emitMentionTelemetry(telemetry: ITelemetryService | undefined, enriched: Awaited<ReturnType<typeof enrichPromptWithMentions>>): void;

package/dist/session/unified-session-persistence-service.d.ts

@@ -1,5 +1,5 @@
 import type { HookEventPayload, SubAgentEndContext, SubAgentStartContext } from "@clinebot/agents";
-import type { providers as LlmsProviders } from "@clinebot/llms";
+import type { LlmsProviders } from "@clinebot/llms";
 import type { SessionStatus } from "../types/common";
 import { SessionArtifacts } from "./session-artifacts";
 import { type SessionManifest } from "./session-manifest";
@@ -45,22 +45,18 @@ export declare class UnifiedSessionPersistenceService {
     private readonly adapter;
     private readonly teamTaskSessionsByAgent;
     protected readonly artifacts: SessionArtifacts;
+    private static readonly STALE_REASON;
+    private static readonly STALE_SOURCE;
     constructor(adapter: SessionPersistenceAdapter);
-    private teamTaskQueueKey;
     ensureSessionsDir(): string;
-    private sessionTranscriptPath;
-    private sessionHookPath;
-    private sessionMessagesPath;
-    private sessionManifestPath;
-    private sessionPathFromStore;
+    private writeManifestFile;
+    writeSessionManifest(manifestPath: string, manifest: SessionManifest): void;
+    private readManifestFile;
+    private buildManifestFromRow;
+    private resolveArtifactPath;
+    private teamTaskQueueKey;
     private activeTeamTaskSessionId;
-    private subagentArtifactPaths;
-    private writeSessionManifestFile;
-    private readSessionManifestFile;
-    private applyResolvedTitleToRow;
-    private createRootSessionId;
     createRootSessionWithArtifacts(input: CreateRootSessionWithArtifactsInput): Promise<RootSessionArtifacts>;
-    writeSessionManifest(manifestPath: string, manifest: SessionManifest): void;
     updateSessionStatus(sessionId: string, status: SessionStatus, exitCode?: number | null): Promise<{
         updated: boolean;
         endedAt?: string;
@@ -74,8 +70,7 @@ export declare class UnifiedSessionPersistenceService {
         updated: boolean;
     }>;
     queueSpawnRequest(event: HookEventPayload): Promise<void>;
-    private readRootSession;
-    private claimQueuedSpawnTask;
+    private buildSubsessionRow;
     upsertSubagentSession(input: UpsertSubagentInput): Promise<string | undefined>;
     upsertSubagentSessionFromHook(event: HookEventPayload): Promise<string | undefined>;
     appendSubagentHookAudit(subSessionId: string, event: HookEventPayload): Promise<void>;
@@ -84,13 +79,14 @@ export declare class UnifiedSessionPersistenceService {
     applySubagentStatus(subSessionId: string, event: HookEventPayload): Promise<void>;
     applySubagentStatusBySessionId(subSessionId: string, status: SessionStatus): Promise<void>;
     applyStatusToRunningChildSessions(parentSessionId: string, status: Exclude<SessionStatus, "running">): Promise<void>;
-    private createTeamTaskSubSession;
     onTeamTaskStart(rootSessionId: string, agentId: string, message: string): Promise<void>;
     onTeamTaskEnd(rootSessionId: string, agentId: string, status: SessionStatus, summary?: string, messages?: LlmsProviders.Message[]): Promise<void>;
     handleSubAgentStart(rootSessionId: string, context: SubAgentStartContext): Promise<void>;
     handleSubAgentEnd(rootSessionId: string, context: SubAgentEndContext): Promise<void>;
     private isPidAlive;
+    private reconcileDeadRunningSession;
     listSessions(limit?: number): Promise<SessionRowShape[]>;
+    reconcileDeadSessions(limit?: number): Promise<number>;
     deleteSession(sessionId: string): Promise<{
         deleted: boolean;
     }>;

package/dist/session/utils/helpers.d.ts

@@ -1,5 +1,5 @@
 import type { AgentConfig, AgentEvent, AgentResult } from "@clinebot/agents";
-import type { providers as LlmsProviders } from "@clinebot/llms";
+import type { LlmsProviders } from "@clinebot/llms";
 import type { SessionRecord } from "../../types/sessions";
 import type { SessionRowShape } from "../session-service";
 import type { StoredMessageWithMetadata } from "./types";

package/dist/session/utils/types.d.ts

@@ -1,5 +1,5 @@
 import type { Agent } from "@clinebot/agents";
-import type { providers as LlmsProviders } from "@clinebot/llms";
+import type { LlmsProviders } from "@clinebot/llms";
 import type { BuiltRuntime } from "../../runtime/session-runtime";
 import type { SessionSource } from "../../types/common";
 import type { CoreSessionConfig } from "../../types/config";

package/dist/telemetry/core-events.d.ts

@@ -0,0 +1,122 @@
+import type { ITelemetryService } from "@clinebot/shared";
+export declare const LegacyTelemetryEvents: {
+    readonly USER: {
+        readonly AUTH_STARTED: "user.auth_started";
+        readonly AUTH_SUCCEEDED: "user.auth_succeeded";
+        readonly AUTH_FAILED: "user.auth_failed";
+        readonly AUTH_LOGGED_OUT: "user.auth_logged_out";
+    };
+    readonly TASK: {
+        readonly CREATED: "task.created";
+        readonly RESTARTED: "task.restarted";
+        readonly COMPLETED: "task.completed";
+        readonly CONVERSATION_TURN: "task.conversation_turn";
+        readonly TOKEN_USAGE: "task.tokens";
+        readonly MODE_SWITCH: "task.mode";
+        readonly TOOL_USED: "task.tool_used";
+        readonly SKILL_USED: "task.skill_used";
+        readonly DIFF_EDIT_FAILED: "task.diff_edit_failed";
+        readonly PROVIDER_API_ERROR: "task.provider_api_error";
+        readonly MENTION_USED: "task.mention_used";
+        readonly MENTION_FAILED: "task.mention_failed";
+        readonly MENTION_SEARCH_RESULTS: "task.mention_search_results";
+        readonly SUBAGENT_STARTED: "task.subagent_started";
+        readonly SUBAGENT_COMPLETED: "task.subagent_completed";
+    };
+    readonly HOOKS: {
+        readonly DISCOVERY_COMPLETED: "hooks.discovery_completed";
+    };
+};
+export declare function captureAuthStarted(telemetry: ITelemetryService | undefined, provider?: string): void;
+export declare function captureAuthSucceeded(telemetry: ITelemetryService | undefined, provider?: string): void;
+export declare function captureAuthFailed(telemetry: ITelemetryService | undefined, provider?: string, errorMessage?: string): void;
+export declare function captureAuthLoggedOut(telemetry: ITelemetryService | undefined, provider?: string, reason?: string): void;
+export declare function identifyAccount(telemetry: ITelemetryService | undefined, account: {
+    id?: string;
+    email?: string;
+    provider?: string;
+    organizationId?: string;
+    organizationName?: string;
+    memberId?: string;
+}): void;
+export declare function captureTaskCreated(telemetry: ITelemetryService | undefined, properties: {
+    ulid: string;
+    apiProvider?: string;
+    openAiCompatibleDomain?: string;
+}): void;
+export declare function captureTaskRestarted(telemetry: ITelemetryService | undefined, properties: {
+    ulid: string;
+    apiProvider?: string;
+    openAiCompatibleDomain?: string;
+}): void;
+export declare function captureTaskCompleted(telemetry: ITelemetryService | undefined, properties: {
+    ulid: string;
+    provider?: string;
+    modelId?: string;
+    mode?: string;
+    durationMs?: number;
+}): void;
+export declare function captureConversationTurnEvent(telemetry: ITelemetryService | undefined, properties: {
+    ulid: string;
+    provider?: string;
+    model?: string;
+    source: "user" | "assistant";
+    mode?: string;
+    tokensIn?: number;
+    tokensOut?: number;
+    cacheWriteTokens?: number;
+    cacheReadTokens?: number;
+    totalCost?: number;
+    isNativeToolCall?: boolean;
+}): void;
+export declare function captureTokenUsage(telemetry: ITelemetryService | undefined, properties: {
+    ulid: string;
+    tokensIn: number;
+    tokensOut: number;
+    model: string;
+}): void;
+export declare function captureModeSwitch(telemetry: ITelemetryService | undefined, ulid: string, mode?: string): void;
+export declare function captureToolUsage(telemetry: ITelemetryService | undefined, properties: {
+    ulid: string;
+    tool: string;
+    modelId?: string;
+    provider?: string;
+    autoApproved?: boolean;
+    success: boolean;
+    isNativeToolCall?: boolean;
+}): void;
+export declare function captureSkillUsed(telemetry: ITelemetryService | undefined, properties: {
+    ulid: string;
+    skillName: string;
+    skillSource: "global" | "project";
+    skillsAvailableGlobal: number;
+    skillsAvailableProject: number;
+    provider?: string;
+    modelId?: string;
+}): void;
+export declare function captureDiffEditFailure(telemetry: ITelemetryService | undefined, properties: {
+    ulid: string;
+    modelId?: string;
+    provider?: string;
+    errorType?: string;
+    isNativeToolCall?: boolean;
+}): void;
+export declare function captureProviderApiError(telemetry: ITelemetryService | undefined, properties: {
+    ulid: string;
+    model: string;
+    errorMessage: string;
+    provider?: string;
+    errorStatus?: number;
+    requestId?: string;
+    isNativeToolCall?: boolean;
+}): void;
+export declare function captureMentionUsed(telemetry: ITelemetryService | undefined, mentionType: "file" | "folder" | "url" | "problems" | "terminal" | "git-changes" | "commit", contentLength?: number): void;
+export declare function captureMentionFailed(telemetry: ITelemetryService | undefined, mentionType: "file" | "folder" | "url" | "problems" | "terminal" | "git-changes" | "commit", errorType: "not_found" | "permission_denied" | "network_error" | "parse_error" | "unknown", errorMessage?: string): void;
+export declare function captureMentionSearchResults(telemetry: ITelemetryService | undefined, query: string, resultCount: number, searchType: "file" | "folder" | "all", isEmpty: boolean): void;
+export declare function captureSubagentExecution(telemetry: ITelemetryService | undefined, properties: {
+    ulid: string;
+    durationMs: number;
+    outputLines: number;
+    success: boolean;
+}): void;
+export declare function captureHookDiscovery(telemetry: ITelemetryService | undefined, hookName: string, globalCount: number, workspaceCount: number): void;

package/dist/tools/definitions.d.ts

@@ -70,7 +70,7 @@ export declare function createAskQuestionTool(executor: AskQuestionExecutor, con
  *
  * const tools = createDefaultTools({
  *   executors: {
- *     readFile: async (path) => fs.readFile(path, "utf-8"),
+ *     readFile: async ({ path }) => fs.readFile(path, "utf-8"),
  *     bash: async (cmd, cwd) => {
  *       return new Promise((resolve, reject) => {
  *         exec(cmd, { cwd }, (err, stdout, stderr) => {

package/dist/tools/executors/file-read.d.ts

@@ -34,7 +34,7 @@ export interface FileReadExecutorOptions {
  *   includeLineNumbers: true,
  * })
  *
- * const content = await readFile("/path/to/file.ts", context)
+ * const content = await readFile({ path: "/path/to/file.ts" }, context)
  * ```
  */
 export declare function createFileReadExecutor(options?: FileReadExecutorOptions): FileReadExecutor;

package/dist/tools/index.d.ts

@@ -9,7 +9,7 @@ export { createApplyPatchTool, createAskQuestionTool, createBashTool, createDefa
 export { type ApplyPatchExecutorOptions, type BashExecutorOptions, createApplyPatchExecutor, createBashExecutor, createDefaultExecutors, createEditorExecutor, createFileReadExecutor, createSearchExecutor, createWebFetchExecutor, type DefaultExecutorsOptions, type EditorExecutorOptions, type FileReadExecutorOptions, type SearchExecutorOptions, type WebFetchExecutorOptions, } from "./executors/index.js";
 export { DEFAULT_MODEL_TOOL_ROUTING_RULES, resolveToolRoutingConfig, type ToolRoutingRule, } from "./model-tool-routing.js";
 export { createDefaultToolsWithPreset, createToolPoliciesWithPreset, type ToolPolicyPresetName, type ToolPresetName, ToolPresets, } from "./presets.js";
-export { type ApplyPatchInput, ApplyPatchInputSchema, type AskQuestionInput, AskQuestionInputSchema, type EditFileInput, EditFileInputSchema, type FetchWebContentInput, FetchWebContentInputSchema, type ReadFilesInput, ReadFilesInputSchema, type RunCommandsInput, RunCommandsInputSchema, type SearchCodebaseInput, SearchCodebaseInputSchema, type SkillsInput, SkillsInputSchema, type WebFetchRequest, WebFetchRequestSchema, } from "./schemas.js";
+export { type ApplyPatchInput, ApplyPatchInputSchema, type AskQuestionInput, AskQuestionInputSchema, type EditFileInput, EditFileInputSchema, type FetchWebContentInput, FetchWebContentInputSchema, type ReadFileRequest, ReadFileRequestSchema, type ReadFilesInput, ReadFilesInputSchema, type RunCommandsInput, RunCommandsInputSchema, type SearchCodebaseInput, SearchCodebaseInputSchema, type SkillsInput, SkillsInputSchema, type WebFetchRequest, WebFetchRequestSchema, } from "./schemas.js";
 export type { ApplyPatchExecutor, AskQuestionExecutor, BashExecutor, CreateDefaultToolsOptions, DefaultToolName, DefaultToolsConfig, EditorExecutor, FileReadExecutor, SearchExecutor, SkillsExecutor, SkillsExecutorSkillMetadata, SkillsExecutorWithMetadata, ToolExecutors, ToolOperationResult, WebFetchExecutor, } from "./types.js";
 import type { Tool } from "@clinebot/agents";
 import { type DefaultExecutorsOptions } from "./executors/index.js";

package/dist/tools/presets.d.ts

@@ -113,7 +113,7 @@ export declare function createToolPoliciesWithPreset(presetName: ToolPolicyPrese
  * ```typescript
  * const tools = createDefaultToolsWithPreset("readonly", {
  *   executors: {
- *     readFile: async (path) => fs.readFile(path, "utf-8"),
+ *     readFile: async ({ path }) => fs.readFile(path, "utf-8"),
  *     search: async (query, cwd) => searchFiles(query, cwd),
  *     webFetch: async (url, prompt) => fetchAndAnalyze(url, prompt),
  *   },

package/dist/tools/schemas.d.ts

@@ -5,18 +5,53 @@
  * and are used for both validation and JSON Schema generation.
  */
 import { z } from "zod";
+export declare const ReadFileLineRangeSchema: z.ZodObject<{
+    start_line: z.ZodOptional<z.ZodNumber>;
+    end_line: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const ReadFileRequestSchema: z.ZodObject<{
+    path: z.ZodString;
+    start_line: z.ZodOptional<z.ZodNumber>;
+    end_line: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
 /**
  * Schema for read_files tool input
  */
 export declare const ReadFilesInputSchema: z.ZodObject<{
-    file_paths: z.ZodArray<z.ZodString>;
+    files: z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        start_line: z.ZodOptional<z.ZodNumber>;
+        end_line: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
 }, z.core.$strip>;
 /**
  * Union schema for read_files tool input, allowing either a single string, an array of strings, or the full object schema
  */
 export declare const ReadFilesInputUnionSchema: z.ZodUnion<readonly [z.ZodObject<{
+    files: z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        start_line: z.ZodOptional<z.ZodNumber>;
+        end_line: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+}, z.core.$strip>, z.ZodObject<{
+    path: z.ZodString;
+    start_line: z.ZodOptional<z.ZodNumber>;
+    end_line: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>, z.ZodArray<z.ZodObject<{
+    path: z.ZodString;
+    start_line: z.ZodOptional<z.ZodNumber>;
+    end_line: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>>, z.ZodArray<z.ZodString>, z.ZodString, z.ZodObject<{
+    files: z.ZodObject<{
+        path: z.ZodString;
+        start_line: z.ZodOptional<z.ZodNumber>;
+        end_line: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
     file_paths: z.ZodArray<z.ZodString>;
-}, z.core.$strip>, z.ZodArray<z.ZodString>, z.ZodString]>;
+}, z.core.$strip>, z.ZodObject<{
+    file_paths: z.ZodString;
+}, z.core.$strip>]>;
 /**
  * Schema for search_codebase tool input
  */
@@ -28,7 +63,9 @@ export declare const SearchCodebaseInputSchema: z.ZodObject<{
  */
 export declare const SearchCodebaseUnionInputSchema: z.ZodUnion<readonly [z.ZodObject<{
     queries: z.ZodArray<z.ZodString>;
-}, z.core.$strip>, z.ZodArray<z.ZodString>, z.ZodString]>;
+}, z.core.$strip>, z.ZodArray<z.ZodString>, z.ZodString, z.ZodObject<{
+    queries: z.ZodString;
+}, z.core.$strip>]>;
 /**
  * Schema for run_commands tool input
  */
@@ -40,6 +77,8 @@ export declare const RunCommandsInputSchema: z.ZodObject<{
  */
 export declare const RunCommandsInputUnionSchema: z.ZodUnion<readonly [z.ZodObject<{
     commands: z.ZodArray<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    commands: z.ZodString;
 }, z.core.$strip>, z.ZodArray<z.ZodString>, z.ZodString]>;
 /**
  * Schema for a single web fetch request
@@ -89,6 +128,10 @@ export declare const AskQuestionInputSchema: z.ZodObject<{
     question: z.ZodString;
     options: z.ZodArray<z.ZodString>;
 }, z.core.$strip>;
+/**
+ * Input for a single file read request
+ */
+export type ReadFileRequest = z.infer<typeof ReadFileRequestSchema>;
 /**
  * Input for the read_files tool
  */

package/dist/tools/types.d.ts

@@ -4,7 +4,7 @@
  * Type definitions for executors, configuration, and results.
  */
 import type { ToolContext } from "@clinebot/agents";
-import type { ApplyPatchInput, EditFileInput } from "./schemas";
+import type { ApplyPatchInput, EditFileInput, ReadFileRequest } from "./schemas";
 /**
  * Result from a single tool operation
  */
@@ -23,11 +23,11 @@ export interface ToolOperationResult {
 /**
  * Executor for reading files
  *
- * @param filePath - Absolute path to the file to read
+ * @param request - File path and optional inclusive line range to read
  * @param context - Tool execution context
  * @returns The file content as a string
  */
-export type FileReadExecutor = (filePath: string, context: ToolContext) => Promise<string>;
+export type FileReadExecutor = (request: ReadFileRequest, context: ToolContext) => Promise<string>;
 /**
  * Executor for searching the codebase
  *

package/dist/types/config.d.ts

@@ -1,5 +1,5 @@
 import type { AgentConfig, AgentHooks, ConsecutiveMistakeLimitContext, ConsecutiveMistakeLimitDecision, HookErrorMode, TeamEvent, Tool } from "@clinebot/agents";
-import type { providers as LlmsProviders } from "@clinebot/llms";
+import type { LlmsProviders } from "@clinebot/llms";
 import type { AgentMode, BasicLogger, ITelemetryService, SessionExecutionConfig, SessionPromptConfig, SessionWorkspaceConfig } from "@clinebot/shared";
 import type { ToolRoutingRule } from "../tools/model-tool-routing.js";
 export type CoreAgentMode = AgentMode;

package/dist/types/provider-settings.d.ts

@@ -1,9 +1,9 @@
-import { providers } from "@clinebot/llms";
+import { LlmsProviders } from "@clinebot/llms";
 import { z } from "zod";
-export type ProviderConfig = providers.ProviderConfig;
-export type ProviderSettings = providers.ProviderSettings;
+export type ProviderConfig = LlmsProviders.ProviderConfig;
+export type ProviderSettings = LlmsProviders.ProviderSettings;
 export declare const ProviderSettingsSchema: z.ZodType<ProviderSettings>;
-export declare const toProviderConfig: typeof providers.toProviderConfig;
+export declare const toProviderConfig: typeof LlmsProviders.toProviderConfig;
 export type ProviderTokenSource = "manual" | "oauth" | "migration";
 export interface StoredProviderSettingsEntry {
     settings: ProviderSettings;

package/dist/types.d.ts

@@ -1,4 +1,4 @@
-import type { providers as LlmsProviders } from "@clinebot/llms";
+import type { LlmsProviders } from "@clinebot/llms";
 import type { CoreSessionEvent } from "./types/events";
 export type { AgentConfigWatcher, AgentConfigWatcherEvent, AgentYamlConfig, BuildAgentConfigOverridesOptions, CreateAgentConfigWatcherOptions, CreateInstructionWatcherOptions, CreateRulesConfigDefinitionOptions, CreateSkillsConfigDefinitionOptions, CreateUserInstructionConfigWatcherOptions, CreateWorkflowsConfigDefinitionOptions, LoadAgentPluginFromPathOptions, ParseMarkdownFrontmatterResult, ParseYamlFrontmatterResult, ResolveAgentPluginPathsOptions, RuleConfig, SkillConfig, UnifiedConfigDefinition, UnifiedConfigFileCandidate, UnifiedConfigFileContext, UnifiedConfigRecord, UnifiedConfigWatcherEvent, UnifiedConfigWatcherOptions, UserInstructionConfig, UserInstructionConfigType, UserInstructionConfigWatcher, UserInstructionConfigWatcherEvent, WorkflowConfig, } from "./agents";
 export { createAgentConfigDefinition, createAgentConfigWatcher, createRulesConfigDefinition, createSkillsConfigDefinition, createUserInstructionConfigWatcher, createWorkflowsConfigDefinition, discoverPluginModulePaths, loadAgentPluginFromPath, loadAgentPluginsFromPaths, parseAgentConfigFromYaml, parsePartialAgentConfigFromYaml, parseRuleConfigFromMarkdown, parseSkillConfigFromMarkdown, parseWorkflowConfigFromMarkdown, RULES_CONFIG_DIRECTORY_NAME, resolveAgentPluginPaths, resolveAgentTools, resolveAndLoadAgentPlugins, resolveDocumentsRulesDirectoryPath, resolveDocumentsWorkflowsDirectoryPath, resolvePluginConfigSearchPaths, resolveRulesConfigSearchPaths, resolveSkillsConfigSearchPaths, resolveWorkflowsConfigSearchPaths, SKILLS_CONFIG_DIRECTORY_NAME, toPartialAgentConfig, UnifiedConfigFileWatcher, WORKFLOWS_CONFIG_DIRECTORY_NAME, } from "./agents";

package/package.json

@@ -1,10 +1,11 @@
 {
 	"name": "@clinebot/core",
-	"version": "0.0.7",
+	"version": "0.0.10",
 	"main": "./dist/index.node.js",
 	"dependencies": {
-		"@clinebot/agents": "0.0.7",
-		"@clinebot/llms": "0.0.7",
+		"@clinebot/agents": "0.0.10",
+		"@clinebot/llms": "0.0.10",
+		"@clinebot/shared": "0.0.10",
 		"@opentelemetry/api": "^1.9.0",
 		"@opentelemetry/api-logs": "^0.56.0",
 		"@opentelemetry/exporter-logs-otlp-http": "^0.56.0",