@coursebuilder/core/dist/providers/openai.cjs

Core package for Course Builder

"use strict";
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
var __export = (target, all) => {
  for (var name in all)
    __defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
  if (from && typeof from === "object" || typeof from === "function") {
    for (let key of __getOwnPropNames(from))
      if (!__hasOwnProp.call(to, key) && key !== except)
        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
  }
  return to;
};
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
var __publicField = (obj, key, value) => {
  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
  return value;
};

// src/providers/openai.ts
var openai_exports = {};
__export(openai_exports, {
  MockOpenAIProvider: () => MockOpenAIProvider,
  STREAM_COMPLETE: () => STREAM_COMPLETE,
  default: () => OpenAIProvider
});
module.exports = __toCommonJS(openai_exports);
var import_openai = require("@ai-sdk/openai");
var import_ai = require("ai");
var STREAM_COMPLETE = `\\ok`;
var _a;
var PartyKitChunkPublisher = (_a = class {
  constructor(requestId, partyUrlBase) {
    __publicField(this, "requestId");
    __publicField(this, "interval", 250);
    __publicField(this, "buffer");
    __publicField(this, "partyUrl");
    this.requestId = requestId;
    this.buffer = {
      contents: ""
    };
    this.partyUrl = `${partyUrlBase}/party/${requestId}`;
  }
  async publishMessage(message) {
    await this.sendToPartyKit(message, this.requestId, this.partyUrl);
  }
  async appendToBufferAndPublish(text) {
    let resolve = /* @__PURE__ */ __name((_val) => {
    }, "resolve");
    this.buffer.contents += text;
    if (this.buffer.signal) {
      return;
    }
    this.buffer.signal = new Promise((r) => {
      resolve = r;
    });
    setTimeout(() => {
      if (this.buffer.contents.length === 0) {
        resolve();
        return;
      }
      this.sendToPartyKit(this.buffer.contents, this.requestId, this.partyUrl);
      resolve();
      this.buffer = {
        contents: ""
      };
    }, this.interval);
  }
  async waitForBuffer() {
    await this.buffer.signal;
  }
  async sendToPartyKit(body, requestId, partyUrl) {
    return await fetch(partyUrl, {
      method: "POST",
      body: JSON.stringify({
        body,
        requestId,
        name: "ai.message"
      })
    }).catch((e) => {
      console.error("Failed to send chunk to PartyKit:", e);
    });
  }
}, __name(_a, "PartyKitChunkPublisher"), _a);
function OpenAIProvider(options) {
  const client = (0, import_openai.createOpenAI)({
    apiKey: options.apiKey,
    ...options.baseUrl && {
      baseURL: options.baseUrl
    }
  });
  return {
    id: "openai",
    name: "OpenAI",
    type: "llm",
    options,
    ...options,
    createChatCompletion: async (createChatOptions) => {
      try {
        const modelName = createChatOptions.model || options.defaultModel || "gpt-4o";
        const publisher = new PartyKitChunkPublisher(createChatOptions.chatId, options.partyUrlBase);
        const result = await (0, import_ai.streamText)({
          model: client(modelName),
          messages: createChatOptions.messages,
          onChunk: async ({ chunk }) => {
            if (chunk.type === "text-delta") {
              await publisher.appendToBufferAndPublish(chunk.textDelta);
            }
          }
        });
        let fullText = "";
        for await (const textPart of result.textStream) {
          fullText += textPart;
        }
        await publisher.waitForBuffer();
        await publisher.publishMessage(STREAM_COMPLETE);
        return {
          role: "assistant",
          content: fullText
        };
      } catch (error) {
        console.error("OpenAI streaming error:", error);
        throw error;
      }
    }
  };
}
__name(OpenAIProvider, "OpenAIProvider");
var MockOpenAIProvider = {
  id: "mock-openai",
  name: "Mock OpenAI",
  type: "llm",
  options: {
    apiKey: "mock-api-key",
    partyUrlBase: "mock-callback-url"
  },
  apiKey: "mock-api-key",
  partyUrlBase: "mock-callback-url",
  createChatCompletion: () => Promise.resolve(null)
};
// Annotate the CommonJS export names for ESM import in node:
0 && (module.exports = {
  MockOpenAIProvider,
  STREAM_COMPLETE
});
//# sourceMappingURL=openai.cjs.map