@clinebot/core 0.0.37 → 0.0.38

package/src/transports/remote.ts

@@ -1,27 +0,0 @@
-import { normalizeHubWebSocketUrl } from "../hub/client";
-import { HubRuntimeHost, type HubRuntimeHostOptions } from "./hub";
-
-export interface RemoteRuntimeHostOptions
-	extends Omit<HubRuntimeHostOptions, "url"> {
-	endpoint: string;
-	workspaceRoot?: string;
-	cwd?: string;
-}
-
-export class RemoteRuntimeHost extends HubRuntimeHost {
-	constructor(options: RemoteRuntimeHostOptions) {
-		super(
-			{
-				url: normalizeHubWebSocketUrl(options.endpoint),
-				authToken: options.authToken,
-				clientType: options.clientType ?? "core-remote-runtime",
-				displayName: options.displayName ?? "core remote runtime",
-				requestToolApproval: options.requestToolApproval,
-			},
-			{
-				workspaceRoot: options.workspaceRoot,
-				cwd: options.cwd,
-			},
-		);
-	}
-}

package/src/transports/runtime-host-support.ts

@@ -1,140 +0,0 @@
-import { existsSync } from "node:fs";
-import { readFile } from "node:fs/promises";
-import type * as LlmsProviders from "@clinebot/llms";
-import { formatDisplayUserInput } from "@clinebot/shared";
-import type { HookEventPayload } from "../hooks";
-import type {
-	RuntimeHostSubscribeOptions,
-	SessionAccumulatedUsage,
-} from "../runtime/runtime-host";
-import type { CoreSessionEvent } from "../types/events";
-
-export class RuntimeHostEventBus {
-	private readonly listeners = new Set<{
-		listener: (event: CoreSessionEvent) => void;
-		sessionId?: string;
-	}>();
-
-	subscribe(
-		listener: (event: CoreSessionEvent) => void,
-		options?: RuntimeHostSubscribeOptions,
-	): () => void {
-		const entry = {
-			listener,
-			sessionId: options?.sessionId?.trim() || undefined,
-		};
-		this.listeners.add(entry);
-		return () => {
-			this.listeners.delete(entry);
-		};
-	}
-
-	emit(event: CoreSessionEvent): void {
-		const sessionId = event.payload.sessionId?.trim();
-		for (const entry of this.listeners) {
-			if (entry.sessionId && entry.sessionId !== sessionId) {
-				continue;
-			}
-			entry.listener(event);
-		}
-	}
-
-	get size(): number {
-		return this.listeners.size;
-	}
-}
-
-export async function readPersistedMessagesFile(
-	messagesPath?: string | null,
-): Promise<LlmsProviders.Message[]> {
-	const path = messagesPath?.trim();
-	if (!path || !existsSync(path)) return [];
-	try {
-		const raw = (await readFile(path, "utf8")).trim();
-		if (!raw) return [];
-		const parsed = JSON.parse(raw) as unknown;
-		if (Array.isArray(parsed)) {
-			return sanitizeDisplayMessages(parsed as LlmsProviders.Message[]);
-		}
-		if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
-			const messages = (parsed as { messages?: unknown }).messages;
-			if (Array.isArray(messages)) {
-				return sanitizeDisplayMessages(messages as LlmsProviders.Message[]);
-			}
-		}
-		return [];
-	} catch {
-		return [];
-	}
-}
-
-function sanitizeDisplayMessage(
-	message: LlmsProviders.Message,
-): LlmsProviders.Message {
-	if (message.role !== "user") {
-		return message;
-	}
-	if (typeof message.content === "string") {
-		return {
-			...message,
-			content: formatDisplayUserInput(message.content),
-		};
-	}
-	return {
-		...message,
-		content: message.content.map((part) => {
-			if (part.type !== "text" || typeof part.text !== "string") {
-				return part;
-			}
-			return {
-				...part,
-				text: formatDisplayUserInput(part.text),
-			};
-		}),
-	};
-}
-
-export function sanitizeDisplayMessages(
-	messages: LlmsProviders.Message[],
-): LlmsProviders.Message[] {
-	return messages.map(sanitizeDisplayMessage);
-}
-
-export function cloneAccumulatedUsage(
-	usage: SessionAccumulatedUsage | undefined,
-): SessionAccumulatedUsage | undefined {
-	return usage ? { ...usage } : undefined;
-}
-
-type HookAuditBackend = {
-	queueSpawnRequest(payload: HookEventPayload): Promise<void>;
-	upsertSubagentSessionFromHook(
-		payload: HookEventPayload,
-	): Promise<string | undefined>;
-	appendSubagentHookAudit(
-		sessionId: string,
-		payload: HookEventPayload,
-	): Promise<void>;
-	applySubagentStatus(
-		sessionId: string,
-		payload: HookEventPayload,
-	): Promise<void>;
-};
-
-export async function replaySubagentHookEvent(
-	payload: HookEventPayload,
-	backend: HookAuditBackend,
-): Promise<void> {
-	const shouldTouchSessions =
-		payload.hookName === "tool_call" || !!payload.parent_agent_id;
-	if (!shouldTouchSessions) {
-		return;
-	}
-	await backend.queueSpawnRequest(payload);
-	const subSessionId = await backend.upsertSubagentSessionFromHook(payload);
-	if (!subSessionId) {
-		return;
-	}
-	await backend.appendSubagentHookAudit(subSessionId, payload);
-	await backend.applySubagentStatus(subSessionId, payload);
-}

package/src/types/chat-schema.ts

@@ -1,81 +0,0 @@
-import { z } from "zod";
-
-export const ChatSessionConfigSchema = z.object({
-	workspaceRoot: z.string().min(1),
-	cwd: z.string().optional(),
-	provider: z.string().min(1),
-	model: z.string().min(1),
-	mode: z.enum(["act", "plan"]).default("act"),
-	apiKey: z.string(),
-	systemPrompt: z.string().optional(),
-	rules: z.string().optional(),
-	maxIterations: z.number().int().positive().optional(),
-	enableTools: z.boolean(),
-	enableSpawn: z.boolean().optional(),
-	enableTeams: z.boolean().optional(),
-	autoApproveTools: z.boolean().optional(),
-	missionStepInterval: z.number().int().positive().optional(),
-	missionTimeIntervalMs: z.number().int().positive().optional(),
-});
-
-export const ChatSessionStatusSchema = z.enum([
-	"idle",
-	"starting",
-	"running",
-	"stopping",
-	"completed",
-	"cancelled",
-	"failed",
-	"error",
-]);
-
-export const ChatMessageRoleSchema = z.enum([
-	"user",
-	"assistant",
-	"tool",
-	"system",
-	"status",
-	"error",
-]);
-
-export const ChatMessageSchema = z.object({
-	id: z.string().min(1),
-	sessionId: z.string().nullable(),
-	role: ChatMessageRoleSchema,
-	content: z.string(),
-	createdAt: z.number().int().nonnegative(),
-	meta: z
-		.object({
-			stream: z.enum(["stdout", "stderr"]).optional(),
-			toolName: z.string().optional(),
-			iteration: z.number().int().nonnegative().optional(),
-			agentId: z.string().optional(),
-			conversationId: z.string().optional(),
-			hookEventName: z.string().optional(),
-			inputTokens: z.number().int().nonnegative().optional(),
-			outputTokens: z.number().int().nonnegative().optional(),
-		})
-		.optional(),
-});
-
-export const ChatSummarySchema = z.object({
-	toolCalls: z.number().int().nonnegative(),
-	tokensIn: z.number().int().nonnegative(),
-	tokensOut: z.number().int().nonnegative(),
-});
-
-export const ChatViewStateSchema = z.object({
-	sessionId: z.string().nullable(),
-	status: ChatSessionStatusSchema,
-	config: ChatSessionConfigSchema,
-	messages: z.array(ChatMessageSchema),
-	rawTranscript: z.string(),
-	error: z.string().nullable(),
-	summary: ChatSummarySchema,
-});
-
-export type ChatSessionConfig = z.infer<typeof ChatSessionConfigSchema>;
-export type ChatSessionStatus = z.infer<typeof ChatSessionStatusSchema>;
-export type ChatMessage = z.infer<typeof ChatMessageSchema>;
-export type ChatSummary = z.infer<typeof ChatSummarySchema>;
-export type ChatViewState = z.infer<typeof ChatViewStateSchema>;

package/src/types/common.ts

@@ -1,26 +0,0 @@
-import { SESSION_STATUS_VALUES } from "@clinebot/shared";
-
-export const SESSION_STATUSES = SESSION_STATUS_VALUES;
-
-export type SessionStatus = (typeof SESSION_STATUSES)[number];
-
-export const SessionSource = {
-	CORE: "core",
-	CLI: "cli",
-	SUBAGENT: "subagent",
-	DESKTOP: "desktop",
-	KANBAN: "kanban",
-	API: "api",
-	WEB: "web",
-	VSCODE: "vscode",
-	ENTERPRISE: "enterprise",
-	IDE: "ide",
-	JETBRAINS: "jetbrains",
-	NEOVIM: "neovim",
-	UNKNOWN: "unknown",
-} as const;
-
-export type BuiltinSessionSource =
-	(typeof SessionSource)[keyof typeof SessionSource];
-
-export type SessionSource = BuiltinSessionSource | (string & {});

package/src/types/config.ts

@@ -1,220 +0,0 @@
-import type { ModelInfo } from "@clinebot/llms";
-import type {
-	AgentConfig,
-	AgentHooks,
-	AgentMode,
-	BasicLogger,
-	ConsecutiveMistakeLimitContext,
-	ConsecutiveMistakeLimitDecision,
-	ExtensionContext,
-	HookErrorMode,
-	ITelemetryService,
-	MessageWithMetadata,
-	SessionExecutionConfig,
-	SessionPromptConfig,
-	SessionWorkspaceConfig,
-	Tool,
-} from "@clinebot/shared";
-import type { ToolRoutingRule } from "../extensions/tools/model-tool-routing";
-import type { TeamEvent } from "../extensions/tools/team";
-import type { ProviderConfig } from "./provider-settings";
-
-export type CoreAgentMode = AgentMode;
-
-export interface CoreModelConfig {
-	providerId: string;
-	modelId: string;
-	apiKey?: string;
-	baseUrl?: string;
-	headers?: Record<string, string>;
-	providerConfig?: ProviderConfig;
-	knownModels?: Record<string, ModelInfo>;
-	/**
-	 * Request model-side thinking/reasoning when supported.
-	 */
-	thinking?: boolean;
-	/**
-	 * Explicit reasoning effort override for capable models.
-	 */
-	reasoningEffort?: ProviderConfig["reasoningEffort"];
-}
-
-export interface CoreRuntimeFeatures {
-	enableTools: boolean;
-	enableSpawnAgent: boolean;
-	enableAgentTeams: boolean;
-	disableMcpSettingsTools?: boolean;
-	yolo?: boolean;
-}
-
-export interface CoreCompactionContext {
-	agentId: string;
-	conversationId: string;
-	parentAgentId: string | null;
-	iteration: number;
-	messages: MessageWithMetadata[];
-	model: {
-		id: string;
-		provider: string;
-		info?: ModelInfo;
-	};
-	contextWindowTokens: number;
-	triggerTokens: number;
-	thresholdRatio: number;
-	utilizationRatio: number;
-}
-
-export interface CoreCompactionResult {
-	messages: MessageWithMetadata[];
-}
-
-export interface CoreCompactionSummarizerConfig {
-	providerId: string;
-	modelId: string;
-	apiKey?: string;
-	baseUrl?: string;
-	headers?: Record<string, string>;
-	knownModels?: Record<string, ModelInfo>;
-	providerConfig?: ProviderConfig;
-	maxOutputTokens?: number;
-}
-
-export type CoreCompactionStrategy = "basic" | "agentic";
-
-export interface CoreCompactionConfig {
-	enabled?: boolean;
-	strategy?: CoreCompactionStrategy;
-	thresholdRatio?: number;
-	reserveTokens?: number;
-	preserveRecentTokens?: number;
-	contextWindowTokens?: number;
-	summarizer?: CoreCompactionSummarizerConfig;
-	compact?: (
-		context: CoreCompactionContext,
-	) =>
-		| Promise<CoreCompactionResult | undefined>
-		| CoreCompactionResult
-		| undefined;
-}
-
-/**
- * Context passed to a custom `createCheckpoint` implementation.
- */
-export interface CoreCheckpointContext {
-	/** Absolute path to the working directory of the session. */
-	cwd: string;
-	/** The session identifier. */
-	sessionId: string;
-	/** Monotonically increasing run counter for this session (starts at 1). */
-	runCount: number;
-}
-
-/**
- * Configuration for the built-in git-based checkpoint feature.
- *
- * Checkpoints capture a restorable snapshot of the workspace at the start of
- * each root-agent run so that changes made during a session can be rolled back.
- *
- * @example Disable checkpoints entirely:
- * ```ts
- * checkpoint: { enabled: false }
- * ```
- *
- * @example Bring your own checkpoint implementation:
- * ```ts
- * checkpoint: {
- *   createCheckpoint: async ({ cwd, sessionId, runCount }) => {
- *     const ref = await mySnapshotFn(cwd);
- *     return { ref, createdAt: Date.now(), runCount };
- *   },
- * }
- * ```
- */
-export interface CoreCheckpointConfig {
-	/**
-	 * Whether to create checkpoints on each root-agent run start.
-	 * Defaults to `false` — checkpoints are **opt-in**. Set to `true` to
-	 * enable the built-in git stash/ref checkpoint behaviour for this session.
-	 */
-	enabled?: boolean;
-	/**
-	 * Replace the built-in git stash/ref checkpoint logic with a custom
-	 * implementation. Called once at the start of each root-agent run (before
-	 * the first agent iteration).
-	 *
-	 * Return an object with at least `ref`, `createdAt`, and `runCount` to have
-	 * the entry recorded in session metadata, or return `undefined` to skip
-	 * writing a checkpoint for that run.
-	 */
-	createCheckpoint?: (context: CoreCheckpointContext) =>
-		| Promise<
-				| {
-						ref: string;
-						createdAt: number;
-						runCount: number;
-						kind?: "stash" | "commit";
-				  }
-				| undefined
-		  >
-		| {
-				ref: string;
-				createdAt: number;
-				runCount: number;
-				kind?: "stash" | "commit";
-		  }
-		| undefined;
-}
-
-export interface CoreSessionConfig
-	extends CoreModelConfig,
-		CoreRuntimeFeatures,
-		Omit<SessionWorkspaceConfig, "workspaceRoot">,
-		Omit<SessionPromptConfig, "systemPrompt">,
-		Omit<
-			SessionExecutionConfig,
-			| "enableTools"
-			| "teamName"
-			| "missionLogIntervalSteps"
-			| "missionLogIntervalMs"
-			| "maxConsecutiveMistakes"
-		> {
-	/**
-	 * Core/hub runtime session identifier.
-	 *
-	 * When provided, this becomes the host-owned id for persistence, hub
-	 * subscriptions, send/abort/stop commands, and approval routing. When
-	 * omitted, the runtime host creates one. This is distinct from the agent
-	 * conversation id, which is generated by the conversation store for
-	 * transcript/tool/hook context.
-	 */
-	sessionId?: string;
-	workspaceRoot?: string;
-	systemPrompt: string;
-	teamName?: string;
-	missionLogIntervalSteps?: number;
-	missionLogIntervalMs?: number;
-	hooks?: AgentHooks;
-	hookErrorMode?: HookErrorMode;
-	logger?: BasicLogger;
-	telemetry?: ITelemetryService;
-	extensionContext?: ExtensionContext;
-	extraTools?: Tool[];
-	pluginPaths?: string[];
-	extensions?: AgentConfig["extensions"];
-	execution?: AgentConfig["execution"];
-	compaction?: CoreCompactionConfig;
-	checkpoint?: CoreCheckpointConfig;
-	onTeamEvent?: (event: TeamEvent) => void;
-	onConsecutiveMistakeLimitReached?: (
-		context: ConsecutiveMistakeLimitContext,
-	) =>
-		| Promise<ConsecutiveMistakeLimitDecision>
-		| ConsecutiveMistakeLimitDecision;
-	toolRoutingRules?: ToolRoutingRule[];
-	/**
-	 * Optional skill allowlist for the `skills` tool. When provided, only these
-	 * skills are surfaced in tool metadata and invocable by name.
-	 */
-	skills?: string[];
-	workspaceMetadata?: string;
-}

package/src/types/events.ts

@@ -1,80 +0,0 @@
-export interface SessionChunkEvent {
-	sessionId: string;
-	stream: "stdout" | "stderr" | "agent";
-	chunk: string;
-	ts: number;
-}
-
-export interface SessionEndedEvent {
-	sessionId: string;
-	reason: string;
-	ts: number;
-}
-
-export interface SessionToolEvent {
-	sessionId: string;
-	hookEventName:
-		| "tool_call"
-		| "tool_result"
-		| "agent_end"
-		| "agent_error"
-		| "session_shutdown";
-	agentId?: string;
-	conversationId?: string;
-	parentAgentId?: string;
-	iteration?: number;
-	toolName?: string;
-	inputTokens?: number;
-	outputTokens?: number;
-	ts?: string;
-}
-
-export interface SessionTeamProgressEvent {
-	sessionId: string;
-	teamName: string;
-	lifecycle: import("@clinebot/shared").TeamProgressLifecycleEvent;
-	summary: import("@clinebot/shared").TeamProgressSummary;
-}
-
-export interface SessionPendingPrompt {
-	id: string;
-	prompt: string;
-	delivery: "queue" | "steer";
-	attachmentCount: number;
-}
-
-export interface SessionPendingPromptsEvent {
-	sessionId: string;
-	prompts: SessionPendingPrompt[];
-}
-
-export interface SessionPendingPromptSubmittedEvent {
-	sessionId: string;
-	id: string;
-	prompt: string;
-	delivery: "queue" | "steer";
-	attachmentCount: number;
-}
-
-export type CoreSessionEvent =
-	| { type: "chunk"; payload: SessionChunkEvent }
-	| {
-			type: "agent_event";
-			payload: {
-				sessionId: string;
-				event: import("@clinebot/shared").AgentEvent;
-				/** Identifies the named agent within the team (e.g. "educator", "assessor", "coordinator") for both lead and teammate agents */
-				teamAgentId?: string;
-				/** Whether this is the lead agent or a teammate */
-				teamRole?: "lead" | "teammate";
-			};
-	  }
-	| { type: "team_progress"; payload: SessionTeamProgressEvent }
-	| { type: "pending_prompts"; payload: SessionPendingPromptsEvent }
-	| {
-			type: "pending_prompt_submitted";
-			payload: SessionPendingPromptSubmittedEvent;
-	  }
-	| { type: "ended"; payload: SessionEndedEvent }
-	| { type: "hook"; payload: SessionToolEvent }
-	| { type: "status"; payload: { sessionId: string; status: string } };

package/src/types/index.ts

@@ -1,26 +0,0 @@
-export type { SessionSource, SessionStatus } from "./common";
-export type {
-	CoreAgentMode,
-	CoreModelConfig,
-	CoreRuntimeFeatures,
-	CoreSessionConfig,
-} from "./config";
-export type {
-	CoreSessionEvent,
-	SessionChunkEvent,
-	SessionEndedEvent,
-	SessionPendingPrompt,
-	SessionPendingPromptSubmittedEvent,
-	SessionPendingPromptsEvent,
-	SessionTeamProgressEvent,
-	SessionToolEvent,
-} from "./events";
-export type {
-	ProviderConfig,
-	ProviderSettings,
-	ProviderTokenSource,
-	StoredProviderSettings,
-	StoredProviderSettingsEntry,
-} from "./provider-settings";
-export type { SessionRecord, SessionRef } from "./sessions";
-export type { ArtifactStore, SessionStore, TeamStore } from "./storage";

package/src/types/provider-settings.ts

@@ -1,54 +0,0 @@
-import { z } from "zod";
-import {
-	type ProviderClient,
-	type ProviderConfig,
-	type ProviderProtocol,
-	type ProviderSettings,
-	ProviderSettingsSchema,
-	toProviderConfig,
-} from "../llms/provider-settings";
-
-export type {
-	ProviderClient,
-	ProviderConfig,
-	ProviderProtocol,
-	ProviderSettings,
-};
-export const ProviderSettingsSchemaTyped: z.ZodType<ProviderSettings> =
-	ProviderSettingsSchema;
-export { toProviderConfig };
-
-export type ProviderTokenSource = "manual" | "oauth" | "migration";
-
-export interface StoredProviderSettingsEntry {
-	settings: ProviderSettings;
-	updatedAt: string;
-	tokenSource: ProviderTokenSource;
-}
-
-export interface StoredProviderSettings {
-	version: 1;
-	lastUsedProvider?: string;
-	providers: Record<string, StoredProviderSettingsEntry>;
-}
-
-export const StoredProviderSettingsEntrySchema: z.ZodType<StoredProviderSettingsEntry> =
-	z.object({
-		settings: ProviderSettingsSchema,
-		updatedAt: z.string().datetime(),
-		tokenSource: z.enum(["manual", "oauth", "migration"]).default("manual"),
-	});
-
-export const StoredProviderSettingsSchema: z.ZodType<StoredProviderSettings> =
-	z.object({
-		version: z.literal(1),
-		lastUsedProvider: z.string().min(1).optional(),
-		providers: z.record(z.string(), StoredProviderSettingsEntrySchema),
-	});
-
-export function emptyStoredProviderSettings(): StoredProviderSettings {
-	return {
-		version: 1,
-		providers: {},
-	};
-}