@clinebot/shared 0.0.8 → 0.0.9

package/src/llms/model-id.ts

@@ -0,0 +1,154 @@
+export const MODELS_DEV_PROVIDER_KEY_ENTRIES: ReadonlyArray<{
+	modelsDevKey: string;
+	generatedProviderId?: string;
+	runtimeProviderId?: string;
+}> = [
+	{
+		modelsDevKey: "openai",
+		generatedProviderId: "openai",
+		runtimeProviderId: "openai-native",
+	},
+	{
+		modelsDevKey: "openai",
+		generatedProviderId: "openai",
+		runtimeProviderId: "openai-codex",
+	},
+	{
+		modelsDevKey: "anthropic",
+		generatedProviderId: "anthropic",
+	},
+	{
+		modelsDevKey: "anthropic",
+		generatedProviderId: "anthropic",
+		runtimeProviderId: "claude-code",
+	},
+	{
+		modelsDevKey: "google",
+		generatedProviderId: "gemini",
+	},
+	{
+		modelsDevKey: "deepseek",
+		generatedProviderId: "deepseek",
+	},
+	{ modelsDevKey: "xai", generatedProviderId: "xai" },
+	{
+		modelsDevKey: "togetherai",
+		runtimeProviderId: "together",
+		generatedProviderId: "together",
+	},
+	{
+		modelsDevKey: "sap-ai-core",
+		runtimeProviderId: "sapaicore",
+		generatedProviderId: "sapaicore",
+	},
+	{
+		modelsDevKey: "fireworks-ai",
+		runtimeProviderId: "fireworks",
+		generatedProviderId: "fireworks",
+	},
+	{
+		modelsDevKey: "groq",
+		runtimeProviderId: "groq",
+		generatedProviderId: "groq",
+	},
+	{
+		modelsDevKey: "cerebras",
+		runtimeProviderId: "cerebras",
+		generatedProviderId: "cerebras",
+	},
+	{
+		modelsDevKey: "sambanova",
+		runtimeProviderId: "sambanova",
+		generatedProviderId: "sambanova",
+	},
+	{
+		modelsDevKey: "nebius",
+		runtimeProviderId: "nebius",
+		generatedProviderId: "nebius",
+	},
+	{
+		modelsDevKey: "huggingface",
+		runtimeProviderId: "huggingface",
+		generatedProviderId: "huggingface",
+	},
+	{
+		modelsDevKey: "openrouter",
+		runtimeProviderId: "cline",
+		generatedProviderId: "openrouter",
+	},
+	{ modelsDevKey: "ollama", runtimeProviderId: "ollama-cloud" },
+	{ modelsDevKey: "ollama-cloud", generatedProviderId: "ollama" },
+	{
+		modelsDevKey: "vercel",
+		runtimeProviderId: "dify",
+		generatedProviderId: "vercel-ai-gateway",
+	},
+	{
+		modelsDevKey: "vercel",
+		generatedProviderId: "vercel-ai-gateway",
+	},
+	{
+		modelsDevKey: "aihubmix",
+		runtimeProviderId: "aihubmix",
+		generatedProviderId: "aihubmix",
+	},
+	{ modelsDevKey: "hicap", runtimeProviderId: "hicap" },
+	{ modelsDevKey: "nous-research", runtimeProviderId: "nousResearch" },
+	{ modelsDevKey: "huawei-cloud-maas", runtimeProviderId: "huawei-cloud-maas" },
+	{
+		modelsDevKey: "baseten",
+		runtimeProviderId: "baseten",
+		generatedProviderId: "baseten",
+	},
+	{
+		modelsDevKey: "google-vertex-anthropic",
+		generatedProviderId: "vertex",
+	},
+	{ modelsDevKey: "lmstudio", generatedProviderId: "lmstudio" },
+	{ modelsDevKey: "zai", generatedProviderId: "zai" },
+	{ modelsDevKey: "requesty", generatedProviderId: "requesty" },
+	{ modelsDevKey: "amazon-bedrock", generatedProviderId: "bedrock" },
+	{ modelsDevKey: "moonshotai", generatedProviderId: "moonshot" },
+	{ modelsDevKey: "minimax", generatedProviderId: "minimax" },
+];
+
+function buildProviderKeyMap(
+	key: "modelsDevKey" | "generatedProviderId",
+): Record<string, string> {
+	return Object.fromEntries(
+		MODELS_DEV_PROVIDER_KEY_ENTRIES.flatMap((entry) => {
+			const providerId =
+				key === "modelsDevKey" ? entry.modelsDevKey : entry.generatedProviderId;
+			return providerId ? [[entry.modelsDevKey, providerId]] : [];
+		}),
+	);
+}
+
+export const MODELS_DEV_PROVIDER_KEY_MAP = buildProviderKeyMap(
+	"generatedProviderId",
+);
+
+function dedupe(values: readonly string[]): string[] {
+	return [...new Set(values)];
+}
+
+export function resolveProviderModelCatalogKeys(providerId: string): string[] {
+	const mapped = MODELS_DEV_PROVIDER_KEY_ENTRIES.flatMap((entry) => {
+		if (!entry.generatedProviderId) {
+			return [];
+		}
+		if (
+			entry.generatedProviderId === providerId ||
+			entry.runtimeProviderId === providerId
+		) {
+			return [entry.generatedProviderId];
+		}
+		return [];
+	});
+
+	if (providerId === "nousResearch") {
+		return dedupe([...mapped, "nousresearch", providerId]);
+	}
+
+	return dedupe([...mapped, providerId]);
+}

package/src/llms/tools.ts

@@ -0,0 +1,137 @@
+/**
+ * Types and Zod Schemas for the Agent Package
+ *
+ * This module defines all TypeScript types and Zod validation schemas
+ * for agent configuration, tools, events, and results.
+ */
+
+import { z } from "zod";
+
+// =============================================================================
+// Tool Context
+// =============================================================================
+
+/**
+ * Context passed to tool execution functions
+ */
+export interface ToolContext {
+	/** Unique identifier for the agent instance */
+	agentId: string;
+	/** Unique identifier for the current conversation */
+	conversationId: string;
+	/** Current iteration number in the agentic loop */
+	iteration: number;
+	/** Abort signal for cancellation */
+	abortSignal?: AbortSignal;
+	/** Optional metadata for the tool execution */
+	metadata?: Record<string, unknown>;
+}
+
+export interface ToolPolicy {
+	/**
+	 * Whether the tool can be executed at all.
+	 * @default true
+	 */
+	enabled?: boolean;
+	/**
+	 * Whether this tool can run without asking the client for approval.
+	 * @default true
+	 */
+	autoApprove?: boolean;
+}
+
+export const ToolContextSchema = z.object({
+	agentId: z.string(),
+	conversationId: z.string(),
+	iteration: z.number(),
+	abortSignal: z.custom<AbortSignal>().optional(),
+	metadata: z.record(z.string(), z.unknown()).optional(),
+});
+
+// =============================================================================
+// Tool Definition
+// =============================================================================
+
+/**
+ * A tool that the agent can use
+ *
+ * @template TInput - The type of the input to the tool
+ * @template TOutput - The type of the output from the tool
+ */
+export interface Tool<TInput = unknown, TOutput = unknown> {
+	/** Unique name for the tool */
+	name: string;
+	/** Human-readable description of what the tool does */
+	description: string;
+	/** JSON Schema defining the tool's input parameters */
+	inputSchema: Record<string, unknown>;
+	/** The function that executes the tool */
+	execute: (input: TInput, context: ToolContext) => Promise<TOutput>;
+	/**
+	 * Optional timeout in milliseconds for tool execution
+	 * @default 30000 (30 seconds)
+	 */
+	timeoutMs?: number;
+	/**
+	 * Whether the tool can be retried on failure
+	 * @default true
+	 */
+	retryable?: boolean;
+	/**
+	 * Maximum number of retries for this tool
+	 * @default 2
+	 */
+	maxRetries?: number;
+}
+
+// =============================================================================
+// Tool Call Record
+// =============================================================================
+
+/**
+ * Record of a tool call execution
+ */
+export interface ToolCallRecord {
+	/** Unique identifier for this tool call */
+	id: string;
+	/** Name of the tool that was called */
+	name: string;
+	/** Input passed to the tool */
+	input: unknown;
+	/** Output returned from the tool (if successful) */
+	output: unknown;
+	/** Error message (if the tool failed) */
+	error?: string;
+	/** Time taken to execute the tool in milliseconds */
+	durationMs: number;
+	/** Timestamp when the tool call started */
+	startedAt: Date;
+	/** Timestamp when the tool call ended */
+	endedAt: Date;
+}
+
+export interface ToolApprovalRequest {
+	agentId: string;
+	conversationId: string;
+	iteration: number;
+	toolCallId: string;
+	toolName: string;
+	input: unknown;
+	policy: ToolPolicy;
+}
+
+export interface ToolApprovalResult {
+	approved: boolean;
+	reason?: string;
+}
+
+export const ToolCallRecordSchema = z.object({
+	id: z.string(),
+	name: z.string(),
+	input: z.unknown(),
+	output: z.unknown(),
+	error: z.string().optional(),
+	durationMs: z.number(),
+	startedAt: z.date(),
+	endedAt: z.date(),
+});

package/src/logging/logger.ts

@@ -0,0 +1,9 @@
+export interface BasicLogger {
+	debug?: (message: string, metadata?: Record<string, unknown>) => void;
+	info?: (message: string, metadata?: Record<string, unknown>) => void;
+	warn?: (message: string, metadata?: Record<string, unknown>) => void;
+	error?: (
+		message: string,
+		metadata?: Record<string, unknown> & { error?: unknown },
+	) => void;
+}

package/src/parse/json.ts

@@ -0,0 +1,43 @@
+import { jsonrepair } from "jsonrepair";
+
+function tryParseJson(text: string): unknown {
+	return JSON.parse(text);
+}
+
+export function parseJsonStream(input: unknown): unknown {
+	if (typeof input !== "string") return input;
+
+	const text = input.trimStart();
+	if (!(text.startsWith("{") || text.startsWith("["))) return input;
+
+	try {
+		return tryParseJson(text);
+	} catch {
+		try {
+			return tryParseJson(jsonrepair(text));
+		} catch {
+			return input;
+		}
+	}
+}
+
+export function safeJsonStringify(input: unknown): string {
+	const seen = new WeakSet<object>();
+
+	try {
+		const result = JSON.stringify(input, (_key, value) => {
+			if (typeof value === "bigint") return value.toString();
+
+			if (value && typeof value === "object") {
+				if (seen.has(value as object)) return "[Circular]";
+				seen.add(value as object);
+			}
+
+			return value;
+		});
+
+		return result ?? "null";
+	} catch {
+		return String(input);
+	}
+}

package/src/parse/time.ts

@@ -0,0 +1,21 @@
+/**
+ * Parses a date string and returns a human-readable format.
+ * If the input is invalid, it returns the original string or a placeholder.
+ *
+ * @param dateStr - The date string to parse.
+ * @returns A human-readable date string or the original input if invalid.
+ */
+export function formatHumanReadableDate(dateStr?: string): string {
+	if (!dateStr) return "(unknown-date)";
+	const date = new Date(dateStr);
+	if (Number.isNaN(date.getTime())) return dateStr;
+	return date.toLocaleString("en-US", {
+		year: "numeric",
+		month: "numeric",
+		day: "numeric",
+		hour: "numeric",
+		minute: "numeric",
+		second: "numeric",
+		hour12: true,
+	});
+}

package/src/parse/zod.ts

@@ -0,0 +1,23 @@
+/**
+ * Zod Utilities
+ *
+ * Helper functions for working with Zod schemas.
+ */
+
+import { z } from "zod";
+
+/**
+ * Validate input using a Zod schema
+ * Throws a formatted error if validation fails
+ */
+export function validateWithZod<T>(schema: z.ZodType<T>, input: unknown): T {
+	const result = schema.safeParse(input);
+	if (!result.success) {
+		throw new Error(z.prettifyError(result.error));
+	}
+	return result.data;
+}
+
+export function zodToJsonSchema(schema: z.ZodTypeAny): Record<string, unknown> {
+	return z.toJSONSchema(schema);
+}

package/src/prompt/format.ts

@@ -0,0 +1,22 @@
+export function formatFileContentBlock(path: string, content: string): string {
+	return `<file_content path="${path}">\n${content}\n</file_content>`;
+}
+
+export function formatUserInputBlock(
+	input: string,
+	mode: "act" | "plan" = "act",
+): string {
+	return `<user_input mode="${mode}">${input}</user_input>`;
+}
+
+export function normalizeUserInput(input?: string): string {
+	if (!input?.trim()) return "";
+	return xmlTagsRemoval(input, "user_input");
+}
+
+export function xmlTagsRemoval(input?: string, tag?: string): string {
+	if (!input?.trim()) return "";
+	if (!tag) return input;
+	const regex = new RegExp(`<${tag}.*?>(.*?)</${tag}>`, "g");
+	return input.replace(regex, "$1");
+}