@prompty/openai 2.0.0-alpha.1

package/dist/index.cjs

@@ -0,0 +1,671 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  OpenAIExecutor: () => OpenAIExecutor,
+  OpenAIProcessor: () => OpenAIProcessor,
+  buildChatArgs: () => buildChatArgs,
+  buildEmbeddingArgs: () => buildEmbeddingArgs,
+  buildImageArgs: () => buildImageArgs,
+  buildResponsesArgs: () => buildResponsesArgs,
+  messageToWire: () => messageToWire,
+  processResponse: () => processResponse
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/executor.ts
+var import_openai = __toESM(require("openai"), 1);
+var import_core = require("@prompty/core");
+var import_core2 = require("@prompty/core");
+var import_core3 = require("@prompty/core");
+
+// src/wire.ts
+function messageToWire(msg) {
+  const wire = { role: msg.role };
+  for (const [k, v] of Object.entries(msg.metadata)) {
+    if (k !== "role" && k !== "content") {
+      wire[k] = v;
+    }
+  }
+  const content = msg.toTextContent();
+  if (typeof content === "string") {
+    wire.content = content;
+  } else {
+    wire.content = msg.parts.map(partToWire);
+  }
+  return wire;
+}
+function partToWire(part) {
+  switch (part.kind) {
+    case "text":
+      return { type: "text", text: part.value };
+    case "image": {
+      const imageUrl = { url: part.source };
+      if (part.detail) imageUrl.detail = part.detail;
+      return { type: "image_url", image_url: imageUrl };
+    }
+    case "audio":
+      return {
+        type: "input_audio",
+        input_audio: {
+          data: part.source,
+          ...part.mediaType && { format: part.mediaType }
+        }
+      };
+    case "file":
+      return { type: "file", file: { url: part.source } };
+  }
+}
+function buildChatArgs(agent, messages) {
+  const model = agent.model?.id || "gpt-4";
+  const wireMessages = messages.map(messageToWire);
+  const args = {
+    model,
+    messages: wireMessages,
+    ...buildOptions(agent)
+  };
+  const tools = toolsToWire(agent);
+  if (tools.length > 0) {
+    args.tools = tools;
+  }
+  const responseFormat = outputSchemaToWire(agent);
+  if (responseFormat) {
+    args.response_format = responseFormat;
+  }
+  return args;
+}
+function buildEmbeddingArgs(agent, data) {
+  const model = agent.model?.id || "text-embedding-ada-002";
+  const args = {
+    input: Array.isArray(data) ? data : [data],
+    model
+  };
+  const extra = agent.model?.options?.additionalProperties;
+  if (extra) {
+    for (const [k, v] of Object.entries(extra)) {
+      args[k] = v;
+    }
+  }
+  return args;
+}
+function buildImageArgs(agent, data) {
+  const model = agent.model?.id || "dall-e-3";
+  let prompt;
+  if (typeof data === "string") {
+    prompt = data;
+  } else if (Array.isArray(data)) {
+    prompt = data.map((m) => {
+      if (typeof m.text === "string") return m.text;
+      if (Array.isArray(m.parts)) {
+        return m.parts.filter((p) => p.kind === "text").map((p) => p.value).join("");
+      }
+      return String(m);
+    }).join("\n").trim();
+  } else {
+    prompt = String(data);
+  }
+  const args = { prompt, model };
+  const extra = agent.model?.options?.additionalProperties;
+  if (extra) {
+    for (const [k, v] of Object.entries(extra)) {
+      args[k] = v;
+    }
+  }
+  return args;
+}
+var KIND_TO_JSON_TYPE = {
+  string: "string",
+  integer: "integer",
+  float: "number",
+  number: "number",
+  boolean: "boolean",
+  array: "array",
+  object: "object"
+};
+function buildOptions(agent) {
+  const opts = agent.model?.options;
+  if (!opts) return {};
+  const result = {};
+  if (opts.temperature !== void 0) result.temperature = opts.temperature;
+  if (opts.maxOutputTokens !== void 0) result.max_completion_tokens = opts.maxOutputTokens;
+  if (opts.topP !== void 0) result.top_p = opts.topP;
+  if (opts.frequencyPenalty !== void 0) result.frequency_penalty = opts.frequencyPenalty;
+  if (opts.presencePenalty !== void 0) result.presence_penalty = opts.presencePenalty;
+  if (opts.stopSequences !== void 0) result.stop = opts.stopSequences;
+  if (opts.seed !== void 0) result.seed = opts.seed;
+  if (opts.additionalProperties) {
+    for (const [k, v] of Object.entries(opts.additionalProperties)) {
+      if (!(k in result)) {
+        result[k] = v;
+      }
+    }
+  }
+  return result;
+}
+function schemaToWire(properties) {
+  const props = {};
+  const required = [];
+  for (const p of properties) {
+    if (!p.name) continue;
+    const schema = {
+      type: KIND_TO_JSON_TYPE[p.kind ?? "string"] ?? "string"
+    };
+    if (p.description) schema.description = p.description;
+    if (p.enumValues && p.enumValues.length > 0) schema.enum = p.enumValues;
+    props[p.name] = schema;
+    if (p.required) required.push(p.name);
+  }
+  const result = { type: "object", properties: props };
+  if (required.length > 0) result.required = required;
+  return result;
+}
+function propertyToJsonSchema(prop) {
+  const schema = {
+    type: KIND_TO_JSON_TYPE[prop.kind ?? "string"] ?? "string"
+  };
+  if (prop.description) schema.description = prop.description;
+  if (prop.enumValues && prop.enumValues.length > 0) schema.enum = prop.enumValues;
+  if (prop.kind === "array") {
+    schema.items = prop.items ? propertyToJsonSchema(prop.items) : { type: "string" };
+  }
+  if (prop.kind === "object") {
+    if (prop.properties) {
+      const nested = {};
+      const req = [];
+      for (const p of prop.properties) {
+        if (!p.name) continue;
+        nested[p.name] = propertyToJsonSchema(p);
+        req.push(p.name);
+      }
+      schema.properties = nested;
+      schema.required = req;
+    } else {
+      schema.properties = {};
+      schema.required = [];
+    }
+    schema.additionalProperties = false;
+  }
+  return schema;
+}
+function toolsToWire(agent) {
+  const tools = agent.tools;
+  if (!tools || tools.length === 0) return [];
+  const result = [];
+  for (const t of tools) {
+    if (t.kind !== "function") continue;
+    const funcDef = { name: t.name };
+    if (t.description) funcDef.description = t.description;
+    const params = t.parameters;
+    if (params && Array.isArray(params)) {
+      funcDef.parameters = schemaToWire(params);
+    }
+    const strict = t.strict;
+    if (strict) {
+      funcDef.strict = true;
+      if (funcDef.parameters) {
+        funcDef.parameters.additionalProperties = false;
+      }
+    }
+    result.push({ type: "function", function: funcDef });
+  }
+  return result;
+}
+function outputSchemaToWire(agent) {
+  const outputs = agent.outputs;
+  if (!outputs || outputs.length === 0) return null;
+  const properties = {};
+  const required = [];
+  for (const prop of outputs) {
+    if (!prop.name) continue;
+    properties[prop.name] = propertyToJsonSchema(prop);
+    required.push(prop.name);
+  }
+  const name = (agent.name || "response").toLowerCase().replace(/[\s-]/g, "_");
+  return {
+    type: "json_schema",
+    json_schema: {
+      name,
+      strict: true,
+      schema: {
+        type: "object",
+        properties,
+        required,
+        additionalProperties: false
+      }
+    }
+  };
+}
+function buildResponsesArgs(agent, messages) {
+  const model = agent.model?.id || "gpt-4o";
+  const systemParts = [];
+  const inputMessages = [];
+  for (const msg of messages) {
+    if (msg.role === "system" || msg.role === "developer") {
+      systemParts.push(msg.text);
+    } else {
+      inputMessages.push(messageToResponsesInput(msg));
+    }
+  }
+  const args = {
+    model,
+    input: inputMessages
+  };
+  if (systemParts.length > 0) {
+    args.instructions = systemParts.join("\n\n");
+  }
+  const responseOpts = buildResponsesOptions(agent);
+  Object.assign(args, responseOpts);
+  const tools = responsesToolsToWire(agent);
+  if (tools.length > 0) {
+    args.tools = tools;
+  }
+  const textConfig = outputSchemaToResponsesWire(agent);
+  if (textConfig) {
+    args.text = textConfig;
+  }
+  return args;
+}
+function messageToResponsesInput(msg) {
+  const content = msg.toTextContent();
+  if (msg.metadata.tool_call_id) {
+    return {
+      type: "function_call_output",
+      call_id: msg.metadata.tool_call_id,
+      output: typeof content === "string" ? content : JSON.stringify(content)
+    };
+  }
+  const role = msg.role === "tool" ? "user" : msg.role;
+  return { role, content };
+}
+function buildResponsesOptions(agent) {
+  const opts = agent.model?.options;
+  if (!opts) return {};
+  const result = {};
+  if (opts.temperature !== void 0) result.temperature = opts.temperature;
+  if (opts.maxOutputTokens !== void 0) result.max_output_tokens = opts.maxOutputTokens;
+  if (opts.topP !== void 0) result.top_p = opts.topP;
+  if (opts.additionalProperties) {
+    for (const [k, v] of Object.entries(opts.additionalProperties)) {
+      if (!(k in result)) {
+        result[k] = v;
+      }
+    }
+  }
+  return result;
+}
+function responsesToolsToWire(agent) {
+  const tools = agent.tools;
+  if (!tools || tools.length === 0) return [];
+  const result = [];
+  for (const t of tools) {
+    if (t.kind !== "function") continue;
+    const tool = {
+      type: "function",
+      name: t.name
+    };
+    if (t.description) tool.description = t.description;
+    const params = t.parameters;
+    if (params && Array.isArray(params)) {
+      tool.parameters = schemaToWire(params);
+    }
+    const strict = t.strict;
+    if (strict) {
+      tool.strict = true;
+      if (tool.parameters) {
+        tool.parameters.additionalProperties = false;
+      }
+    }
+    result.push(tool);
+  }
+  return result;
+}
+function outputSchemaToResponsesWire(agent) {
+  const outputs = agent.outputs;
+  if (!outputs || outputs.length === 0) return null;
+  const properties = {};
+  const required = [];
+  for (const prop of outputs) {
+    if (!prop.name) continue;
+    properties[prop.name] = propertyToJsonSchema(prop);
+    required.push(prop.name);
+  }
+  const name = (agent.name || "response").toLowerCase().replace(/[\s-]/g, "_");
+  return {
+    format: {
+      type: "json_schema",
+      name,
+      strict: true,
+      schema: {
+        type: "object",
+        properties,
+        required,
+        additionalProperties: false
+      }
+    }
+  };
+}
+
+// src/executor.ts
+var OpenAIExecutor = class {
+  async execute(agent, messages) {
+    return (0, import_core3.traceSpan)("OpenAIExecutor", async (emit) => {
+      emit("signature", "prompty.openai.executor.OpenAIExecutor.invoke");
+      emit("inputs", { data: messages });
+      const client = this.resolveClient(agent);
+      const clientName = client.constructor?.name ?? "OpenAI";
+      await (0, import_core3.traceSpan)(clientName, async (ctorEmit) => {
+        ctorEmit("signature", `${clientName}.ctor`);
+        const conn = agent.model?.connection;
+        if (conn instanceof import_core.ReferenceConnection) {
+          ctorEmit("inputs", { source: "reference", name: conn.name });
+        } else {
+          ctorEmit("inputs", (0, import_core3.sanitizeValue)("ctor", this.clientKwargs(agent)));
+        }
+        ctorEmit("result", clientName);
+      });
+      const apiType = agent.model?.apiType ?? "chat";
+      const result = await this.executeApiCall(client, clientName, agent, messages, apiType);
+      emit("result", result);
+      return result;
+    });
+  }
+  /** Dispatch to the appropriate API and trace the call. */
+  async executeApiCall(client, clientName, agent, messages, apiType) {
+    switch (apiType) {
+      case "chat":
+      case "agent": {
+        const args = buildChatArgs(agent, messages);
+        const isStreaming = !!args.stream;
+        return (0, import_core3.traceSpan)("create", async (callEmit) => {
+          callEmit("signature", `${clientName}.chat.completions.create`);
+          callEmit("inputs", (0, import_core3.sanitizeValue)("create", args));
+          const result = await client.chat.completions.create(
+            args
+          );
+          if (isStreaming) {
+            return new import_core.PromptyStream(`${clientName}Executor`, result);
+          }
+          callEmit("result", result);
+          return result;
+        });
+      }
+      case "embedding": {
+        const args = buildEmbeddingArgs(agent, messages);
+        return (0, import_core3.traceSpan)("create", async (callEmit) => {
+          callEmit("signature", `${clientName}.embeddings.create`);
+          callEmit("inputs", (0, import_core3.sanitizeValue)("create", args));
+          const result = await client.embeddings.create(
+            args
+          );
+          callEmit("result", result);
+          return result;
+        });
+      }
+      case "image": {
+        const args = buildImageArgs(agent, messages);
+        return (0, import_core3.traceSpan)("generate", async (callEmit) => {
+          callEmit("signature", `${clientName}.images.generate`);
+          callEmit("inputs", (0, import_core3.sanitizeValue)("generate", args));
+          const result = await client.images.generate(
+            args
+          );
+          callEmit("result", result);
+          return result;
+        });
+      }
+      case "responses": {
+        const args = buildResponsesArgs(agent, messages);
+        const isStreaming = !!args.stream;
+        return (0, import_core3.traceSpan)("create", async (callEmit) => {
+          callEmit("signature", `${clientName}.responses.create`);
+          callEmit("inputs", (0, import_core3.sanitizeValue)("create", args));
+          const result = await client.responses.create(
+            args
+          );
+          if (isStreaming) {
+            return new import_core.PromptyStream(`${clientName}Executor`, result);
+          }
+          callEmit("result", result);
+          return result;
+        });
+      }
+      default:
+        throw new Error(`Unsupported apiType: ${apiType}`);
+    }
+  }
+  resolveClient(agent) {
+    const conn = agent.model?.connection;
+    if (conn instanceof import_core.ReferenceConnection) {
+      return (0, import_core2.getConnection)(conn.name);
+    }
+    const kwargs = this.clientKwargs(agent);
+    return new import_openai.default(kwargs);
+  }
+  clientKwargs(agent) {
+    const kwargs = {};
+    const conn = agent.model?.connection;
+    if (conn instanceof import_core.ApiKeyConnection) {
+      if (conn.apiKey) kwargs.apiKey = conn.apiKey;
+      if (conn.endpoint) kwargs.baseURL = conn.endpoint;
+    }
+    return kwargs;
+  }
+};
+
+// src/processor.ts
+var import_core4 = require("@prompty/core");
+var OpenAIProcessor = class {
+  async process(agent, response) {
+    return (0, import_core4.traceSpan)("OpenAIProcessor", async (emit) => {
+      emit("signature", "prompty.openai.processor.OpenAIProcessor.invoke");
+      emit("inputs", { data: response });
+      const result = processResponse(agent, response);
+      if (!isAsyncIterable(response)) {
+        emit("result", result);
+      }
+      return result;
+    });
+  }
+};
+function processResponse(agent, response) {
+  if (typeof response !== "object" || response === null) return response;
+  if (isAsyncIterable(response)) {
+    return streamGenerator(response);
+  }
+  const r = response;
+  if (r.object === "response" && Array.isArray(r.output)) {
+    return processResponsesApi(agent, r);
+  }
+  if (r.choices) {
+    return processChatCompletion(agent, r);
+  }
+  if (r.data && r.object === "list") {
+    return processEmbedding(r);
+  }
+  if (r.data && Array.isArray(r.data)) {
+    const data = r.data;
+    if (data.length > 0 && ("url" in data[0] || "b64_json" in data[0])) {
+      return processImage(r);
+    }
+  }
+  return response;
+}
+function isAsyncIterable(value) {
+  return typeof value === "object" && value !== null && Symbol.asyncIterator in value;
+}
+async function* streamGenerator(response) {
+  const toolCallAcc = /* @__PURE__ */ new Map();
+  for await (const chunk of response) {
+    const c = chunk;
+    const choices = c.choices;
+    if (!choices || choices.length === 0) continue;
+    const delta = choices[0].delta;
+    if (!delta) continue;
+    if (delta.content != null) {
+      yield delta.content;
+    }
+    const tcDeltas = delta.tool_calls;
+    if (tcDeltas) {
+      for (const tcDelta of tcDeltas) {
+        const idx = tcDelta.index;
+        if (!toolCallAcc.has(idx)) {
+          toolCallAcc.set(idx, { id: "", name: "", arguments: "" });
+        }
+        const acc = toolCallAcc.get(idx);
+        if (tcDelta.id) acc.id = tcDelta.id;
+        const fn = tcDelta.function;
+        if (fn) {
+          if (fn.name) acc.name = fn.name;
+          if (fn.arguments) acc.arguments += fn.arguments;
+        }
+      }
+    }
+    if (delta.refusal != null) {
+      throw new Error(`Model refused: ${delta.refusal}`);
+    }
+  }
+  const sortedIndices = [...toolCallAcc.keys()].sort((a, b) => a - b);
+  for (const idx of sortedIndices) {
+    const tc = toolCallAcc.get(idx);
+    yield { id: tc.id, name: tc.name, arguments: tc.arguments };
+  }
+}
+function processResponsesApi(agent, response) {
+  const output = response.output;
+  const funcCalls = [];
+  for (const item of output) {
+    if (item.type === "function_call") {
+      funcCalls.push({
+        id: item.call_id ?? item.id ?? "",
+        name: item.name,
+        arguments: item.arguments
+      });
+    }
+  }
+  if (funcCalls.length > 0) {
+    return funcCalls;
+  }
+  const outputText = response.output_text;
+  if (outputText !== void 0) {
+    if (agent.outputs && agent.outputs.length > 0) {
+      try {
+        return JSON.parse(outputText);
+      } catch {
+        return outputText;
+      }
+    }
+    return outputText;
+  }
+  const texts = [];
+  for (const item of output) {
+    if (item.type === "message") {
+      const content = item.content;
+      if (content) {
+        for (const part of content) {
+          if (part.type === "output_text" || part.type === "text") {
+            texts.push(part.text);
+          }
+        }
+      }
+    }
+  }
+  if (texts.length > 0) {
+    const text = texts.join("");
+    if (agent.outputs && agent.outputs.length > 0) {
+      try {
+        return JSON.parse(text);
+      } catch {
+        return text;
+      }
+    }
+    return text;
+  }
+  return response;
+}
+function processChatCompletion(agent, response) {
+  const choices = response.choices;
+  if (!choices || choices.length === 0) return null;
+  const choice = choices[0];
+  const message = choice.message;
+  if (!message) return null;
+  const toolCalls = message.tool_calls;
+  if (toolCalls && toolCalls.length > 0) {
+    return toolCalls.map((tc) => {
+      const fn = tc.function;
+      return {
+        id: tc.id,
+        name: fn.name,
+        arguments: fn.arguments
+      };
+    });
+  }
+  const content = message.content;
+  if (content === null) return null;
+  if (agent.outputs && agent.outputs.length > 0) {
+    try {
+      return JSON.parse(content);
+    } catch {
+      return content;
+    }
+  }
+  return content;
+}
+function processEmbedding(response) {
+  const data = response.data;
+  if (data.length === 1) {
+    return data[0].embedding;
+  }
+  return data.map((d) => d.embedding);
+}
+function processImage(response) {
+  const data = response.data;
+  if (data.length === 1) {
+    return data[0].url ?? data[0].b64_json;
+  }
+  return data.map((d) => d.url ?? d.b64_json);
+}
+
+// src/index.ts
+var import_core5 = require("@prompty/core");
+(0, import_core5.registerExecutor)("openai", new OpenAIExecutor());
+(0, import_core5.registerProcessor)("openai", new OpenAIProcessor());
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  OpenAIExecutor,
+  OpenAIProcessor,
+  buildChatArgs,
+  buildEmbeddingArgs,
+  buildImageArgs,
+  buildResponsesArgs,
+  messageToWire,
+  processResponse
+});
+//# sourceMappingURL=index.cjs.map