@cline/core 0.0.45 → 0.0.46

package/dist/auth/cline.d.ts

@@ -1,5 +1,5 @@
 import { type ITelemetryService } from "@cline/shared";
-import type { OAuthCredentials, OAuthLoginCallbacks, OAuthProviderInterface } from "./types";
+import type { OAuthCredentials, OAuthLoginCallbacks } from "./types";
 export type ClineTokenResolution = {
     forceRefresh?: boolean;
     refreshBufferMs?: number;
@@ -60,5 +60,4 @@ export declare function completeClineDeviceAuth(options: {
 }): Promise<ClineOAuthCredentials>;
 export declare function refreshClineToken(current: ClineOAuthCredentials, options: ClineOAuthProviderOptions): Promise<ClineOAuthCredentials>;
 export declare function getValidClineCredentials(currentCredentials: ClineOAuthCredentials | null, providerOptions: ClineOAuthProviderOptions, options?: ClineTokenResolution): Promise<ClineOAuthCredentials | null>;
-export declare function createClineOAuthProvider(options: ClineOAuthProviderOptions): OAuthProviderInterface;
 export {};

package/dist/auth/codex.d.ts

@@ -5,7 +5,7 @@
  * It is only intended for CLI use, not browser environments.
  */
 import type { ITelemetryService } from "@cline/shared";
-import type { OAuthCredentials, OAuthPrompt, OAuthProviderInterface } from "./types";
+import type { OAuthCredentials, OAuthPrompt } from "./types";
 export declare const OPENAI_CODEX_OAUTH_CONFIG: {
     readonly authorizationEndpoint: "https://auth.openai.com/oauth/authorize";
     readonly tokenEndpoint: "https://auth.openai.com/oauth/token";
@@ -38,6 +38,3 @@ export declare function refreshOpenAICodexToken(refreshToken: string, fallback?:
 export declare function getValidOpenAICodexCredentials(currentCredentials: OAuthCredentials | null, options?: RefreshTokenResolution & {
     telemetry?: ITelemetryService;
 }): Promise<OAuthCredentials | null>;
-export declare function isOpenAICodexTokenExpired(credentials: OAuthCredentials, refreshBufferMs?: number): boolean;
-export declare function normalizeOpenAICodexCredentials(credentials: OAuthCredentials): OAuthCredentials;
-export declare const openaiCodexOAuthProvider: OAuthProviderInterface;

package/dist/auth/oca.d.ts

@@ -1,5 +1,5 @@
 import type { ITelemetryService } from "@cline/shared";
-import type { OAuthCredentials, OAuthLoginCallbacks, OAuthProviderInterface, OcaClientMetadata, OcaOAuthProviderOptions, OcaTokenResolution } from "./types";
+import type { OAuthCredentials, OAuthLoginCallbacks, OcaOAuthProviderOptions, OcaTokenResolution } from "./types";
 export declare const DEFAULT_INTERNAL_IDCS_CLIENT_ID = "a8331954c0cf48ba99b5dd223a14c6ea";
 export declare const DEFAULT_INTERNAL_IDCS_URL = "https://idcs-9dc693e80d9b469480d7afe00e743931.identity.oraclecloud.com";
 export declare const DEFAULT_INTERNAL_IDCS_SCOPES = "openid offline_access";
@@ -19,10 +19,3 @@ export declare function getValidOcaCredentials(currentCredentials: OAuthCredenti
 }, providerOptions?: OcaOAuthProviderOptions & {
     telemetry?: ITelemetryService;
 }): Promise<OAuthCredentials | null>;
-export declare function createOcaOAuthProvider(options?: OcaOAuthProviderOptions): OAuthProviderInterface;
-export declare function generateOcaOpcRequestId(taskId: string, token: string): Promise<string>;
-export declare function createOcaRequestHeaders(input: {
-    accessToken: string;
-    taskId: string;
-    metadata?: OcaClientMetadata;
-}): Promise<Record<string, string>>;

package/dist/auth/provider-auth-registry.d.ts

@@ -0,0 +1,52 @@
+import { type ITelemetryService } from "@cline/shared";
+import type { ProviderSettingsManager } from "../services/storage/provider-settings-manager";
+import type { ProviderSettings } from "../types/provider-settings";
+import type { OAuthCredentials, OAuthLoginCallbacks } from "./types";
+export type ProviderOAuthCredentials = OAuthCredentials;
+export interface ProviderAuthLoginInput {
+    settings?: ProviderSettings;
+    callbacks: OAuthLoginCallbacks;
+    telemetry?: ITelemetryService;
+}
+export interface ProviderAuthRefreshInput {
+    settings: ProviderSettings;
+    credentials: ProviderOAuthCredentials;
+    forceRefresh?: boolean;
+    telemetry?: ITelemetryService;
+}
+export interface ProviderAuthSaveCredentialsInput {
+    manager: ProviderSettingsManager;
+    settings?: ProviderSettings;
+    credentials: ProviderOAuthCredentials;
+    setLastUsed?: boolean;
+    save?: boolean;
+}
+export interface ProviderAuthHandler {
+    providerId: string;
+    storageProviderId: string;
+    getApiKey(settings: ProviderSettings | undefined): string | undefined;
+    login(input: ProviderAuthLoginInput): Promise<ProviderOAuthCredentials>;
+    refresh(input: ProviderAuthRefreshInput): Promise<ProviderOAuthCredentials | null>;
+    saveCredentials(input: ProviderAuthSaveCredentialsInput): ProviderSettings;
+    isConfigured(settings: ProviderSettings | undefined): boolean;
+    normalizeStoredAccessToken?(accessToken: string): string;
+}
+export declare function getProviderAuthHandler(providerId: string): ProviderAuthHandler | undefined;
+export declare function isOAuthProvider(providerId: string): boolean;
+export declare function getProviderAuthStorageId(providerId: string): string | undefined;
+export declare function resolveProviderApiKeyFromSettings(manager: ProviderSettingsManager, providerId: string): string | undefined;
+export declare function loginAndSaveProviderOAuthCredentials(manager: ProviderSettingsManager, providerId: string, input: {
+    callbacks: OAuthLoginCallbacks;
+    telemetry?: ITelemetryService;
+}): Promise<ProviderSettings>;
+export declare function getProviderOAuthCredentialsFromSettings(providerId: string, settings: ProviderSettings): ProviderOAuthCredentials | null;
+export declare function saveProviderOAuthCredentials(input: {
+    manager: ProviderSettingsManager;
+    providerId: string;
+    settings?: ProviderSettings;
+    credentials: ProviderOAuthCredentials;
+    setLastUsed?: boolean;
+    save?: boolean;
+}): ProviderSettings;
+export declare function getPersistedProviderApiKey(providerId: string, settings?: ProviderSettings): string | undefined;
+export declare function formatProviderOAuthApiKey(providerId: string, credentials: Pick<ProviderOAuthCredentials, "access">): string;

package/dist/extensions/config/user-instruction-service.d.ts

@@ -1,4 +1,5 @@
 import type { AgentExtension } from "@cline/shared";
+import type { SkillsExecutorWithMetadata } from "../tools";
 import { type AvailableRuntimeCommand } from "./runtime-commands";
 import { type CreateUserInstructionConfigWatcherOptions, type UserInstructionConfig, type UserInstructionConfigType } from "./user-instruction-config-loader";
 import { type CreateUserInstructionPluginOptions } from "./user-instruction-plugin";
@@ -18,6 +19,7 @@ export interface UserInstructionConfigService {
     listRuntimeCommands(): AvailableRuntimeCommand[];
     resolveRuntimeSlashCommand(input: string): string;
     hasConfiguredSkills(allowedSkillNames?: ReadonlyArray<string>): boolean;
+    createSkillsExecutor?(allowedSkillNames?: ReadonlyArray<string>): SkillsExecutorWithMetadata;
     createExtension(options: Omit<CreateUserInstructionPluginOptions, "watcher" | "watcherReady">): AgentExtension;
 }
 export declare function createUserInstructionConfigService(options?: CreateUserInstructionConfigServiceOptions): UserInstructionConfigService;

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

@@ -0,0 +1,26 @@
+export interface ConfiguredAgentConfig {
+    name: string;
+    description: string;
+    tools?: string[];
+    skills?: string[];
+    providerId?: string;
+    modelId?: string;
+    maxIterations?: number;
+    systemPrompt: string;
+    path?: string;
+}
+export interface ConfiguredAgentReadError {
+    path: string;
+    error: Error;
+}
+export interface ConfiguredAgentLoadResult {
+    configs: ConfiguredAgentConfig[];
+    errors: ConfiguredAgentReadError[];
+}
+export declare function parseConfiguredAgentConfig(content: string, options?: {
+    path?: string;
+}): ConfiguredAgentConfig;
+export declare function loadConfiguredAgentConfigs(input: {
+    workspaceRoot?: string;
+    searchPaths?: string[];
+}): ConfiguredAgentLoadResult;

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

@@ -0,0 +1,28 @@
+import { type AgentEvent, type AgentTool, type AgentToolContext, type HookErrorMode, type ToolApprovalRequest, type ToolApprovalResult, type ToolPolicy } from "@cline/shared";
+import { z } from "zod";
+import type { ConfiguredAgentConfig } from "./configured-agent-config";
+import { type DelegatedAgentConfigProvider } from "./delegated-agent";
+import type { SubAgentEndContext, SubAgentStartContext } from "./spawn-agent-tool";
+declare const ConfiguredAgentInputSchema: z.ZodObject<{
+    prompt: z.ZodString;
+}, z.core.$strip>;
+export type ConfiguredAgentInput = z.infer<typeof ConfiguredAgentInputSchema>;
+export interface ConfiguredAgentToolDescriptor {
+    toolName: string;
+    config: ConfiguredAgentConfig;
+}
+export interface ConfiguredAgentToolConfig {
+    configProvider: DelegatedAgentConfigProvider;
+    agents: ConfiguredAgentConfig[];
+    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>;
+}
+export declare function buildConfiguredAgentToolName(agentName: string): string;
+export declare function buildConfiguredAgentToolDescriptors(agents: readonly ConfiguredAgentConfig[]): ConfiguredAgentToolDescriptor[];
+export declare function createConfiguredAgentTools(options: ConfiguredAgentToolConfig): AgentTool[];
+export {};

package/dist/extensions/tools/team/index.d.ts

@@ -1,2 +1,5 @@
+export { type ConfiguredAgentConfig, type ConfiguredAgentLoadResult, type ConfiguredAgentReadError, loadConfiguredAgentConfigs, parseConfiguredAgentConfig, } from "./configured-agent-config";
+export { buildConfiguredAgentToolDescriptors, buildConfiguredAgentToolName, type ConfiguredAgentInput, type ConfiguredAgentToolConfig, type ConfiguredAgentToolDescriptor, createConfiguredAgentTools, } from "./configured-agent-tool";
 export { buildTeamProgressSummary, toTeamProgressLifecycleEvent, } from "./projections";
 export * from "./runtime";
+export type { SubAgentEndContext, SubAgentStartContext, } from "./spawn-agent-tool";