| |
| import type { OpenClawConfig } from "../../config/types.openclaw.js"; |
| import type { ProviderRuntimeModel } from "../../plugins/provider-runtime-model.types.js"; |
| import { parseAgentSessionKey } from "../../routing/session-key.js"; |
| import { isDefaultAgentRuntimeId, normalizeOptionalAgentRuntimeId } from "../agent-runtime-id.js"; |
| import { DEFAULT_MODEL, DEFAULT_PROVIDER } from "../defaults.js"; |
| import { resolveAgentHarnessPolicy } from "../harness/policy.js"; |
| import { |
| selectAgentHarness, |
| selectAgentHarnessForPreparedModelProviders, |
| } from "../harness/selection.js"; |
| import { projectPreparedModelProvider } from "../harness/support.js"; |
| import type { AgentHarness } from "../harness/types.js"; |
| import { |
| ensureAuthProfileStore, |
| ensureAuthProfileStoreWithoutExternalProfiles, |
| } from "../model-auth.js"; |
| import type { ModelManifestNormalizationContext } from "../model-ref-shared.js"; |
| import { isOpenAIProvider } from "../openai-routing.js"; |
| import { |
| providerUsesCredentialScopedModelMetadata, |
| resolveReusableRuntimeModelAuth, |
| } from "../runtime-plan/credential-scoped-model.js"; |
| import { |
| prepareAgentRuntimeAuth, |
| type PreparedAgentRuntimeAuth, |
| type PreparedAgentRuntimeAuthAttempt, |
| } from "../runtime-plan/prepare-auth.js"; |
| import type { AgentRuntimeAuthPlan, AgentRuntimePlan } from "../runtime-plan/types.js"; |
| import { |
| resolveCompactionHarnessRuntime, |
| resolveCompactionTargetRuntime, |
| resolveEmbeddedCompactionTarget, |
| } from "./compaction-runtime-context.js"; |
|
|
| export function projectCodexHostTranscriptBytePreflightConfig( |
| config: OpenClawConfig | undefined, |
| active: boolean, |
| ): OpenClawConfig | undefined { |
| const compaction = config?.agents?.defaults?.compaction; |
| if ( |
| !active || |
| !compaction || |
| (!Object.hasOwn(compaction, "model") && !Object.hasOwn(compaction, "provider")) |
| ) { |
| return config; |
| } |
| const { model: _model, provider: _provider, ...projectedCompaction } = compaction; |
| return { |
| ...config, |
| agents: { |
| ...config.agents, |
| defaults: { ...config.agents?.defaults, compaction: projectedCompaction }, |
| }, |
| }; |
| } |
|
|
| |
| export function resolveCompactionRuntimeSelection(params: { |
| config?: OpenClawConfig; |
| provider?: string | null; |
| modelId?: string | null; |
| authProfileId?: string | null; |
| modelSelectionLocked?: boolean; |
| sandboxSessionKey?: string | null; |
| sandboxAgentId?: string; |
| sessionKey?: string | null; |
| agentId?: string; |
| boundHarnessRuntime?: string | null; |
| preparedRuntimePlan?: AgentRuntimePlan; |
| runtimeAuthPlan?: AgentRuntimeAuthPlan; |
| selectedHarnessRuntime?: string; |
| allowPluginNormalization?: boolean; |
| manifestPlugins?: ModelManifestNormalizationContext["manifestPlugins"]; |
| }) { |
| const runtimePolicySessionKey = params.sandboxSessionKey ?? params.sessionKey ?? undefined; |
| const runtimePolicyAgentId = |
| params.sandboxAgentId ?? |
| (params.sandboxSessionKey && parseAgentSessionKey(params.sandboxSessionKey) |
| ? undefined |
| : params.agentId); |
| const policyTarget = resolveEmbeddedCompactionTarget({ |
| config: params.config, |
| provider: params.provider, |
| modelId: params.modelId, |
| authProfileId: params.authProfileId, |
| modelSelectionLocked: params.modelSelectionLocked, |
| defaultProvider: DEFAULT_PROVIDER, |
| defaultModel: DEFAULT_MODEL, |
| allowPluginNormalization: params.allowPluginNormalization, |
| manifestPlugins: params.manifestPlugins, |
| }); |
| const policyProvider = policyTarget.provider ?? DEFAULT_PROVIDER; |
| const policyModelId = policyTarget.model ?? DEFAULT_MODEL; |
| const policy = resolveAgentHarnessPolicy({ |
| provider: policyProvider, |
| modelId: policyModelId, |
| config: params.config, |
| agentId: runtimePolicyAgentId, |
| sessionKey: runtimePolicySessionKey, |
| }); |
| const configuredHarnessRuntime = |
| policy.runtimeSource && |
| policy.runtimeSource !== "implicit" && |
| !isDefaultAgentRuntimeId(policy.runtime) |
| ? policy.runtime |
| : undefined; |
| const boundHarnessRuntime = normalizeOptionalAgentRuntimeId(params.boundHarnessRuntime); |
| const selectedHarnessRuntime = |
| params.selectedHarnessRuntime ?? |
| resolveCompactionHarnessRuntime({ |
| boundHarnessRuntime, |
| preparedRuntimePlan: params.preparedRuntimePlan, |
| configuredHarnessRuntime, |
| provider: policyProvider, |
| modelId: policyModelId, |
| }); |
| const target = { |
| ...policyTarget, |
| ...resolveCompactionTargetRuntime(policyTarget.provider, selectedHarnessRuntime), |
| }; |
| const provider = target.provider ?? DEFAULT_PROVIDER; |
| const modelId = target.model ?? DEFAULT_MODEL; |
| const selectedRuntime = normalizeOptionalAgentRuntimeId(selectedHarnessRuntime); |
| const attemptNativeHarnessCompaction = Boolean( |
| selectedRuntime && |
| selectedRuntime !== "auto" && |
| selectedRuntime !== "openclaw" && |
| (!isOpenAIProvider(provider) || target.nativeHarnessCompaction === true), |
| ); |
| return { |
| attemptNativeHarnessCompaction, |
| runtimePolicySessionKey, |
| runtimePolicyAgentId, |
| boundHarnessRuntime, |
| selectedHarnessRuntime, |
| selectedHarnessRuntimeOverride: boundHarnessRuntime ? undefined : selectedHarnessRuntime, |
| target, |
| runtimeModelAuth: resolveReusableRuntimeModelAuth({ |
| plan: params.runtimeAuthPlan ?? params.preparedRuntimePlan?.auth, |
| provider, |
| modelId, |
| authProfileId: target.authProfileId, |
| }), |
| provider, |
| runtimeProvider: target.runtimeProvider ?? provider, |
| contextConfigProvider: target.contextProvider ?? provider, |
| modelId, |
| }; |
| } |
|
|
| |
| export async function prepareCompactionHarnessAuth(params: { |
| config?: OpenClawConfig; |
| provider: string; |
| metadataProvider?: string; |
| modelId: string; |
| model?: ProviderRuntimeModel; |
| reusableRuntimeAuthPlan?: AgentRuntimeAuthPlan; |
| agentDir: string; |
| workspaceDir: string; |
| authProfileId?: string; |
| authProfileIdSource?: "auto" | "user"; |
| runtimePolicyAgentId?: string; |
| runtimePolicySessionKey?: string | null; |
| agentHarnessId?: string; |
| agentHarnessRuntimeOverride?: string; |
| convergenceErrorPrefix?: "Prepared compaction" | "Prepared queued compaction"; |
| }): Promise<{ |
| runtimeAuthProfileStore: ReturnType<typeof ensureAuthProfileStore>; |
| runtimeAuthPreparation: PreparedAgentRuntimeAuth; |
| selectedPreparedHarness: AgentHarness; |
| providerUsesProfileScopedModelMetadata: boolean; |
| }> { |
| const runtimeAuthProfileStore = isOpenAIProvider(params.provider) |
| ? ensureAuthProfileStore(params.agentDir, { |
| profileId: params.authProfileId ?? params.reusableRuntimeAuthPlan?.forwardedAuthProfileId, |
| externalCliProviderIds: ["openai"], |
| allowKeychainPrompt: false, |
| }) |
| : ensureAuthProfileStoreWithoutExternalProfiles(params.agentDir, { |
| profileId: params.authProfileId ?? params.reusableRuntimeAuthPlan?.forwardedAuthProfileId, |
| allowKeychainPrompt: false, |
| }); |
| const harnessSelectionParams = { |
| provider: params.provider, |
| modelId: params.modelId, |
| config: params.config, |
| agentId: params.runtimePolicyAgentId, |
| sessionKey: params.runtimePolicySessionKey ?? undefined, |
| agentHarnessId: params.agentHarnessId, |
| agentHarnessRuntimeOverride: params.agentHarnessRuntimeOverride, |
| }; |
| const selectPreparedHarness = (attempts: readonly PreparedAgentRuntimeAuthAttempt[]) => |
| selectAgentHarnessForPreparedModelProviders({ |
| ...harnessSelectionParams, |
| modelProviders: attempts.map((attempt) => |
| projectPreparedModelProvider({ |
| model: params.model, |
| plan: attempt.plan, |
| attemptKind: attempt.kind, |
| }), |
| ), |
| }); |
| const initialHarness = params.reusableRuntimeAuthPlan |
| ? undefined |
| : selectAgentHarness({ |
| ...harnessSelectionParams, |
| modelProvider: projectPreparedModelProvider({ model: params.model }), |
| }); |
| const prepare = (harness: AgentHarness) => |
| prepareAgentRuntimeAuth({ |
| provider: params.provider, |
| modelId: params.modelId, |
| modelApi: params.model?.api, |
| modelBaseUrl: params.model?.baseUrl, |
| config: params.config, |
| agentId: params.runtimePolicyAgentId, |
| env: process.env, |
| agentDir: params.agentDir, |
| workspaceDir: params.workspaceDir, |
| authProfileStore: runtimeAuthProfileStore, |
| sessionAuthProfileId: params.authProfileId, |
| sessionAuthProfileSource: params.authProfileIdSource, |
| harnessId: harness.id, |
| harnessRuntime: harness.id, |
| harnessAuthBootstrap: harness.authBootstrap, |
| }); |
| let runtimeAuthPreparation: PreparedAgentRuntimeAuth = params.reusableRuntimeAuthPlan |
| ? { |
| plan: params.reusableRuntimeAuthPlan, |
| attempts: [{ kind: "implicit", plan: params.reusableRuntimeAuthPlan }], |
| } |
| : prepare(initialHarness!); |
| let selectedPreparedHarness = selectPreparedHarness(runtimeAuthPreparation.attempts); |
| if (!params.reusableRuntimeAuthPlan && selectedPreparedHarness.id !== initialHarness?.id) { |
| runtimeAuthPreparation = prepare(selectedPreparedHarness); |
| const confirmedHarness = selectPreparedHarness(runtimeAuthPreparation.attempts); |
| if (confirmedHarness.id !== selectedPreparedHarness.id) { |
| throw new Error( |
| `${params.convergenceErrorPrefix ?? "Prepared compaction"} auth routes did not converge on one agent harness for ${params.provider}/${params.modelId}.`, |
| ); |
| } |
| selectedPreparedHarness = confirmedHarness; |
| } |
| return { |
| runtimeAuthProfileStore, |
| runtimeAuthPreparation, |
| selectedPreparedHarness, |
| providerUsesProfileScopedModelMetadata: providerUsesCredentialScopedModelMetadata({ |
| provider: params.metadataProvider ?? params.provider, |
| modelId: params.modelId, |
| config: params.config, |
| agentDir: params.agentDir, |
| workspaceDir: params.workspaceDir, |
| }), |
| }; |
| } |
|
|
