@osdk/aip-core 0.2.0

package/build/cjs/index.cjs

@@ -0,0 +1,1012 @@
+'use strict';
+
+var languageModels = require('@osdk/language-models');
+
+// src/internal/options.ts
+function resolveMessages(callerLabel, system, prompt, messages) {
+  if (prompt != null && messages != null) {
+    throw new Error(`${callerLabel}: cannot specify both \`prompt\` and \`messages\`: choose one.`);
+  }
+  const sys = resolveSystem(system);
+  const body = resolveBody(prompt, messages);
+  if (sys.length === 0 && body.length === 0) {
+    throw new Error(`${callerLabel}: must provide at least one of \`system\`, \`prompt\`, or \`messages\`.`);
+  }
+  return [...sys, ...body];
+}
+function resolveSystem(system) {
+  if (system == null) {
+    return [];
+  }
+  if (typeof system === "string") {
+    return system === "" ? [] : [{
+      role: "system",
+      content: system
+    }];
+  }
+  if (Array.isArray(system)) {
+    return system;
+  }
+  return [system];
+}
+function resolveBody(prompt, messages) {
+  if (messages != null) {
+    return messages;
+  }
+  if (prompt == null) {
+    return [];
+  }
+  if (typeof prompt === "string") {
+    return [{
+      role: "user",
+      content: prompt
+    }];
+  }
+  return prompt;
+}
+
+// src/model.ts
+var internals = /* @__PURE__ */ new WeakMap();
+function foundryModel(options) {
+  const identifier = typeof options.model === "string" ? {
+    type: "lmsModel",
+    apiName: options.model
+  } : options.model;
+  const id = identifier.type === "lmsModel" ? identifier.apiName : identifier.registeredModelRid;
+  const handle = Object.freeze({
+    modelId: `foundry/${id}`,
+    provider: "foundry-lms"
+  });
+  internals.set(handle, {
+    client: options.client,
+    identifier
+  });
+  return handle;
+}
+function _getFoundryInternal(model) {
+  const handle = internals.get(model);
+  if (handle == null) {
+    throw new Error(`LanguageModel(modelId=${model.modelId}, provider=${model.provider}) was not constructed via foundryModel(). Only foundry-lms models are supported in v0.`);
+  }
+  return handle;
+}
+function getModelApiName(identifier) {
+  return identifier.type === "lmsModel" ? identifier.apiName : identifier.registeredModelRid;
+}
+function mapUsage(raw) {
+  return {
+    inputTokens: raw.prompt_tokens,
+    outputTokens: raw.completion_tokens,
+    totalTokens: raw.total_tokens,
+    reasoningTokens: raw.completion_tokens_details?.reasoning_tokens,
+    cachedInputTokens: raw.prompt_tokens_details?.cached_tokens
+  };
+}
+var EMPTY_USAGE = {
+  inputTokens: void 0,
+  outputTokens: void 0,
+  totalTokens: void 0
+};
+function mapFinishReason(reason) {
+  switch (reason) {
+    case "stop":
+      return "stop";
+    case "length":
+      return "length";
+    case "tool_calls":
+    case "function_call":
+      return "tool-calls";
+    case "content_filter":
+      return "content-filter";
+    default:
+      return "other";
+  }
+}
+function convertMessage(m, warnings) {
+  switch (m.role) {
+    case "system":
+      return [{
+        role: "system",
+        content: m.content
+      }];
+    case "user": {
+      if (typeof m.content === "string") {
+        return [{
+          role: "user",
+          content: m.content
+        }];
+      }
+      const parts = [];
+      for (const p of m.content) {
+        if (p.type === "text") {
+          parts.push({
+            type: "text",
+            text: p.text
+          });
+        } else {
+          warnings.push({
+            type: "other",
+            message: `Unsupported user content part "${p.type}": ignored in v0`
+          });
+        }
+      }
+      return [{
+        role: "user",
+        content: parts
+      }];
+    }
+    case "assistant": {
+      if (typeof m.content === "string") {
+        return [{
+          role: "assistant",
+          content: m.content
+        }];
+      }
+      let text = "";
+      const toolCalls = [];
+      for (const p of m.content) {
+        switch (p.type) {
+          case "text":
+            text += p.text;
+            break;
+          case "tool-call":
+            toolCalls.push({
+              id: p.toolCallId,
+              type: "function",
+              function: {
+                name: p.toolName,
+                arguments: JSON.stringify(p.input ?? {})
+              }
+            });
+            break;
+          case "reasoning":
+          case "file":
+            warnings.push({
+              type: "other",
+              message: `Unsupported assistant content part "${p.type}": ignored in v0`
+            });
+            break;
+        }
+      }
+      return [{
+        role: "assistant",
+        content: text.length > 0 ? text : null,
+        tool_calls: toolCalls.length > 0 ? toolCalls : void 0
+      }];
+    }
+    case "tool":
+      return m.content.map((part) => ({
+        role: "tool",
+        content: stringifyToolResult(part, warnings),
+        tool_call_id: part.toolCallId
+      }));
+  }
+}
+function stringifyToolResult(part, warnings) {
+  switch (part.output.type) {
+    case "text":
+    case "error-text":
+      return part.output.value;
+    case "json":
+    case "error-json":
+      return JSON.stringify(part.output.value);
+    case "content":
+      return part.output.value.map((c) => {
+        if (c.type === "text") {
+          return c.text;
+        }
+        warnings.push({
+          type: "other",
+          message: `Unsupported tool result media: ignored in v0`
+        });
+        return "";
+      }).filter((s) => s.length > 0).join("\n");
+  }
+}
+function convertTools(tools, warnings) {
+  return Object.entries(tools).map(([name, tool]) => {
+    const parameters = isJsonSchemaLike(tool.inputSchema) ? tool.inputSchema : (warnings.push({
+      type: "unsupported-tool",
+      details: `Tool "${name}" inputSchema is not a JSON Schema; v0 only supports plain JSON Schema objects. Defaulting to {} parameters.`
+    }), {
+      type: "object",
+      properties: {}
+    });
+    return {
+      type: "function",
+      function: {
+        name,
+        description: tool.description,
+        parameters
+      }
+    };
+  });
+}
+function convertToolChoice(choice) {
+  if (choice == null) {
+    return void 0;
+  }
+  if (choice === "auto" || choice === "none" || choice === "required") {
+    return choice;
+  }
+  return {
+    type: "function",
+    function: {
+      name: choice.toolName
+    }
+  };
+}
+function isJsonSchemaLike(value) {
+  return typeof value === "object" && value != null && ("type" in value || "properties" in value || "$ref" in value || "oneOf" in value || "anyOf" in value || "allOf" in value);
+}
+function parseToolArguments(args, warnings) {
+  if (args === "") {
+    return {};
+  }
+  try {
+    return JSON.parse(args);
+  } catch {
+    warnings.push({
+      type: "other",
+      message: `Tool call arguments were not valid JSON; passing through as a raw string`
+    });
+    return args;
+  }
+}
+function buildOpenAiRequestBody(args, streaming) {
+  const common = {
+    model: args.apiName,
+    messages: args.messages.map((m) => convertMessage(m, args.warnings)).flat(),
+    max_tokens: args.maxOutputTokens,
+    temperature: args.temperature,
+    top_p: args.topP,
+    stop: args.stopSequences,
+    seed: args.seed,
+    presence_penalty: args.presencePenalty,
+    frequency_penalty: args.frequencyPenalty,
+    tools: args.tools != null ? convertTools(args.tools, args.warnings) : void 0,
+    tool_choice: convertToolChoice(args.toolChoice)
+  };
+  if (streaming) {
+    return {
+      ...common,
+      stream: true,
+      stream_options: {
+        include_usage: true
+      }
+    };
+  }
+  return {
+    ...common,
+    stream: false
+  };
+}
+function buildAssistantContent(text, toolCalls) {
+  if (toolCalls.length === 0) {
+    return text;
+  }
+  const parts = [];
+  if (text.length > 0) {
+    parts.push({
+      type: "text",
+      text
+    });
+  }
+  for (const tc of toolCalls) {
+    parts.push({
+      type: "tool-call",
+      toolCallId: tc.toolCallId,
+      toolName: tc.toolName,
+      input: tc.input
+    });
+  }
+  return parts;
+}
+function filterHeaders(input) {
+  const out = {};
+  for (const [k, v] of Object.entries(input)) {
+    if (v != null) {
+      out[k] = v;
+    }
+  }
+  return out;
+}
+async function safeReadText(res) {
+  try {
+    return await res.text();
+  } catch {
+    return void 0;
+  }
+}
+async function postChatCompletions(args) {
+  const handle = _getFoundryInternal(args.model);
+  const baseUrl = languageModels.getOpenAiBaseUrl(handle.client);
+  const url = new URL("chat/completions", `${baseUrl}/`).toString();
+  const res = await handle.client.fetch(url, {
+    method: "POST",
+    headers: filterHeaders({
+      "Content-Type": "application/json",
+      Accept: args.accept,
+      ...args.headers ?? {}
+    }),
+    body: JSON.stringify(args.body),
+    signal: args.abortSignal
+  });
+  if (!res.ok) {
+    const errBody = await safeReadText(res);
+    throw new Error(`LMS chat/completions request failed: ${res.status} ${res.statusText}` + (errBody ? `: ${errBody}` : ""));
+  }
+  return res;
+}
+
+// src/internal/runStep.ts
+async function runStep(input) {
+  const apiName = getModelApiName(_getFoundryInternal(input.model).identifier);
+  const body = buildOpenAiRequestBody({
+    apiName,
+    ...input
+  }, false);
+  const res = await postChatCompletions({
+    model: input.model,
+    body,
+    accept: "application/json",
+    headers: input.headers,
+    abortSignal: input.abortSignal
+  });
+  const data = await res.json();
+  return parseResponse(data, body, input.warnings);
+}
+function parseResponse(res, request, warnings) {
+  const choice = res.choices[0];
+  if (choice == null) {
+    throw new Error("LMS chat/completions response did not include any choices");
+  }
+  const message = choice.message;
+  const text = message.content ?? "";
+  const reasoningText = message.reasoning ?? message.reasoning_content;
+  const toolCalls = (message.tool_calls ?? []).map((c) => ({
+    type: "tool-call",
+    toolCallId: c.id,
+    toolName: c.function.name,
+    input: parseToolArguments(c.function.arguments, warnings)
+  }));
+  const reasoning = reasoningText != null ? [{
+    type: "reasoning",
+    text: reasoningText
+  }] : [];
+  const content = [];
+  if (text.length > 0) {
+    content.push({
+      type: "text",
+      text
+    });
+  }
+  for (const r of reasoning) {
+    content.push({
+      type: "reasoning",
+      text: r.text
+    });
+  }
+  for (const tc of toolCalls) {
+    content.push({
+      ...tc,
+      type: "tool-call"
+    });
+  }
+  const usage = res.usage != null ? mapUsage(res.usage) : EMPTY_USAGE;
+  const finishReason = mapFinishReason(choice.finish_reason);
+  const responseMessages = [{
+    role: "assistant",
+    content: buildAssistantContent(text, toolCalls)
+  }];
+  return {
+    content,
+    text,
+    reasoning,
+    reasoningText,
+    toolCalls,
+    toolResults: [],
+    finishReason,
+    rawFinishReason: choice.finish_reason,
+    usage,
+    warnings: warnings.length > 0 ? warnings : void 0,
+    request: {
+      body: request
+    },
+    response: {
+      id: res.id,
+      modelId: res.model,
+      timestamp: new Date(res.created * 1e3),
+      body: res,
+      messages: responseMessages
+    },
+    providerMetadata: void 0
+  };
+}
+
+// src/generateText.ts
+async function generateText(options) {
+  const messages = resolveMessages("generateText", options.system, options.prompt, options.messages);
+  const step = await runStep({
+    model: options.model,
+    messages,
+    tools: options.tools,
+    toolChoice: options.toolChoice,
+    maxOutputTokens: options.maxOutputTokens,
+    temperature: options.temperature,
+    topP: options.topP,
+    stopSequences: options.stopSequences,
+    seed: options.seed,
+    presencePenalty: options.presencePenalty,
+    frequencyPenalty: options.frequencyPenalty,
+    abortSignal: options.abortSignal,
+    headers: options.headers,
+    warnings: []
+  });
+  await options.onStepFinish?.(step);
+  const totalUsage = step.usage;
+  await options.onFinish?.({
+    ...step,
+    steps: [step],
+    totalUsage
+  });
+  return {
+    ...step,
+    totalUsage,
+    steps: [step]
+  };
+}
+
+// src/internal/streamStep.ts
+async function streamStep(input) {
+  const apiName = getModelApiName(_getFoundryInternal(input.model).identifier);
+  const body = buildOpenAiRequestBody({
+    apiName,
+    ...input
+  }, true);
+  const res = await postChatCompletions({
+    model: input.model,
+    body,
+    accept: "text/event-stream",
+    headers: input.headers,
+    abortSignal: input.abortSignal
+  });
+  if (res.body == null) {
+    throw new Error("LMS chat/completions response had no streaming body");
+  }
+  return parseSseStream({
+    body: res.body,
+    onChunk: input.onChunk,
+    warnings: input.warnings,
+    request: {
+      body
+    }
+  });
+}
+var TEXT_PART_ID = "text-0";
+var REASONING_PART_ID = "reasoning-0";
+async function parseSseStream(args) {
+  const reader = args.body.pipeThrough(new TextDecoderStream()).getReader();
+  let buffer = "";
+  let textBuf = "";
+  let reasoningStarted = false;
+  let reasoningBuf = "";
+  let finishReason = "other";
+  let rawFinishReason;
+  let usage;
+  const toolCallAcc = /* @__PURE__ */ new Map();
+  let responseInitialized = false;
+  let responseId;
+  let responseModel;
+  let responseCreated;
+  try {
+    while (true) {
+      const {
+        value,
+        done
+      } = await reader.read();
+      if (done) {
+        break;
+      }
+      buffer += value.replace(/\r\n/g, "\n");
+      let frameEnd = buffer.indexOf("\n\n");
+      while (frameEnd !== -1) {
+        const frame = buffer.slice(0, frameEnd);
+        buffer = buffer.slice(frameEnd + 2);
+        for (const line of frame.split("\n")) {
+          if (!line.startsWith("data:")) {
+            continue;
+          }
+          const payload = line.slice(5).trim();
+          if (payload === "") {
+            continue;
+          }
+          if (payload === "[DONE]") {
+            continue;
+          }
+          let parsed;
+          try {
+            parsed = JSON.parse(payload);
+          } catch {
+            args.warnings.push({
+              type: "other",
+              message: `Skipped malformed SSE frame: ${payload.slice(0, 80)}`
+            });
+            continue;
+          }
+          if (isErrorFrame(parsed)) {
+            throw new Error(extractErrorMessage(parsed));
+          }
+          const chunk = parsed;
+          if (!responseInitialized) {
+            responseId = chunk.id;
+            responseModel = chunk.model;
+            responseCreated = chunk.created;
+            responseInitialized = true;
+          }
+          if (chunk.usage != null) {
+            usage = mapUsage(chunk.usage);
+          }
+          for (const choice of chunk.choices ?? []) {
+            const delta = choice.delta;
+            const contentDelta = delta.content;
+            if (typeof contentDelta === "string" && contentDelta.length > 0) {
+              textBuf += contentDelta;
+              await args.onChunk({
+                type: "text-delta",
+                id: TEXT_PART_ID,
+                delta: contentDelta
+              });
+            }
+            const reasoningDelta = delta.reasoning ?? delta.reasoning_content;
+            if (typeof reasoningDelta === "string" && reasoningDelta.length > 0) {
+              reasoningStarted = true;
+              reasoningBuf += reasoningDelta;
+              await args.onChunk({
+                type: "reasoning-delta",
+                id: REASONING_PART_ID,
+                delta: reasoningDelta
+              });
+            }
+            if (delta.tool_calls != null) {
+              for (const tc of delta.tool_calls) {
+                if (typeof tc.index !== "number") {
+                  continue;
+                }
+                const acc = toolCallAcc.get(tc.index) ?? {
+                  id: "",
+                  name: "",
+                  args: ""
+                };
+                if (tc.id != null) {
+                  acc.id = tc.id;
+                }
+                if (tc.function?.name != null) {
+                  acc.name = tc.function.name;
+                }
+                if (tc.function?.arguments != null) {
+                  acc.args += tc.function.arguments;
+                }
+                toolCallAcc.set(tc.index, acc);
+              }
+            }
+            if (choice.finish_reason != null) {
+              rawFinishReason = choice.finish_reason;
+              finishReason = mapFinishReason(choice.finish_reason);
+            }
+          }
+        }
+        frameEnd = buffer.indexOf("\n\n");
+      }
+    }
+  } finally {
+    reader.releaseLock();
+  }
+  const finalUsage = usage ?? EMPTY_USAGE;
+  const toolCalls = Array.from(toolCallAcc.entries()).map(([index, acc]) => ({
+    type: "tool-call",
+    toolCallId: acc.id !== "" ? acc.id : `tool_call_${index}`,
+    toolName: acc.name,
+    input: parseToolArguments(acc.args, args.warnings)
+  }));
+  for (const tc of toolCalls) {
+    await args.onChunk({
+      type: "tool-call",
+      toolCallId: tc.toolCallId,
+      toolName: tc.toolName,
+      input: tc.input
+    });
+  }
+  await args.onChunk({
+    type: "finish",
+    finishReason,
+    rawFinishReason,
+    usage: finalUsage
+  });
+  const response = {
+    id: responseId,
+    modelId: responseModel,
+    timestamp: responseCreated != null ? new Date(responseCreated * 1e3) : void 0,
+    messages: [{
+      role: "assistant",
+      content: buildAssistantContent(textBuf, toolCalls)
+    }]
+  };
+  return {
+    text: textBuf,
+    reasoningText: reasoningStarted ? reasoningBuf : void 0,
+    toolCalls,
+    finishReason,
+    rawFinishReason,
+    usage: finalUsage,
+    request: args.request,
+    response
+  };
+}
+function isErrorFrame(payload) {
+  return typeof payload === "object" && payload != null && "error" in payload && payload.error != null;
+}
+function extractErrorMessage(payload) {
+  const err = payload.error;
+  if (typeof err === "string") {
+    return err;
+  }
+  if (typeof err === "object" && err != null) {
+    const message = err.message;
+    if (typeof message === "string") {
+      return message;
+    }
+  }
+  return "LMS chat/completions stream emitted an error frame";
+}
+
+// src/streamText.ts
+function streamText(options) {
+  const warnings = [];
+  const messages = resolveMessages("streamText", options.system, options.prompt, options.messages);
+  const final = createDeferred();
+  const internalAbort = new AbortController();
+  const abortHandler = () => internalAbort.abort();
+  if (options.abortSignal != null) {
+    if (options.abortSignal.aborted) {
+      internalAbort.abort();
+    } else {
+      options.abortSignal.addEventListener("abort", abortHandler);
+    }
+  }
+  const detachAbortHandler = () => {
+    options.abortSignal?.removeEventListener("abort", abortHandler);
+  };
+  let streamController;
+  let streamClosed = false;
+  const run = async () => {
+    try {
+      const result = await streamStep({
+        model: options.model,
+        messages,
+        tools: options.tools,
+        toolChoice: options.toolChoice,
+        maxOutputTokens: options.maxOutputTokens,
+        temperature: options.temperature,
+        topP: options.topP,
+        stopSequences: options.stopSequences,
+        seed: options.seed,
+        presencePenalty: options.presencePenalty,
+        frequencyPenalty: options.frequencyPenalty,
+        abortSignal: internalAbort.signal,
+        headers: options.headers,
+        warnings,
+        onChunk: async (chunk) => {
+          if (!streamClosed) {
+            streamController?.enqueue(chunk);
+          }
+          if (options.onChunk != null) {
+            await options.onChunk(chunk);
+          }
+        }
+      });
+      streamController?.close();
+      streamClosed = true;
+      const finalWarnings = warnings.length > 0 ? warnings : void 0;
+      final.resolve({
+        text: result.text,
+        reasoningText: result.reasoningText,
+        usage: result.usage,
+        finishReason: result.finishReason,
+        toolCalls: result.toolCalls,
+        warnings: finalWarnings,
+        response: result.response,
+        request: result.request
+      });
+      if (options.onFinish != null) {
+        await options.onFinish({
+          finishReason: result.finishReason,
+          text: result.text,
+          reasoningText: result.reasoningText,
+          toolCalls: result.toolCalls,
+          usage: result.usage,
+          totalUsage: result.usage,
+          warnings: finalWarnings,
+          response: result.response,
+          request: result.request
+        });
+      }
+    } catch (err) {
+      const error = err instanceof Error ? err : new Error(String(err));
+      if (!streamClosed) {
+        streamController?.enqueue({
+          type: "error",
+          error
+        });
+        streamController?.error(error);
+        streamClosed = true;
+      }
+      final.reject(error);
+      if (options.onError != null) {
+        await options.onError(error);
+      }
+    } finally {
+      detachAbortHandler();
+    }
+  };
+  const sourceStream = new ReadableStream({
+    start(controller) {
+      streamController = controller;
+      void run();
+    },
+    cancel() {
+      internalAbort.abort();
+      detachAbortHandler();
+    }
+  });
+  const [fullStreamBranch, textStreamBranch] = sourceStream.tee();
+  const textStream = textStreamBranch.pipeThrough(new TransformStream({
+    transform(chunk, controller) {
+      if (chunk.type === "text-delta") {
+        controller.enqueue(chunk.delta);
+      }
+    }
+  }));
+  const warningsPromise = final.promise.then((s) => s.warnings, () => warnings.length > 0 ? warnings : void 0);
+  return {
+    fullStream: fullStreamBranch,
+    textStream,
+    text: silence(final.promise.then((s) => s.text)),
+    reasoningText: silence(final.promise.then((s) => s.reasoningText)),
+    usage: silence(final.promise.then((s) => s.usage)),
+    totalUsage: silence(final.promise.then((s) => s.usage)),
+    finishReason: silence(final.promise.then((s) => s.finishReason)),
+    toolCalls: silence(final.promise.then((s) => s.toolCalls)),
+    warnings: warningsPromise,
+    response: silence(final.promise.then((s) => s.response)),
+    request: silence(final.promise.then((s) => s.request))
+  };
+}
+function silence(p) {
+  p.catch(() => {
+  });
+  return p;
+}
+function createDeferred() {
+  let resolveFn = () => {
+  };
+  let rejectFn = () => {
+  };
+  const promise = new Promise((res, rej) => {
+    resolveFn = res;
+    rejectFn = rej;
+  });
+  promise.catch(() => {
+  });
+  return {
+    promise,
+    resolve: resolveFn,
+    reject: rejectFn
+  };
+}
+
+// src/uiMessage.ts
+function getUIMessageText(message) {
+  let buf = "";
+  for (const p of message.parts) {
+    if (p.type === "text") {
+      buf += p.text;
+    }
+  }
+  return buf;
+}
+
+// src/internal/uiMessageBridge.ts
+function uiMessagesToModelMessages(ui, system) {
+  const out = [];
+  const transportSystemSet = system != null && system.length > 0;
+  if (transportSystemSet) {
+    out.push({
+      role: "system",
+      content: system
+    });
+  }
+  for (const m of ui) {
+    const text = getUIMessageText(m);
+    if (text.length === 0) {
+      continue;
+    }
+    if (m.role === "system" && transportSystemSet) {
+      continue;
+    }
+    out.push({
+      role: m.role,
+      content: text
+    });
+  }
+  return out;
+}
+
+// src/lmsChatTransport.ts
+var LmsChatTransport = class {
+  constructor(opts) {
+    this.opts = opts;
+  }
+  sendMessages = async (args) => {
+    const result = streamText({
+      model: this.opts.model,
+      // System prompt is folded into the model-message list by the bridge so
+      // it isn't double-prepended (transport.system + system messages from
+      // args.messages would both land otherwise).
+      messages: uiMessagesToModelMessages(args.messages, this.opts.system),
+      temperature: this.opts.temperature,
+      maxOutputTokens: this.opts.maxOutputTokens,
+      topP: this.opts.topP,
+      presencePenalty: this.opts.presencePenalty,
+      frequencyPenalty: this.opts.frequencyPenalty,
+      stopSequences: this.opts.stopSequences,
+      seed: this.opts.seed,
+      headers: mergeHeaders(this.opts.headers, args.headers),
+      abortSignal: args.abortSignal
+    });
+    const assistantId = args.messageId;
+    const textPartId = `${assistantId}-text-0`;
+    const reasoningPartId = `${assistantId}-reasoning-0`;
+    let textOpen = false;
+    let reasoningOpen = false;
+    let startEmitted = false;
+    return result.fullStream.pipeThrough(new TransformStream({
+      transform(chunk, controller) {
+        if (!startEmitted) {
+          startEmitted = true;
+          controller.enqueue({
+            type: "start",
+            messageId: assistantId
+          });
+          controller.enqueue({
+            type: "start-step"
+          });
+        }
+        const closeText = () => {
+          if (textOpen) {
+            textOpen = false;
+            controller.enqueue({
+              type: "text-end",
+              id: textPartId
+            });
+          }
+        };
+        const closeReasoning = () => {
+          if (reasoningOpen) {
+            reasoningOpen = false;
+            controller.enqueue({
+              type: "reasoning-end",
+              id: reasoningPartId
+            });
+          }
+        };
+        switch (chunk.type) {
+          case "text-delta": {
+            if (!textOpen) {
+              textOpen = true;
+              controller.enqueue({
+                type: "text-start",
+                id: textPartId
+              });
+            }
+            controller.enqueue({
+              type: "text-delta",
+              id: textPartId,
+              delta: chunk.delta
+            });
+            return;
+          }
+          case "reasoning-delta": {
+            if (!reasoningOpen) {
+              reasoningOpen = true;
+              controller.enqueue({
+                type: "reasoning-start",
+                id: reasoningPartId
+              });
+            }
+            controller.enqueue({
+              type: "reasoning-delta",
+              id: reasoningPartId,
+              delta: chunk.delta
+            });
+            return;
+          }
+          case "tool-call": {
+            controller.enqueue({
+              type: "tool-input-available",
+              toolCallId: chunk.toolCallId,
+              toolName: chunk.toolName,
+              input: chunk.input
+            });
+            return;
+          }
+          case "finish": {
+            closeText();
+            closeReasoning();
+            controller.enqueue({
+              type: "finish-step"
+            });
+            controller.enqueue({
+              type: "finish",
+              messageMetadata: {
+                finishReason: chunk.finishReason,
+                usage: chunk.usage
+              }
+            });
+            return;
+          }
+          case "error": {
+            closeText();
+            closeReasoning();
+            controller.enqueue({
+              type: "error",
+              errorText: chunk.error.message
+            });
+            return;
+          }
+          default: {
+            const unhandled = chunk;
+            controller.enqueue({
+              type: "error",
+              errorText: `Unhandled chunk type "${unhandled.type}"`
+            });
+          }
+        }
+      }
+    }));
+  };
+  reconnectToStream = async (_args) => {
+    return null;
+  };
+};
+function mergeHeaders(base, override) {
+  if (base == null && override == null) {
+    return void 0;
+  }
+  const out = {
+    ...base ?? {}
+  };
+  if (override != null) {
+    for (const [k, v] of Object.entries(override)) {
+      out[k] = v;
+    }
+  }
+  return out;
+}
+
+// src/internal/ids.ts
+function generateMessageId() {
+  if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") {
+    return crypto.randomUUID();
+  }
+  return `msg-${Math.random().toString(36).slice(2, 10)}-${Date.now()}`;
+}
+
+exports.LmsChatTransport = LmsChatTransport;
+exports.foundryModel = foundryModel;
+exports.generateMessageId = generateMessageId;
+exports.generateText = generateText;
+exports.getUIMessageText = getUIMessageText;
+exports.streamText = streamText;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map