@llm4ts/core 0.1.0

package/src/ConnectorConfig.ts

@@ -0,0 +1,146 @@
+import * as Duration from "effect/Duration"
+import * as Effect from "effect/Effect"
+import * as Schema from "effect/Schema"
+import { ConnectorId, ConnectorIds, LlmConfig, type LlmProvider } from "./Models.ts"
+
+export class DockerSandbox extends Schema.TaggedClass<DockerSandbox>()("Docker", {
+  image: Schema.String,
+  mount: Schema.Boolean.pipe(Schema.withConstructorDefault(Effect.succeed(true))),
+  network: Schema.optionalKey(Schema.String)
+}) {}
+
+export class PodmanSandbox extends Schema.TaggedClass<PodmanSandbox>()("Podman", {}) {}
+export class SeatbeltMacOsSandbox extends Schema.TaggedClass<SeatbeltMacOsSandbox>()(
+  "SeatbeltMacOS",
+  {}
+) {}
+export class RunscSandbox extends Schema.TaggedClass<RunscSandbox>()("Runsc", {}) {}
+export class LxcSandbox extends Schema.TaggedClass<LxcSandbox>()("Lxc", {}) {}
+
+export const CliSandbox = Schema.Union([
+  DockerSandbox,
+  PodmanSandbox,
+  SeatbeltMacOsSandbox,
+  RunscSandbox,
+  LxcSandbox
+])
+export type CliSandbox = typeof CliSandbox.Type
+
+const emptyStringRecord: Readonly<Record<string, string>> = Object.freeze({})
+
+export class ApiConnectorConfig extends Schema.TaggedClass<ApiConnectorConfig>()(
+  "ApiConnectorConfig",
+  {
+    connectorId: ConnectorId,
+    model: Schema.optionalKey(Schema.String),
+    baseUrl: Schema.optionalKey(Schema.String),
+    apiKey: Schema.optionalKey(
+      Schema.Redacted(Schema.String, {
+        disallowJsonEncode: true
+      })
+    ),
+    timeout: Schema.Duration.pipe(
+      Schema.withConstructorDefault(Effect.succeed(Duration.seconds(300)))
+    ),
+    maxRetries: Schema.Int.pipe(Schema.withConstructorDefault(Effect.succeed(3))),
+    requestsPerMinute: Schema.Int.pipe(Schema.withConstructorDefault(Effect.succeed(60))),
+    burstSize: Schema.Int.pipe(Schema.withConstructorDefault(Effect.succeed(10))),
+    acquireTimeout: Schema.Duration.pipe(
+      Schema.withConstructorDefault(Effect.succeed(Duration.seconds(30)))
+    ),
+    temperature: Schema.optionalKey(Schema.Number),
+    maxTokens: Schema.optionalKey(Schema.Int)
+  }
+) {}
+
+export class CliConnectorConfig extends Schema.TaggedClass<CliConnectorConfig>()(
+  "CliConnectorConfig",
+  {
+    connectorId: ConnectorId,
+    model: Schema.optionalKey(Schema.String),
+    timeout: Schema.Duration.pipe(
+      Schema.withConstructorDefault(Effect.succeed(Duration.seconds(300)))
+    ),
+    maxRetries: Schema.Int.pipe(Schema.withConstructorDefault(Effect.succeed(3))),
+    flags: Schema.Record(Schema.String, Schema.String).pipe(
+      Schema.withConstructorDefault(Effect.succeed(emptyStringRecord))
+    ),
+    sandbox: Schema.optionalKey(CliSandbox),
+    turnLimit: Schema.optionalKey(Schema.Int),
+    envVars: Schema.Record(Schema.String, Schema.String).pipe(
+      Schema.withConstructorDefault(Effect.succeed(emptyStringRecord))
+    ),
+    workingDir: Schema.optionalKey(Schema.String),
+    readOnly: Schema.Boolean.pipe(Schema.withConstructorDefault(Effect.succeed(false)))
+  }
+) {}
+
+export const ConnectorConfig = Schema.Union([ApiConnectorConfig, CliConnectorConfig])
+export type ConnectorConfig = typeof ConnectorConfig.Type
+
+const providerForConnector = (connectorId: ConnectorId): LlmProvider => {
+  switch (connectorId.value) {
+    case "anthropic":
+      return "Anthropic"
+    case "gemini-api":
+      return "GeminiApi"
+    case "lm-studio":
+      return "LmStudio"
+    case "ollama":
+      return "Ollama"
+    case "mock":
+      return "Mock"
+    default:
+      return "OpenAI"
+  }
+}
+
+export const toLlmConfig = (config: ApiConnectorConfig): LlmConfig =>
+  new LlmConfig({
+    provider: providerForConnector(config.connectorId),
+    model: config.model ?? "",
+    timeout: config.timeout,
+    maxRetries: config.maxRetries,
+    requestsPerMinute: config.requestsPerMinute,
+    burstSize: config.burstSize,
+    acquireTimeout: config.acquireTimeout,
+    ...(config.baseUrl === undefined ? {} : { baseUrl: config.baseUrl }),
+    ...(config.apiKey === undefined ? {} : { apiKey: config.apiKey }),
+    ...(config.temperature === undefined ? {} : { temperature: config.temperature }),
+    ...(config.maxTokens === undefined ? {} : { maxTokens: config.maxTokens })
+  })
+
+const emptyConnectors: ReadonlyArray<ConnectorConfig> = Object.freeze([])
+
+export class FallbackChain extends Schema.Class<FallbackChain>("FallbackChain")({
+  connectors: Schema.Array(ConnectorConfig).pipe(
+    Schema.withConstructorDefault(Effect.succeed(emptyConnectors))
+  )
+}) {
+  get isEmpty(): boolean {
+    return this.connectors.length === 0
+  }
+
+  get nonEmpty(): boolean {
+    return this.connectors.length > 0
+  }
+}
+
+export const emptyFallbackChain = new FallbackChain()
+
+export const defaultCliConnectorConfigs = Object.freeze({
+  Claude: new CliConnectorConfig({ connectorId: ConnectorIds.ClaudeCli }),
+  Codex: new CliConnectorConfig({ connectorId: ConnectorIds.Codex })
+})
+
+export const defaultReasoningConfig = (
+  coder: ConnectorConfig,
+  explicit?: ConnectorConfig
+): ConnectorConfig => {
+  if (explicit !== undefined) {
+    return explicit
+  }
+  return coder instanceof CliConnectorConfig
+    ? CliConnectorConfig.make({ ...coder, readOnly: true })
+    : coder
+}

package/src/ConnectorRegistry.ts

@@ -0,0 +1,184 @@
+import * as Context from "effect/Context"
+import * as Effect from "effect/Effect"
+import type {
+  ApiConnectorConfig,
+  CliConnectorConfig,
+  ConnectorConfig,
+  FallbackChain
+} from "./ConnectorConfig.ts"
+import {
+  ApiConnectorConfig as ApiConfig,
+  CliConnectorConfig as CliConfig
+} from "./ConnectorConfig.ts"
+import type { ApiConnectorShape, CliConnectorShape, ConnectorShape } from "./Connector.ts"
+import { ConfigError, type LlmError } from "./Errors.ts"
+import { HealthStatus, type ConnectorId, type ConnectorKind } from "./Models.ts"
+
+export interface ConnectorFactory {
+  readonly connectorId: ConnectorId
+  readonly kind: ConnectorKind
+  readonly create: (config: ConnectorConfig) => Effect.Effect<ConnectorShape, LlmError>
+}
+
+export interface ConnectorRegistryShape {
+  readonly resolve: (config: ConnectorConfig) => Effect.Effect<ConnectorShape, LlmError>
+  readonly resolveApi: (config: ApiConnectorConfig) => Effect.Effect<ApiConnectorShape, LlmError>
+  readonly resolveCli: (config: CliConnectorConfig) => Effect.Effect<CliConnectorShape, LlmError>
+  readonly resolveFallback: (chain: FallbackChain) => Effect.Effect<ConnectorShape, LlmError>
+  readonly available: Effect.Effect<ReadonlyArray<ConnectorId>>
+  readonly healthCheckAll: Effect.Effect<ReadonlyMap<ConnectorId, HealthStatus>>
+}
+
+export class ConnectorRegistry extends Context.Service<ConnectorRegistry, ConnectorRegistryShape>()(
+  "@llm4ts/core/ConnectorRegistry"
+) {}
+
+const unknownHealth = (): HealthStatus =>
+  HealthStatus.make({
+    availability: "Unknown",
+    authStatus: "Unknown"
+  })
+
+const isApiConnector = (connector: ConnectorShape): connector is ApiConnectorShape =>
+  connector.kind === "Api"
+
+const isCliConnector = (connector: ConnectorShape): connector is CliConnectorShape =>
+  connector.kind === "Cli" &&
+  "interactionSupport" in connector &&
+  "buildArgv" in connector &&
+  "buildInteractiveArgv" in connector &&
+  "complete" in connector &&
+  "completeStream" in connector
+
+const healthEntry = (
+  id: ConnectorId,
+  status: HealthStatus
+): readonly [ConnectorId, HealthStatus] => [id, status]
+
+export const makeConnectorRegistry = (
+  factories: Iterable<ConnectorFactory>
+): ConnectorRegistryShape => {
+  const byId = new Map<string, ConnectorFactory>()
+  for (const factory of factories) {
+    byId.set(factory.connectorId.value, factory)
+  }
+
+  const resolve = (config: ConnectorConfig): Effect.Effect<ConnectorShape, LlmError> => {
+    const factory = byId.get(config.connectorId.value)
+    return factory === undefined
+      ? Effect.fail(
+          ConfigError.make({
+            message: `Unknown connector: ${config.connectorId.value}`
+          })
+        )
+      : factory.create(config)
+  }
+
+  const resolveApi = (config: ApiConnectorConfig): Effect.Effect<ApiConnectorShape, LlmError> =>
+    Effect.flatMap(resolve(config), (connector) =>
+      isApiConnector(connector)
+        ? Effect.succeed(connector)
+        : Effect.fail(
+            ConfigError.make({
+              message: `Expected ApiConnector, got ${connector.kind}`
+            })
+          )
+    )
+
+  const resolveCli = (config: CliConnectorConfig): Effect.Effect<CliConnectorShape, LlmError> =>
+    Effect.flatMap(resolve(config), (connector) =>
+      isCliConnector(connector)
+        ? Effect.succeed(connector)
+        : Effect.fail(
+            ConfigError.make({
+              message: `Expected CliConnector, got ${connector.kind}`
+            })
+          )
+    )
+
+  const resolveFallback = (chain: FallbackChain): Effect.Effect<ConnectorShape, LlmError> => {
+    const loop = (
+      remaining: ReadonlyArray<ConnectorConfig>,
+      failures: ReadonlyArray<string>
+    ): Effect.Effect<ConnectorShape, LlmError> => {
+      const [config, ...tail] = remaining
+      if (config === undefined) {
+        return Effect.fail(
+          ConfigError.make({
+            message:
+              failures.length === 0
+                ? "Fallback chain is empty"
+                : `No fallback connector is available: ${failures.join("; ")}`
+          })
+        )
+      }
+
+      return Effect.result(
+        Effect.flatMap(resolve(config), (connector) =>
+          Effect.map(connector.isAvailable, (available) => ({
+            connector,
+            available
+          }))
+        )
+      ).pipe(
+        Effect.flatMap((result) => {
+          if (result._tag === "Success" && result.success.available) {
+            return Effect.succeed(result.success.connector)
+          }
+
+          const reason =
+            result._tag === "Failure"
+              ? `${config.connectorId.value}: ${result.failure.message}`
+              : `${config.connectorId.value}: unavailable`
+          return Effect.suspend(() => loop(tail, [...failures, reason]))
+        })
+      )
+    }
+
+    return loop(chain.connectors, [])
+  }
+
+  const available = Effect.sync(() => Array.from(byId.values(), (factory) => factory.connectorId))
+
+  const healthCheckAll = Effect.forEach(Array.from(byId.values()), (factory) => {
+    const defaultConfig: ConnectorConfig =
+      factory.kind === "Api"
+        ? ApiConfig.make({ connectorId: factory.connectorId })
+        : CliConfig.make({ connectorId: factory.connectorId })
+
+    return Effect.result(
+      Effect.flatMap(factory.create(defaultConfig), (connector) => connector.healthCheck)
+    ).pipe(
+      Effect.map((result) =>
+        healthEntry(
+          factory.connectorId,
+          result._tag === "Success" ? result.success : unknownHealth()
+        )
+      )
+    )
+  }).pipe(Effect.map((entries) => new Map<ConnectorId, HealthStatus>(entries)))
+
+  return {
+    resolve,
+    resolveApi,
+    resolveCli,
+    resolveFallback,
+    available,
+    healthCheckAll
+  }
+}
+
+export const resolveConnector = (
+  config: ConnectorConfig
+): Effect.Effect<ConnectorShape, LlmError, ConnectorRegistry> =>
+  Effect.flatMap(ConnectorRegistry, (registry) => registry.resolve(config))
+
+export const resolveApiConnector = (
+  config: ApiConnectorConfig
+): Effect.Effect<ApiConnectorShape, LlmError, ConnectorRegistry> =>
+  Effect.flatMap(ConnectorRegistry, (registry) => registry.resolveApi(config))
+
+export const resolveCliConnector = (
+  config: CliConnectorConfig
+): Effect.Effect<CliConnectorShape, LlmError, ConnectorRegistry> =>
+  Effect.flatMap(ConnectorRegistry, (registry) => registry.resolveCli(config))

package/src/ContextManagement.ts

@@ -0,0 +1,372 @@
+import * as Crypto from "effect/Crypto"
+import * as DateTime from "effect/DateTime"
+import * as Effect from "effect/Effect"
+import * as Schema from "effect/Schema"
+import { ConversationMessage, type PromptRole } from "./Conversation.ts"
+import type { LlmProvider } from "./Models.ts"
+
+export class ContextInvalidInput extends Schema.TaggedErrorClass<ContextInvalidInput>()(
+  "InvalidInput",
+  {
+    message: Schema.String
+  }
+) {}
+
+export class ContextParseFailed extends Schema.TaggedErrorClass<ContextParseFailed>()(
+  "ParseFailed",
+  {
+    message: Schema.String
+  }
+) {}
+
+export class ContextSummarizationFailed extends Schema.TaggedErrorClass<ContextSummarizationFailed>()(
+  "SummarizationFailed",
+  {
+    message: Schema.String
+  }
+) {}
+
+export class ContextToolLoopFailed extends Schema.TaggedErrorClass<ContextToolLoopFailed>()(
+  "ToolLoopFailed",
+  {
+    message: Schema.String
+  }
+) {}
+
+export const ContextError = Schema.Union([
+  ContextInvalidInput,
+  ContextParseFailed,
+  ContextSummarizationFailed,
+  ContextToolLoopFailed
+])
+export type ContextError = typeof ContextError.Type
+
+export class ContextLimits extends Schema.Class<ContextLimits>("ContextLimits")({
+  maxTokens: Schema.Int,
+  warningThresholdPct: Schema.Number.pipe(Schema.withConstructorDefault(Effect.succeed(0.85)))
+}) {}
+
+export class ContextWindow extends Schema.Class<ContextWindow>("ContextWindow")({
+  messages: Schema.Array(ConversationMessage),
+  totalTokens: Schema.Int,
+  approachingLimit: Schema.Boolean,
+  trimmed: Schema.Boolean
+}) {}
+
+export class DropOldestFifo extends Schema.TaggedClass<DropOldestFifo>()("DropOldestFifo", {}) {}
+
+export class SlidingWindow extends Schema.TaggedClass<SlidingWindow>()("SlidingWindow", {}) {}
+
+export class PriorityBased extends Schema.TaggedClass<PriorityBased>()("PriorityBased", {}) {}
+
+export class SummarizeOldMessages extends Schema.TaggedClass<SummarizeOldMessages>()(
+  "SummarizeOldMessages",
+  {
+    summaryTargetTokens: Schema.Int.pipe(Schema.withConstructorDefault(Effect.succeed(256)))
+  }
+) {}
+
+export const ContextTrimmingStrategy = Schema.Union([
+  DropOldestFifo,
+  SlidingWindow,
+  PriorityBased,
+  SummarizeOldMessages
+])
+export type ContextTrimmingStrategy = typeof ContextTrimmingStrategy.Type
+
+export const ContextTrimmingStrategies = Object.freeze({
+  DropOldestFifo: DropOldestFifo.make({}),
+  SlidingWindow: SlidingWindow.make({}),
+  PriorityBased: PriorityBased.make({}),
+  SummarizeOldMessages: (summaryTargetTokens = 256): SummarizeOldMessages =>
+    SummarizeOldMessages.make({ summaryTargetTokens })
+})
+
+export interface TokenCounter {
+  readonly countText: (provider: LlmProvider, text: string) => number
+  readonly countMessage: (provider: LlmProvider, message: ConversationMessage) => number
+  readonly countMessages: (provider: LlmProvider, messages: Iterable<ConversationMessage>) => number
+}
+
+const roleOverhead = (role: PromptRole): number => {
+  switch (role) {
+    case "System":
+      return 6
+    case "User":
+    case "Assistant":
+      return 5
+    case "Tool":
+      return 8
+  }
+}
+
+const providerCharactersPerToken = (provider: LlmProvider): number => {
+  switch (provider) {
+    case "OpenAI":
+    case "OpenCode":
+      return 4
+    case "Anthropic":
+      return 3.8
+    case "GeminiApi":
+    case "GeminiCli":
+      return 4.2
+    case "LmStudio":
+    case "Ollama":
+    case "Mock":
+      return 4.5
+  }
+}
+
+const countText = (provider: LlmProvider, text: string): number =>
+  Math.max(1, Math.ceil(Math.max(text.length, 1) / providerCharactersPerToken(provider)))
+
+const countMessage = (provider: LlmProvider, message: ConversationMessage): number =>
+  countText(provider, message.content) + roleOverhead(message.role)
+
+export const defaultTokenCounter: TokenCounter = {
+  countText,
+  countMessage,
+  countMessages: (provider, messages) =>
+    Array.from(messages).reduce((total, message) => total + countMessage(provider, message), 0)
+}
+
+export interface MessageSummarizer<R = never> {
+  readonly summarize: (
+    messages: ReadonlyArray<ConversationMessage>,
+    targetTokens: number
+  ) => Effect.Effect<ConversationMessage, ContextError, R>
+}
+
+export const simpleMessageSummarizer: MessageSummarizer<Crypto.Crypto> = {
+  summarize: (messages, targetTokens) => {
+    if (messages.length === 0) {
+      return Effect.fail(
+        ContextInvalidInput.make({
+          message: "Cannot summarize empty messages"
+        })
+      )
+    }
+
+    const summaryText = messages
+      .slice(0, 8)
+      .map((message) => `${message.role.toLowerCase()}: ${message.content.slice(0, 160)}`)
+      .join("\n")
+
+    return Effect.gen(function* () {
+      const crypto = yield* Crypto.Crypto
+      const id = yield* crypto.randomUUIDv4.pipe(
+        Effect.mapError((error) =>
+          ContextSummarizationFailed.make({
+            message: `Failed to generate summary id: ${error.message}`
+          })
+        )
+      )
+      const timestamp = yield* DateTime.now
+
+      return ConversationMessage.make({
+        id,
+        role: "Assistant",
+        content: `Summary of previous context:\n${summaryText}`,
+        timestamp,
+        tokens: Math.max(1, targetTokens),
+        metadata: { summary: "true" },
+        important: true
+      })
+    })
+  }
+}
+
+const annotateTokens = (
+  messages: ReadonlyArray<ConversationMessage>,
+  provider: LlmProvider,
+  tokenCounter: TokenCounter
+): ReadonlyArray<ConversationMessage> =>
+  messages.map((message) =>
+    message.tokens > 0
+      ? message
+      : ConversationMessage.make({
+          ...message,
+          tokens: tokenCounter.countMessage(provider, message)
+        })
+  )
+
+const dropOldest = (
+  messages: ReadonlyArray<ConversationMessage>,
+  maxTokens: number
+): ReadonlyArray<ConversationMessage> => {
+  let used = 0
+  let kept: ReadonlyArray<ConversationMessage> = []
+
+  for (const message of Array.from(messages).reverse()) {
+    if (used + message.tokens <= maxTokens) {
+      used += message.tokens
+      kept = [message, ...kept]
+    }
+  }
+
+  return kept
+}
+
+const slidingWindow = (
+  messages: ReadonlyArray<ConversationMessage>,
+  maxTokens: number
+): ReadonlyArray<ConversationMessage> => {
+  const system = messages.filter((message) => message.role === "System")
+  const recentNonSystem = messages.filter((message) => message.role !== "System")
+  const systemTokens = system.reduce((total, message) => total + message.tokens, 0)
+  const tail = dropOldest(recentNonSystem, Math.max(0, maxTokens - systemTokens))
+  return [...system, ...tail].slice(-messages.length)
+}
+
+const priorityWindow = (
+  messages: ReadonlyArray<ConversationMessage>,
+  maxTokens: number
+): ReadonlyArray<ConversationMessage> => {
+  const scored = messages.map((message, index) => ({
+    message,
+    score:
+      (message.role === "System" ? 1_000 : 0) +
+      (message.role === "Tool" ? 600 : 0) +
+      (message.important ? 400 : 0) +
+      index
+  }))
+  scored.sort(
+    (left, right) =>
+      right.score - left.score ||
+      DateTime.toEpochMillis(left.message.timestamp) -
+        DateTime.toEpochMillis(right.message.timestamp)
+  )
+
+  let used = 0
+  const selected: Array<ConversationMessage> = []
+  for (const candidate of scored) {
+    if (used + candidate.message.tokens <= maxTokens) {
+      used += candidate.message.tokens
+      selected.push(candidate.message)
+    }
+  }
+
+  return selected.sort(
+    (left, right) =>
+      DateTime.toEpochMillis(left.timestamp) - DateTime.toEpochMillis(right.timestamp)
+  )
+}
+
+const summarizeOldMessages = <R>(
+  messages: ReadonlyArray<ConversationMessage>,
+  maxTokens: number,
+  summaryTargetTokens: number,
+  provider: LlmProvider,
+  tokenCounter: TokenCounter,
+  summarizer: MessageSummarizer<R>
+): Effect.Effect<ReadonlyArray<ConversationMessage>, ContextError, R> => {
+  if (messages.length <= 2) {
+    return Effect.succeed(dropOldest(messages, maxTokens))
+  }
+
+  const splitIndex = Math.max(1, Math.floor(messages.length / 2))
+  const oldMessages = messages.slice(0, splitIndex)
+  const recentMessages = messages.slice(splitIndex)
+
+  return Effect.map(summarizer.summarize(oldMessages, summaryTargetTokens), (summary) => {
+    const annotatedSummary = ConversationMessage.make({
+      ...summary,
+      tokens: tokenCounter.countMessage(provider, summary)
+    })
+    return dropOldest([annotatedSummary, ...recentMessages], maxTokens)
+  })
+}
+
+export function applyContextWindow(
+  messages: ReadonlyArray<ConversationMessage>,
+  provider: LlmProvider,
+  limits: ContextLimits,
+  strategy: DropOldestFifo | SlidingWindow | PriorityBased,
+  tokenCounter?: TokenCounter
+): Effect.Effect<ContextWindow, ContextError>
+export function applyContextWindow(
+  messages: ReadonlyArray<ConversationMessage>,
+  provider: LlmProvider,
+  limits: ContextLimits,
+  strategy: ContextTrimmingStrategy,
+  tokenCounter?: TokenCounter
+): Effect.Effect<ContextWindow, ContextError, Crypto.Crypto>
+export function applyContextWindow<R>(
+  messages: ReadonlyArray<ConversationMessage>,
+  provider: LlmProvider,
+  limits: ContextLimits,
+  strategy: ContextTrimmingStrategy,
+  tokenCounter: TokenCounter,
+  summarizer: MessageSummarizer<R>
+): Effect.Effect<ContextWindow, ContextError, R>
+export function applyContextWindow<R>(
+  messages: ReadonlyArray<ConversationMessage>,
+  provider: LlmProvider,
+  limits: ContextLimits,
+  strategy: ContextTrimmingStrategy,
+  tokenCounter: TokenCounter = defaultTokenCounter,
+  summarizer?: MessageSummarizer<R>
+): Effect.Effect<ContextWindow, ContextError, R | Crypto.Crypto> {
+  if (limits.maxTokens <= 0) {
+    return Effect.fail(
+      ContextInvalidInput.make({
+        message: "maxTokens must be > 0"
+      })
+    )
+  }
+
+  const withTokens = annotateTokens(messages, provider, tokenCounter)
+  const totalBefore = withTokens.reduce((total, message) => total + message.tokens, 0)
+
+  const trimmed: Effect.Effect<
+    readonly [messages: ReadonlyArray<ConversationMessage>, wasTrimmed: boolean],
+    ContextError,
+    R | Crypto.Crypto
+  > =
+    totalBefore <= limits.maxTokens
+      ? Effect.succeed([withTokens, false])
+      : (() => {
+          switch (strategy._tag) {
+            case "DropOldestFifo":
+              return Effect.succeed([dropOldest(withTokens, limits.maxTokens), true])
+            case "SlidingWindow":
+              return Effect.succeed([slidingWindow(withTokens, limits.maxTokens), true])
+            case "PriorityBased":
+              return Effect.succeed([priorityWindow(withTokens, limits.maxTokens), true])
+            case "SummarizeOldMessages": {
+              const summarized: Effect.Effect<
+                ReadonlyArray<ConversationMessage>,
+                ContextError,
+                R | Crypto.Crypto
+              > = summarizer === undefined
+                ? summarizeOldMessages(
+                    withTokens,
+                    limits.maxTokens,
+                    strategy.summaryTargetTokens,
+                    provider,
+                    tokenCounter,
+                    simpleMessageSummarizer
+                  )
+                : summarizeOldMessages(
+                    withTokens,
+                    limits.maxTokens,
+                    strategy.summaryTargetTokens,
+                    provider,
+                    tokenCounter,
+                    summarizer
+                  )
+              return Effect.map(summarized, (messages) => [messages, true])
+            }
+          }
+        })()
+
+  return Effect.map(trimmed, ([finalMessages, wasTrimmed]) => {
+    const totalTokens = finalMessages.reduce((total, message) => total + message.tokens, 0)
+    return ContextWindow.make({
+      messages: finalMessages,
+      totalTokens,
+      approachingLimit: totalTokens >= limits.maxTokens * limits.warningThresholdPct,
+      trimmed: wasTrimmed
+    })
+  })
+}