@providerprotocol/ai 0.0.33 → 0.0.35

package/dist/cerebras/index.js

@@ -0,0 +1,648 @@
+import {
+  parseSSEStream
+} from "../chunk-PMK5LZ5Z.js";
+import {
+  parseJsonResponse
+} from "../chunk-A2IM7PGT.js";
+import {
+  resolveApiKey
+} from "../chunk-ARVM24K2.js";
+import {
+  createProvider
+} from "../chunk-JA3UZALR.js";
+import {
+  AssistantMessage,
+  generateId,
+  isAssistantMessage,
+  isToolResultMessage,
+  isUserMessage
+} from "../chunk-BRP5XJ6Q.js";
+import {
+  doFetch,
+  doStreamFetch,
+  normalizeHttpError,
+  toError
+} from "../chunk-AY55T37A.js";
+import {
+  ErrorCode,
+  ModalityType,
+  UPPError
+} from "../chunk-COS4ON4G.js";
+import {
+  StreamEventType,
+  objectDelta
+} from "../chunk-6S222DHN.js";
+
+// src/providers/cerebras/transform.ts
+function normalizeSystem(system) {
+  if (system === void 0 || system === null) return void 0;
+  if (typeof system === "string") return system;
+  if (!Array.isArray(system)) {
+    throw new UPPError(
+      "System prompt must be a string or an array of text blocks",
+      ErrorCode.InvalidRequest,
+      "cerebras",
+      ModalityType.LLM
+    );
+  }
+  const texts = [];
+  for (const block of system) {
+    if (!block || typeof block !== "object" || !("text" in block)) {
+      throw new UPPError(
+        "System prompt array must contain objects with a text field",
+        ErrorCode.InvalidRequest,
+        "cerebras",
+        ModalityType.LLM
+      );
+    }
+    const textValue = block.text;
+    if (typeof textValue !== "string") {
+      throw new UPPError(
+        "System prompt text must be a string",
+        ErrorCode.InvalidRequest,
+        "cerebras",
+        ModalityType.LLM
+      );
+    }
+    if (textValue.length > 0) {
+      texts.push(textValue);
+    }
+  }
+  return texts.length > 0 ? texts.join("\n\n") : void 0;
+}
+function filterValidContent(content) {
+  return content.filter((c) => c && typeof c.type === "string");
+}
+function transformContentBlock(block) {
+  switch (block.type) {
+    case "text":
+      return { type: "text", text: block.text };
+    case "image":
+      throw new UPPError(
+        "Cerebras does not support image input",
+        ErrorCode.InvalidRequest,
+        "cerebras",
+        ModalityType.LLM
+      );
+    case "document":
+      throw new UPPError(
+        "Cerebras does not support document input",
+        ErrorCode.InvalidRequest,
+        "cerebras",
+        ModalityType.LLM
+      );
+    default:
+      throw new UPPError(
+        `Unsupported content type: ${block.type}`,
+        ErrorCode.InvalidRequest,
+        "cerebras",
+        ModalityType.LLM
+      );
+  }
+}
+function transformMessage(message) {
+  if (isUserMessage(message)) {
+    const validContent = filterValidContent(message.content);
+    if (validContent.length === 1 && validContent[0]?.type === "text") {
+      return {
+        role: "user",
+        content: validContent[0].text
+      };
+    }
+    return {
+      role: "user",
+      content: validContent.map(transformContentBlock)
+    };
+  }
+  if (isAssistantMessage(message)) {
+    const validContent = filterValidContent(message.content);
+    const textContent = validContent.filter((c) => c.type === "text").map((c) => c.text).join("");
+    const assistantMessage = {
+      role: "assistant",
+      content: textContent || null
+    };
+    if (message.toolCalls && message.toolCalls.length > 0) {
+      assistantMessage.tool_calls = message.toolCalls.map((call) => ({
+        id: call.toolCallId,
+        type: "function",
+        function: {
+          name: call.toolName,
+          arguments: JSON.stringify(call.arguments)
+        }
+      }));
+    }
+    return assistantMessage;
+  }
+  if (isToolResultMessage(message)) {
+    const results = message.results.map((result) => ({
+      role: "tool",
+      tool_call_id: result.toolCallId,
+      content: typeof result.result === "string" ? result.result : JSON.stringify(result.result)
+    }));
+    return results[0] ?? null;
+  }
+  return null;
+}
+function transformToolResults(message) {
+  if (!isToolResultMessage(message)) {
+    const single = transformMessage(message);
+    return single ? [single] : [];
+  }
+  return message.results.map((result) => ({
+    role: "tool",
+    tool_call_id: result.toolCallId,
+    content: typeof result.result === "string" ? result.result : JSON.stringify(result.result)
+  }));
+}
+function transformMessages(messages, system) {
+  const result = [];
+  const normalizedSystem = normalizeSystem(system);
+  if (normalizedSystem) {
+    result.push({
+      role: "system",
+      content: normalizedSystem
+    });
+  }
+  for (const message of messages) {
+    if (isToolResultMessage(message)) {
+      const toolMessages = transformToolResults(message);
+      result.push(...toolMessages);
+    } else {
+      const transformed = transformMessage(message);
+      if (transformed) {
+        result.push(transformed);
+      }
+    }
+  }
+  return result;
+}
+function extractToolOptions(tool) {
+  const cerebrasMeta = tool.metadata?.cerebras;
+  return { strict: cerebrasMeta?.strict };
+}
+function transformTool(tool) {
+  const { strict } = extractToolOptions(tool);
+  return {
+    type: "function",
+    function: {
+      name: tool.name,
+      description: tool.description,
+      parameters: {
+        type: "object",
+        properties: tool.parameters.properties,
+        required: tool.parameters.required,
+        ...tool.parameters.additionalProperties !== void 0 ? { additionalProperties: tool.parameters.additionalProperties } : {}
+      },
+      ...strict !== void 0 ? { strict } : {}
+    }
+  };
+}
+function transformRequest(request, modelId) {
+  const params = request.params ?? {};
+  const cerebrasRequest = {
+    ...params,
+    model: modelId,
+    messages: transformMessages(request.messages, request.system)
+  };
+  if (request.tools && request.tools.length > 0) {
+    cerebrasRequest.tools = request.tools.map(transformTool);
+  }
+  if (request.structure) {
+    const schema = {
+      type: "object",
+      properties: request.structure.properties,
+      required: request.structure.required,
+      ...request.structure.additionalProperties !== void 0 ? { additionalProperties: request.structure.additionalProperties } : { additionalProperties: false }
+    };
+    if (request.structure.description) {
+      schema.description = request.structure.description;
+    }
+    cerebrasRequest.response_format = {
+      type: "json_schema",
+      json_schema: {
+        name: "json_response",
+        description: request.structure.description,
+        schema,
+        strict: true
+      }
+    };
+  }
+  return cerebrasRequest;
+}
+function transformResponse(data) {
+  const choice = data.choices[0];
+  if (!choice) {
+    throw new UPPError(
+      "No choices in Cerebras response",
+      ErrorCode.InvalidResponse,
+      "cerebras",
+      ModalityType.LLM
+    );
+  }
+  const textContent = [];
+  let structuredData;
+  if (choice.message.content) {
+    textContent.push({ type: "text", text: choice.message.content });
+    try {
+      structuredData = JSON.parse(choice.message.content);
+    } catch {
+    }
+  }
+  const toolCalls = [];
+  if (choice.message.tool_calls) {
+    for (const call of choice.message.tool_calls) {
+      let args = {};
+      try {
+        args = JSON.parse(call.function.arguments);
+      } catch {
+      }
+      toolCalls.push({
+        toolCallId: call.id,
+        toolName: call.function.name,
+        arguments: args
+      });
+    }
+  }
+  const message = new AssistantMessage(
+    textContent,
+    toolCalls.length > 0 ? toolCalls : void 0,
+    {
+      id: data.id || generateId(),
+      metadata: {
+        cerebras: {
+          model: data.model,
+          finish_reason: choice.finish_reason,
+          system_fingerprint: data.system_fingerprint,
+          reasoning: choice.message.reasoning,
+          time_info: data.time_info
+        }
+      }
+    }
+  );
+  const usage = {
+    inputTokens: data.usage.prompt_tokens,
+    outputTokens: data.usage.completion_tokens,
+    totalTokens: data.usage.total_tokens,
+    cacheReadTokens: data.usage.prompt_tokens_details?.cached_tokens ?? 0,
+    cacheWriteTokens: 0
+  };
+  let stopReason = "end_turn";
+  switch (choice.finish_reason) {
+    case "stop":
+      stopReason = "end_turn";
+      break;
+    case "length":
+      stopReason = "max_tokens";
+      break;
+    case "tool_calls":
+      stopReason = "tool_use";
+      break;
+    case "content_filter":
+      stopReason = "content_filter";
+      break;
+  }
+  return {
+    message,
+    usage,
+    stopReason,
+    data: structuredData
+  };
+}
+function createStreamState() {
+  return {
+    id: "",
+    model: "",
+    text: "",
+    reasoning: "",
+    toolCalls: /* @__PURE__ */ new Map(),
+    finishReason: null,
+    inputTokens: 0,
+    outputTokens: 0,
+    cacheReadTokens: 0
+  };
+}
+function transformStreamEvent(chunk, state) {
+  const events = [];
+  if (chunk.id && !state.id) {
+    state.id = chunk.id;
+    events.push({ type: StreamEventType.MessageStart, index: 0, delta: {} });
+  }
+  if (chunk.model) {
+    state.model = chunk.model;
+  }
+  const choice = chunk.choices[0];
+  if (choice) {
+    if (choice.delta.content) {
+      state.text += choice.delta.content;
+      events.push({
+        type: StreamEventType.TextDelta,
+        index: 0,
+        delta: { text: choice.delta.content }
+      });
+    }
+    if (choice.delta.reasoning) {
+      state.reasoning += choice.delta.reasoning;
+      events.push({
+        type: StreamEventType.ReasoningDelta,
+        index: 0,
+        delta: { text: choice.delta.reasoning }
+      });
+    }
+    if (choice.delta.tool_calls) {
+      for (const toolCallDelta of choice.delta.tool_calls) {
+        const index = toolCallDelta.index;
+        let toolCall = state.toolCalls.get(index);
+        if (!toolCall) {
+          toolCall = { id: "", name: "", arguments: "" };
+          state.toolCalls.set(index, toolCall);
+        }
+        if (toolCallDelta.id) {
+          toolCall.id = toolCallDelta.id;
+        }
+        if (toolCallDelta.function?.name) {
+          toolCall.name = toolCallDelta.function.name;
+        }
+        if (toolCallDelta.function?.arguments) {
+          toolCall.arguments += toolCallDelta.function.arguments;
+          events.push({
+            type: StreamEventType.ToolCallDelta,
+            index,
+            delta: {
+              toolCallId: toolCall.id,
+              toolName: toolCall.name,
+              argumentsJson: toolCallDelta.function.arguments
+            }
+          });
+        }
+      }
+    }
+    if (choice.finish_reason) {
+      state.finishReason = choice.finish_reason;
+      events.push({ type: StreamEventType.MessageStop, index: 0, delta: {} });
+    }
+  }
+  if (chunk.usage) {
+    state.inputTokens = chunk.usage.prompt_tokens;
+    state.outputTokens = chunk.usage.completion_tokens;
+    state.cacheReadTokens = chunk.usage.prompt_tokens_details?.cached_tokens ?? 0;
+  }
+  if (chunk.time_info) {
+    state.timeInfo = chunk.time_info;
+  }
+  return events;
+}
+function buildResponseFromState(state) {
+  const textContent = [];
+  let structuredData;
+  if (state.text) {
+    textContent.push({ type: "text", text: state.text });
+    try {
+      structuredData = JSON.parse(state.text);
+    } catch {
+    }
+  }
+  const toolCalls = [];
+  for (const [, toolCall] of state.toolCalls) {
+    let args = {};
+    if (toolCall.arguments) {
+      try {
+        args = JSON.parse(toolCall.arguments);
+      } catch {
+      }
+    }
+    toolCalls.push({
+      toolCallId: toolCall.id,
+      toolName: toolCall.name,
+      arguments: args
+    });
+  }
+  const messageId = state.id || generateId();
+  const message = new AssistantMessage(
+    textContent,
+    toolCalls.length > 0 ? toolCalls : void 0,
+    {
+      id: messageId,
+      metadata: {
+        cerebras: {
+          model: state.model,
+          finish_reason: state.finishReason,
+          reasoning: state.reasoning || void 0,
+          time_info: state.timeInfo
+        }
+      }
+    }
+  );
+  const usage = {
+    inputTokens: state.inputTokens,
+    outputTokens: state.outputTokens,
+    totalTokens: state.inputTokens + state.outputTokens,
+    cacheReadTokens: state.cacheReadTokens,
+    cacheWriteTokens: 0
+  };
+  let stopReason = "end_turn";
+  switch (state.finishReason) {
+    case "stop":
+      stopReason = "end_turn";
+      break;
+    case "length":
+      stopReason = "max_tokens";
+      break;
+    case "tool_calls":
+      stopReason = "tool_use";
+      break;
+    case "content_filter":
+      stopReason = "content_filter";
+      break;
+  }
+  return {
+    message,
+    usage,
+    stopReason,
+    data: structuredData
+  };
+}
+
+// src/providers/cerebras/llm.ts
+var CEREBRAS_API_URL = "https://api.cerebras.ai/v1/chat/completions";
+var CEREBRAS_CAPABILITIES = {
+  streaming: true,
+  tools: true,
+  structuredOutput: true,
+  imageInput: false,
+  documentInput: false,
+  videoInput: false,
+  audioInput: false
+};
+function createLLMHandler() {
+  let providerRef = null;
+  return {
+    _setProvider(provider) {
+      providerRef = provider;
+    },
+    bind(modelId) {
+      if (!providerRef) {
+        throw new UPPError(
+          "Provider reference not set. Handler must be used with createProvider() or have _setProvider called.",
+          ErrorCode.InvalidRequest,
+          "cerebras",
+          ModalityType.LLM
+        );
+      }
+      const model = {
+        modelId,
+        capabilities: CEREBRAS_CAPABILITIES,
+        get provider() {
+          return providerRef;
+        },
+        async complete(request) {
+          const apiKey = await resolveApiKey(
+            request.config,
+            "CEREBRAS_API_KEY",
+            "cerebras",
+            "llm"
+          );
+          const baseUrl = request.config.baseUrl ?? CEREBRAS_API_URL;
+          const body = transformRequest(request, modelId);
+          const headers = {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${apiKey}`
+          };
+          if (request.config.headers) {
+            for (const [key, value] of Object.entries(request.config.headers)) {
+              if (value !== void 0) {
+                headers[key] = value;
+              }
+            }
+          }
+          const response = await doFetch(
+            baseUrl,
+            {
+              method: "POST",
+              headers,
+              body: JSON.stringify(body),
+              signal: request.signal
+            },
+            request.config,
+            "cerebras",
+            "llm"
+          );
+          const data = await parseJsonResponse(response, "cerebras", "llm");
+          return transformResponse(data);
+        },
+        stream(request) {
+          const state = createStreamState();
+          let responseResolve;
+          let responseReject;
+          const responsePromise = new Promise((resolve, reject) => {
+            responseResolve = resolve;
+            responseReject = reject;
+          });
+          async function* generateEvents() {
+            try {
+              const apiKey = await resolveApiKey(
+                request.config,
+                "CEREBRAS_API_KEY",
+                "cerebras",
+                "llm"
+              );
+              const baseUrl = request.config.baseUrl ?? CEREBRAS_API_URL;
+              const body = transformRequest(request, modelId);
+              body.stream = true;
+              body.stream_options = { include_usage: true };
+              const headers = {
+                "Content-Type": "application/json",
+                Authorization: `Bearer ${apiKey}`,
+                Accept: "text/event-stream"
+              };
+              if (request.config.headers) {
+                for (const [key, value] of Object.entries(request.config.headers)) {
+                  if (value !== void 0) {
+                    headers[key] = value;
+                  }
+                }
+              }
+              const response = await doStreamFetch(
+                baseUrl,
+                {
+                  method: "POST",
+                  headers,
+                  body: JSON.stringify(body),
+                  signal: request.signal
+                },
+                request.config,
+                "cerebras",
+                "llm"
+              );
+              if (!response.ok) {
+                const error = await normalizeHttpError(response, "cerebras", "llm");
+                responseReject(error);
+                throw error;
+              }
+              if (!response.body) {
+                const error = new UPPError(
+                  "No response body for streaming request",
+                  ErrorCode.ProviderError,
+                  "cerebras",
+                  ModalityType.LLM
+                );
+                responseReject(error);
+                throw error;
+              }
+              for await (const data of parseSSEStream(response.body)) {
+                if (data === "[DONE]") {
+                  continue;
+                }
+                if (typeof data === "object" && data !== null) {
+                  const chunk = data;
+                  if ("error" in chunk && chunk.error) {
+                    const errorData = chunk.error;
+                    const error = new UPPError(
+                      errorData.message ?? "Unknown error",
+                      ErrorCode.ProviderError,
+                      "cerebras",
+                      ModalityType.LLM
+                    );
+                    responseReject(error);
+                    throw error;
+                  }
+                  const uppEvents = transformStreamEvent(chunk, state);
+                  for (const event of uppEvents) {
+                    yield event;
+                    if (request.structure && event.type === StreamEventType.TextDelta) {
+                      yield objectDelta(event.delta.text ?? "", event.index);
+                    }
+                  }
+                }
+              }
+              responseResolve(buildResponseFromState(state));
+            } catch (error) {
+              const err = toError(error);
+              responseReject(err);
+              throw err;
+            }
+          }
+          return {
+            [Symbol.asyncIterator]() {
+              return generateEvents();
+            },
+            response: responsePromise
+          };
+        }
+      };
+      return model;
+    }
+  };
+}
+
+// src/providers/cerebras/index.ts
+var cerebras = createProvider({
+  name: "cerebras",
+  version: "1.0.0",
+  handlers: {
+    llm: createLLMHandler()
+  }
+});
+export {
+  cerebras
+};
+//# sourceMappingURL=index.js.map