@llm4ts/core 2.54.1 → 3.1.0

package/src/providers/GeminiApiProvider.ts

@@ -10,25 +10,18 @@ import {
   ConnectorIds,
   LlmChunk,
   TokenUsage,
-  ToolCall,
-  ToolCallResponse,
   type JsonSchema,
   type LlmConfig,
-  type Message,
-  type ToolDefinition
+  type Message
 } from "../Models.ts"
 import { collect } from "../Streaming.ts"
 import { parseFromText } from "../StructuredOutput.ts"
 import {
   GeminiContent,
-  GeminiFunctionDeclaration,
   GeminiGenerateContentRequest,
-  GeminiGenerateContentRequestWithTools,
   GeminiGenerateContentResponse,
-  GeminiGenerateContentResponseFull,
   GeminiGenerationConfig,
-  GeminiPart,
-  GeminiToolDef
+  GeminiPart
 } from "./GeminiModels.ts"
 
 interface GeminiRequiredConfig {
@@ -75,25 +68,6 @@ export const buildGeminiRequest = (
         })
   })
 
-export const buildGeminiToolRequest = (
-  prompt: string,
-  tools: ReadonlyArray<ToolDefinition>
-): GeminiGenerateContentRequestWithTools =>
-  GeminiGenerateContentRequestWithTools.make({
-    contents: promptContents(prompt),
-    tools: [
-      GeminiToolDef.make({
-        functionDeclarations: tools.map((tool) =>
-          GeminiFunctionDeclaration.make({
-            name: tool.name,
-            description: tool.description,
-            parameters: tool.parameters
-          })
-        )
-      })
-    ]
-  })
-
 const decodeResponse = (
   raw: string,
   context: string
@@ -107,18 +81,6 @@ const decodeResponse = (
     )
   )
 
-const decodeToolResponse = (
-  raw: string
-): Effect.Effect<GeminiGenerateContentResponseFull, ParseError> =>
-  Schema.decodeUnknownEffect(Schema.fromJsonString(GeminiGenerateContentResponseFull))(raw).pipe(
-    Effect.mapError((error) =>
-      ParseError.make({
-        message: `Failed to decode Gemini tool response: ${String(error)}`,
-        raw
-      })
-    )
-  )
-
 const usageFromResponse = (response: GeminiGenerateContentResponse): TokenUsage | undefined => {
   const usage = response.usageMetadata
   return usage === undefined
@@ -274,48 +236,6 @@ export const makeGeminiApiProvider = (
       return result
     })
 
-  const executeWithTools = (
-    prompt: string,
-    tools: ReadonlyArray<ToolDefinition>
-  ): Effect.Effect<ToolCallResponse, LlmError> =>
-    Effect.gen(function* () {
-      const { apiKey, baseUrl } = yield* requiredConfig
-      const raw = yield* httpClient.postJson(
-        endpoint(baseUrl, "generateContent"),
-        JSON.stringify(buildGeminiToolRequest(prompt, tools)),
-        headers(apiKey),
-        config.timeout
-      )
-      const response = yield* decodeToolResponse(raw)
-      const candidate = response.candidates[0]
-      if (candidate === undefined) {
-        return yield* Effect.fail(
-          ParseError.make({
-            message: "Gemini tool response has no candidates",
-            raw
-          })
-        )
-      }
-      const calls = candidate.content.parts.flatMap((part) =>
-        part.functionCall === undefined ? [] : [part.functionCall]
-      )
-      const text = candidate.content.parts
-        .map((part) => part.text)
-        .find((part) => part !== undefined && part !== null)
-
-      return ToolCallResponse.make({
-        toolCalls: calls.map((call, index) =>
-          ToolCall.make({
-            id: `gemini_call_${index}`,
-            name: call.name,
-            arguments: JSON.stringify(call.args) ?? "{}"
-          })
-        ),
-        finishReason: candidate.finishReason ?? "STOP",
-        ...(text === undefined || text === null ? {} : { content: text })
-      })
-    })
-
   const executeStream = (prompt: string): Stream.Stream<LlmChunk, LlmError> =>
     executeStreamWithContents(promptContents(prompt))
 
@@ -330,7 +250,6 @@ export const makeGeminiApiProvider = (
     id: ConnectorIds.GeminiApi,
     executeStream,
     executeStreamWithHistory: (messages) => executeStreamWithContents(geminiContents(messages)),
-    executeWithTools,
     executeStructuredWithUsage,
     isAvailable
   })

package/src/providers/GeminiModels.ts

@@ -49,49 +49,3 @@ export class GeminiGenerateContentResponse extends Schema.Class<GeminiGenerateCo
   candidates: arrayWithDefaults(GeminiCandidate),
   usageMetadata: Schema.optionalKey(GeminiUsageMetadata)
 }) {}
-
-export class GeminiFunctionDeclaration extends Schema.Class<GeminiFunctionDeclaration>(
-  "GeminiFunctionDeclaration"
-)({
-  name: Schema.String,
-  description: Schema.String,
-  parameters: JsonSchema
-}) {}
-
-export class GeminiToolDef extends Schema.Class<GeminiToolDef>("GeminiToolDef")({
-  functionDeclarations: Schema.Array(GeminiFunctionDeclaration)
-}) {}
-
-export class GeminiFunctionCall extends Schema.Class<GeminiFunctionCall>("GeminiFunctionCall")({
-  name: Schema.String,
-  args: Schema.Json
-}) {}
-
-export class GeminiPartFull extends Schema.Class<GeminiPartFull>("GeminiPartFull")({
-  text: Schema.optionalKey(Schema.NullOr(Schema.String)),
-  functionCall: Schema.optionalKey(GeminiFunctionCall)
-}) {}
-
-export class GeminiContentFull extends Schema.Class<GeminiContentFull>("GeminiContentFull")({
-  parts: Schema.Array(GeminiPartFull)
-}) {}
-
-export class GeminiCandidateFull extends Schema.Class<GeminiCandidateFull>("GeminiCandidateFull")({
-  content: GeminiContentFull,
-  finishReason: Schema.optionalKey(Schema.NullOr(Schema.String))
-}) {}
-
-export class GeminiGenerateContentResponseFull extends Schema.Class<GeminiGenerateContentResponseFull>(
-  "GeminiGenerateContentResponseFull"
-)({
-  candidates: arrayWithDefaults(GeminiCandidateFull),
-  usageMetadata: Schema.optionalKey(GeminiUsageMetadata)
-}) {}
-
-export class GeminiGenerateContentRequestWithTools extends Schema.Class<GeminiGenerateContentRequestWithTools>(
-  "GeminiGenerateContentRequestWithTools"
-)({
-  contents: Schema.Array(GeminiContent),
-  tools: Schema.Array(GeminiToolDef),
-  generationConfig: Schema.optionalKey(GeminiGenerationConfig)
-}) {}

package/src/providers/LmStudioProvider.ts

@@ -3,7 +3,7 @@ import * as Redacted from "effect/Redacted"
 import * as Schema from "effect/Schema"
 import * as Stream from "effect/Stream"
 import { makeApiConnector, type ApiConnectorShape } from "../Connector.ts"
-import { ConfigError, InvalidRequestError, ParseError, type LlmError } from "../Errors.ts"
+import { ConfigError, ParseError, type LlmError } from "../Errors.ts"
 import type { HttpClientShape } from "../HttpClient.ts"
 import type { StructuredResult } from "../LlmService.ts"
 import {
@@ -264,12 +264,6 @@ export const makeLmStudioProvider = (
         })
       ]),
     executeStreamWithHistory: (messages) => streamRequest(lmStudioHistory(messages)),
-    executeWithTools: () =>
-      Effect.fail(
-        InvalidRequestError.make({
-          message: "LmStudio provider does not yet support tool calling in this implementation"
-        })
-      ),
     executeStructuredWithUsage,
     isAvailable
   })

package/src/providers/MlxLmProvider.ts

@@ -2,7 +2,7 @@ import * as Effect from "effect/Effect"
 import * as Schema from "effect/Schema"
 import * as Stream from "effect/Stream"
 import { makeApiConnector, type ApiConnectorShape } from "../Connector.ts"
-import { ConfigError, InvalidRequestError, ParseError, type LlmError } from "../Errors.ts"
+import { ConfigError, ParseError, type LlmError } from "../Errors.ts"
 import type { HttpClientShape } from "../HttpClient.ts"
 import { normalizeLabelProbabilities } from "../LabelScoring.ts"
 import type { LabelSequence, StructuredResult } from "../LlmService.ts"
@@ -346,8 +346,6 @@ export const makeMlxLmProvider = (
     executeStream: (prompt) =>
       streamRequest([OpenAIChatMessage.make({ role: "user", content: prompt })]),
     executeStreamWithHistory: (messages) => streamRequest(openAIHistoryMessages(messages)),
-    executeWithTools: () =>
-      Effect.fail(InvalidRequestError.make({ message: "mlx-lm does not support tool calling" })),
     executeStructuredWithUsage,
     scoreLabels,
     scoreLabelSequence,

package/src/providers/MockProvider.ts

@@ -11,7 +11,6 @@ import {
   HealthStatus,
   LlmChunk,
   TokenUsage,
-  ToolCallResponse,
   type JsonSchema,
   type LlmConfig,
   type Message
@@ -307,14 +306,6 @@ export const makeMockProvider = (config: LlmConfig): ApiConnectorShape => {
     ),
     executeStream,
     executeStreamWithHistory: (messages) => executeStream(lastUserPrompt(messages)),
-    executeWithTools: (_prompt) =>
-      Effect.succeed(
-        ToolCallResponse.make({
-          content: mockResponse(),
-          toolCalls: [],
-          finishReason: "stop"
-        })
-      ),
     executeStructured: <A, E, RD, RE>(
       prompt: string,
       schema: Schema.ConstraintCodec<A, E, RD, RE>,

package/src/providers/OllamaProvider.ts

@@ -2,7 +2,7 @@ import * as Effect from "effect/Effect"
 import * as Schema from "effect/Schema"
 import * as Stream from "effect/Stream"
 import { makeApiConnector, type ApiConnectorShape } from "../Connector.ts"
-import { ConfigError, InvalidRequestError, ParseError, type LlmError } from "../Errors.ts"
+import { ConfigError, ParseError, type LlmError } from "../Errors.ts"
 import type { HttpClientShape } from "../HttpClient.ts"
 import type { StructuredResult } from "../LlmService.ts"
 import {
@@ -224,12 +224,6 @@ export const makeOllamaProvider = (
     id: ConnectorIds.Ollama,
     executeStream: (prompt) => generateStream(prompt),
     executeStreamWithHistory: (messages) => chatStream(ollamaHistory(messages)),
-    executeWithTools: () =>
-      Effect.fail(
-        InvalidRequestError.make({
-          message: "Ollama provider does not support tool calling"
-        })
-      ),
     executeStructuredWithUsage,
     isAvailable
   })

package/src/providers/OpenAIModels.ts

@@ -101,70 +101,6 @@ export class OpenAIChatCompletionResponse extends Schema.Class<OpenAIChatComplet
   model: Schema.optionalKey(Schema.String)
 }) {}
 
-export class OpenAIFunction extends Schema.Class<OpenAIFunction>("OpenAIFunction")({
-  name: Schema.String,
-  description: Schema.String,
-  parameters: JsonSchema
-}) {}
-
-export class OpenAITool extends Schema.Class<OpenAITool>("OpenAITool")({
-  type: Schema.String.pipe(Schema.withConstructorDefault(Effect.succeed("function"))),
-  function: OpenAIFunction
-}) {}
-
-export class OpenAIToolCallFunction extends Schema.Class<OpenAIToolCallFunction>(
-  "OpenAIToolCallFunction"
-)({
-  name: Schema.String,
-  arguments: Schema.String
-}) {}
-
-export class OpenAIToolCall extends Schema.Class<OpenAIToolCall>("OpenAIToolCall")({
-  id: Schema.String,
-  type: Schema.String,
-  function: OpenAIToolCallFunction
-}) {}
-
-const noToolCalls: ReadonlyArray<OpenAIToolCall> = Object.freeze([])
-
-export class OpenAIChatMessageWithTools extends Schema.Class<OpenAIChatMessageWithTools>(
-  "OpenAIChatMessageWithTools"
-)({
-  role: Schema.String,
-  content: Schema.optionalKey(Schema.NullOr(Schema.String)),
-  tool_calls: Schema.Array(OpenAIToolCall).pipe(
-    Schema.withConstructorDefault(Effect.succeed(noToolCalls))
-  )
-}) {}
-
-export class OpenAIChatChoiceWithTools extends Schema.Class<OpenAIChatChoiceWithTools>(
-  "OpenAIChatChoiceWithTools"
-)({
-  index: Schema.Int.pipe(Schema.withConstructorDefault(Effect.succeed(0))),
-  message: Schema.optionalKey(OpenAIChatMessageWithTools),
-  finish_reason: Schema.optionalKey(Schema.NullOr(Schema.String))
-}) {}
-
-export class OpenAIChatCompletionResponseWithTools extends Schema.Class<OpenAIChatCompletionResponseWithTools>(
-  "OpenAIChatCompletionResponseWithTools"
-)({
-  id: Schema.optionalKey(Schema.String),
-  choices: Schema.Array(OpenAIChatChoiceWithTools),
-  usage: Schema.optionalKey(OpenAITokenUsage),
-  model: Schema.optionalKey(Schema.String)
-}) {}
-
-export class OpenAIChatCompletionRequestWithTools extends Schema.Class<OpenAIChatCompletionRequestWithTools>(
-  "OpenAIChatCompletionRequestWithTools"
-)({
-  model: Schema.String,
-  messages: Schema.Array(OpenAIChatMessage),
-  tools: Schema.Array(OpenAITool),
-  temperature: Schema.optionalKey(Schema.Number),
-  max_tokens: Schema.optionalKey(Schema.Int),
-  stream: Schema.optionalKey(Schema.Boolean)
-}) {}
-
 export class OpenAIChatChunkDelta extends Schema.Class<OpenAIChatChunkDelta>(
   "OpenAIChatChunkDelta"
 )({

package/src/providers/OpenAIProvider.ts

@@ -10,27 +10,20 @@ import {
   ConnectorCapabilities,
   ConnectorIds,
   LlmChunk,
-  ToolCall,
-  ToolCallResponse,
   type JsonSchema,
   type LlmConfig,
   type Message,
-  type MessageRole,
-  type ToolDefinition
+  type MessageRole
 } from "../Models.ts"
 import { parseFromText } from "../StructuredOutput.ts"
 import { effortWord } from "./CliSupport.ts"
 import {
   OpenAIChatChunk,
   OpenAIChatCompletionRequest,
-  OpenAIChatCompletionRequestWithTools,
   OpenAIChatCompletionResponse,
-  OpenAIChatCompletionResponseWithTools,
   OpenAIChatMessage,
-  OpenAIFunction,
   OpenAIJsonSchemaSpec,
-  OpenAIResponseFormat,
-  OpenAITool
+  OpenAIResponseFormat
 } from "./OpenAIModels.ts"
 
 const emptyHeaders: Readonly<Record<string, string>> = Object.freeze({})
@@ -80,33 +73,6 @@ export const buildOpenAIChatRequest = (
     ...(config.effort === undefined ? {} : { reasoning_effort: effortWord(config.effort, "xhigh") })
   })
 
-export const buildOpenAIToolRequest = (
-  config: LlmConfig,
-  prompt: string,
-  tools: ReadonlyArray<ToolDefinition>
-): OpenAIChatCompletionRequestWithTools =>
-  OpenAIChatCompletionRequestWithTools.make({
-    model: config.model,
-    messages: [
-      OpenAIChatMessage.make({
-        role: "user",
-        content: prompt
-      })
-    ],
-    tools: tools.map((tool) =>
-      OpenAITool.make({
-        function: OpenAIFunction.make({
-          name: tool.name,
-          description: tool.description,
-          parameters: tool.parameters
-        })
-      })
-    ),
-    temperature: config.temperature ?? 0.7,
-    stream: false,
-    ...(config.maxTokens === undefined ? {} : { max_tokens: config.maxTokens })
-  })
-
 const decodeCompletionResponse = (
   raw: string
 ): Effect.Effect<OpenAIChatCompletionResponse, ParseError> =>
@@ -119,18 +85,6 @@ const decodeCompletionResponse = (
     )
   )
 
-const decodeToolResponse = (
-  raw: string
-): Effect.Effect<OpenAIChatCompletionResponseWithTools, ParseError> =>
-  schemaDecode.tools(raw).pipe(
-    Effect.mapError((error) =>
-      ParseError.make({
-        message: `Failed to decode OpenAI tool response: ${String(error)}`,
-        raw
-      })
-    )
-  )
-
 const decodeStreamChunk = (raw: string): Effect.Effect<OpenAIChatChunk, ParseError> =>
   schemaDecode.chunk(raw).pipe(
     Effect.mapError((error) =>
@@ -143,7 +97,6 @@ const decodeStreamChunk = (raw: string): Effect.Effect<OpenAIChatChunk, ParseErr
 
 const schemaDecode = {
   completion: Schema.decodeUnknownEffect(Schema.fromJsonString(OpenAIChatCompletionResponse)),
-  tools: Schema.decodeUnknownEffect(Schema.fromJsonString(OpenAIChatCompletionResponseWithTools)),
   chunk: Schema.decodeUnknownEffect(Schema.fromJsonString(OpenAIChatChunk))
 }
 
@@ -270,39 +223,6 @@ export const makeOpenAIProvider = (
       return result
     })
 
-  const executeWithTools = (
-    prompt: string,
-    tools: ReadonlyArray<ToolDefinition>
-  ): Effect.Effect<ToolCallResponse, LlmError> =>
-    Effect.gen(function* () {
-      const { baseUrl } = yield* requiredConfig
-      const request = buildOpenAIToolRequest(config, prompt, tools)
-      const raw = yield* httpClient.postJson(
-        `${baseUrl}/chat/completions`,
-        JSON.stringify(request),
-        authHeaders(),
-        config.timeout
-      )
-      const response = yield* decodeToolResponse(raw)
-      const choice = response.choices[0]
-      const toolCalls =
-        choice?.message?.tool_calls.map((toolCall) =>
-          ToolCall.make({
-            id: toolCall.id,
-            name: toolCall.function.name,
-            arguments: toolCall.function.arguments
-          })
-        ) ?? []
-      const content = choice?.message?.content ?? undefined
-      const finishReason = choice?.finish_reason ?? "stop"
-
-      return ToolCallResponse.make({
-        toolCalls,
-        finishReason,
-        ...(content === undefined || content === null ? {} : { content })
-      })
-    })
-
   // Parity with llm4zio v4.2.0 OpenAIProvider.isAvailable (`catchAll(_ => ZIO.succeed(true))`):
   // a configured baseUrl counts as available even when the /models probe fails.
   const isAvailable: Effect.Effect<boolean> =
@@ -327,7 +247,6 @@ export const makeOpenAIProvider = (
         })
       ]),
     executeStreamWithHistory: (messages) => executeStreamRequest(openAIHistoryMessages(messages)),
-    executeWithTools,
     executeStructuredWithUsage,
     isAvailable,
     capabilities: ConnectorCapabilities.make({ readOnlyEnforcement: "enforced", effort: "mapped" })

package/dist/ContextManagement.d.ts

@@ -1,78 +0,0 @@
-import * as Crypto from "effect/Crypto";
-import * as Effect from "effect/Effect";
-import * as Schema from "effect/Schema";
-import { ConversationMessage } from "./Conversation.ts";
-import type { LlmProvider } from "./Models.ts";
-declare const ContextInvalidInput_base: Schema.Class<ContextInvalidInput, Schema.TaggedStruct<"InvalidInput", {
-    readonly message: Schema.String;
-}>, import("effect/Cause").YieldableError>;
-export declare class ContextInvalidInput extends ContextInvalidInput_base {
-}
-declare const ContextParseFailed_base: Schema.Class<ContextParseFailed, Schema.TaggedStruct<"ParseFailed", {
-    readonly message: Schema.String;
-}>, import("effect/Cause").YieldableError>;
-export declare class ContextParseFailed extends ContextParseFailed_base {
-}
-declare const ContextSummarizationFailed_base: Schema.Class<ContextSummarizationFailed, Schema.TaggedStruct<"SummarizationFailed", {
-    readonly message: Schema.String;
-}>, import("effect/Cause").YieldableError>;
-export declare class ContextSummarizationFailed extends ContextSummarizationFailed_base {
-}
-declare const ContextToolLoopFailed_base: Schema.Class<ContextToolLoopFailed, Schema.TaggedStruct<"ToolLoopFailed", {
-    readonly message: Schema.String;
-}>, import("effect/Cause").YieldableError>;
-export declare class ContextToolLoopFailed extends ContextToolLoopFailed_base {
-}
-export declare const ContextError: Schema.Union<readonly [typeof ContextInvalidInput, typeof ContextParseFailed, typeof ContextSummarizationFailed, typeof ContextToolLoopFailed]>;
-export type ContextError = typeof ContextError.Type;
-declare const ContextLimits_base: Schema.Class<ContextLimits, Schema.Struct<{
-    readonly maxTokens: Schema.Int;
-    readonly warningThresholdPct: Schema.withConstructorDefault<Schema.Number>;
-}>, {}>;
-export declare class ContextLimits extends ContextLimits_base {
-}
-declare const ContextWindow_base: Schema.Class<ContextWindow, Schema.Struct<{
-    readonly messages: Schema.$Array<typeof ConversationMessage>;
-    readonly totalTokens: Schema.Int;
-    readonly approachingLimit: Schema.Boolean;
-    readonly trimmed: Schema.Boolean;
-}>, {}>;
-export declare class ContextWindow extends ContextWindow_base {
-}
-declare const DropOldestFifo_base: Schema.Class<DropOldestFifo, Schema.TaggedStruct<"DropOldestFifo", {}>, {}>;
-export declare class DropOldestFifo extends DropOldestFifo_base {
-}
-declare const SlidingWindow_base: Schema.Class<SlidingWindow, Schema.TaggedStruct<"SlidingWindow", {}>, {}>;
-export declare class SlidingWindow extends SlidingWindow_base {
-}
-declare const PriorityBased_base: Schema.Class<PriorityBased, Schema.TaggedStruct<"PriorityBased", {}>, {}>;
-export declare class PriorityBased extends PriorityBased_base {
-}
-declare const SummarizeOldMessages_base: Schema.Class<SummarizeOldMessages, Schema.TaggedStruct<"SummarizeOldMessages", {
-    readonly summaryTargetTokens: Schema.withConstructorDefault<Schema.Int>;
-}>, {}>;
-export declare class SummarizeOldMessages extends SummarizeOldMessages_base {
-}
-export declare const ContextTrimmingStrategy: Schema.Union<readonly [typeof DropOldestFifo, typeof SlidingWindow, typeof PriorityBased, typeof SummarizeOldMessages]>;
-export type ContextTrimmingStrategy = typeof ContextTrimmingStrategy.Type;
-export declare const ContextTrimmingStrategies: Readonly<{
-    DropOldestFifo: DropOldestFifo;
-    SlidingWindow: SlidingWindow;
-    PriorityBased: PriorityBased;
-    SummarizeOldMessages: (summaryTargetTokens?: number) => SummarizeOldMessages;
-}>;
-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;
-}
-export declare const defaultTokenCounter: TokenCounter;
-export interface MessageSummarizer<R = never> {
-    readonly summarize: (messages: ReadonlyArray<ConversationMessage>, targetTokens: number) => Effect.Effect<ConversationMessage, ContextError, R>;
-}
-export declare const simpleMessageSummarizer: MessageSummarizer<Crypto.Crypto>;
-export declare function applyContextWindow(messages: ReadonlyArray<ConversationMessage>, provider: LlmProvider, limits: ContextLimits, strategy: DropOldestFifo | SlidingWindow | PriorityBased, tokenCounter?: TokenCounter): Effect.Effect<ContextWindow, ContextError>;
-export declare function applyContextWindow(messages: ReadonlyArray<ConversationMessage>, provider: LlmProvider, limits: ContextLimits, strategy: ContextTrimmingStrategy, tokenCounter?: TokenCounter): Effect.Effect<ContextWindow, ContextError, Crypto.Crypto>;
-export declare function applyContextWindow<R>(messages: ReadonlyArray<ConversationMessage>, provider: LlmProvider, limits: ContextLimits, strategy: ContextTrimmingStrategy, tokenCounter: TokenCounter, summarizer: MessageSummarizer<R>): Effect.Effect<ContextWindow, ContextError, R>;
-export {};
-//# sourceMappingURL=ContextManagement.d.ts.map

package/dist/ContextManagement.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ContextManagement.d.ts","sourceRoot":"","sources":["../src/ContextManagement.ts"],"names":[],"mappings":"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"}