@cline/shared 0.0.38-nightly.1778113663

package/dist/llms/ai-sdk-format.d.ts

@@ -0,0 +1,42 @@
+export type AiSdkFormatterMessageRole = "user" | "assistant" | "tool";
+export type AiSdkFormatterPart = {
+    type: "text";
+    text: string;
+} | {
+    type: "reasoning";
+    text: string;
+    providerOptions?: Record<string, Record<string, unknown>>;
+} | {
+    type: "image";
+    image: string | Uint8Array | ArrayBuffer | URL;
+    mediaType?: string;
+} | {
+    type: "file";
+    path: string;
+    content: string;
+} | {
+    type: "tool-call";
+    toolCallId: string;
+    toolName: string;
+    input: unknown;
+    providerOptions?: Record<string, Record<string, unknown>>;
+} | {
+    type: "tool-result";
+    toolCallId: string;
+    toolName: string;
+    output: unknown;
+    isError?: boolean;
+};
+export interface AiSdkFormatterMessage {
+    role: AiSdkFormatterMessageRole;
+    content: string | AiSdkFormatterPart[];
+}
+export type AiSdkMessagePart = Record<string, unknown>;
+export type AiSdkMessage = {
+    role: "system" | "user" | "assistant" | "tool";
+    content: string | AiSdkMessagePart[];
+};
+export declare function toAiSdkToolResultOutput(output: unknown, isError?: boolean): Record<string, unknown>;
+export declare function formatMessagesForAiSdk(systemContent: string | AiSdkMessagePart[] | undefined, messages: readonly AiSdkFormatterMessage[], options?: {
+    assistantToolCallArgKey?: "args" | "input";
+}): AiSdkMessage[];

package/dist/llms/gateway.d.ts

@@ -0,0 +1,117 @@
+import type { AgentMessage, AgentModelEvent, AgentToolDefinition } from "../agent";
+import type { BasicLogger } from "../logging/logger";
+import type { ProviderCapability } from "../rpc/runtime";
+export type JsonValue = string | number | boolean | null | JsonValue[] | {
+    [key: string]: JsonValue | undefined;
+};
+export type GatewayModelCapability = "text" | "tools" | "reasoning" | "images" | "audio" | "structured-output";
+export type GatewayPromptCacheStrategy = "anthropic-automatic";
+export type GatewayUsageCostDisplay = "show" | "hide";
+export interface GatewayProviderMetadata {
+    promptCacheStrategy?: GatewayPromptCacheStrategy;
+    usageCostDisplay?: GatewayUsageCostDisplay;
+    [key: string]: JsonValue | undefined;
+}
+export interface GatewayModelDefinition {
+    id: string;
+    name: string;
+    providerId: string;
+    description?: string;
+    contextWindow?: number;
+    maxOutputTokens?: number;
+    capabilities?: readonly GatewayModelCapability[];
+    metadata?: Record<string, JsonValue | undefined>;
+}
+export interface GatewayProviderManifest {
+    id: string;
+    name: string;
+    description?: string;
+    defaultModelId: string;
+    models: readonly GatewayModelDefinition[];
+    capabilities?: readonly ProviderCapability[];
+    env?: readonly ("browser" | "node")[];
+    api?: string;
+    apiKeyEnv?: readonly string[];
+    docsUrl?: string;
+    metadata?: GatewayProviderMetadata;
+}
+export interface GatewayProviderSettings {
+    apiKey?: string;
+    apiKeyResolver?: () => string | undefined | Promise<string | undefined>;
+    apiKeyEnv?: readonly string[];
+    baseUrl?: string;
+    headers?: Record<string, string>;
+    timeoutMs?: number;
+    fetch?: typeof fetch;
+    options?: Record<string, unknown>;
+    metadata?: GatewayProviderMetadata;
+}
+export interface GatewayResolvedProviderConfig extends GatewayProviderSettings {
+    providerId: string;
+}
+export interface GatewayProviderConfig extends GatewayProviderSettings {
+    providerId: string;
+    enabled?: boolean;
+    defaultModelId?: string;
+    models?: readonly Omit<GatewayModelDefinition, "providerId">[];
+}
+export interface GatewayModelSelection {
+    providerId: string;
+    modelId?: string;
+}
+export interface GatewayResolvedModel {
+    provider: GatewayProviderManifest;
+    model: GatewayModelDefinition;
+}
+export interface GatewayProviderContext {
+    provider: GatewayProviderManifest;
+    model: GatewayModelDefinition;
+    config: GatewayResolvedProviderConfig;
+    signal?: AbortSignal;
+    logger?: BasicLogger;
+}
+export interface GatewayStreamRequest {
+    providerId: string;
+    modelId: string;
+    systemPrompt?: string;
+    messages: readonly AgentMessage[];
+    tools?: readonly AgentToolDefinition[];
+    temperature?: number;
+    maxTokens?: number;
+    metadata?: Record<string, unknown>;
+    reasoning?: {
+        enabled?: boolean;
+        effort?: "low" | "medium" | "high";
+        budgetTokens?: number;
+    };
+    signal?: AbortSignal;
+}
+export interface GatewayProvider {
+    stream(request: GatewayStreamRequest, context: GatewayProviderContext): AsyncIterable<AgentModelEvent> | Promise<AsyncIterable<AgentModelEvent>>;
+}
+export type GatewayProviderFactory = (config: GatewayResolvedProviderConfig) => GatewayProvider | Promise<GatewayProvider>;
+export interface GatewayProviderRegistration {
+    manifest: GatewayProviderManifest;
+    defaults?: GatewayProviderSettings;
+    createProvider?: GatewayProviderFactory;
+    loadProvider?: () => Promise<Pick<GatewayProviderRegistration, "createProvider">>;
+}
+export interface GatewayModelHandleOptions {
+    tools?: readonly AgentToolDefinition[];
+    temperature?: number;
+    maxTokens?: number;
+    metadata?: Record<string, unknown>;
+    reasoning?: {
+        enabled?: boolean;
+        effort?: "low" | "medium" | "high";
+        budgetTokens?: number;
+    };
+    signal?: AbortSignal;
+}
+export interface GatewayConfig {
+    builtins?: false | readonly string[];
+    providers?: readonly GatewayProviderRegistration[];
+    providerConfigs?: readonly GatewayProviderConfig[];
+    fetch?: typeof fetch;
+    logger?: BasicLogger;
+}

package/dist/llms/messages.d.ts

@@ -0,0 +1,147 @@
+/**
+ * Message Types
+ *
+ * Standardized message format for input to providers.
+ * This is a simplified, provider-agnostic format that can be
+ * converted to any provider's native format.
+ */
+/**
+ * Message roles
+ */
+export type MessageRole = "user" | "assistant";
+/**
+ * Text content block
+ */
+export interface TextContent {
+    type: "text";
+    text: string;
+    /** Thought signature for this text part (Gemini) */
+    signature?: string;
+}
+/**
+ * File content block for Cline
+ */
+export interface FileContent {
+    type: "file";
+    content: string;
+    /** Absolute Path */
+    path: string;
+    source?: string;
+}
+/**
+ * Image content block
+ */
+export interface ImageContent {
+    type: "image";
+    /** Base64 encoded image data */
+    data: string;
+    /** MIME type (e.g., "image/png", "image/jpeg") */
+    mediaType: string;
+}
+/**
+ * Tool use content block (assistant's tool call)
+ */
+export interface ToolUseContent {
+    type: "tool_use";
+    /** Unique ID for this tool call */
+    id: string;
+    /** Provider-native call ID for this tool call (if available) */
+    call_id?: string;
+    /** Name of the tool being called */
+    name: string;
+    /** Arguments for the tool call */
+    input: Record<string, unknown>;
+    /** Thought signature for this function call part (Gemini) */
+    signature?: string;
+}
+/**
+ * Tool result content block (user's response to tool call)
+ */
+export interface ToolResultContent {
+    type: "tool_result";
+    /** ID of the tool call this is responding to */
+    tool_use_id: string;
+    /** Result content (can be text or error) */
+    content: string | Array<TextContent | ImageContent | FileContent>;
+    /** Whether this result represents an error */
+    is_error?: boolean;
+}
+/**
+ * Thinking/reasoning content block
+ */
+export interface ThinkingContent {
+    type: "thinking";
+    /** The thinking/reasoning text */
+    thinking: string;
+    /** Signature for the thinking block (provider-specific) */
+    signature?: string;
+    /** Provider-native call ID for this reasoning block (if available) */
+    call_id?: string;
+    /** Structured reasoning details that can be replayed for tool-call continuation */
+    details?: unknown[];
+    /** Backward-compatible alias used by some internal processors */
+    summary?: unknown[];
+}
+/**
+ * Redacted thinking content block
+ */
+export interface RedactedThinkingContent {
+    type: "redacted_thinking";
+    /** Encrypted/redacted data */
+    data: string;
+    /** Provider-native call ID for this reasoning block (if available) */
+    call_id?: string;
+}
+/**
+ * Union of all content block types
+ */
+export type ContentBlock = TextContent | ImageContent | ToolUseContent | ToolResultContent | ThinkingContent | FileContent | RedactedThinkingContent;
+/**
+ * A single message in the conversation
+ */
+export interface Message {
+    /** Message role */
+    role: MessageRole;
+    /** Message content - can be a simple string or array of content blocks */
+    content: string | ContentBlock[];
+}
+/**
+ * Extended message with metadata (used for storage/history)
+ */
+export interface MessageWithMetadata extends Message {
+    /** Unique message ID */
+    id?: string;
+    /** Logical agent kind for persisted session/history consumers */
+    agent?: string;
+    /** Concrete session id that owns this persisted message */
+    sessionId?: string;
+    /** Additional message metadata for storage/history consumers */
+    metadata?: Record<string, unknown>;
+    /** Model info at the time of generation */
+    modelInfo?: {
+        id: string;
+        provider: string;
+        family?: string;
+    };
+    /** Token usage metrics */
+    metrics?: {
+        inputTokens?: number;
+        outputTokens?: number;
+        cacheReadTokens?: number;
+        cacheWriteTokens?: number;
+        cost?: number;
+    };
+    /** Timestamp of when the message was created */
+    ts?: number;
+}
+/**
+ * Tool definition for native tool calling
+ */
+export interface ToolDefinition {
+    /** Tool name */
+    name: string;
+    /** Tool description */
+    description: string;
+    /** JSON Schema for the tool's input parameters */
+    inputSchema: Record<string, unknown>;
+}

package/dist/llms/model-info.d.ts

@@ -0,0 +1,112 @@
+/**
+ * Model Information Types
+ *
+ * Zod schemas and inferred types for model capabilities, pricing,
+ * and metadata. These live in shared so that agent types can reference
+ * ModelInfo without depending on @cline/llms.
+ */
+import { z } from "zod";
+export declare const ApiFormatSchema: z.ZodEnum<{
+    default: "default";
+    "openai-responses": "openai-responses";
+    r1: "r1";
+}>;
+export type ApiFormat = z.infer<typeof ApiFormatSchema>;
+export declare const ApiFormat: {
+    readonly DEFAULT: "default";
+    readonly OPENAI_RESPONSES: "openai-responses";
+    readonly R1: "r1";
+};
+export declare const ModelCapabilitySchema: z.ZodEnum<{
+    images: "images";
+    tools: "tools";
+    streaming: "streaming";
+    "prompt-cache": "prompt-cache";
+    reasoning: "reasoning";
+    "reasoning-effort": "reasoning-effort";
+    "computer-use": "computer-use";
+    "global-endpoint": "global-endpoint";
+    structured_output: "structured_output";
+    temperature: "temperature";
+    files: "files";
+}>;
+export type ModelCapability = z.infer<typeof ModelCapabilitySchema>;
+export declare const ModelStatusSchema: z.ZodEnum<{
+    active: "active";
+    preview: "preview";
+    deprecated: "deprecated";
+    legacy: "legacy";
+}>;
+export type ModelStatus = z.infer<typeof ModelStatusSchema>;
+export declare const ModelPricingSchema: z.ZodObject<{
+    input: z.ZodOptional<z.ZodNumber>;
+    output: z.ZodOptional<z.ZodNumber>;
+    cacheWrite: z.ZodOptional<z.ZodNumber>;
+    cacheRead: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export type ModelPricing = z.infer<typeof ModelPricingSchema>;
+export declare const ThinkingConfigSchema: z.ZodObject<{
+    maxBudget: z.ZodOptional<z.ZodNumber>;
+    outputPrice: z.ZodOptional<z.ZodNumber>;
+    thinkingLevel: z.ZodOptional<z.ZodEnum<{
+        low: "low";
+        high: "high";
+    }>>;
+}, z.core.$strip>;
+export type ThinkingConfig = z.infer<typeof ThinkingConfigSchema>;
+export declare const ModelInfoSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    maxTokens: z.ZodOptional<z.ZodNumber>;
+    contextWindow: z.ZodOptional<z.ZodNumber>;
+    capabilities: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        images: "images";
+        tools: "tools";
+        streaming: "streaming";
+        "prompt-cache": "prompt-cache";
+        reasoning: "reasoning";
+        "reasoning-effort": "reasoning-effort";
+        "computer-use": "computer-use";
+        "global-endpoint": "global-endpoint";
+        structured_output: "structured_output";
+        temperature: "temperature";
+        files: "files";
+    }>>>;
+    apiFormat: z.ZodOptional<z.ZodEnum<{
+        default: "default";
+        "openai-responses": "openai-responses";
+        r1: "r1";
+    }>>;
+    systemRole: z.ZodOptional<z.ZodEnum<{
+        system: "system";
+        developer: "developer";
+    }>>;
+    temperature: z.ZodOptional<z.ZodNumber>;
+    pricing: z.ZodOptional<z.ZodObject<{
+        input: z.ZodOptional<z.ZodNumber>;
+        output: z.ZodOptional<z.ZodNumber>;
+        cacheWrite: z.ZodOptional<z.ZodNumber>;
+        cacheRead: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    thinkingConfig: z.ZodOptional<z.ZodObject<{
+        maxBudget: z.ZodOptional<z.ZodNumber>;
+        outputPrice: z.ZodOptional<z.ZodNumber>;
+        thinkingLevel: z.ZodOptional<z.ZodEnum<{
+            low: "low";
+            high: "high";
+        }>>;
+    }, z.core.$strip>>;
+    status: z.ZodOptional<z.ZodEnum<{
+        active: "active";
+        preview: "preview";
+        deprecated: "deprecated";
+        legacy: "legacy";
+    }>>;
+    deprecationNotice: z.ZodOptional<z.ZodString>;
+    replacedBy: z.ZodOptional<z.ZodString>;
+    releaseDate: z.ZodOptional<z.ZodString>;
+    deprecationDate: z.ZodOptional<z.ZodString>;
+    family: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type ModelInfo = z.infer<typeof ModelInfoSchema>;

package/dist/llms/reasoning-effort.d.ts

@@ -0,0 +1,21 @@
+export declare const REASONING_EFFORT_RATIOS: {
+    readonly xhigh: 0.95;
+    readonly high: 0.8;
+    readonly medium: 0.5;
+    readonly low: 0.2;
+    readonly minimal: 0.1;
+    readonly none: 0;
+};
+export type ReasoningEffortValue = keyof typeof REASONING_EFFORT_RATIOS;
+export declare const DEFAULT_REASONING_EFFORT: ReasoningEffortValue | undefined;
+export declare function resolveEffectiveReasoningEffort(reasoningEffort?: string, thinking?: boolean): ReasoningEffortValue | undefined;
+export declare function resolveReasoningEffortRatio(effort?: string, options?: {
+    fallbackEffort?: ReasoningEffortValue;
+}): number | undefined;
+export declare function resolveReasoningBudgetFromRatio(options: {
+    effort?: string;
+    maxBudget: number;
+    scaleTokens?: number;
+    minimumBudget?: number;
+    fallbackEffort?: ReasoningEffortValue;
+}): number | undefined;

package/dist/llms/requests.d.ts

@@ -0,0 +1,2 @@
+export declare const DEFAULT_REQUEST_HEADERS: Record<string, string>;
+export declare function serializeAbortReason(reason: unknown): unknown;

package/dist/llms/tools.d.ts

@@ -0,0 +1,86 @@
+/**
+ * Shared tool policy and execution record types.
+ */
+import { z } from "zod";
+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;
+}
+/**
+ * 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 {
+    /**
+     * Core/hub runtime session identifier.
+     *
+     * This is the routing and lifecycle id for the task/session that owns the
+     * tool call. Hosts and hub transports use it to deliver approval events to
+     * clients subscribed to that session and to correlate approval responses
+     * with the pending runtime session. It should not be used as the transcript
+     * id for model history.
+     */
+    sessionId: string;
+    /**
+     * Agent instance identifier.
+     *
+     * This identifies the lead or delegated agent that requested the tool call.
+     * It is used for attribution in approval prompts, events, telemetry, and
+     * team/sub-agent flows. It is not a hub routing key and should not be used
+     * to find the owning runtime session.
+     */
+    agentId: string;
+    /**
+     * Agent conversation/transcript identifier.
+     *
+     * This identifies the model conversation that produced the tool call. Tools,
+     * hooks, telemetry, and persisted session metadata use it to correlate work
+     * with the agent's message history. It is contextual data, not the hub event
+     * routing key.
+     */
+    conversationId: string;
+    iteration: number;
+    toolCallId: string;
+    toolName: string;
+    input: unknown;
+    policy: ToolPolicy;
+}
+export interface ToolApprovalResult {
+    approved: boolean;
+    reason?: string;
+}
+export declare const ToolCallRecordSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    input: z.ZodUnknown;
+    output: z.ZodUnknown;
+    error: z.ZodOptional<z.ZodString>;
+    durationMs: z.ZodNumber;
+    startedAt: z.ZodDate;
+    endedAt: z.ZodDate;
+}, z.core.$strip>;

package/dist/logging/logger.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Cross-package logging surface for hosts that inject their own logger (for example `pino` or the VS Code API).
+ *
+ * {@link BasicLogger.debug} is for verbose diagnostics (hosts typically gate this behind a debug log level).
+ * {@link BasicLogger.log} is the primary channel for operational messages that are not errors.
+ * {@link BasicLogger.error} is optional; when omitted, hosts may route failures through {@link BasicLogger.log}
+ * with {@link BasicLogMetadata.severity} `"error"` or handle errors elsewhere.
+ *
+ * Use {@link noopBasicLogger} when you need a fully-defined no-op implementation.
+ */
+/**
+ * Optional structured fields used across the SDK and recommended for host log backends.
+ * Callers may add other keys freely; these names are the shared convention for cross-component queries.
+ */
+export interface BasicLogMetadata extends Record<string, unknown> {
+    sessionId?: string;
+    runId?: string;
+    providerId?: string;
+    toolName?: string;
+    durationMs?: number;
+    /**
+     * When using {@link BasicLogger.log}, disambiguates severity for backends that map a single `log`
+     * method onto multiple output levels (for example Pino `info` vs `warn`).
+     */
+    severity?: "info" | "warn" | "error";
+}
+export interface BasicLogger {
+    /** Verbose diagnostics; hosts should no-op or filter when not in debug mode. */
+    debug: (message: string, metadata?: BasicLogMetadata) => void;
+    /** Operational messages (replaces former `info` / non-error `warn` split). */
+    log: (message: string, metadata?: BasicLogMetadata) => void;
+    error?: (message: string, metadata?: BasicLogMetadata & {
+        error?: unknown;
+    }) => void;
+}
+/** All levels implemented as no-ops; safe default when no logger is injected. */
+export declare const noopBasicLogger: BasicLogger;

package/dist/parse/error.d.ts

@@ -0,0 +1,2 @@
+export declare function getErrorMessage(error: unknown): string;
+export declare function getErrorCode(error: unknown): string;

package/dist/parse/headers/utils.d.ts

@@ -0,0 +1 @@
+export declare function parseKeyPairsIntoRecord(value?: string): Record<string, string>;

package/dist/parse/json.d.ts

@@ -0,0 +1,3 @@
+export declare function parseJsonStream(input: unknown): unknown;
+export declare function safeJsonStringify(input: unknown): string;
+export declare function safeJsonParse<T>(raw: string): T | undefined;

package/dist/parse/shell.d.ts

@@ -0,0 +1,2 @@
+export declare function getDefaultShell(platform: string): string;
+export declare function getShellArgs(shell: string, command: string): string[];

package/dist/parse/string.d.ts

@@ -0,0 +1,4 @@
+export declare function sanitizeFileName(value: string): string;
+export declare function truncateStr(str: string, maxLen: number): string;
+export declare function truncateSplit(str?: string, splitBy?: string, maxLen?: number): string;
+export declare function maskSecret(value: string): string;

package/dist/parse/time.d.ts

@@ -0,0 +1,9 @@
+/**
+ * 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 declare function formatHumanReadableDate(dateStr?: string): string;
+export declare function formatUptime(ms: number): string;

package/dist/parse/zod.d.ts

@@ -0,0 +1,12 @@
+/**
+ * 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 declare function validateWithZod<T>(schema: z.ZodType<T>, input: unknown): T;
+export declare function zodToJsonSchema(schema: z.ZodTypeAny): Record<string, unknown>;

package/dist/prompt/cline.d.ts

@@ -0,0 +1,24 @@
+import type { WorkspaceContext } from "../extensions/context";
+import type { WorkspaceInfo } from "../session/workspace";
+export declare function processWorkspaceInfo(info: WorkspaceInfo): string;
+/**
+ * Options for building the Cline system prompt.
+ *
+ * Extends WorkspaceContext so callers can spread an ExtensionContext.workspace
+ * directly. `workspaceRoot` is accepted as an alias for `rootPath` to support
+ * existing call sites that set it explicitly.
+ */
+export interface ClineSystemPromptOptions extends Omit<WorkspaceContext, "rootPath"> {
+    /**
+     * Workspace root path. Accepts either `rootPath` (from WorkspaceContext/WorkspaceInfo)
+     * or `workspaceRoot` (legacy alias) — whichever is provided will be used.
+     */
+    rootPath?: string;
+    /** Alias for rootPath — kept for backwards compatibility with existing call sites */
+    workspaceRoot?: string;
+    /** Per-request system prompt override */
+    overridePrompt?: string;
+    /** Provider ID — used to gate Cline-specific metadata injection */
+    providerId?: string;
+}
+export declare function buildClineSystemPrompt(options: ClineSystemPromptOptions): string;

package/dist/prompt/format.d.ts

@@ -0,0 +1,11 @@
+export declare function formatFileContentBlock(path: string, content: string): string;
+export declare function formatUserInputBlock(input: string, mode?: "act" | "plan" | "yolo"): string;
+export declare function formatUserCommandBlock(input: string, slash: string): string;
+export type UserCommandEnvelope = {
+    slash: string;
+    content: string;
+};
+export declare function parseUserCommandEnvelope(input?: string): UserCommandEnvelope | undefined;
+export declare function normalizeUserInput(input?: string): string;
+export declare function formatDisplayUserInput(input?: string): string;
+export declare function xmlTagsRemoval(input?: string, tag?: string): string;

package/dist/prompt/system.d.ts

@@ -0,0 +1,2 @@
+export declare const DEFAULT_CLINE_SYSTEM_PROMPT = "You are Cline, an AI coding agent. Your primary goal is to assist users with various coding tasks by leveraging your knowledge and the tools at your disposal. Given the user's prompt, you should use the tools available to you to answer user's question.\n\nAlways gather all the necessary context before starting to work on a task. For example, if you are generating a unit test or new code, make sure you understand the requirement, the naming conventions, frameworks and libraries used and aligned in the current codebase, and the environment and commands used to run and test the code etc. Always validate the new unit test at the end including running the code if possible for live feedback.\nReview each question carefully and answer it with detailed, accurate information.\nIf you need more information, use one of the available tools or ask for clarification instead of making assumptions or lies.\n\nEnvironment you are running in:\n<env>\n1. Platform: {{PLATFORM_NAME}}\n2. Date: {{CURRENT_DATE}}\n3. IDE: {{IDE_NAME}}\n4. Working Directory: {{CWD}}\n</env>\n\nRemember:\n- Always adhere to existing code conventions and patterns.\n- Use only libraries and frameworks that are confirmed to be in use in the current codebase.\n- Provide complete and functional code without omissions or placeholders.\n- Be explicit about any assumptions or limitations in your solution.\n- Always show your planning process before executing any task. This will help ensure that you have a clear understanding of the requirements and that your approach aligns with the user's needs.\n- Always use absolute paths when referring to files.\n- Always verify the files you have edited or created at the end of the task to ensure they are completed and working as expected.\n\nBegin by analyzing the user's input and gathering any necessary additional context. Then, present your plan at the start of your response along with tool calls before proceeding with the task. It's OK for this section to be quite long.\n\nREMEMBER, be helpful and proactive! Don't ask for permission to do something when you can do it! Do not indicates you will be using a tool unless you are actually going to use it.\n\nIMPORTANT: Always includes tool calls in your response until the task is completed. Response without tool calls will considered as completed with final answer.\n\nWhen you have completed the task, please provide a summary of what you did and any relevant information that the user should know. This will help ensure that the user understands the changes made and can easily follow up if they have any questions or need further assistance. Do not indicate that you will perform an action without actually doing it. Always provide the final result in your response. Always validate your answer with checking the code and running it if possible. \n\nIf user asked a simple question without any coding context, answer it directly without using any tools.\n{{CLINE_RULES}}\n{{CLINE_METADATA}}";
+export declare const YOLO_CLINE_SYSTEM_PROMPT = "You are Cline, a careful and helpful coding agent that works in the background.\nYou are tasked to solve an issue reported by the user who you cannot communicate with directly.\nYour goal is to utilize the tools at your disposal to investigate and answer the question according to user's instructions with the aim to verify that the issue is resolved.\n\nRULES:\n- Always adhere to existing code conventions and patterns.\n- Use only libraries and frameworks that are confirmed and compatible to be in use in the current codebase.\n- Provide complete and functional code without omissions or placeholders.\n- Always show your planning process before executing any task. This will help ensure that you have a clear understanding of the requirements and that your approach aligns with the user's request.\n- Always use absolute paths when referring to files.\n- Always verify the files you have edited or created at the end of the task to ensure they are completed and working as expected.\n\nEnvironment you are running in:\n<env>\n1. Platform: {{PLATFORM_NAME}}\n2. Date: {{CURRENT_DATE}}\n3. IDE: {{IDE_NAME}}\n4. Working Directory: {{CWD}}\n</env>\n\nIMPORTANT: \nWhen the user describes a bug, unexpected behavior, or provides a bug report, your primary goal is to produce a correct fix in the source code that resolves the issue. \nA correct fix means the underlying behavior is fixed \u2014 not just the symptoms addressed superficially. \nAfter applying your fix, you must run the relevant test suite to confirm your changes actually resolve the problem. If tests fail, analyze the failures, revise your fix, and re-run until tests pass. \nDo not consider the task complete until tests pass.\nAlways includes tool calls in your response until the task is completed. You should only end the task when all the requirements are met by calling the 'submit_and_exit' tool.\nResponse without the submit_and_exit tool call will considered not completed and the task will continue.\n{{CLINE_RULES}}\n{{CLINE_METADATA}}";

package/dist/remote-config/constants.d.ts

@@ -0,0 +1,5 @@
+/**
+ * URI scheme for opening remote rules/workflows in the editor.
+ * Used to construct URIs like: remote://rule/{name} or remote://workflow/{name}
+ */
+export declare const REMOTE_URI_SCHEME = "remote://";