@burtson-labs/bandit-engine 2.0.8

package/dist/chunk-AVC6IZJQ.mjs

@@ -0,0 +1,2157 @@
+import {
+  debugLogger
+} from "./chunk-KCI46M23.mjs";
+
+// src/store/aiProviderStore.ts
+import { create } from "zustand";
+
+// src/services/ai-provider/providers/ollama.provider.ts
+import { map as map2 } from "rxjs";
+
+// src/services/ollama/ollama.service.ts
+import { catchError, from, lastValueFrom, map, Observable, of, shareReplay, switchMap, throwError, timeout } from "rxjs";
+var handleError = () => (obs) => obs.pipe(
+  switchMap(
+    (response) => response.ok ? of(response) : throwError(() => new Error(`Request failed: ${response.status} ${response.statusText}`))
+  )
+);
+var parseResponseBody = async (response, responseType) => {
+  if (responseType === "text") {
+    return await response.text();
+  }
+  return await response.json();
+};
+var OllamaService = class {
+  constructor(_baseUrl, _tokenFactory) {
+    this._baseUrl = _baseUrl;
+    this._tokenFactory = _tokenFactory;
+    if (!this._baseUrl) {
+      this._baseUrl = "http://localhost:11434";
+      debugLogger.warn(`No base URL provided, using default: ${this._baseUrl}`);
+    }
+  }
+  _tryGatewayWithTimeout(args) {
+    const { url, responseType, timeoutMs } = args;
+    const source = this._get(url, responseType);
+    const mapped = source.pipe(
+      catchError((e) => e?.message.includes("401") ? of(true) : of(false)),
+      map(() => true),
+      timeout(timeoutMs)
+    );
+    return mapped;
+  }
+  /**
+   * Validates the availability of the service at the given base URL.
+   * @param fallbackUrl The fallback URL to try if the base URL is not available.
+   * @returns An object containing the URL and availability status.
+   */
+  async validateServiceAvailability(args) {
+    const { fallbackUrl, timeoutMs } = args;
+    const responseType = "text";
+    const availablility = {
+      url: "",
+      isAvailable: false
+    };
+    try {
+      debugLogger.debug(`Validating service availability at ${this._baseUrl}`);
+      availablility.url = this._baseUrl;
+      availablility.isAvailable = await lastValueFrom(
+        this._tryGatewayWithTimeout({
+          url: availablility.url,
+          responseType,
+          timeoutMs
+        })
+      );
+      if (!availablility.isAvailable) {
+        throw new Error(`Service not available at ${this._baseUrl}`);
+      }
+      return availablility;
+    } catch (e) {
+      debugLogger.warn(`Service not available at ${this._baseUrl}, trying fallback URL: ${fallbackUrl}`);
+      try {
+        availablility.url = fallbackUrl;
+        availablility.isAvailable = await lastValueFrom(
+          this._tryGatewayWithTimeout({
+            url: availablility.url,
+            responseType,
+            timeoutMs
+          })
+        );
+        if (!availablility.isAvailable) {
+          throw new Error(`Service not available at ${fallbackUrl}`);
+        }
+        this._baseUrl = fallbackUrl;
+        return availablility;
+      } catch (e2) {
+        debugLogger.error(`Service not available at fallback URL: ${fallbackUrl}`);
+        throw e2;
+      }
+    }
+  }
+  generate(request) {
+    const url = `${this._baseUrl}/api/generate`;
+    return new Observable((observer) => {
+      const task = fetch(url, {
+        method: "POST",
+        headers: this._getHeaders(),
+        body: JSON.stringify({ ...request, stream: request.stream === false ? false : true })
+      });
+      task.then((response) => {
+        this._throwErrorIfNotOk(url, response);
+        const reader = response.body?.getReader();
+        const decoder = new TextDecoder();
+        let buffer = "";
+        const read = () => {
+          reader?.read().then(({ done, value }) => {
+            if (done) {
+              if (buffer.trim() !== "") {
+                try {
+                  observer.next(JSON.parse(buffer));
+                } catch (err) {
+                  observer.error(err);
+                  debugLogger.error("Final chunk parsing error (generate):", { buffer });
+                }
+              }
+              observer.complete();
+              return;
+            }
+            buffer += decoder.decode(value, { stream: true });
+            const lines = buffer.split("\n");
+            buffer = lines.pop() ?? "";
+            for (const line of lines) {
+              if (line.trim()) {
+                try {
+                  observer.next(JSON.parse(line));
+                } catch (err) {
+                  observer.error(err);
+                  debugLogger.error("Error parsing JSON line (generate):", { line });
+                }
+              }
+            }
+            read();
+          }).catch((err) => observer.error(err));
+        };
+        read();
+      }).catch((err) => observer.error(err));
+    });
+  }
+  // generate(request: GenerateRequest): Observable<GenerateResponse> {
+  //   const url = `${this._baseUrl}/api/generate`;
+  //   return this._post<GenerateRequest, GenerateResponse>(url, request);
+  // }
+  chat(request) {
+    const url = `${this._baseUrl}/api/chat`;
+    return new Observable((observer) => {
+      const task = fetch(url, {
+        method: "POST",
+        headers: this._getHeaders(),
+        body: JSON.stringify({ ...request, stream: true })
+      });
+      task.then((response) => {
+        this._throwErrorIfNotOk(url, response);
+        const reader = response.body?.getReader();
+        const decoder = new TextDecoder();
+        let buffer = "";
+        const read = () => {
+          reader?.read().then(({ done, value }) => {
+            if (done) {
+              if (buffer.trim() !== "") {
+                try {
+                  observer.next(JSON.parse(buffer));
+                } catch (err) {
+                  observer.error(err);
+                  debugLogger.error("Final chunk parsing error (chat):", { buffer });
+                }
+              }
+              observer.complete();
+              return;
+            }
+            buffer += decoder.decode(value, { stream: true });
+            const lines = buffer.split("\n");
+            buffer = lines.pop() ?? "";
+            for (const line of lines) {
+              if (line.trim()) {
+                try {
+                  observer.next(JSON.parse(line));
+                } catch (err) {
+                  observer.error(err);
+                  debugLogger.error("Error parsing JSON line (chat):", { line });
+                }
+              }
+            }
+            read();
+          }).catch((err) => observer.error(err));
+        };
+        read();
+      }).catch((err) => observer.error(err));
+    });
+  }
+  listModels() {
+    const url = `${this._baseUrl}/api/tags`;
+    const response = this._get(url);
+    const result = response.pipe(
+      map((data) => data.models),
+      shareReplay(1)
+    );
+    return result;
+  }
+  _get(url, responseType = "json") {
+    const requestInit = {
+      method: "GET",
+      headers: this._getHeaders()
+    };
+    const response = from(fetch(url, requestInit));
+    const handleFetchError = response.pipe(handleError());
+    const data = handleFetchError.pipe(switchMap((res) => from(parseResponseBody(res, responseType))));
+    const result = data.pipe(shareReplay(1));
+    return result;
+  }
+  _post(url, body) {
+    const response = from(fetch(url, {
+      method: "POST",
+      headers: this._getHeaders(),
+      body: JSON.stringify(body)
+    }));
+    const handleFetchError = response.pipe(handleError());
+    const json = handleFetchError.pipe(switchMap((res) => from(parseResponseBody(res, "json"))));
+    const result = json.pipe(shareReplay(1));
+    return result;
+  }
+  _throwErrorIfNotOk(url, response) {
+    if (!response.ok) {
+      throw new Error(`POST ${url} failed: ${response.status} ${response.statusText}`);
+    }
+  }
+  _getHeaders() {
+    const token = this._tokenFactory();
+    if (!token) {
+      debugLogger.warn("OllamaService: No token found, using empty string for Authorization header");
+    }
+    return {
+      "Content-Type": "application/json",
+      "Authorization": `Bearer ${token || ""}`
+    };
+  }
+};
+
+// src/services/ai-provider/providers/deprecated.ts
+function deprecatedOpenAIProvider() {
+  debugLogger.warn('\u26A0\uFE0F  DEPRECATION WARNING: Direct OpenAI provider is deprecated. Please migrate to GatewayProvider with provider: "openai". See GATEWAY_MIGRATION_GUIDE.md for details.');
+}
+function deprecatedAzureOpenAIProvider() {
+  debugLogger.warn('\u26A0\uFE0F  DEPRECATION WARNING: Direct Azure OpenAI provider is deprecated. Please migrate to GatewayProvider with provider: "azure-openai". See GATEWAY_MIGRATION_GUIDE.md for details.');
+}
+function deprecatedAnthropicProvider() {
+  debugLogger.warn('\u26A0\uFE0F  DEPRECATION WARNING: Direct Anthropic provider is deprecated. Please migrate to GatewayProvider with provider: "anthropic". See GATEWAY_MIGRATION_GUIDE.md for details.');
+}
+function deprecatedOllamaProvider() {
+  debugLogger.info('\u2139\uFE0F  INFO: Direct Ollama provider is available for local development. For production environments, consider using GatewayProvider with provider: "ollama" for enhanced management. See GATEWAY_MIGRATION_GUIDE.md for details.');
+}
+
+// src/services/ai-provider/providers/ollama.provider.ts
+var OllamaProvider = class {
+  ollamaService;
+  config;
+  constructor(config) {
+    deprecatedOllamaProvider();
+    this.config = config;
+    const baseUrl = config.baseUrl || "http://localhost:11434";
+    debugLogger.info("OllamaProvider: Constructor", {
+      configBaseUrl: config.baseUrl,
+      finalBaseUrl: baseUrl,
+      hasTokenFactory: !!config.tokenFactory
+    });
+    this.ollamaService = new OllamaService(
+      baseUrl,
+      config.tokenFactory || (() => null)
+    );
+  }
+  chat(request) {
+    const ollamaRequest = {
+      model: request.model,
+      messages: request.messages.map((msg) => ({
+        role: msg.role,
+        content: msg.content
+      })),
+      stream: request.stream,
+      options: request.options,
+      images: request.images
+    };
+    return this.ollamaService.chat(ollamaRequest).pipe(
+      map2((response) => ({
+        message: {
+          content: response.message.content,
+          role: "assistant"
+        },
+        done: response.done
+      }))
+    );
+  }
+  generate(request) {
+    const ollamaRequest = {
+      model: request.model,
+      prompt: request.prompt,
+      stream: request.stream,
+      options: request.options
+    };
+    return this.ollamaService.generate(ollamaRequest).pipe(
+      map2((response) => ({
+        response: response.response,
+        done: response.done
+      }))
+    );
+  }
+  listModels() {
+    return this.ollamaService.listModels().pipe(
+      map2((models) => models.map((model) => ({
+        name: model.name,
+        size: model.size,
+        details: model.details,
+        digest: model.digest,
+        modified_at: model.modified_at
+      })))
+    );
+  }
+  async validateServiceAvailability(args) {
+    return this.ollamaService.validateServiceAvailability({
+      fallbackUrl: args.fallbackUrl || "",
+      timeoutMs: args.timeoutMs
+    });
+  }
+  getProviderType() {
+    return "ollama" /* OLLAMA */;
+  }
+  getConfig() {
+    return this.config;
+  }
+};
+
+// src/services/ai-provider/providers/openai.provider.ts
+import { Observable as Observable3, from as from2, switchMap as switchMap2, map as map3, throwError as throwError2 } from "rxjs";
+var OpenAIProvider = class {
+  config;
+  baseUrl;
+  constructor(config) {
+    deprecatedOpenAIProvider();
+    this.config = config;
+    this.baseUrl = config.baseUrl || "https://api.openai.com/v1";
+  }
+  chat(request) {
+    const url = `${this.baseUrl}/chat/completions`;
+    const payload = {
+      model: request.model,
+      messages: request.messages,
+      stream: Boolean(request.stream),
+      temperature: request.temperature,
+      max_tokens: request.maxTokens
+    };
+    if (request.stream) {
+      return this.streamChatRequest(url, payload);
+    } else {
+      return this.nonStreamChatRequest(url, payload);
+    }
+  }
+  generate(request) {
+    const chatRequest = {
+      model: request.model,
+      messages: [{ role: "user", content: request.prompt }],
+      stream: request.stream,
+      options: request.options
+    };
+    return this.chat(chatRequest).pipe(
+      map3((response) => ({
+        response: response.message.content,
+        done: response.done
+      }))
+    );
+  }
+  listModels() {
+    const url = `${this.baseUrl}/models`;
+    return from2(fetch(url, {
+      headers: this.getHeaders()
+    })).pipe(
+      switchMap2((response) => {
+        if (!response.ok) {
+          return throwError2(() => new Error(`Failed to list models: ${response.status}`));
+        }
+        return from2(response.json());
+      }),
+      map3(
+        (data) => data.data.map((model) => ({
+          name: model.id,
+          details: {
+            format: "openai",
+            family: model.object
+          }
+        }))
+      )
+    );
+  }
+  async validateServiceAvailability(args) {
+    try {
+      const controller = new AbortController();
+      const timeoutId = setTimeout(() => controller.abort(), args.timeoutMs);
+      const response = await fetch(`${this.baseUrl}/models`, {
+        headers: this.getHeaders(),
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      return {
+        url: this.baseUrl,
+        isAvailable: response.ok
+      };
+    } catch (error) {
+      if (args.fallbackUrl) {
+        try {
+          const controller = new AbortController();
+          const timeoutId = setTimeout(() => controller.abort(), args.timeoutMs);
+          const response = await fetch(`${args.fallbackUrl}/models`, {
+            headers: this.getHeaders(),
+            signal: controller.signal
+          });
+          clearTimeout(timeoutId);
+          if (response.ok) {
+            this.baseUrl = args.fallbackUrl;
+            return {
+              url: args.fallbackUrl,
+              isAvailable: true
+            };
+          }
+        } catch (fallbackError) {
+        }
+      }
+      return {
+        url: this.baseUrl,
+        isAvailable: false
+      };
+    }
+  }
+  getProviderType() {
+    return "openai" /* OPENAI */;
+  }
+  getConfig() {
+    return this.config;
+  }
+  streamChatRequest(url, payload) {
+    return new Observable3((observer) => {
+      const task = fetch(url, {
+        method: "POST",
+        headers: {
+          ...this.getHeaders(),
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify(payload)
+      });
+      task.then((response) => {
+        if (!response.ok) {
+          observer.error(new Error(`OpenAI request failed: ${response.status}`));
+          return;
+        }
+        const reader = response.body?.getReader();
+        const decoder = new TextDecoder();
+        let buffer = "";
+        const read = () => {
+          reader?.read().then(({ done, value }) => {
+            if (done) {
+              observer.next({
+                message: { content: "", role: "assistant" },
+                done: true
+              });
+              observer.complete();
+              return;
+            }
+            buffer += decoder.decode(value, { stream: true });
+            const lines = buffer.split("\n");
+            buffer = lines.pop() ?? "";
+            for (const line of lines) {
+              if (line.trim() && line.startsWith("data: ")) {
+                const data = line.slice(6).trim();
+                if (data === "[DONE]") {
+                  observer.next({
+                    message: { content: "", role: "assistant" },
+                    done: true
+                  });
+                  observer.complete();
+                  return;
+                }
+                try {
+                  const parsed = JSON.parse(data);
+                  const content = parsed.choices?.[0]?.delta?.content ?? "";
+                  if (content) {
+                    observer.next({
+                      message: { content, role: "assistant" },
+                      done: false
+                    });
+                  }
+                } catch (err) {
+                  debugLogger.error("Error parsing OpenAI stream data:", { data, error: err });
+                }
+              }
+            }
+            read();
+          }).catch((err) => observer.error(err));
+        };
+        read();
+      }).catch((err) => observer.error(err));
+    });
+  }
+  nonStreamChatRequest(url, payload) {
+    return from2(fetch(url, {
+      method: "POST",
+      headers: {
+        ...this.getHeaders(),
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(payload)
+    })).pipe(
+      switchMap2((response) => {
+        if (!response.ok) {
+          return throwError2(() => new Error(`OpenAI request failed: ${response.status}`));
+        }
+        return from2(response.json());
+      }),
+      map3((data) => ({
+        message: {
+          content: data.choices?.[0]?.message?.content ?? "",
+          role: "assistant"
+        },
+        done: true
+      }))
+    );
+  }
+  getHeaders() {
+    const headers = {};
+    if (this.config.apiKey) {
+      headers["Authorization"] = `Bearer ${this.config.apiKey}`;
+    }
+    return headers;
+  }
+};
+
+// src/services/ai-provider/providers/azure-openai.provider.ts
+import { Observable as Observable4, from as from3, switchMap as switchMap3, map as map4, throwError as throwError3 } from "rxjs";
+var AzureOpenAIProvider = class {
+  config;
+  baseUrl;
+  constructor(config) {
+    deprecatedAzureOpenAIProvider();
+    this.config = config;
+    if (!config.baseUrl || !config.deploymentName || !config.apiVersion) {
+      throw new Error("Azure OpenAI requires baseUrl, deploymentName, and apiVersion");
+    }
+    this.baseUrl = config.baseUrl;
+  }
+  chat(request) {
+    const url = `${this.baseUrl}/openai/deployments/${this.config.deploymentName}/chat/completions?api-version=${this.config.apiVersion}`;
+    const payload = {
+      messages: request.messages,
+      stream: Boolean(request.stream),
+      temperature: request.temperature,
+      max_tokens: request.maxTokens
+    };
+    if (request.stream) {
+      return this.streamChatRequest(url, payload);
+    } else {
+      return this.nonStreamChatRequest(url, payload);
+    }
+  }
+  generate(request) {
+    const chatRequest = {
+      model: request.model,
+      messages: [{ role: "user", content: request.prompt }],
+      stream: request.stream,
+      options: request.options
+    };
+    return this.chat(chatRequest).pipe(
+      map4((response) => ({
+        response: response.message.content,
+        done: response.done
+      }))
+    );
+  }
+  listModels() {
+    const model = {
+      name: this.config.deploymentName || "azure-deployment",
+      details: {
+        format: "azure-openai",
+        family: "gpt"
+      }
+    };
+    return new Observable4((observer) => {
+      observer.next([model]);
+      observer.complete();
+    });
+  }
+  async validateServiceAvailability(args) {
+    try {
+      const controller = new AbortController();
+      const timeoutId = setTimeout(() => controller.abort(), args.timeoutMs);
+      const testUrl = `${this.baseUrl}/openai/deployments/${this.config.deploymentName}/chat/completions?api-version=${this.config.apiVersion}`;
+      const response = await fetch(testUrl, {
+        method: "POST",
+        headers: this.getHeaders(),
+        body: JSON.stringify({
+          messages: [{ role: "user", content: "test" }],
+          max_tokens: 1
+        }),
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      return {
+        url: this.baseUrl,
+        isAvailable: response.ok || response.status === 400
+        // 400 might be expected for the test
+      };
+    } catch (error) {
+      if (args.fallbackUrl) {
+        try {
+          const controller = new AbortController();
+          const timeoutId = setTimeout(() => controller.abort(), args.timeoutMs);
+          const testUrl = `${args.fallbackUrl}/openai/deployments/${this.config.deploymentName}/chat/completions?api-version=${this.config.apiVersion}`;
+          const response = await fetch(testUrl, {
+            method: "POST",
+            headers: this.getHeaders(),
+            body: JSON.stringify({
+              messages: [{ role: "user", content: "test" }],
+              max_tokens: 1
+            }),
+            signal: controller.signal
+          });
+          clearTimeout(timeoutId);
+          if (response.ok || response.status === 400) {
+            this.baseUrl = args.fallbackUrl;
+            return {
+              url: args.fallbackUrl,
+              isAvailable: true
+            };
+          }
+        } catch (fallbackError) {
+        }
+      }
+      return {
+        url: this.baseUrl,
+        isAvailable: false
+      };
+    }
+  }
+  getProviderType() {
+    return "azure-openai" /* AZURE_OPENAI */;
+  }
+  getConfig() {
+    return this.config;
+  }
+  streamChatRequest(url, payload) {
+    return new Observable4((observer) => {
+      const task = fetch(url, {
+        method: "POST",
+        headers: {
+          ...this.getHeaders(),
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify(payload)
+      });
+      task.then((response) => {
+        if (!response.ok) {
+          observer.error(new Error(`Azure OpenAI request failed: ${response.status}`));
+          return;
+        }
+        const reader = response.body?.getReader();
+        const decoder = new TextDecoder();
+        let buffer = "";
+        const read = () => {
+          reader?.read().then(({ done, value }) => {
+            if (done) {
+              observer.next({
+                message: { content: "", role: "assistant" },
+                done: true
+              });
+              observer.complete();
+              return;
+            }
+            buffer += decoder.decode(value, { stream: true });
+            const lines = buffer.split("\n");
+            buffer = lines.pop() ?? "";
+            for (const line of lines) {
+              if (line.trim() && line.startsWith("data: ")) {
+                const data = line.slice(6).trim();
+                if (data === "[DONE]") {
+                  observer.next({
+                    message: { content: "", role: "assistant" },
+                    done: true
+                  });
+                  observer.complete();
+                  return;
+                }
+                try {
+                  const parsed = JSON.parse(data);
+                  const content = parsed.choices?.[0]?.delta?.content ?? "";
+                  if (content) {
+                    observer.next({
+                      message: { content, role: "assistant" },
+                      done: false
+                    });
+                  }
+                } catch (err) {
+                  debugLogger.error("Error parsing Azure OpenAI stream data:", { data, error: err });
+                }
+              }
+            }
+            read();
+          }).catch((err) => observer.error(err));
+        };
+        read();
+      }).catch((err) => observer.error(err));
+    });
+  }
+  nonStreamChatRequest(url, payload) {
+    return from3(fetch(url, {
+      method: "POST",
+      headers: {
+        ...this.getHeaders(),
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(payload)
+    })).pipe(
+      switchMap3((response) => {
+        if (!response.ok) {
+          return throwError3(() => new Error(`Azure OpenAI request failed: ${response.status}`));
+        }
+        return from3(response.json());
+      }),
+      map4((data) => {
+        const content = data.choices?.[0]?.message?.content ?? "";
+        return {
+          message: {
+            content,
+            role: "assistant"
+          },
+          done: true
+        };
+      })
+    );
+  }
+  getHeaders() {
+    const headers = {};
+    if (this.config.apiKey) {
+      headers["api-key"] = this.config.apiKey;
+    }
+    return headers;
+  }
+};
+
+// src/services/ai-provider/providers/anthropic.provider.ts
+import { Observable as Observable5, from as from4, switchMap as switchMap4, map as map5, throwError as throwError4 } from "rxjs";
+var AnthropicProvider = class {
+  config;
+  baseUrl;
+  constructor(config) {
+    deprecatedAnthropicProvider();
+    this.config = config;
+    this.baseUrl = config.baseUrl || "https://api.anthropic.com/v1";
+  }
+  chat(request) {
+    const url = `${this.baseUrl}/messages`;
+    const systemMessage = request.messages.find((msg) => msg.role === "system");
+    const userMessages = request.messages.filter((msg) => msg.role !== "system");
+    const payload = {
+      model: request.model,
+      messages: userMessages.map((msg) => ({
+        role: msg.role === "user" ? "user" : "assistant",
+        content: msg.content
+      })),
+      system: systemMessage?.content,
+      stream: Boolean(request.stream),
+      temperature: request.temperature,
+      max_tokens: request.maxTokens ?? 1e3
+    };
+    if (request.stream) {
+      return this.streamChatRequest(url, payload);
+    } else {
+      return this.nonStreamChatRequest(url, payload);
+    }
+  }
+  generate(request) {
+    const chatRequest = {
+      model: request.model,
+      messages: [{ role: "user", content: request.prompt }],
+      stream: request.stream,
+      options: request.options
+    };
+    return this.chat(chatRequest).pipe(
+      map5((response) => ({
+        response: response.message.content,
+        done: response.done
+      }))
+    );
+  }
+  listModels() {
+    const commonModels = [
+      {
+        name: "claude-3-5-sonnet-20241022",
+        details: {
+          format: "anthropic",
+          family: "claude-3.5"
+        }
+      },
+      {
+        name: "claude-3-5-haiku-20241022",
+        details: {
+          format: "anthropic",
+          family: "claude-3.5"
+        }
+      },
+      {
+        name: "claude-3-opus-20240229",
+        details: {
+          format: "anthropic",
+          family: "claude-3"
+        }
+      },
+      {
+        name: "claude-3-sonnet-20240229",
+        details: {
+          format: "anthropic",
+          family: "claude-3"
+        }
+      },
+      {
+        name: "claude-3-haiku-20240307",
+        details: {
+          format: "anthropic",
+          family: "claude-3"
+        }
+      }
+    ];
+    return new Observable5((observer) => {
+      observer.next(commonModels);
+      observer.complete();
+    });
+  }
+  async validateServiceAvailability(args) {
+    try {
+      const controller = new AbortController();
+      const timeoutId = setTimeout(() => controller.abort(), args.timeoutMs);
+      const response = await fetch(`${this.baseUrl}/messages`, {
+        method: "POST",
+        headers: this.getHeaders(),
+        body: JSON.stringify({
+          model: "claude-3-haiku-20240307",
+          messages: [{ role: "user", content: "test" }],
+          max_tokens: 1
+        }),
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      return {
+        url: this.baseUrl,
+        isAvailable: response.ok || response.status === 400
+        // 400 might be expected for the test
+      };
+    } catch (error) {
+      if (args.fallbackUrl) {
+        try {
+          const controller = new AbortController();
+          const timeoutId = setTimeout(() => controller.abort(), args.timeoutMs);
+          const response = await fetch(`${args.fallbackUrl}/messages`, {
+            method: "POST",
+            headers: this.getHeaders(),
+            body: JSON.stringify({
+              model: "claude-3-haiku-20240307",
+              messages: [{ role: "user", content: "test" }],
+              max_tokens: 1
+            }),
+            signal: controller.signal
+          });
+          clearTimeout(timeoutId);
+          if (response.ok || response.status === 400) {
+            this.baseUrl = args.fallbackUrl;
+            return {
+              url: args.fallbackUrl,
+              isAvailable: true
+            };
+          }
+        } catch (fallbackError) {
+        }
+      }
+      return {
+        url: this.baseUrl,
+        isAvailable: false
+      };
+    }
+  }
+  getProviderType() {
+    return "anthropic" /* ANTHROPIC */;
+  }
+  getConfig() {
+    return this.config;
+  }
+  streamChatRequest(url, payload) {
+    return new Observable5((observer) => {
+      const task = fetch(url, {
+        method: "POST",
+        headers: {
+          ...this.getHeaders(),
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify(payload)
+      });
+      task.then((response) => {
+        if (!response.ok) {
+          observer.error(new Error(`Anthropic request failed: ${response.status}`));
+          return;
+        }
+        const reader = response.body?.getReader();
+        const decoder = new TextDecoder();
+        let buffer = "";
+        const read = () => {
+          reader?.read().then(({ done, value }) => {
+            if (done) {
+              observer.next({
+                message: { content: "", role: "assistant" },
+                done: true
+              });
+              observer.complete();
+              return;
+            }
+            buffer += decoder.decode(value, { stream: true });
+            const lines = buffer.split("\n");
+            buffer = lines.pop() ?? "";
+            for (const line of lines) {
+              if (line.trim() && line.startsWith("data: ")) {
+                const data = line.slice(6).trim();
+                if (data === "[DONE]") {
+                  observer.next({
+                    message: { content: "", role: "assistant" },
+                    done: true
+                  });
+                  observer.complete();
+                  return;
+                }
+                try {
+                  const parsed = JSON.parse(data);
+                  const content = parsed.delta?.text || "";
+                  if (content) {
+                    observer.next({
+                      message: { content, role: "assistant" },
+                      done: false
+                    });
+                  }
+                } catch (err) {
+                  debugLogger.error("Error parsing Anthropic stream data:", { data, error: err });
+                }
+              }
+            }
+            read();
+          }).catch((err) => observer.error(err));
+        };
+        read();
+      }).catch((err) => observer.error(err));
+    });
+  }
+  nonStreamChatRequest(url, payload) {
+    return from4(fetch(url, {
+      method: "POST",
+      headers: {
+        ...this.getHeaders(),
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(payload)
+    })).pipe(
+      switchMap4((response) => {
+        if (!response.ok) {
+          return throwError4(() => new Error(`Anthropic request failed: ${response.status}`));
+        }
+        return from4(response.json());
+      }),
+      map5((data) => ({
+        message: {
+          content: this.extractContentText(data),
+          role: "assistant"
+        },
+        done: true
+      }))
+    );
+  }
+  extractContentText(payload) {
+    const { content } = payload;
+    if (Array.isArray(content)) {
+      for (const entry of content) {
+        if (typeof entry === "string") {
+          return entry;
+        }
+        if (entry && typeof entry === "object" && "text" in entry) {
+          const text = entry.text;
+          if (typeof text === "string") {
+            return text;
+          }
+        }
+      }
+    } else if (typeof content === "string") {
+      return content;
+    }
+    if (typeof payload.completion === "string") {
+      return payload.completion;
+    }
+    if (payload.message && typeof payload.message.content === "string") {
+      return payload.message.content;
+    }
+    return "";
+  }
+  getHeaders() {
+    const headers = {
+      "anthropic-version": "2023-06-01"
+    };
+    if (this.config.apiKey) {
+      headers["x-api-key"] = this.config.apiKey;
+    }
+    return headers;
+  }
+};
+
+// src/services/ai-provider/providers/gateway.provider.ts
+import { map as map11 } from "rxjs";
+
+// src/services/gateway/gateway.service.ts
+import axios, { AxiosHeaders } from "axios";
+import { catchError as catchError2, from as from5, lastValueFrom as lastValueFrom2, map as map6, Observable as Observable6, of as of2, shareReplay as shareReplay2, timeout as timeout2 } from "rxjs";
+var GatewayService = class {
+  constructor(_baseUrl, _tokenFactory, _feedbackEmail) {
+    this._baseUrl = _baseUrl;
+    this._tokenFactory = _tokenFactory;
+    this._feedbackEmail = _feedbackEmail;
+    if (!this._baseUrl) {
+      this._baseUrl = "http://localhost:5000";
+      debugLogger.warn(`No gateway URL provided, using default: ${this._baseUrl}`);
+    }
+    this._baseUrl = this._baseUrl.replace(/\/$/, "");
+    if (this._baseUrl.endsWith("/api")) {
+      this._baseUrl = this._baseUrl.slice(0, -4);
+      debugLogger.info(`Removed /api suffix from gateway URL: ${this._baseUrl}`);
+    }
+    this._client = this._createAxiosClient();
+  }
+  _client;
+  _createAxiosClient() {
+    const instance = axios.create({
+      baseURL: this._baseUrl,
+      headers: {
+        "Content-Type": "application/json"
+      }
+    });
+    instance.interceptors.request.use((config) => {
+      const token = this._tokenFactory();
+      const headers = AxiosHeaders.from(config.headers ?? {});
+      if (!headers.has("Content-Type")) {
+        headers.set("Content-Type", "application/json");
+      }
+      if (token && token.trim()) {
+        headers.set("Authorization", `Bearer ${token}`);
+      } else if (headers.has("Authorization")) {
+        headers.delete("Authorization");
+      }
+      config.headers = headers;
+      return config;
+    });
+    instance.interceptors.response.use(
+      (response) => response,
+      (error) => Promise.reject(this._normalizeAxiosError(error))
+    );
+    return instance;
+  }
+  _normalizeAxiosError(error) {
+    if (error.response) {
+      return this._createHttpError(
+        `Request failed: ${error.response.status} ${error.response.statusText ?? ""}`,
+        {
+          status: error.response.status,
+          statusText: error.response.statusText ?? "",
+          data: error.response.data,
+          url: error.config?.url ?? ""
+        }
+      );
+    }
+    if (error.request) {
+      return new Error(`No response received from gateway: ${error.message}`);
+    }
+    return new Error(error.message);
+  }
+  _createHttpError(message, response) {
+    return Object.assign(new Error(message), { response });
+  }
+  _setBaseUrl(url) {
+    this._baseUrl = url;
+    this._client.defaults.baseURL = url;
+  }
+  _tryGatewayWithTimeout(args) {
+    const { url, responseType, timeoutMs } = args;
+    const source = this._get(url, responseType);
+    const mapped = source.pipe(
+      catchError2((e) => e?.message.includes("401") ? of2(true) : of2(false)),
+      map6(() => true),
+      timeout2(timeoutMs)
+    );
+    return mapped;
+  }
+  /**
+   * Validates the availability of the gateway service.
+   * @param fallbackUrl The fallback URL to try if the base URL is not available.
+   * @returns An object containing the URL and availability status.
+   */
+  async validateServiceAvailability(args) {
+    const { fallbackUrl, timeoutMs } = args;
+    const responseType = "json";
+    const availability = {
+      url: "",
+      isAvailable: false
+    };
+    try {
+      debugLogger.debug(`Validating gateway service availability at ${this._baseUrl}`);
+      availability.url = this._baseUrl;
+      availability.isAvailable = await lastValueFrom2(
+        this._tryGatewayWithTimeout({
+          url: `${availability.url}/api/health`,
+          responseType,
+          timeoutMs
+        })
+      );
+      if (!availability.isAvailable) {
+        throw new Error(`Gateway service not available at ${this._baseUrl}`);
+      }
+      return availability;
+    } catch (e) {
+      if (fallbackUrl) {
+        debugLogger.warn(`Gateway service not available at ${this._baseUrl}, trying fallback URL: ${fallbackUrl}`);
+        try {
+          availability.url = fallbackUrl.replace(/\/$/, "");
+          availability.isAvailable = await lastValueFrom2(
+            this._tryGatewayWithTimeout({
+              url: `${availability.url}/api/health`,
+              responseType,
+              timeoutMs
+            })
+          );
+          if (!availability.isAvailable) {
+            throw new Error(`Gateway service not available at ${fallbackUrl}`);
+          }
+          this._setBaseUrl(availability.url);
+          return availability;
+        } catch (e2) {
+          debugLogger.error(`Gateway service not available at fallback URL: ${fallbackUrl}`);
+          throw e2;
+        }
+      } else {
+        debugLogger.error(`Gateway service not available and no fallback URL provided`);
+        throw e;
+      }
+    }
+  }
+  /**
+   * Get gateway health status and available providers
+   */
+  getHealth() {
+    const url = `${this._baseUrl}/api/health`;
+    return this._get(url);
+  }
+  /**
+   * Chat completion using the gateway API
+   */
+  chat(request) {
+    const endpoint = request.provider === "ollama" ? `/api/${request.provider}/chat` : request.provider ? `/api/${request.provider}/chat/completions` : "/api/chat/completions";
+    const url = `${this._baseUrl}${endpoint}`;
+    debugLogger.debug(`Gateway chat request to ${url} with provider: ${request.provider || "default"}`, {
+      model: request.model,
+      messageCount: request.messages.length,
+      hasImages: !!(request.images && request.images.length > 0),
+      imageCount: request.images?.length || 0
+    });
+    const requestBody = { ...request, stream: request.stream !== false };
+    return new Observable6((observer) => {
+      const controller = new AbortController();
+      const task = fetch(url, {
+        method: "POST",
+        headers: this._getHeaders(),
+        body: JSON.stringify(requestBody),
+        signal: controller.signal
+      });
+      task.then(async (response) => {
+        debugLogger.debug(`Gateway chat response status: ${response.status} for provider: ${request.provider || "default"}`);
+        if (!response.ok) {
+          let errorText = "";
+          let errorData = null;
+          try {
+            errorText = await response.text();
+            debugLogger.error("GatewayService chat error response body", {
+              status: response.status,
+              statusText: response.statusText,
+              url: response.url,
+              body: errorText
+            });
+          } catch (readError) {
+            debugLogger.error("GatewayService chat failed to read error response body", { error: readError });
+            errorText = `Request failed with status ${response.status}`;
+          }
+          try {
+            errorData = JSON.parse(errorText);
+            debugLogger.error("GatewayService chat parsed error payload", errorData);
+          } catch (parseError) {
+            debugLogger.error("GatewayService chat error payload was not valid JSON");
+            errorData = { message: errorText };
+          }
+          const error = this._createHttpError(
+            `POST ${url} failed: ${response.status} ${response.statusText ?? ""}`,
+            {
+              status: response.status,
+              statusText: response.statusText ?? "",
+              data: errorData,
+              url
+            }
+          );
+          throw error;
+        }
+        const reader = response.body?.getReader();
+        const decoder = new TextDecoder();
+        let buffer = "";
+        const read = () => {
+          reader?.read().then(({ done, value }) => {
+            if (done) {
+              if (buffer.trim() !== "") {
+                try {
+                  const finalResponse = JSON.parse(buffer);
+                  observer.next(finalResponse);
+                } catch (err) {
+                  debugLogger.error("GatewayService chat final chunk parsing error", { buffer, error: err });
+                  observer.error(err);
+                }
+              }
+              observer.complete();
+              return;
+            }
+            buffer += decoder.decode(value, { stream: true });
+            const lines = buffer.split("\n");
+            buffer = lines.pop() ?? "";
+            for (const line of lines) {
+              const trimmed = line.trim();
+              if (trimmed) {
+                let data = trimmed;
+                if (trimmed.startsWith("data: ")) {
+                  data = trimmed.slice(6);
+                  if (data === "[DONE]") {
+                    observer.complete();
+                    return;
+                  }
+                }
+                try {
+                  const parsed = JSON.parse(data);
+                  if (request.provider === "ollama" && parsed.message) {
+                    const transformed = {
+                      id: `chatcmpl-${Date.now()}`,
+                      object: "chat.completion.chunk",
+                      created: Math.floor(new Date(parsed.created_at || Date.now()).getTime() / 1e3),
+                      model: parsed.model,
+                      choices: [{
+                        index: 0,
+                        delta: {
+                          role: parsed.message.role,
+                          content: parsed.message.content
+                        },
+                        finish_reason: parsed.done ? parsed.done_reason || "stop" : null
+                      }]
+                    };
+                    if (parsed.done && parsed.total_duration) {
+                      transformed.usage = {
+                        prompt_tokens: parsed.prompt_eval_count || 0,
+                        completion_tokens: parsed.eval_count || 0,
+                        total_tokens: (parsed.prompt_eval_count || 0) + (parsed.eval_count || 0)
+                      };
+                    }
+                    observer.next(transformed);
+                  } else {
+                    observer.next(parsed);
+                  }
+                } catch (err) {
+                  debugLogger.error("GatewayService chat stream chunk parsing error", {
+                    line: trimmed,
+                    rawData: data,
+                    error: err
+                  });
+                  observer.error(err);
+                }
+              }
+            }
+            read();
+          }).catch((err) => observer.error(err));
+        };
+        read();
+      }).catch((err) => {
+        debugLogger.error("GatewayService chat fetch error", {
+          error: err,
+          url,
+          provider: request.provider
+        });
+        observer.error(err);
+      });
+      return () => {
+        try {
+          controller.abort();
+        } catch {
+        }
+      };
+    });
+  }
+  /**
+   * Text generation using the gateway API
+   */
+  generate(request) {
+    const endpoint = request.provider ? `/api/${request.provider}/generate` : "/api/generate";
+    const url = `${this._baseUrl}${endpoint}`;
+    debugLogger.debug(`Gateway generate request to ${url} with provider: ${request.provider || "default"}`);
+    return new Observable6((observer) => {
+      const task = fetch(url, {
+        method: "POST",
+        headers: this._getHeaders(),
+        body: JSON.stringify({ ...request, stream: request.stream !== false })
+      });
+      task.then(async (response) => {
+        if (!response.ok) {
+          let errorText = "";
+          let errorData = null;
+          try {
+            errorText = await response.text();
+          } catch (readError) {
+            errorText = `Request failed with status ${response.status}`;
+          }
+          try {
+            errorData = JSON.parse(errorText);
+          } catch (parseError) {
+            errorData = { message: errorText };
+          }
+          const error = this._createHttpError(
+            `POST ${url} failed: ${response.status} ${response.statusText ?? ""}`,
+            {
+              status: response.status,
+              statusText: response.statusText ?? "",
+              data: errorData,
+              url
+            }
+          );
+          throw error;
+        }
+        const reader = response.body?.getReader();
+        const decoder = new TextDecoder();
+        let buffer = "";
+        const read = () => {
+          reader?.read().then(({ done, value }) => {
+            if (done) {
+              if (buffer.trim() !== "") {
+                try {
+                  observer.next(JSON.parse(buffer));
+                } catch (err) {
+                  observer.error(err);
+                  debugLogger.error("Final chunk parsing error (gateway generate):", { buffer });
+                }
+              }
+              observer.complete();
+              return;
+            }
+            buffer += decoder.decode(value, { stream: true });
+            const lines = buffer.split("\n");
+            buffer = lines.pop() ?? "";
+            for (const line of lines) {
+              if (line.trim()) {
+                try {
+                  observer.next(JSON.parse(line));
+                } catch (err) {
+                  observer.error(err);
+                  debugLogger.error("Error parsing JSON line (gateway generate):", { line });
+                }
+              }
+            }
+            read();
+          }).catch((err) => observer.error(err));
+        };
+        read();
+      }).catch((err) => observer.error(err));
+    });
+  }
+  /**
+   * List all available models from all providers
+   */
+  listModels() {
+    const url = `${this._baseUrl}/api/models`;
+    const response = this._get(url);
+    const result = response.pipe(
+      map6((data) => data.models),
+      shareReplay2(1)
+    );
+    return result;
+  }
+  /**
+   * List models for a specific provider
+   */
+  listModelsByProvider(provider) {
+    const url = `${this._baseUrl}/api/models/${provider}`;
+    const response = this._get(url);
+    const result = response.pipe(
+      map6((data) => data.models),
+      shareReplay2(1)
+    );
+    return result;
+  }
+  getMemory() {
+    const url = `${this._baseUrl}/api/memory`;
+    return this._get(url);
+  }
+  _get(url, responseType = "json") {
+    const request = this._client.get(url, { responseType });
+    return from5(request).pipe(
+      map6((response) => response.data),
+      shareReplay2(1)
+    );
+  }
+  _post(url, body) {
+    const request = this._client.post(url, body);
+    return from5(request).pipe(
+      map6((response) => response.data),
+      shareReplay2(1)
+    );
+  }
+  _getHeaders() {
+    const token = this._tokenFactory();
+    const headers = {
+      "Content-Type": "application/json"
+    };
+    if (token && token.trim() !== "") {
+      headers["Authorization"] = `Bearer ${token}`;
+      debugLogger.debug("Authorization header set with token");
+    } else {
+      debugLogger.warn("GatewayService: No token found, skipping Authorization header");
+    }
+    return headers;
+  }
+  /**
+   * Submit feedback to the gateway API
+   */
+  submitFeedback(feedback) {
+    const url = `${this._baseUrl}/api/feedback`;
+    debugLogger.debug("Gateway feedback submission", {
+      category: feedback.category,
+      priority: feedback.priority,
+      hasImages: !!(feedback.images && feedback.images.length > 0),
+      hasAttachments: !!(feedback.attachments && feedback.attachments.length > 0)
+    });
+    return from5(
+      this._client.post(url, feedback).then((response) => response.data)
+    ).pipe(
+      catchError2((error) => {
+        debugLogger.error("Feedback submission failed, using email fallback", error);
+        const fallbackResponse = {
+          id: `fallback-${Date.now()}`,
+          status: "submitted",
+          message: "Feedback submission failed. Opening email client as fallback.",
+          mailtoUrl: this._generateMailtoUrl(feedback)
+        };
+        return of2(fallbackResponse);
+      })
+    );
+  }
+  /**
+   * Generate a mailto URL as fallback for feedback submission
+   */
+  _generateMailtoUrl(feedback) {
+    const subject = encodeURIComponent(`[${feedback.category.toUpperCase()}] ${feedback.title}`);
+    let body = `Category: ${feedback.category}
+`;
+    body += `Priority: ${feedback.priority}
+`;
+    if (feedback.annoyanceLevel) {
+      const annoyanceLabels = {
+        1: "\u{1F60A} Not annoying at all",
+        2: "\u{1F610} Slightly annoying",
+        3: "\u{1F644} Moderately annoying",
+        4: "\u{1F620} Very annoying",
+        5: "\u{1F92C} Extremely annoying"
+      };
+      body += `Annoyance Level: ${feedback.annoyanceLevel}/5 - ${annoyanceLabels[feedback.annoyanceLevel]}
+`;
+    }
+    body += `
+Description:
+${feedback.description}
+
+`;
+    if (feedback.sessionInfo) {
+      body += `Session Info:
+`;
+      body += `- Model: ${feedback.sessionInfo.currentModel}
+`;
+      body += `- Provider: ${feedback.sessionInfo.currentProvider}
+`;
+      body += `- Conversation: ${feedback.sessionInfo.conversationId}
+`;
+      body += `- Timestamp: ${feedback.sessionInfo.timestamp}
+
+`;
+    }
+    if (feedback.browserInfo) {
+      body += `Browser Info:
+`;
+      body += `- Name: ${feedback.browserInfo.name}
+`;
+      body += `- Version: ${feedback.browserInfo.version}
+`;
+      body += `- Platform: ${feedback.browserInfo.platform}
+
+`;
+    }
+    if (feedback.userAgent) {
+      body += `User Agent: ${feedback.userAgent}
+
+`;
+    }
+    if (feedback.contactEmail) {
+      body += `Contact Email: ${feedback.contactEmail}
+
+`;
+    }
+    if (feedback.images && feedback.images.length > 0) {
+      body += `\u{1F4CE} IMAGE ATTACHMENT:
+`;
+      body += `Please paste your clipboard contents here (Ctrl+V or Cmd+V)
+
+`;
+    }
+    if (feedback.attachments && feedback.attachments.length > 0) {
+      body += `\u{1F4CE} IMPORTANT - FILES TO ATTACH:
+`;
+      body += `Please attach the following ${feedback.attachments.length} file(s) to this email:
+`;
+      feedback.attachments.forEach((attachment, index) => {
+        body += `   \u2022 File ${index + 1}: ${attachment.name || `[Attachment ${index + 1}]`}
+`;
+      });
+      body += `
+(Note: Files cannot be automatically included in email links)
+
+`;
+    }
+    body += `---
+Generated by Bandit AI Feedback System`;
+    const encodedBody = encodeURIComponent(body);
+    const toEmail = this._feedbackEmail || "feedback@burtson.ai";
+    return `mailto:${toEmail}?subject=${subject}&body=${encodedBody}`;
+  }
+};
+
+// src/services/gateway/openai-gateway.service.ts
+import { map as map7 } from "rxjs/operators";
+var OpenAIGatewayService = class {
+  _gatewayService;
+  constructor(gatewayUrl, tokenFactory) {
+    this._gatewayService = new GatewayService(gatewayUrl, tokenFactory);
+    debugLogger.info("OpenAIGatewayService initialized", { gatewayUrl });
+  }
+  /**
+   * Validates the availability of the gateway service for OpenAI
+   */
+  async validateServiceAvailability(args) {
+    return this._gatewayService.validateServiceAvailability(args);
+  }
+  /**
+   * Chat completion using OpenAI through the gateway
+   */
+  chat(request) {
+    const gatewayRequest = {
+      ...request,
+      provider: "openai"
+    };
+    debugLogger.debug("OpenAI Gateway chat request", {
+      model: request.model,
+      messageCount: request.messages.length,
+      stream: request.stream
+    });
+    return this._gatewayService.chat(gatewayRequest);
+  }
+  /**
+   * Text completion using OpenAI through the gateway
+   */
+  complete(prompt, options) {
+    const gatewayRequest = {
+      model: options.model,
+      prompt,
+      temperature: options.temperature,
+      max_tokens: options.max_tokens,
+      stream: options.stream,
+      stop: options.stop,
+      provider: "openai"
+    };
+    debugLogger.debug("OpenAI Gateway completion request", {
+      model: options.model,
+      promptLength: prompt.length,
+      stream: options.stream
+    });
+    return this._gatewayService.generate(gatewayRequest);
+  }
+  /**
+   * List available OpenAI models through the gateway
+   */
+  listModels() {
+    debugLogger.debug("Fetching OpenAI models through gateway");
+    return this._gatewayService.listModelsByProvider("openai");
+  }
+  /**
+   * Get gateway health with OpenAI provider status
+   */
+  getHealth() {
+    return this._gatewayService.getHealth().pipe(
+      map7((health) => ({
+        ...health,
+        openai_status: health.providers.find((p) => p.name === "openai")?.status || "unavailable"
+      }))
+    );
+  }
+};
+
+// src/services/gateway/azure-openai-gateway.service.ts
+import { map as map8 } from "rxjs/operators";
+var AzureOpenAIGatewayService = class {
+  _gatewayService;
+  _azureConfig;
+  constructor(gatewayUrl, tokenFactory, azureConfig) {
+    this._gatewayService = new GatewayService(gatewayUrl, tokenFactory);
+    this._azureConfig = azureConfig;
+    debugLogger.info("AzureOpenAIGatewayService initialized", {
+      gatewayUrl,
+      deploymentName: azureConfig.deploymentName,
+      apiVersion: azureConfig.apiVersion
+    });
+  }
+  /**
+   * Validates the availability of the gateway service for Azure OpenAI
+   */
+  async validateServiceAvailability(args) {
+    return this._gatewayService.validateServiceAvailability(args);
+  }
+  /**
+   * Chat completion using Azure OpenAI through the gateway
+   */
+  chat(request) {
+    const gatewayRequest = {
+      ...request,
+      model: this._azureConfig.deploymentName,
+      // Use deployment name as model
+      provider: "azure-openai"
+    };
+    debugLogger.debug("Azure OpenAI Gateway chat request", {
+      deploymentName: this._azureConfig.deploymentName,
+      apiVersion: this._azureConfig.apiVersion,
+      messageCount: request.messages.length,
+      stream: request.stream
+    });
+    return this._gatewayService.chat(gatewayRequest);
+  }
+  /**
+   * Text completion using Azure OpenAI through the gateway
+   */
+  complete(prompt, options) {
+    const gatewayRequest = {
+      model: options.model || this._azureConfig.deploymentName,
+      prompt,
+      temperature: options.temperature,
+      max_tokens: options.max_tokens,
+      stream: options.stream,
+      stop: options.stop,
+      provider: "azure-openai"
+    };
+    debugLogger.debug("Azure OpenAI Gateway completion request", {
+      deploymentName: options.model || this._azureConfig.deploymentName,
+      promptLength: prompt.length,
+      stream: options.stream
+    });
+    return this._gatewayService.generate(gatewayRequest);
+  }
+  /**
+   * List available Azure OpenAI models through the gateway
+   */
+  listModels() {
+    debugLogger.debug("Fetching Azure OpenAI models through gateway");
+    return this._gatewayService.listModelsByProvider("azure-openai");
+  }
+  /**
+   * Get gateway health with Azure OpenAI provider status
+   */
+  getHealth() {
+    return this._gatewayService.getHealth().pipe(
+      map8((health) => ({
+        ...health,
+        azure_openai_status: health.providers.find((p) => p.name === "azure-openai")?.status || "unavailable",
+        azure_config: {
+          deploymentName: this._azureConfig.deploymentName,
+          apiVersion: this._azureConfig.apiVersion
+        }
+      }))
+    );
+  }
+  /**
+   * Update Azure configuration
+   */
+  updateAzureConfig(newConfig) {
+    this._azureConfig = { ...this._azureConfig, ...newConfig };
+    debugLogger.info("Azure OpenAI configuration updated", this._azureConfig);
+  }
+  /**
+   * Get current Azure configuration
+   */
+  getAzureConfig() {
+    return { ...this._azureConfig };
+  }
+};
+
+// src/services/gateway/anthropic-gateway.service.ts
+import { map as map9 } from "rxjs/operators";
+var AnthropicGatewayService = class {
+  _gatewayService;
+  constructor(gatewayUrl, tokenFactory) {
+    this._gatewayService = new GatewayService(gatewayUrl, tokenFactory);
+    debugLogger.info("AnthropicGatewayService initialized", { gatewayUrl });
+  }
+  /**
+   * Validates the availability of the gateway service for Anthropic
+   */
+  async validateServiceAvailability(args) {
+    return this._gatewayService.validateServiceAvailability(args);
+  }
+  /**
+   * Chat completion using Anthropic through the gateway
+   */
+  chat(request) {
+    const gatewayRequest = {
+      model: request.model,
+      messages: request.messages,
+      stream: request.stream,
+      temperature: request.temperature,
+      max_tokens: request.max_tokens,
+      top_p: request.top_p,
+      stop: request.stop_sequences,
+      provider: "anthropic"
+    };
+    debugLogger.debug("Anthropic Gateway chat request", {
+      model: request.model,
+      messageCount: request.messages.length,
+      stream: request.stream,
+      hasSystem: !!request.system
+    });
+    return this._gatewayService.chat(gatewayRequest);
+  }
+  /**
+   * Text completion using Anthropic through the gateway
+   */
+  complete(prompt, options) {
+    const gatewayRequest = {
+      model: options.model,
+      prompt,
+      temperature: options.temperature,
+      max_tokens: options.max_tokens,
+      stream: options.stream,
+      stop: options.stop_sequences,
+      provider: "anthropic"
+    };
+    debugLogger.debug("Anthropic Gateway completion request", {
+      model: options.model,
+      promptLength: prompt.length,
+      stream: options.stream,
+      hasSystem: !!options.system
+    });
+    return this._gatewayService.generate(gatewayRequest);
+  }
+  /**
+   * List available Anthropic models through the gateway
+   */
+  listModels() {
+    debugLogger.debug("Fetching Anthropic models through gateway");
+    return this._gatewayService.listModelsByProvider("anthropic");
+  }
+  /**
+   * Get gateway health with Anthropic provider status
+   */
+  getHealth() {
+    return this._gatewayService.getHealth().pipe(
+      map9((health) => ({
+        ...health,
+        anthropic_status: health.providers.find((p) => p.name === "anthropic")?.status || "unavailable"
+      }))
+    );
+  }
+  /**
+   * Helper method to convert system message to Anthropic format
+   * Anthropic treats system messages differently - they can be separate from messages
+   */
+  extractSystemMessage(messages) {
+    const systemMessage = messages.find((msg) => msg.role === "system");
+    const userMessages = messages.filter((msg) => msg.role !== "system");
+    return {
+      messages: userMessages,
+      system: systemMessage?.content
+    };
+  }
+  /**
+   * Enhanced chat method that handles Anthropic's system message format
+   */
+  chatWithSystem(request) {
+    const { messages, system } = this.extractSystemMessage(request.messages);
+    const enhancedRequest = {
+      ...request,
+      messages,
+      system: system || request.system
+    };
+    return this.chat(enhancedRequest);
+  }
+};
+
+// src/services/gateway/ollama-gateway.service.ts
+import { map as map10 } from "rxjs/operators";
+var OllamaGatewayService = class {
+  _gatewayService;
+  constructor(gatewayUrl, tokenFactory) {
+    this._gatewayService = new GatewayService(gatewayUrl, tokenFactory);
+    debugLogger.info("OllamaGatewayService initialized", { gatewayUrl });
+  }
+  /**
+   * Validates the availability of the gateway service for Ollama
+   */
+  async validateServiceAvailability(args) {
+    return this._gatewayService.validateServiceAvailability(args);
+  }
+  /**
+   * Chat completion using Ollama through the gateway
+   */
+  chat(request) {
+    const gatewayRequest = {
+      ...request,
+      provider: "ollama"
+    };
+    debugLogger.debug("Ollama Gateway chat request", {
+      model: request.model,
+      messageCount: request.messages.length,
+      stream: request.stream,
+      hasImages: !!(request.images && request.images.length > 0)
+    });
+    return this._gatewayService.chat(gatewayRequest);
+  }
+  /**
+   * Text generation using Ollama through the gateway
+   */
+  generate(request) {
+    const gatewayRequest = {
+      ...request,
+      provider: "ollama"
+    };
+    debugLogger.debug("Ollama Gateway generate request", {
+      model: request.model,
+      promptLength: request.prompt.length,
+      stream: request.stream,
+      hasImages: !!(request.images && request.images.length > 0)
+    });
+    return this._gatewayService.generate(gatewayRequest);
+  }
+  /**
+   * List available Ollama models through the gateway
+   */
+  listModels() {
+    debugLogger.debug("Fetching Ollama models through gateway");
+    return this._gatewayService.listModelsByProvider("ollama");
+  }
+  /**
+   * Get gateway health with Ollama provider status
+   */
+  getHealth() {
+    return this._gatewayService.getHealth().pipe(
+      map10((health) => ({
+        ...health,
+        ollama_status: health.providers.find((p) => p.name === "ollama")?.status || "unavailable"
+      }))
+    );
+  }
+};
+
+// src/services/ai-provider/providers/gateway.provider.ts
+var GatewayProvider = class {
+  config;
+  gatewayService;
+  providerSpecificService = null;
+  constructor(config) {
+    this.config = config;
+    if (!config.gatewayUrl) {
+      throw new Error("Gateway provider requires gatewayUrl in config");
+    }
+    if (!config.provider) {
+      throw new Error("Gateway provider requires provider field to specify backend (openai, azure-openai, anthropic, ollama)");
+    }
+    const tokenFactory = config.tokenFactory || (() => null);
+    this.gatewayService = new GatewayService(config.gatewayUrl, tokenFactory);
+    this.createProviderSpecificService(config.gatewayUrl, tokenFactory);
+    debugLogger.info("GatewayProvider initialized", {
+      gatewayUrl: config.gatewayUrl,
+      backendProvider: config.provider
+    });
+  }
+  createProviderSpecificService(gatewayUrl, tokenFactory) {
+    switch (this.config.provider) {
+      case "openai":
+        this.providerSpecificService = new OpenAIGatewayService(gatewayUrl, tokenFactory);
+        break;
+      case "azure-openai":
+        if (!this.config.deploymentName || !this.config.apiVersion) {
+          throw new Error("Azure OpenAI gateway provider requires deploymentName and apiVersion");
+        }
+        this.providerSpecificService = new AzureOpenAIGatewayService(
+          gatewayUrl,
+          tokenFactory,
+          {
+            deploymentName: this.config.deploymentName,
+            apiVersion: this.config.apiVersion
+          }
+        );
+        break;
+      case "anthropic":
+        this.providerSpecificService = new AnthropicGatewayService(gatewayUrl, tokenFactory);
+        break;
+      case "ollama":
+        this.providerSpecificService = new OllamaGatewayService(gatewayUrl, tokenFactory);
+        break;
+      default:
+        debugLogger.warn("Unknown provider for gateway, using generic gateway service", {
+          provider: this.config.provider
+        });
+    }
+  }
+  chat(request) {
+    const messages = request.messages.map((msg) => ({
+      role: msg.role,
+      content: msg.content
+    }));
+    if (request.images && request.images.length > 0) {
+      const lastUserMessageIndex = messages.map((m) => m.role).lastIndexOf("user");
+      if (this.config.provider === "ollama") {
+        if (lastUserMessageIndex !== -1) {
+          messages[lastUserMessageIndex] = {
+            ...messages[lastUserMessageIndex],
+            images: request.images
+          };
+        }
+      } else if (["openai", "azure-openai", "anthropic"].includes(this.config.provider || "")) {
+        if (lastUserMessageIndex !== -1) {
+          const currentMessage = messages[lastUserMessageIndex];
+          const contentArray = [
+            {
+              type: "text",
+              text: currentMessage.content
+            }
+          ];
+          request.images.forEach((base64Image) => {
+            contentArray.push({
+              type: "image_url",
+              image_url: {
+                url: base64Image.startsWith("data:") ? base64Image : `data:image/jpeg;base64,${base64Image}`,
+                detail: "auto"
+              }
+            });
+          });
+          messages[lastUserMessageIndex] = {
+            ...messages[lastUserMessageIndex],
+            content: contentArray
+          };
+        }
+      }
+    }
+    const gatewayRequest = {
+      model: request.model,
+      messages,
+      stream: request.stream,
+      temperature: request.temperature,
+      max_tokens: request.maxTokens,
+      provider: this.config.provider,
+      // Only include top-level images for Ollama (fallback)
+      images: this.config.provider === "ollama" ? request.images : void 0
+    };
+    debugLogger.debug("Gateway provider chat request", {
+      model: request.model,
+      provider: this.config.provider,
+      messageCount: request.messages.length,
+      stream: request.stream,
+      hasImages: !!(request.images && request.images.length > 0),
+      imageCount: request.images?.length || 0,
+      imageStrategy: this.config.provider === "ollama" ? "message-level-array" : ["openai", "azure-openai", "anthropic"].includes(this.config.provider || "") ? "structured-content" : "top-level-fallback",
+      finalMessages: messages.map((m) => ({
+        role: m.role,
+        hasImages: Array.isArray(m.images) && m.images.length > 0,
+        contentType: Array.isArray(m.content) ? "structured" : "text"
+      }))
+    });
+    return this.gatewayService.chat(gatewayRequest).pipe(
+      map11((response) => ({
+        message: {
+          content: response.choices?.[0]?.message?.content || response.choices?.[0]?.delta?.content || "",
+          role: "assistant"
+        },
+        done: response.choices?.[0]?.finish_reason === "stop" || response.choices?.[0]?.finish_reason === "length"
+      }))
+    );
+  }
+  generate(request) {
+    const gatewayRequest = {
+      model: request.model,
+      prompt: request.prompt,
+      stream: request.stream,
+      provider: this.config.provider
+    };
+    debugLogger.debug("Gateway provider generate request", {
+      model: request.model,
+      provider: this.config.provider,
+      promptLength: request.prompt.length,
+      stream: request.stream
+    });
+    return this.gatewayService.generate(gatewayRequest).pipe(
+      map11((response) => ({
+        response: response.response || "",
+        done: response.done || false
+      }))
+    );
+  }
+  listModels() {
+    debugLogger.debug("Gateway provider listing models", { provider: this.config.provider });
+    if (this.config.provider) {
+      return this.gatewayService.listModelsByProvider(this.config.provider).pipe(
+        map11((models) => models.map((model) => ({
+          name: model.id || model.name,
+          size: model.size,
+          details: model.details,
+          digest: model.digest,
+          modified_at: model.modified_at
+        })))
+      );
+    } else {
+      return this.gatewayService.listModels().pipe(
+        map11((models) => models.map((model) => ({
+          name: model.id || model.name,
+          size: model.size,
+          details: model.details,
+          digest: model.digest,
+          modified_at: model.modified_at
+        })))
+      );
+    }
+  }
+  async validateServiceAvailability(args) {
+    debugLogger.debug("Gateway provider validating service availability");
+    return this.gatewayService.validateServiceAvailability(args);
+  }
+  getProviderType() {
+    return "gateway" /* GATEWAY */;
+  }
+  getConfig() {
+    return this.config;
+  }
+  /**
+   * Get the backend provider type
+   */
+  getBackendProvider() {
+    return this.config.provider;
+  }
+  /**
+   * Get gateway health including backend provider status
+   */
+  getHealth() {
+    return this.gatewayService.getHealth().pipe(
+      map11((health) => ({
+        ...health,
+        backend_provider: this.config.provider,
+        backend_provider_status: health.providers.find((p) => p.name === this.config.provider)?.status || "unavailable"
+      }))
+    );
+  }
+  /**
+   * Use provider-specific service if available for enhanced functionality
+   */
+  getProviderSpecificService() {
+    return this.providerSpecificService;
+  }
+};
+
+// src/services/ai-provider/ai-provider.factory.ts
+var AIProviderFactory = class {
+  static createProvider(config) {
+    switch (config.type) {
+      case "ollama" /* OLLAMA */:
+        return new OllamaProvider(config);
+      case "openai" /* OPENAI */:
+        return new OpenAIProvider(config);
+      case "azure-openai" /* AZURE_OPENAI */:
+        return new AzureOpenAIProvider(config);
+      case "anthropic" /* ANTHROPIC */:
+        return new AnthropicProvider(config);
+      case "gateway" /* GATEWAY */:
+        return new GatewayProvider(config);
+      default:
+        throw new Error(`Unsupported AI provider type: ${config.type}`);
+    }
+  }
+  static getSupportedProviders() {
+    return [
+      "ollama" /* OLLAMA */,
+      "openai" /* OPENAI */,
+      "azure-openai" /* AZURE_OPENAI */,
+      "anthropic" /* ANTHROPIC */,
+      "gateway" /* GATEWAY */
+    ];
+  }
+  static validateConfig(config) {
+    switch (config.type) {
+      case "ollama" /* OLLAMA */:
+        return true;
+      // Ollama only needs baseUrl which has defaults
+      case "openai" /* OPENAI */:
+        return !!config.apiKey;
+      case "azure-openai" /* AZURE_OPENAI */:
+        return !!(config.baseUrl && config.apiKey && config.apiVersion && config.deploymentName);
+      case "anthropic" /* ANTHROPIC */:
+        return !!config.apiKey;
+      case "gateway" /* GATEWAY */:
+        return !!(config.gatewayUrl && config.provider);
+      default:
+        return false;
+    }
+  }
+};
+
+// src/store/aiProviderStore.ts
+var useAIProviderStore = create((set, get) => ({
+  provider: null,
+  config: null,
+  setProvider: (provider, config) => set({ provider, config }),
+  createProvider: (config) => {
+    try {
+      const provider = AIProviderFactory.createProvider(config);
+      set({ provider, config });
+    } catch (error) {
+      debugLogger.error("Failed to create AI provider:", { error });
+      throw error;
+    }
+  },
+  switchProvider: (config) => {
+    const currentProvider = get().provider;
+    try {
+      const newProvider = AIProviderFactory.createProvider(config);
+      set({ provider: newProvider, config });
+    } catch (error) {
+      debugLogger.error("Failed to switch AI provider:", { error });
+      throw error;
+    }
+  }
+}));
+
+export {
+  GatewayService,
+  AIProviderFactory,
+  useAIProviderStore
+};
+//# sourceMappingURL=chunk-AVC6IZJQ.mjs.map