@cline/core 0.0.83 → 0.0.84-nightly.1790044161

package/dist/cron/service/schedule-tool.d.ts

@@ -6,10 +6,10 @@ export declare const ScheduledTaskInputSchema: z.ZodObject<{
         update: "update";
         create: "create";
         list: "list";
-        pause: "pause";
-        resume: "resume";
         get: "get";
         delete: "delete";
+        pause: "pause";
+        resume: "resume";
         run_now: "run_now";
     }>;
     schedule_id: z.ZodOptional<z.ZodString>;
@@ -24,8 +24,8 @@ export declare const ScheduledTaskInputSchema: z.ZodObject<{
     timezone: z.ZodOptional<z.ZodNullable<z.ZodString>>;
     enabled: z.ZodOptional<z.ZodBoolean>;
     mode: z.ZodOptional<z.ZodEnum<{
-        plan: "plan";
         act: "act";
+        plan: "plan";
         yolo: "yolo";
     }>>;
     system_prompt: z.ZodOptional<z.ZodNullable<z.ZodString>>;

package/dist/extensions/composio/composio-tools-extension.d.ts

@@ -0,0 +1,13 @@
+import type { AgentExtension, BasicLogger } from "@cline/shared";
+export declare function resolveComposioToolsStatePath(accountId: string): string;
+/**
+ * Builds the extension for the current connector state, or undefined when
+ * there is nothing to register (no state file, or no connected toolkit with
+ * tools) — sessions without connectors pay one file read.
+ *
+ * The state is read once here, at session-bootstrap time, so a session's
+ * tool set is frozen at start exactly like the previous plugin's was.
+ */
+export declare function createComposioToolsExtension(options?: {
+    logger?: BasicLogger;
+}): Promise<AgentExtension | undefined>;

package/dist/extensions/context/compaction-shared.d.ts

@@ -8,9 +8,17 @@ export declare const DEFAULT_MAX_INPUT_TOKENS = 128000;
 export declare const CONTEXT_WINDOW_INPUT_RATIO = 0.9;
 /** Compact once the transcript consumes this share of the usable input budget. */
 export declare const COMPACTION_TRIGGER_RATIO = 0.9;
+/**
+ * Upper bound on how far the provider's actual input count may scale the
+ * compaction budget down relative to the character-based estimate. Dense
+ * content realistically tokenizes ~2-3x denser than the 3-chars-per-token
+ * assumption; the cap stops a pathologically small estimate from collapsing
+ * the budget and compacting every turn.
+ */
+export declare const MAX_INPUT_UNDERESTIMATE_FACTOR = 4;
 export declare const DEFAULT_TARGET_RATIO = 0.7;
 export declare const DEFAULT_PRESERVE_RECENT_TOKENS = 20000;
-export declare const DEFAULT_SUMMARY_MAX_OUTPUT_TOKENS = 4096;
+export declare const DEFAULT_SUMMARY_MAX_OUTPUT_TOKENS = 8192;
 export declare const TOOL_RESULT_CHAR_LIMIT = 2000;
 export declare const FILE_CONTENT_CHAR_LIMIT = 2000;
 export declare const MIN_TRUNCATED_MESSAGE_TOKENS = 8;

package/dist/extensions/context/compaction.d.ts

@@ -19,6 +19,12 @@ export interface ContextPipelinePrepareTurnInput {
      * successful LLM request.
      */
     overflowRecovery?: boolean;
+    /**
+     * Actual provider-reported input tokens for the previous request this run,
+     * used as a floor on the char-based estimate so dense content still triggers
+     * compaction. See AgentPrepareTurnContext.previousRequestInputTokens.
+     */
+    previousRequestInputTokens?: number;
     emitStatusNotice?: (message: string, metadata?: Record<string, unknown>) => void;
 }
 export interface ContextPipelinePrepareTurnResult {

package/dist/extensions/tools/team/configured-agent-tool.d.ts

@@ -1,4 +1,4 @@
-import { type AgentEvent, type AgentTool, type AgentToolContext, type HookErrorMode, type ToolApprovalRequest, type ToolApprovalResult, type ToolPolicy } from "@cline/shared";
+import { type AgentEvent, type AgentTool, type AgentToolContext, type HookErrorMode } from "@cline/shared";
 import { z } from "zod";
 import type { ConfiguredAgentConfig } from "./configured-agent-config";
 import { type DelegatedAgentConfigProvider } from "./delegated-agent";
@@ -17,8 +17,6 @@ export interface ConfiguredAgentToolConfig {
     createSubAgentTools?: (agent: ConfiguredAgentConfig, input: ConfiguredAgentInput, context: AgentToolContext) => AgentTool[] | Promise<AgentTool[]>;
     onSubAgentEvent?: (event: AgentEvent) => void;
     hookErrorMode?: HookErrorMode;
-    toolPolicies?: Record<string, ToolPolicy>;
-    requestToolApproval?: (request: ToolApprovalRequest) => Promise<ToolApprovalResult> | ToolApprovalResult;
     onSubAgentStart?: (context: SubAgentStartContext) => void | Promise<void>;
     onSubAgentEnd?: (context: SubAgentEndContext) => void | Promise<void>;
 }

package/dist/hooks/hook-file-hooks.d.ts

@@ -1,4 +1,19 @@
 import type { AgentExtension, AgentHooks, BasicLogger, WorkspaceInfo } from "@cline/shared";
+import { type HookEventName } from "./subprocess";
+/**
+ * Reports how long a fire-and-forget hook actually ran, once per hook. Hosts
+ * use it to learn the real runtime distribution of detached hooks —
+ * unmeasurable while nothing awaits them — before deciding to run any of them
+ * blocking. `exited: false` is a censored observation (the hook was still
+ * running after the observation window, so it ran at least `durationMs`),
+ * which is what keeps the sample from covering only hooks that finish.
+ */
+export type HookRuntimeObserver = (event: {
+    hookName: HookEventName;
+    durationMs: number;
+    exitCode: number | null;
+    exited: boolean;
+}) => void;
 type HookRuntimeOptions = {
     cwd: string;
     workspacePath: string;
@@ -7,6 +22,18 @@ type HookRuntimeOptions = {
     toolCallTimeoutMs?: number;
     /** Keep asynchronous hooks attached until exit. Intended for deterministic tests. */
     detachAsyncHooks?: boolean;
+    /**
+     * Run agent_start/agent_resume hooks blocking, honoring their control
+     * output (cancel, contextModification). Off by default: these hooks have
+     * always been fire-and-forget with stdio ignored, so an existing
+     * long-running script would otherwise stall every run start until the
+     * timeout. A host that flips this on must tell hook authors that
+     * long-running run-start hooks need to background themselves (spawn a
+     * detached child and exit).
+     */
+    blockingRunStartHooks?: boolean;
+    /** Observes how long detached hooks run. See {@link HookRuntimeObserver}. */
+    onHookRuntime?: HookRuntimeObserver;
     /** Structured git + path metadata forwarded into every hook payload. */
     workspaceInfo?: WorkspaceInfo;
 };

package/dist/hooks/subprocess-runner.d.ts

@@ -9,6 +9,29 @@ export interface RunSubprocessEventOptions {
         pid?: number;
         detached: boolean;
     }) => void;
+    /**
+     * Reports a detached hook's runtime exactly once. The run never waits on
+     * this: detached hooks are fire-and-forget by contract, and this only
+     * observes them so hosts can measure how long they actually take.
+     *
+     * `exited: true` means the hook finished and `durationMs` is its runtime.
+     * `exited: false` is a censored observation: the hook was still running
+     * after the observation window, and `durationMs` is that window, so read
+     * it as "ran at least this long" and count these separately — the
+     * case that matters most, since those are the hooks that would stall a
+     * blocking run. Without it the sample would only contain hooks that
+     * finished.
+     *
+     * Nothing is reported if the parent exits before either happens.
+     */
+    onDetachedSettled?: (event: {
+        command: string[];
+        durationMs: number;
+        exitCode: number | null;
+        exited: boolean;
+    }) => void;
+    /** Overrides the censoring window for `onDetachedSettled`. */
+    detachedObservationMs?: number;
 }
 export interface RunSubprocessEventResult {
     exitCode: number | null;

package/dist/hooks/subprocess.d.ts

@@ -49,6 +49,16 @@ export interface SubprocessHooksOptions {
     workspaceInfo?: WorkspaceInfo;
     env?: NodeJS.ProcessEnv;
     timeoutMs?: number;
+    /**
+     * Run agent_start/agent_resume hooks blocking, honoring their control
+     * output (cancel, contextModification). Off by default: these hooks have
+     * always been fire-and-forget with stdio ignored, so an existing
+     * long-running script would otherwise stall every run start until the
+     * timeout. A host that flips this on must tell hook authors that
+     * long-running run-start hooks need to background themselves (spawn a
+     * detached child and exit).
+     */
+    blockingRunStartHooks?: boolean;
     onDispatchError?: (error: Error, payload: HookEventPayload) => void;
     onDispatch?: (event: {
         payload: HookEventPayload;

package/dist/hub/client/index.d.ts

@@ -1,5 +1,10 @@
 import { type HubClientRegistration, type HubCommandEnvelope, type HubEventEnvelope, type HubReplyEnvelope } from "@cline/shared";
 import { type HubOwnerContext } from "../discovery";
+type HubCommandOptions = {
+    timeoutMs?: number | null;
+    /** Synchronous local guard, checked after connection before each dispatch. */
+    beforeDispatch?: () => void;
+};
 export interface HubClientOptions {
     url: string;
     clientId?: string;
@@ -81,9 +86,7 @@ export declare class NodeHubClient {
     subscribe(listener: (event: HubEventEnvelope) => void, options?: {
         sessionId?: string;
     }): () => void;
-    command(command: HubCommandEnvelope["command"], payload?: Record<string, unknown>, sessionId?: string, options?: {
-        timeoutMs?: number | null;
-    }): Promise<HubReplyEnvelope>;
+    command(command: HubCommandEnvelope["command"], payload?: Record<string, unknown>, sessionId?: string, options?: HubCommandOptions): Promise<HubReplyEnvelope>;
     private commandOnce;
     private recoverLocalHubTransport;
     private hasActiveSubscriptions;
@@ -154,3 +157,4 @@ export declare function restartLocalHubIfIdleAfterStartupTimeout(options: {
     workspaceRoot?: string;
     cwd?: string;
 }): Promise<string | undefined>;
+export {};