@opencode/core 0.0.0-reserved → 2.0.1

package/dist/chunks/repository-7zs56f9j.js

@@ -0,0 +1,604 @@
+import {
+  convertToOpenAICompatibleChatMessages2
+} from "./repository-fxgpk5d8.js";
+import {
+  getResponseMetadata2
+} from "./repository-g4wezp1m.js";
+import {
+  mapOpenAICompatibleFinishReason2
+} from "./repository-x61499pn.js";
+import {
+  openaiCompatibleProviderOptions2
+} from "./repository-af5trqkr.js";
+import {
+  defaultOpenAICompatibleErrorStructure2
+} from "./repository-afrmfg78.js";
+import {
+  prepareTools2
+} from "./repository-x0ckcb58.js";
+
+// src/github-copilot/chat/openai-compatible-chat-language-model.ts
+import {
+  InvalidResponseDataError
+} from "@ai-sdk/provider";
+import {
+  combineHeaders,
+  createEventSourceResponseHandler,
+  createJsonErrorResponseHandler,
+  createJsonResponseHandler,
+  generateId,
+  isParsableJson,
+  parseProviderOptions,
+  postJsonToApi
+} from "@ai-sdk/provider-utils";
+import { z } from "zod/v4";
+class OpenAICompatibleChatLanguageModel2 {
+  specificationVersion = "v3";
+  supportsStructuredOutputs;
+  modelId;
+  config;
+  failedResponseHandler;
+  chunkSchema;
+  constructor(modelId, config) {
+    this.modelId = modelId;
+    this.config = config;
+    const errorStructure = config.errorStructure ?? defaultOpenAICompatibleErrorStructure2;
+    this.chunkSchema = createOpenAICompatibleChatChunkSchema(errorStructure.errorSchema);
+    this.failedResponseHandler = createJsonErrorResponseHandler(errorStructure);
+    this.supportsStructuredOutputs = config.supportsStructuredOutputs ?? false;
+  }
+  get provider() {
+    return this.config.provider;
+  }
+  get providerOptionsName() {
+    return this.config.provider.split(".")[0].trim();
+  }
+  get supportedUrls() {
+    return this.config.supportedUrls?.() ?? {};
+  }
+  async getArgs({
+    prompt,
+    maxOutputTokens,
+    temperature,
+    topP,
+    topK,
+    frequencyPenalty,
+    presencePenalty,
+    providerOptions,
+    stopSequences,
+    responseFormat,
+    seed,
+    toolChoice,
+    tools
+  }) {
+    const warnings = [];
+    const compatibleOptions = Object.assign(await parseProviderOptions({
+      provider: "copilot",
+      providerOptions,
+      schema: openaiCompatibleProviderOptions2
+    }) ?? {}, await parseProviderOptions({
+      provider: this.providerOptionsName,
+      providerOptions,
+      schema: openaiCompatibleProviderOptions2
+    }) ?? {});
+    if (topK != null) {
+      warnings.push({ type: "unsupported", feature: "topK" });
+    }
+    if (responseFormat?.type === "json" && responseFormat.schema != null && !this.supportsStructuredOutputs) {
+      warnings.push({
+        type: "unsupported",
+        feature: "responseFormat",
+        details: "JSON response format schema is only supported with structuredOutputs"
+      });
+    }
+    const {
+      tools: openaiTools,
+      toolChoice: openaiToolChoice,
+      toolWarnings
+    } = prepareTools2({
+      tools,
+      toolChoice
+    });
+    return {
+      args: {
+        model: this.modelId,
+        user: compatibleOptions.user,
+        max_tokens: maxOutputTokens,
+        temperature,
+        top_p: topP,
+        frequency_penalty: frequencyPenalty,
+        presence_penalty: presencePenalty,
+        response_format: responseFormat?.type === "json" ? this.supportsStructuredOutputs === true && responseFormat.schema != null ? {
+          type: "json_schema",
+          json_schema: {
+            schema: responseFormat.schema,
+            name: responseFormat.name ?? "response",
+            description: responseFormat.description
+          }
+        } : { type: "json_object" } : undefined,
+        stop: stopSequences,
+        seed,
+        ...Object.fromEntries(Object.entries(providerOptions?.[this.providerOptionsName] ?? {}).filter(([key]) => !Object.keys(openaiCompatibleProviderOptions2.shape).includes(key))),
+        reasoning_effort: compatibleOptions.reasoningEffort,
+        verbosity: compatibleOptions.textVerbosity,
+        messages: convertToOpenAICompatibleChatMessages2(prompt),
+        tools: openaiTools,
+        tool_choice: openaiToolChoice,
+        thinking_budget: compatibleOptions.thinking_budget
+      },
+      warnings: [...warnings, ...toolWarnings]
+    };
+  }
+  async doGenerate(options) {
+    const { args, warnings } = await this.getArgs({ ...options });
+    const body = JSON.stringify(args);
+    const {
+      responseHeaders,
+      value: responseBody,
+      rawValue: rawResponse
+    } = await postJsonToApi({
+      url: this.config.url({
+        path: "/chat/completions",
+        modelId: this.modelId
+      }),
+      headers: combineHeaders(this.config.headers(), options.headers),
+      body: args,
+      failedResponseHandler: this.failedResponseHandler,
+      successfulResponseHandler: createJsonResponseHandler(OpenAICompatibleChatResponseSchema),
+      abortSignal: options.abortSignal,
+      fetch: this.config.fetch
+    });
+    const choice = responseBody.choices[0];
+    const content = [];
+    const text = choice.message.content;
+    if (text != null && text.length > 0) {
+      content.push({
+        type: "text",
+        text,
+        providerMetadata: choice.message.reasoning_opaque ? { copilot: { reasoningOpaque: choice.message.reasoning_opaque } } : undefined
+      });
+    }
+    const reasoning = choice.message.reasoning_text;
+    if (reasoning != null && reasoning.length > 0) {
+      content.push({
+        type: "reasoning",
+        text: reasoning,
+        providerMetadata: choice.message.reasoning_opaque ? { copilot: { reasoningOpaque: choice.message.reasoning_opaque } } : undefined
+      });
+    }
+    if (choice.message.tool_calls != null) {
+      for (const toolCall of choice.message.tool_calls) {
+        content.push({
+          type: "tool-call",
+          toolCallId: toolCall.id ?? generateId(),
+          toolName: toolCall.function.name,
+          input: toolCall.function.arguments,
+          providerMetadata: choice.message.reasoning_opaque ? { copilot: { reasoningOpaque: choice.message.reasoning_opaque } } : undefined
+        });
+      }
+    }
+    const providerMetadata = {
+      [this.providerOptionsName]: {},
+      ...await this.config.metadataExtractor?.extractMetadata?.({
+        parsedBody: rawResponse
+      })
+    };
+    const completionTokenDetails = responseBody.usage?.completion_tokens_details;
+    if (completionTokenDetails?.accepted_prediction_tokens != null) {
+      providerMetadata[this.providerOptionsName].acceptedPredictionTokens = completionTokenDetails?.accepted_prediction_tokens;
+    }
+    if (completionTokenDetails?.rejected_prediction_tokens != null) {
+      providerMetadata[this.providerOptionsName].rejectedPredictionTokens = completionTokenDetails?.rejected_prediction_tokens;
+    }
+    return {
+      content,
+      finishReason: {
+        unified: mapOpenAICompatibleFinishReason2(choice.finish_reason),
+        raw: choice.finish_reason ?? undefined
+      },
+      usage: {
+        inputTokens: {
+          total: responseBody.usage?.prompt_tokens ?? undefined,
+          noCache: undefined,
+          cacheRead: responseBody.usage?.prompt_tokens_details?.cached_tokens ?? undefined,
+          cacheWrite: undefined
+        },
+        outputTokens: {
+          total: responseBody.usage?.completion_tokens ?? undefined,
+          text: undefined,
+          reasoning: responseBody.usage?.completion_tokens_details?.reasoning_tokens ?? undefined
+        },
+        raw: responseBody.usage ?? undefined
+      },
+      providerMetadata,
+      request: { body },
+      response: {
+        ...getResponseMetadata2(responseBody),
+        headers: responseHeaders,
+        body: rawResponse
+      },
+      warnings
+    };
+  }
+  async doStream(options) {
+    const { args, warnings } = await this.getArgs({ ...options });
+    const body = {
+      ...args,
+      stream: true,
+      stream_options: this.config.includeUsage ? { include_usage: true } : undefined
+    };
+    const metadataExtractor = this.config.metadataExtractor?.createStreamExtractor();
+    const { responseHeaders, value: response } = await postJsonToApi({
+      url: this.config.url({
+        path: "/chat/completions",
+        modelId: this.modelId
+      }),
+      headers: combineHeaders(this.config.headers(), options.headers),
+      body,
+      failedResponseHandler: this.failedResponseHandler,
+      successfulResponseHandler: createEventSourceResponseHandler(this.chunkSchema),
+      abortSignal: options.abortSignal,
+      fetch: this.config.fetch
+    });
+    const toolCalls = [];
+    let finishReason = {
+      unified: "other",
+      raw: undefined
+    };
+    const usage = {
+      completionTokens: undefined,
+      completionTokensDetails: {
+        reasoningTokens: undefined,
+        acceptedPredictionTokens: undefined,
+        rejectedPredictionTokens: undefined
+      },
+      promptTokens: undefined,
+      promptTokensDetails: {
+        cachedTokens: undefined
+      },
+      totalTokens: undefined
+    };
+    let isFirstChunk = true;
+    const providerOptionsName = this.providerOptionsName;
+    let isActiveReasoning = false;
+    let isActiveText = false;
+    let reasoningOpaque;
+    return {
+      stream: response.pipeThrough(new TransformStream({
+        start(controller) {
+          controller.enqueue({ type: "stream-start", warnings });
+        },
+        transform(chunk, controller) {
+          if (options.includeRawChunks) {
+            controller.enqueue({ type: "raw", rawValue: chunk.rawValue });
+          }
+          if (!chunk.success) {
+            finishReason = {
+              unified: "error",
+              raw: undefined
+            };
+            controller.enqueue({ type: "error", error: chunk.error });
+            return;
+          }
+          const value = chunk.value;
+          metadataExtractor?.processChunk(chunk.rawValue);
+          if ("error" in value) {
+            finishReason = {
+              unified: "error",
+              raw: undefined
+            };
+            controller.enqueue({ type: "error", error: value.error.message });
+            return;
+          }
+          if (isFirstChunk) {
+            isFirstChunk = false;
+            controller.enqueue({
+              type: "response-metadata",
+              ...getResponseMetadata2(value)
+            });
+          }
+          if (value.usage != null) {
+            const {
+              prompt_tokens,
+              completion_tokens,
+              total_tokens,
+              prompt_tokens_details,
+              completion_tokens_details
+            } = value.usage;
+            usage.promptTokens = prompt_tokens ?? undefined;
+            usage.completionTokens = completion_tokens ?? undefined;
+            usage.totalTokens = total_tokens ?? undefined;
+            if (completion_tokens_details?.reasoning_tokens != null) {
+              usage.completionTokensDetails.reasoningTokens = completion_tokens_details?.reasoning_tokens;
+            }
+            if (completion_tokens_details?.accepted_prediction_tokens != null) {
+              usage.completionTokensDetails.acceptedPredictionTokens = completion_tokens_details?.accepted_prediction_tokens;
+            }
+            if (completion_tokens_details?.rejected_prediction_tokens != null) {
+              usage.completionTokensDetails.rejectedPredictionTokens = completion_tokens_details?.rejected_prediction_tokens;
+            }
+            if (prompt_tokens_details?.cached_tokens != null) {
+              usage.promptTokensDetails.cachedTokens = prompt_tokens_details?.cached_tokens;
+            }
+          }
+          const choice = value.choices[0];
+          if (choice?.finish_reason != null) {
+            finishReason = {
+              unified: mapOpenAICompatibleFinishReason2(choice.finish_reason),
+              raw: choice.finish_reason ?? undefined
+            };
+          }
+          if (choice?.delta == null) {
+            return;
+          }
+          const delta = choice.delta;
+          if (delta.reasoning_opaque) {
+            if (reasoningOpaque != null) {
+              throw new InvalidResponseDataError({
+                data: delta,
+                message: "Multiple reasoning_opaque values received in a single response. Only one thinking part per response is supported."
+              });
+            }
+            reasoningOpaque = delta.reasoning_opaque;
+          }
+          const reasoningContent = delta.reasoning_text;
+          if (reasoningContent) {
+            if (!isActiveReasoning) {
+              controller.enqueue({
+                type: "reasoning-start",
+                id: "reasoning-0"
+              });
+              isActiveReasoning = true;
+            }
+            controller.enqueue({
+              type: "reasoning-delta",
+              id: "reasoning-0",
+              delta: reasoningContent
+            });
+          }
+          if (delta.content) {
+            if (isActiveReasoning && !isActiveText) {
+              controller.enqueue({
+                type: "reasoning-end",
+                id: "reasoning-0",
+                providerMetadata: reasoningOpaque ? { copilot: { reasoningOpaque } } : undefined
+              });
+              isActiveReasoning = false;
+            }
+            if (!isActiveText) {
+              controller.enqueue({
+                type: "text-start",
+                id: "txt-0",
+                providerMetadata: reasoningOpaque ? { copilot: { reasoningOpaque } } : undefined
+              });
+              isActiveText = true;
+            }
+            controller.enqueue({
+              type: "text-delta",
+              id: "txt-0",
+              delta: delta.content
+            });
+          }
+          if (delta.tool_calls != null) {
+            if (isActiveReasoning) {
+              controller.enqueue({
+                type: "reasoning-end",
+                id: "reasoning-0",
+                providerMetadata: reasoningOpaque ? { copilot: { reasoningOpaque } } : undefined
+              });
+              isActiveReasoning = false;
+            }
+            for (const toolCallDelta of delta.tool_calls) {
+              const index = toolCallDelta.index;
+              if (toolCalls[index] == null) {
+                if (toolCallDelta.id == null) {
+                  throw new InvalidResponseDataError({
+                    data: toolCallDelta,
+                    message: `Expected 'id' to be a string.`
+                  });
+                }
+                if (toolCallDelta.function?.name == null) {
+                  throw new InvalidResponseDataError({
+                    data: toolCallDelta,
+                    message: `Expected 'function.name' to be a string.`
+                  });
+                }
+                controller.enqueue({
+                  type: "tool-input-start",
+                  id: toolCallDelta.id,
+                  toolName: toolCallDelta.function.name
+                });
+                toolCalls[index] = {
+                  id: toolCallDelta.id,
+                  function: {
+                    name: toolCallDelta.function.name,
+                    arguments: toolCallDelta.function.arguments ?? ""
+                  },
+                  hasFinished: false
+                };
+                const toolCall = toolCalls[index];
+                if (toolCall.function?.name != null && toolCall.function?.arguments != null) {
+                  if (toolCall.function.arguments.length > 0) {
+                    controller.enqueue({
+                      type: "tool-input-delta",
+                      id: toolCall.id,
+                      delta: toolCall.function.arguments
+                    });
+                  }
+                  if (isParsableJson(toolCall.function.arguments)) {
+                    controller.enqueue({
+                      type: "tool-input-end",
+                      id: toolCall.id
+                    });
+                    controller.enqueue({
+                      type: "tool-call",
+                      toolCallId: toolCall.id ?? generateId(),
+                      toolName: toolCall.function.name,
+                      input: toolCall.function.arguments,
+                      providerMetadata: reasoningOpaque ? { copilot: { reasoningOpaque } } : undefined
+                    });
+                    toolCall.hasFinished = true;
+                  }
+                }
+                continue;
+              }
+              const toolCall = toolCalls[index];
+              if (toolCall.hasFinished) {
+                continue;
+              }
+              if (toolCallDelta.function?.arguments != null) {
+                toolCall.function.arguments += toolCallDelta.function?.arguments ?? "";
+              }
+              controller.enqueue({
+                type: "tool-input-delta",
+                id: toolCall.id,
+                delta: toolCallDelta.function.arguments ?? ""
+              });
+              if (toolCall.function?.name != null && toolCall.function?.arguments != null && isParsableJson(toolCall.function.arguments)) {
+                controller.enqueue({
+                  type: "tool-input-end",
+                  id: toolCall.id
+                });
+                controller.enqueue({
+                  type: "tool-call",
+                  toolCallId: toolCall.id ?? generateId(),
+                  toolName: toolCall.function.name,
+                  input: toolCall.function.arguments,
+                  providerMetadata: reasoningOpaque ? { copilot: { reasoningOpaque } } : undefined
+                });
+                toolCall.hasFinished = true;
+              }
+            }
+          }
+        },
+        flush(controller) {
+          if (isActiveReasoning) {
+            controller.enqueue({
+              type: "reasoning-end",
+              id: "reasoning-0",
+              providerMetadata: reasoningOpaque ? { copilot: { reasoningOpaque } } : undefined
+            });
+          }
+          if (isActiveText) {
+            controller.enqueue({
+              type: "text-end",
+              id: "txt-0",
+              providerMetadata: reasoningOpaque ? { copilot: { reasoningOpaque } } : undefined
+            });
+          }
+          for (const toolCall of toolCalls.filter((toolCall) => !toolCall.hasFinished)) {
+            controller.enqueue({
+              type: "tool-input-end",
+              id: toolCall.id
+            });
+            controller.enqueue({
+              type: "tool-call",
+              toolCallId: toolCall.id ?? generateId(),
+              toolName: toolCall.function.name,
+              input: toolCall.function.arguments
+            });
+          }
+          const providerMetadata = {
+            [providerOptionsName]: {},
+            ...reasoningOpaque ? { copilot: { reasoningOpaque } } : {},
+            ...metadataExtractor?.buildMetadata()
+          };
+          if (usage.completionTokensDetails.acceptedPredictionTokens != null) {
+            providerMetadata[providerOptionsName].acceptedPredictionTokens = usage.completionTokensDetails.acceptedPredictionTokens;
+          }
+          if (usage.completionTokensDetails.rejectedPredictionTokens != null) {
+            providerMetadata[providerOptionsName].rejectedPredictionTokens = usage.completionTokensDetails.rejectedPredictionTokens;
+          }
+          controller.enqueue({
+            type: "finish",
+            finishReason,
+            usage: {
+              inputTokens: {
+                total: usage.promptTokens,
+                noCache: usage.promptTokens != null && usage.promptTokensDetails.cachedTokens != null ? usage.promptTokens - usage.promptTokensDetails.cachedTokens : undefined,
+                cacheRead: usage.promptTokensDetails.cachedTokens,
+                cacheWrite: undefined
+              },
+              outputTokens: {
+                total: usage.completionTokens,
+                text: undefined,
+                reasoning: usage.completionTokensDetails.reasoningTokens
+              },
+              raw: {
+                prompt_tokens: usage.promptTokens ?? null,
+                completion_tokens: usage.completionTokens ?? null,
+                total_tokens: usage.totalTokens ?? null
+              }
+            },
+            providerMetadata
+          });
+        }
+      })),
+      request: { body },
+      response: { headers: responseHeaders }
+    };
+  }
+}
+var openaiCompatibleTokenUsageSchema = z.object({
+  prompt_tokens: z.number().nullish(),
+  completion_tokens: z.number().nullish(),
+  total_tokens: z.number().nullish(),
+  prompt_tokens_details: z.object({
+    cached_tokens: z.number().nullish()
+  }).nullish(),
+  completion_tokens_details: z.object({
+    reasoning_tokens: z.number().nullish(),
+    accepted_prediction_tokens: z.number().nullish(),
+    rejected_prediction_tokens: z.number().nullish()
+  }).nullish()
+}).nullish();
+var OpenAICompatibleChatResponseSchema = z.object({
+  id: z.string().nullish(),
+  created: z.number().nullish(),
+  model: z.string().nullish(),
+  choices: z.array(z.object({
+    message: z.object({
+      role: z.literal("assistant").nullish(),
+      content: z.string().nullish(),
+      reasoning_text: z.string().nullish(),
+      reasoning_opaque: z.string().nullish(),
+      tool_calls: z.array(z.object({
+        id: z.string().nullish(),
+        function: z.object({
+          name: z.string(),
+          arguments: z.string()
+        })
+      })).nullish()
+    }),
+    finish_reason: z.string().nullish()
+  })),
+  usage: openaiCompatibleTokenUsageSchema
+});
+var createOpenAICompatibleChatChunkSchema = (errorSchema) => z.union([
+  z.object({
+    id: z.string().nullish(),
+    created: z.number().nullish(),
+    model: z.string().nullish(),
+    choices: z.array(z.object({
+      delta: z.object({
+        role: z.enum(["assistant"]).nullish(),
+        content: z.string().nullish(),
+        reasoning_text: z.string().nullish(),
+        reasoning_opaque: z.string().nullish(),
+        tool_calls: z.array(z.object({
+          index: z.number(),
+          id: z.string().nullish(),
+          function: z.object({
+            name: z.string().nullish(),
+            arguments: z.string().nullish()
+          })
+        })).nullish()
+      }).nullish(),
+      finish_reason: z.string().nullish()
+    })),
+    usage: openaiCompatibleTokenUsageSchema
+  }),
+  errorSchema
+]);
+
+export { OpenAICompatibleChatLanguageModel2 };

package/dist/chunks/repository-822emrt2.js

@@ -0,0 +1,31 @@
+// src/database/drizzle/sqlite-core/effect/raw.ts
+import { applyEffectWrapper } from "drizzle-orm/effect-core/query-effect";
+import { entityKind } from "drizzle-orm/entity";
+
+class SQLiteEffectRaw2 {
+  execute;
+  getSQL;
+  action;
+  dialect;
+  mapBatchResult;
+  static [entityKind] = "SQLiteEffectRaw";
+  constructor(execute, getSQL, action, dialect, mapBatchResult) {
+    this.execute = execute;
+    this.getSQL = getSQL;
+    this.action = action;
+    this.dialect = dialect;
+    this.mapBatchResult = mapBatchResult;
+  }
+  getQuery() {
+    return { ...this.dialect.sqlToQuery(this.getSQL()), method: this.action };
+  }
+  mapResult(result, isFromBatch) {
+    return isFromBatch ? this.mapBatchResult(result) : result;
+  }
+  _prepare() {
+    return this;
+  }
+}
+applyEffectWrapper(SQLiteEffectRaw2);
+
+export { SQLiteEffectRaw2 };

package/dist/chunks/repository-84czwvzw.js

@@ -0,0 +1,63 @@
+import {
+  Service53,
+  node57,
+  canonical3
+} from "./repository-2yv9jfkc.js";
+import {
+  Service52,
+  node56
+} from "./repository-1bvekr7f.js";
+import {
+  Service15
+} from "./repository-2v08kgv1.js";
+import {
+  layer2
+} from "./repository-qec2v6cx.js";
+
+// src/location-services.ts
+import { Context, Duration, Effect, Exit, Layer, LayerMap, MutableHashMap, Option } from "effect";
+function buildLocationServiceMap2(replacements = []) {
+  return Layer.effect(Service53, Effect.gen(function* () {
+    const owner = yield* Effect.scope;
+    const builds = MutableHashMap.empty();
+    const inner = yield* LayerMap.make((ref) => {
+      const build = {};
+      MutableHashMap.set(builds, ref, build);
+      return Layer.fromBuild((memoMap, scope) => Effect.suspend(() => Layer.buildWithMemoMap(layer2(ref, { replacements: bindings }), memoMap, scope)).pipe(Effect.onExit((exit) => {
+        const finish = Effect.suspend(() => {
+          if (Option.getOrUndefined(MutableHashMap.get(builds, ref)) !== build)
+            return Effect.void;
+          if (Exit.isSuccess(exit)) {
+            build.close = Context.get(exit.value, Service15).close;
+            return Effect.void;
+          }
+          MutableHashMap.remove(builds, ref);
+          return Exit.isFailure(exit) ? inner.invalidate(ref) : Effect.void;
+        });
+        return Exit.isFailure(exit) ? finish.pipe(Effect.forkIn(owner, { startImmediately: true }), Effect.asVoid) : finish;
+      })));
+    }, { idleTimeToLive: Duration.infinity });
+    const map = {
+      ...inner,
+      get: (ref) => inner.get(canonical3(ref)),
+      contextEffect: (ref) => inner.contextEffect(canonical3(ref)),
+      contextEffectOption: (ref) => inner.contextEffectOption(canonical3(ref)),
+      invalidate: (ref) => Effect.suspend(() => {
+        const key = canonical3(ref);
+        const build = Option.getOrUndefined(MutableHashMap.get(builds, key));
+        MutableHashMap.remove(builds, key);
+        return inner.invalidate(key).pipe(Effect.andThen(build?.close ?? Effect.void));
+      })
+    };
+    const bindings = [
+      node56.replace(Layer.succeed(Service52, {
+        provide: (session) => Effect.provide(map.get(session.location))
+      })),
+      ...replacements,
+      node57.replace(Layer.succeed(Service53, map))
+    ];
+    return map;
+  }));
+}
+
+export { buildLocationServiceMap2 };