@schlenkr/ragents 0.1.5 → 0.1.7

package/packages/{agent-core/src → agent/src/loop}/agent.ts

@@ -2,12 +2,11 @@ import {
 	type ImageContent,
 	type Message,
 	type Model,
-	type SimpleStreamOptions,
 	streamSimple,
 	type TextContent,
 	type ThinkingBudgets,
 	type Transport,
-} from "@aicontainer/ai";
+} from "@ragents/ai";
 import { runAgentLoop, runAgentLoopContinue } from "./agent-loop.ts";
 import type {
 	AfterToolCallContext,
@@ -19,16 +18,11 @@ import type {
 	AgentMessage,
 	AgentState,
 	AgentTool,
-	BeforeToolCallContext,
-	BeforeToolCallResult,
 	PrepareNextTurnContext,
-	QueueMode,
 	StreamFn,
 	ToolExecutionMode,
 } from "./types.ts";
 
-export type { QueueMode } from "./types.ts";
-
 function defaultConvertToLlm(messages: AgentMessage[]): Message[] {
 	return messages.filter(
 		(message) => message.role === "user" || message.role === "assistant" || message.role === "toolResult",
@@ -100,10 +94,7 @@ export interface AgentOptions {
 	transformContext?: (messages: AgentMessage[], signal?: AbortSignal) => Promise<AgentMessage[]>;
 	streamFn?: StreamFn;
 	getApiKey?: (provider: string) => Promise<string | undefined> | string | undefined;
-	onPayload?: SimpleStreamOptions["onPayload"];
-	onResponse?: SimpleStreamOptions["onResponse"];
 	formatUnknownToolError?: AgentLoopConfig["formatUnknownToolError"];
-	beforeToolCall?: (context: BeforeToolCallContext, signal?: AbortSignal) => Promise<BeforeToolCallResult | undefined>;
 	afterToolCall?: (context: AfterToolCallContext, signal?: AbortSignal) => Promise<AfterToolCallResult | undefined>;
 	prepareNextTurn?: (
 		signal?: AbortSignal,
@@ -112,9 +103,7 @@ export interface AgentOptions {
 		context: PrepareNextTurnContext,
 		signal?: AbortSignal,
 	) => Promise<AgentLoopTurnUpdate | undefined> | AgentLoopTurnUpdate | undefined;
-	steeringMode?: QueueMode;
-	followUpMode?: QueueMode;
-	onBackgroundToolResult?: AgentLoopConfig["onBackgroundToolResult"];
+	steeringSource?: AgentLoopConfig["getSteeringMessages"];
 	sessionId?: string;
 	thinkingBudgets?: ThinkingBudgets;
 	transport?: Transport;
@@ -122,42 +111,6 @@ export interface AgentOptions {
 	toolExecution?: ToolExecutionMode;
 }
 
-class PendingMessageQueue {
-	private messages: AgentMessage[] = [];
-	public mode: QueueMode;
-
-	constructor(mode: QueueMode) {
-		this.mode = mode;
-	}
-
-	enqueue(message: AgentMessage): void {
-		this.messages.push(message);
-	}
-
-	hasItems(): boolean {
-		return this.messages.length > 0;
-	}
-
-	drain(): AgentMessage[] {
-		if (this.mode === "all") {
-			const drained = this.messages.slice();
-			this.messages = [];
-			return drained;
-		}
-
-		const first = this.messages[0];
-		if (!first) {
-			return [];
-		}
-		this.messages = this.messages.slice(1);
-		return [first];
-	}
-
-	clear(): void {
-		this.messages = [];
-	}
-}
-
 type ActiveRun = {
 	promise: Promise<void>;
 	resolve: () => void;
@@ -168,26 +121,22 @@ type ActiveRun = {
  * Stateful wrapper around the low-level agent loop.
  *
  * `Agent` owns the current transcript, emits lifecycle events, executes tools,
- * and exposes queueing APIs for steering and follow-up messages.
+ * and polls its steering source before each model request.
  */
+const runFailures = new WeakSet<object>();
+
+/** Whether a message is the stand-in the agent reports for a failed run; no model produced it. */
+export const isRunFailure = (message: AgentMessage): boolean => runFailures.has(message);
+
 export class Agent {
 	private _state: MutableAgentState;
 	private readonly listeners = new Set<(event: AgentEvent, signal: AbortSignal) => Promise<void> | void>();
-	private readonly steeringQueue: PendingMessageQueue;
-	private readonly followUpQueue: PendingMessageQueue;
-	private readonly steeringListeners = new Set<() => void>();
 
 	public convertToLlm: (messages: AgentMessage[]) => Message[] | Promise<Message[]>;
 	public transformContext?: (messages: AgentMessage[], signal?: AbortSignal) => Promise<AgentMessage[]>;
 	public streamFn: StreamFn;
 	public getApiKey?: (provider: string) => Promise<string | undefined> | string | undefined;
-	public onPayload?: SimpleStreamOptions["onPayload"];
-	public onResponse?: SimpleStreamOptions["onResponse"];
 	public formatUnknownToolError?: AgentLoopConfig["formatUnknownToolError"];
-	public beforeToolCall?: (
-		context: BeforeToolCallContext,
-		signal?: AbortSignal,
-	) => Promise<BeforeToolCallResult | undefined>;
 	public afterToolCall?: (
 		context: AfterToolCallContext,
 		signal?: AbortSignal,
@@ -210,8 +159,8 @@ export class Agent {
 	public maxRetryDelayMs?: number;
 	/** Tool execution strategy for assistant messages that contain multiple tool calls. */
 	public toolExecution: ToolExecutionMode;
-	/** When set, in-flight tool calls are backgrounded on steering and real results land here. */
-	public onBackgroundToolResult?: AgentLoopConfig["onBackgroundToolResult"];
+	/** Messages to inject into the running prompt before its next model request. */
+	public steeringSource?: AgentLoopConfig["getSteeringMessages"];
 
 	constructor(options: AgentOptions = {}) {
 		this._state = createMutableAgentState(options.initialState);
@@ -219,21 +168,16 @@ export class Agent {
 		this.transformContext = options.transformContext;
 		this.streamFn = options.streamFn ?? streamSimple;
 		this.getApiKey = options.getApiKey;
-		this.onPayload = options.onPayload;
-		this.onResponse = options.onResponse;
 		this.formatUnknownToolError = options.formatUnknownToolError;
-		this.beforeToolCall = options.beforeToolCall;
 		this.afterToolCall = options.afterToolCall;
 		this.prepareNextTurn = options.prepareNextTurn;
 		this.prepareNextTurnWithContext = options.prepareNextTurnWithContext;
-		this.steeringQueue = new PendingMessageQueue(options.steeringMode ?? "one-at-a-time");
-		this.followUpQueue = new PendingMessageQueue(options.followUpMode ?? "one-at-a-time");
 		this.sessionId = options.sessionId;
 		this.thinkingBudgets = options.thinkingBudgets;
 		this.transport = options.transport ?? "auto";
 		this.maxRetryDelayMs = options.maxRetryDelayMs;
 		this.toolExecution = options.toolExecution ?? "parallel";
-		this.onBackgroundToolResult = options.onBackgroundToolResult;
+		this.steeringSource = options.steeringSource;
 	}
 
 	/**
@@ -260,64 +204,6 @@ export class Agent {
 		return this._state;
 	}
 
-	/** Controls how queued steering messages are drained. */
-	set steeringMode(mode: QueueMode) {
-		this.steeringQueue.mode = mode;
-	}
-
-	get steeringMode(): QueueMode {
-		return this.steeringQueue.mode;
-	}
-
-	/** Controls how queued follow-up messages are drained. */
-	set followUpMode(mode: QueueMode) {
-		this.followUpQueue.mode = mode;
-	}
-
-	get followUpMode(): QueueMode {
-		return this.followUpQueue.mode;
-	}
-
-	/** Queue a message to be injected after the current assistant turn finishes. */
-	steer(message: AgentMessage): void {
-		this.steeringQueue.enqueue(message);
-		for (const listener of this.steeringListeners) {
-			listener();
-		}
-	}
-
-	/** Subscribe to steering enqueues; used by the loop to background running tools. */
-	onSteeringQueued(listener: () => void): () => void {
-		this.steeringListeners.add(listener);
-		return () => this.steeringListeners.delete(listener);
-	}
-
-	/** Queue a message to run only after the agent would otherwise stop. */
-	followUp(message: AgentMessage): void {
-		this.followUpQueue.enqueue(message);
-	}
-
-	/** Remove all queued steering messages. */
-	clearSteeringQueue(): void {
-		this.steeringQueue.clear();
-	}
-
-	/** Remove all queued follow-up messages. */
-	clearFollowUpQueue(): void {
-		this.followUpQueue.clear();
-	}
-
-	/** Remove all queued steering and follow-up messages. */
-	clearAllQueues(): void {
-		this.clearSteeringQueue();
-		this.clearFollowUpQueue();
-	}
-
-	/** Returns true when either queue still contains pending messages. */
-	hasQueuedMessages(): boolean {
-		return this.steeringQueue.hasItems() || this.followUpQueue.hasItems();
-	}
-
 	/** Active abort signal for the current run, if any. */
 	get signal(): AbortSignal | undefined {
 		return this.activeRun?.abortController.signal;
@@ -337,15 +223,13 @@ export class Agent {
 		return this.activeRun?.promise ?? Promise.resolve();
 	}
 
-	/** Clear transcript state, runtime state, and queued messages. */
+	/** Clear transcript state and runtime state. */
 	reset(): void {
 		this._state.messages = [];
 		this._state.isStreaming = false;
 		this._state.streamingMessage = undefined;
 		this._state.pendingToolCalls = new Set<string>();
 		this._state.errorMessage = undefined;
-		this.clearFollowUpQueue();
-		this.clearSteeringQueue();
 	}
 
 	/** Start a new prompt from text, a single message, or a batch of messages. */
@@ -354,7 +238,7 @@ export class Agent {
 	async prompt(input: string | AgentMessage | AgentMessage[], images?: ImageContent[]): Promise<void> {
 		if (this.activeRun) {
 			throw new Error(
-				"Agent is already processing a prompt. Use steer() or followUp() to queue messages, or wait for completion.",
+				"Agent is already processing a prompt. Wait for completion or deliver the message through the steering source.",
 			);
 		}
 		const messages = this.normalizePromptInput(input, images);
@@ -373,18 +257,6 @@ export class Agent {
 		}
 
 		if (lastMessage.role === "assistant") {
-			const queuedSteering = this.steeringQueue.drain();
-			if (queuedSteering.length > 0) {
-				await this.runPromptMessages(queuedSteering, { skipInitialSteeringPoll: true });
-				return;
-			}
-
-			const queuedFollowUps = this.followUpQueue.drain();
-			if (queuedFollowUps.length > 0) {
-				await this.runPromptMessages(queuedFollowUps);
-				return;
-			}
-
 			throw new Error("Cannot continue from message role: assistant");
 		}
 
@@ -410,15 +282,12 @@ export class Agent {
 		return [{ role: "user", content, timestamp: Date.now() }];
 	}
 
-	private async runPromptMessages(
-		messages: AgentMessage[],
-		options: { skipInitialSteeringPoll?: boolean } = {},
-	): Promise<void> {
+	private async runPromptMessages(messages: AgentMessage[]): Promise<void> {
 		await this.runWithLifecycle(async (signal) => {
 			await runAgentLoop(
 				messages,
 				this.createContextSnapshot(),
-				this.createLoopConfig(options),
+				this.createLoopConfig(),
 				(event) => this.processEvents(event),
 				signal,
 				this.streamFn,
@@ -446,20 +315,16 @@ export class Agent {
 		};
 	}
 
-	private createLoopConfig(options: { skipInitialSteeringPoll?: boolean } = {}): AgentLoopConfig {
-		let skipInitialSteeringPoll = options.skipInitialSteeringPoll === true;
+	private createLoopConfig(): AgentLoopConfig {
 		return {
 			model: this._state.model,
 			reasoning: this._state.thinkingLevel === "off" ? undefined : this._state.thinkingLevel,
 			sessionId: this.sessionId,
-			onPayload: this.onPayload,
-			onResponse: this.onResponse,
 			transport: this.transport,
 			thinkingBudgets: this.thinkingBudgets,
 			maxRetryDelayMs: this.maxRetryDelayMs,
 			toolExecution: this.toolExecution,
 			formatUnknownToolError: this.formatUnknownToolError,
-			beforeToolCall: this.beforeToolCall,
 			afterToolCall: this.afterToolCall,
 			prepareNextTurn:
 				this.prepareNextTurnWithContext || this.prepareNextTurn
@@ -473,19 +338,7 @@ export class Agent {
 			convertToLlm: this.convertToLlm,
 			transformContext: this.transformContext,
 			getApiKey: this.getApiKey,
-			getSteeringMessages: async () => {
-				if (skipInitialSteeringPoll) {
-					skipInitialSteeringPoll = false;
-					return [];
-				}
-				return this.steeringQueue.drain();
-			},
-			getFollowUpMessages: async () => this.followUpQueue.drain(),
-			hasPendingSteering: () => this.steeringQueue.hasItems(),
-			onSteeringQueued: (listener) => this.onSteeringQueued(listener),
-			onBackgroundToolResult: this.onBackgroundToolResult
-				? (toolCall, result, isError) => this.onBackgroundToolResult?.(toolCall, result, isError)
-				: undefined,
+			getSteeringMessages: async () => (await this.steeringSource?.()) ?? [],
 		};
 	}
 
@@ -515,7 +368,7 @@ export class Agent {
 	}
 
 	private async handleRunFailure(error: unknown, aborted: boolean): Promise<void> {
-		const failureMessage = {
+		const failureMessage: AgentMessage = {
 			role: "assistant",
 			content: [{ type: "text", text: "" }],
 			api: this._state.model.api,
@@ -525,7 +378,8 @@ export class Agent {
 			stopReason: aborted ? "aborted" : "error",
 			errorMessage: error instanceof Error ? error.message : String(error),
 			timestamp: Date.now(),
-		} satisfies AgentMessage;
+		};
+		runFailures.add(failureMessage);
 		await this.processEvents({ type: "message_start", message: failureMessage });
 		await this.processEvents({ type: "message_end", message: failureMessage });
 		await this.processEvents({ type: "turn_end", message: failureMessage, toolResults: [] });

package/packages/{agent-core/src → agent/src/loop}/types.ts

@@ -11,7 +11,7 @@ import type {
 	TextContent,
 	Tool,
 	ToolResultMessage,
-} from "@aicontainer/ai";
+} from "@ragents/ai";
 import type { Static, TSchema } from "typebox";
 
 /**
@@ -40,28 +40,9 @@ export type StreamFn = (
  */
 export type ToolExecutionMode = "sequential" | "parallel";
 
-/**
- * Controls how many queued user messages are injected when the agent loop reaches a queue drain point.
- *
- * - "all": drain and inject every queued message at that point.
- * - "one-at-a-time": drain and inject only the oldest queued message, leaving the rest queued for later drain points.
- */
-export type QueueMode = "all" | "one-at-a-time";
-
 /** A single tool call content block emitted by an assistant message. */
 export type AgentToolCall = Extract<AssistantMessage["content"][number], { type: "toolCall" }>;
 
-/**
- * Result returned from `beforeToolCall`.
- *
- * Returning `{ block: true }` prevents the tool from executing. The loop emits an error tool result instead.
- * `reason` becomes the text shown in that error result. If omitted, a default blocked message is used.
- */
-export interface BeforeToolCallResult {
-	block?: boolean;
-	reason?: string;
-}
-
 /**
  * Partial override returned from `afterToolCall`.
  *
@@ -85,18 +66,6 @@ export interface AfterToolCallResult {
 	terminate?: boolean;
 }
 
-/** Context passed to `beforeToolCall`. */
-export interface BeforeToolCallContext {
-	/** The assistant message that requested the tool call. */
-	assistantMessage: AssistantMessage;
-	/** The raw tool call block from `assistantMessage.content`. */
-	toolCall: AgentToolCall;
-	/** Validated tool arguments for the target tool schema. */
-	args: unknown;
-	/** Current agent context at the time the tool call is prepared. */
-	context: AgentContext;
-}
-
 /** Context passed to `afterToolCall`. */
 export interface AfterToolCallContext {
 	/** The assistant message that requested the tool call. */
@@ -203,7 +172,7 @@ export interface AgentLoopConfig extends SimpleStreamOptions {
 	/**
 	 * Called after each turn fully completes and `turn_end` has been emitted.
 	 *
-	 * If it returns true, the loop emits `agent_end` and exits before polling steering or follow-up queues,
+	 * If it returns true, the loop emits `agent_end` and exits before polling steering messages,
 	 * without starting another LLM call. The current assistant response and any tool executions finish normally.
 	 *
 	 * Use this to request a graceful stop after the current turn, e.g. before context gets too full.
@@ -221,54 +190,9 @@ export interface AgentLoopConfig extends SimpleStreamOptions {
 		context: PrepareNextTurnContext,
 	) => AgentLoopTurnUpdate | undefined | Promise<AgentLoopTurnUpdate | undefined>;
 
-	/**
-	 * Returns steering messages to inject into the conversation mid-run.
-	 *
-	 * Called after the current assistant turn finishes executing its tool calls, unless `shouldStopAfterTurn` exits first.
-	 * If messages are returned, they are added to the context before the next LLM call.
-	 * Tool calls from the current assistant message are not skipped.
-	 *
-	 * Use this for "steering" the agent while it's working.
-	 *
-	 * Contract: must not throw or reject. Return [] when no steering messages are available.
-	 */
+	/** Steering polled before the first model request and after each assistant turn; messages join the context, a rejection ends the run. */
 	getSteeringMessages?: () => Promise<AgentMessage[]>;
 
-	/**
-	 * Non-destructive check whether steering messages are queued.
-	 *
-	 * Used together with `onSteeringQueued` and `onBackgroundToolResult` to background
-	 * running tool calls as soon as steering arrives. Contract: must not throw.
-	 */
-	hasPendingSteering?: () => boolean;
-
-	/**
-	 * Registers a listener invoked whenever a steering message is queued.
-	 * Returns an unsubscribe function. Contract: must not throw.
-	 */
-	onSteeringQueued?: (listener: () => void) => () => void;
-
-	/**
-	 * Receives the real result of a tool call whose in-flight execution was backgrounded
-	 * because steering arrived. The loop already emitted an interim tool result for the call;
-	 * implementations typically re-inject the real result as a queued user message.
-	 * Contract: must not throw.
-	 */
-	onBackgroundToolResult?: (toolCall: AgentToolCall, result: AgentToolResult<any>, isError: boolean) => void;
-
-	/**
-	 * Returns follow-up messages to process after the agent would otherwise stop.
-	 *
-	 * Called when the agent has no more tool calls and no steering messages.
-	 * If messages are returned, they're added to the context and the agent
-	 * continues with another turn.
-	 *
-	 * Use this for follow-up messages that should wait until the agent finishes.
-	 *
-	 * Contract: must not throw or reject. Return [] when no follow-up messages are available.
-	 */
-	getFollowUpMessages?: () => Promise<AgentMessage[]>;
-
 	/**
 	 * Tool execution mode.
 	 * - "sequential": execute tool calls one by one
@@ -283,14 +207,6 @@ export interface AgentLoopConfig extends SimpleStreamOptions {
 	/** Customize an unavailable tool's error text; undefined keeps the default and execution stays blocked. */
 	formatUnknownToolError?: (toolName: string) => string | undefined;
 
-	/**
-	 * Called before a tool is executed, after arguments have been validated.
-	 *
-	 * Return `{ block: true }` to prevent execution. The loop emits an error tool result instead.
-	 * The hook receives the agent abort signal and is responsible for honoring it.
-	 */
-	beforeToolCall?: (context: BeforeToolCallContext, signal?: AbortSignal) => Promise<BeforeToolCallResult | undefined>;
-
 	/**
 	 * Called after a tool finishes executing, before `tool_execution_end` and tool-result message events are emitted.
 	 *
@@ -309,27 +225,12 @@ export interface AgentLoopConfig extends SimpleStreamOptions {
 /**
  * Thinking/reasoning level for models that support it.
  * Note: "xhigh" and "max" are only supported by selected model families. Use model
- * thinking-level metadata from @aicontainer/ai to detect support for a concrete model.
+ * thinking-level metadata from @ragents/ai to detect support for a concrete model.
  */
 export type ThinkingLevel = "off" | "minimal" | "low" | "medium" | "high" | "xhigh" | "max";
 
-/**
- * Extensible interface for custom app messages.
- * Apps can extend via declaration merging:
- *
- * @example
- * ```typescript
- * declare module "@mariozechner/agent" {
- *   interface CustomAgentMessages {
- *     artifact: ArtifactMessage;
- *     notification: NotificationMessage;
- *   }
- * }
- * ```
- */
-export interface CustomAgentMessages {
-	// Empty by default - apps extend via declaration merging
-}
+/** Custom message types; `core/messages.ts` adds them through declaration merging. */
+export interface CustomAgentMessages {}
 
 /**
  * AgentMessage: Union of LLM messages + custom messages.

package/packages/agent/src/utils/child-process.ts

@@ -2,11 +2,8 @@ import {
 	type ChildProcess,
 	type ChildProcessByStdio,
 	spawn as nodeSpawn,
-	spawnSync as nodeSpawnSync,
 	type SpawnOptions,
 	type SpawnOptionsWithStdioTuple,
-	type SpawnSyncOptionsWithStringEncoding,
-	type SpawnSyncReturns,
 	type StdioNull,
 	type StdioPipe,
 } from "node:child_process";
@@ -25,16 +22,6 @@ export function spawnProcess(command: string, args: string[], options: SpawnOpti
 	return process.platform === "win32" ? crossSpawn(command, args, options) : nodeSpawn(command, args, options);
 }
 
-export function spawnProcessSync(
-	command: string,
-	args: string[],
-	options: SpawnSyncOptionsWithStringEncoding,
-): SpawnSyncReturns<string> {
-	return process.platform === "win32"
-		? crossSpawn.sync(command, args, options)
-		: nodeSpawnSync(command, args, options);
-}
-
 /**
  * Wait for a child process to terminate without hanging on inherited stdio handles.
  *

package/packages/agent/src/utils/image-convert.ts

@@ -22,28 +22,3 @@ export async function convertImageBytesToPng(bytes: Uint8Array): Promise<Uint8Ar
 		return null;
 	}
 }
-
-/**
- * Convert image to PNG format for terminal display.
- * Kitty graphics protocol requires PNG format (f=100).
- */
-export async function convertToPng(
-	base64Data: string,
-	mimeType: string,
-): Promise<{ data: string; mimeType: string } | null> {
-	// Already PNG, no conversion needed
-	if (mimeType === "image/png") {
-		return { data: base64Data, mimeType };
-	}
-
-	const bytes = new Uint8Array(Buffer.from(base64Data, "base64"));
-	const pngBytes = await convertImageBytesToPng(bytes);
-	if (!pngBytes) {
-		return null;
-	}
-
-	return {
-		data: Buffer.from(pngBytes).toString("base64"),
-		mimeType: "image/png",
-	};
-}

package/packages/agent/src/utils/paths.ts

@@ -1,8 +1,6 @@
-import { realpathSync } from "node:fs";
 import { homedir } from "node:os";
-import { isAbsolute, join, resolve as nodeResolvePath, relative, sep } from "node:path";
+import { isAbsolute, join, resolve as nodeResolvePath } from "node:path";
 import { fileURLToPath } from "node:url";
-import { spawnProcessSync } from "./child-process.ts";
 
 const UNICODE_SPACES = /[\u00A0\u2000-\u200A\u202F\u205F\u3000]/g;
 
@@ -19,41 +17,6 @@ export interface PathInputOptions {
 	normalizeUnicodeSpaces?: boolean;
 }
 
-/**
- * Resolve a path to its canonical (real) form, following symlinks.
- * Falls back to the raw path if resolution fails (e.g. the target does
- * not exist yet), so that callers never crash on missing filesystem
- * entries.
- */
-export function canonicalizePath(path: string): string {
-	try {
-		return realpathSync(path);
-	} catch {
-		return path;
-	}
-}
-
-/**
- * Returns true if the value is NOT a package source (npm:, git:, etc.)
- * or a remote URL protocol. Bare names, relative paths, and file: URLs
- * are considered local.
- */
-export function isLocalPath(value: string): boolean {
-	const trimmed = value.trim();
-	// Known non-local prefixes. file: URLs are local paths and are intentionally resolved by resolvePath().
-	if (
-		trimmed.startsWith("npm:") ||
-		trimmed.startsWith("git:") ||
-		trimmed.startsWith("github:") ||
-		trimmed.startsWith("http:") ||
-		trimmed.startsWith("https:") ||
-		trimmed.startsWith("ssh:")
-	) {
-		return false;
-	}
-	return true;
-}
-
 export function normalizePath(input: string, options: PathInputOptions = {}): string {
 	let normalized = options.trim ? input.trim() : input;
 	if (options.normalizeUnicodeSpaces) {
@@ -83,36 +46,3 @@ export function resolvePath(input: string, baseDir: string = process.cwd(), opti
 	const normalizedBaseDir = normalizePath(baseDir);
 	return isAbsolute(normalized) ? nodeResolvePath(normalized) : nodeResolvePath(normalizedBaseDir, normalized);
 }
-
-export function getCwdRelativePath(filePath: string, cwd: string): string | undefined {
-	const resolvedCwd = resolvePath(cwd);
-	const resolvedPath = resolvePath(filePath, resolvedCwd);
-	const relativePath = relative(resolvedCwd, resolvedPath);
-	const isInsideCwd =
-		relativePath === "" ||
-		(relativePath !== ".." && !relativePath.startsWith(`..${sep}`) && !isAbsolute(relativePath));
-
-	return isInsideCwd ? relativePath || "." : undefined;
-}
-
-export function formatPathRelativeToCwdOrAbsolute(filePath: string, cwd: string): string {
-	const absolutePath = resolvePath(filePath, cwd);
-	return (getCwdRelativePath(absolutePath, cwd) ?? absolutePath).split(sep).join("/");
-}
-
-export function markPathIgnoredByCloudSync(path: string): void {
-	const attrs =
-		process.platform === "darwin"
-			? ["com.dropbox.ignored", "com.apple.fileprovider.ignore#P"]
-			: process.platform === "linux"
-				? ["user.com.dropbox.ignored"]
-				: [];
-
-	for (const attr of attrs) {
-		if (process.platform === "darwin") {
-			spawnProcessSync("xattr", ["-w", attr, "1", path], { encoding: "utf-8", stdio: "ignore" });
-		} else {
-			spawnProcessSync("setfattr", ["-n", attr, "-v", "1", path], { encoding: "utf-8", stdio: "ignore" });
-		}
-	}
-}