phind-ai-provider/dist/webapi/index.bundle.js

phind ai provider compatible with vercel ai sdk

var __getOwnPropNames = Object.getOwnPropertyNames;
var __commonJS = (cb, mod) => function __require() {
  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
};

// dist/webapi/PhindAIService.js
var require_PhindAIService = __commonJS({
  "dist/webapi/PhindAIService.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.PhindAIService = void 0;
    var PhindAIService = class _PhindAIService {
      specificationVersion = "v1";
      defaultObjectGenerationMode = "json";
      supportsImageUrls = false;
      supportsStructuredOutputs = false;
      modelId;
      static API_URL = "https://https.extension.phind.com/agent/";
      headers = {
        "Content-Type": "application/json",
        Accept: "*/*",
        "Accept-Encoding": "Identity",
        "User-Agent": ""
      };
      constructor(model = "Phind-70B") {
        this.modelId = model;
      }
      get provider() {
        return "phind";
      }
      _normalizeMessages(prompt) {
        if (typeof prompt === "string") {
          return [{ role: "user", content: prompt }];
        }
        return prompt.map((msg) => {
          let content = msg.content;
          if (Array.isArray(content)) {
            content = content.map((p) => typeof p === "string" ? p : p.text ?? "").join(" ");
          } else {
            content = String(content);
          }
          return { role: msg.role, content };
        });
      }
      async doGenerate(options) {
        const messages = this._normalizeMessages(options.prompt);
        const text = await this.chat(messages);
        return {
          text,
          finishReason: "stop",
          usage: { promptTokens: NaN, completionTokens: NaN },
          rawCall: { rawPrompt: options.prompt, rawSettings: {} },
          rawResponse: {},
          request: {},
          response: {},
          warnings: []
        };
      }
      async doStream(options) {
        const messages = this._normalizeMessages(options.prompt);
        const reader = await this.chatReader(messages);
        const stream = new ReadableStream({
          async start(controller) {
            const decoder = new TextDecoder();
            while (true) {
              const { done, value } = await reader.read();
              if (done)
                break;
              const lines = decoder.decode(value, { stream: true }).split("\n");
              for (const line of lines) {
                let delta = line;
                if (delta)
                  controller.enqueue({ type: "text-delta", textDelta: delta });
              }
            }
            controller.enqueue({ type: "finish", finishReason: "stop", usage: { promptTokens: NaN, completionTokens: NaN } });
            controller.close();
            reader.releaseLock();
          }
        });
        return { stream, rawCall: { rawPrompt: options.prompt, rawSettings: {} }, rawResponse: {}, request: {}, warnings: [] };
      }
      async chat(messages) {
        const raw = await this._fetchChatResponse(messages);
        const text = await raw.text();
        const lines = text.split("\n");
        return this._mapResponse(lines);
      }
      async chatReader(messages) {
        const response = await this._fetchChatResponse(messages);
        const reader = response.body.getReader();
        return this.streamMapResponse(reader, this._mapResponse);
      }
      async *chatStream(messages) {
        const reader = await this.chatReader(messages);
        const decoder = new TextDecoder();
        while (true) {
          const { done, value } = await reader.read();
          if (done)
            break;
          const lines = decoder.decode(value, { stream: true }).split("\n");
          for (const line of lines) {
            let delta = line;
            if (delta)
              yield delta;
          }
        }
        reader.releaseLock();
      }
      async streamMapResponse(reader, mapResponse) {
        return new ReadableStream({
          async start(controller) {
            const decoder = new TextDecoder();
            while (true) {
              const { done, value } = await reader.read();
              if (done)
                break;
              const mappedResponse = mapResponse(decoder.decode(value, { stream: true }).split("\n"));
              controller.enqueue(new TextEncoder().encode(mappedResponse));
            }
            controller.close();
            reader.releaseLock();
          }
        }).getReader();
      }
      async _fetchChatResponse(messageHistory) {
        const payload = {
          additional_extension_context: "",
          allow_magic_buttons: true,
          is_vscode_extension: true,
          message_history: messageHistory,
          requested_model: this.modelId,
          user_input: messageHistory.filter((m) => m.role === "user").pop()?.content ?? ""
        };
        const response = await fetch(_PhindAIService.API_URL, {
          method: "POST",
          headers: this.headers,
          body: JSON.stringify(payload)
        });
        if (!response.ok) {
          const err = await response.text();
          console.error("Phind Error:", err);
          throw new Error(`Failed to generate text (Phind): ${response.status} ${response.statusText}`);
        }
        return response;
      }
      _mapResponse(lines) {
        let result = "";
        for (const line of lines) {
          if (!line.startsWith("data: ") || line.includes("[DONE]"))
            continue;
          try {
            result += JSON.parse(line.substring(5))?.choices?.[0]?.delta?.content ?? "";
          } catch {
          }
        }
        return result.replace(/\\n/g, "\n");
      }
    };
    exports.PhindAIService = PhindAIService;
  }
});

// dist/webapi/index.js
var require_index = __commonJS({
  "dist/webapi/index.js"(exports) {
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.PhindAIService = void 0;
    var PhindAIService_1 = require_PhindAIService();
    Object.defineProperty(exports, "PhindAIService", { enumerable: true, get: function() {
      return PhindAIService_1.PhindAIService;
    } });
  }
});
export default require_index();