@mistralai/mistralai 2.2.5 → 2.2.6

package/src/sdk/traces.ts

@@ -0,0 +1,102 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 4845e9e6a8d1
+ */
+
+import { betaObservabilityTracesFetchOptions } from "../funcs/betaObservabilityTracesFetchOptions.js";
+import { betaObservabilityTracesGetSpanById } from "../funcs/betaObservabilityTracesGetSpanById.js";
+import { betaObservabilityTracesGetTraceById } from "../funcs/betaObservabilityTracesGetTraceById.js";
+import { betaObservabilityTracesGetTraceFields } from "../funcs/betaObservabilityTracesGetTraceFields.js";
+import { betaObservabilityTracesGetTraceSpans } from "../funcs/betaObservabilityTracesGetTraceSpans.js";
+import { betaObservabilityTracesSearch } from "../funcs/betaObservabilityTracesSearch.js";
+import { ClientSDK, RequestOptions } from "../lib/sdks.js";
+import * as components from "../models/components/index.js";
+import * as operations from "../models/operations/index.js";
+import { unwrapAsync } from "../types/fp.js";
+
+export class Traces extends ClientSDK {
+  /**
+   * Search traces
+   */
+  async search(
+    request: operations.SearchTracesV1ObservabilityTracesSearchPostRequest,
+    options?: RequestOptions,
+  ): Promise<components.GetTraces> {
+    return unwrapAsync(betaObservabilityTracesSearch(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Get trace field definitions
+   */
+  async getTraceFields(
+    options?: RequestOptions,
+  ): Promise<components.GetTraceFields> {
+    return unwrapAsync(betaObservabilityTracesGetTraceFields(
+      this,
+      options,
+    ));
+  }
+
+  /**
+   * Get trace by id
+   */
+  async getTraceById(
+    request: operations.GetTraceByIdV1ObservabilityTracesTraceIdGetRequest,
+    options?: RequestOptions,
+  ): Promise<components.GetTrace> {
+    return unwrapAsync(betaObservabilityTracesGetTraceById(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Get trace spans
+   */
+  async getTraceSpans(
+    request:
+      operations.GetTraceSpansV1ObservabilityTracesTraceIdSpansGetRequest,
+    options?: RequestOptions,
+  ): Promise<components.GetSpans> {
+    return unwrapAsync(betaObservabilityTracesGetTraceSpans(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Get options for a trace field
+   */
+  async fetchOptions(
+    request:
+      operations.GetTraceFieldOptionsV1ObservabilityTracesFieldsFieldNameOptionsGetRequest,
+    options?: RequestOptions,
+  ): Promise<components.GetTraceFieldOptions> {
+    return unwrapAsync(betaObservabilityTracesFetchOptions(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Get span by id
+   */
+  async getSpanById(
+    request:
+      operations.GetSpanByIdV1ObservabilityTracesTraceIdSpansSpanIdGetRequest,
+    options?: RequestOptions,
+  ): Promise<components.GetSpan> {
+    return unwrapAsync(betaObservabilityTracesGetSpanById(
+      this,
+      request,
+      options,
+    ));
+  }
+}

package/tests/extra/observability/customProvider.test.ts

@@ -0,0 +1,98 @@
+import type { Tracer, TracerProvider } from "@opentelemetry/api";
+import { trace } from "@opentelemetry/api";
+import {
+  getOrCreateOtelTracer,
+  registerTracerProvider,
+} from "../../../src/extra/observability/otel.js";
+import {
+  TracingHook,
+  type TracingContext,
+  TRACING_TRACER_KEY,
+} from "../../../src/hooks/tracing.js";
+import { createMockTracer } from "./helpers.js";
+
+function createMockTracerProvider(tracer: Tracer): TracerProvider {
+  return { getTracer: () => tracer } as TracerProvider;
+}
+
+function createChatRequest(): Request {
+  return new Request("https://api.mistral.ai/v1/chat/completions", {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({
+      model: "mistral-large",
+      messages: [{ role: "user", content: "Hello" }],
+    }),
+  });
+}
+
+function createHookContext(): TracingContext {
+  return {
+    operationID: "chat_completion_v1",
+    baseURL: "https://api.mistral.ai",
+    oAuth2Scopes: null,
+    retryConfig: { strategy: "none" as const },
+    resolvedSecurity: null,
+    options: {},
+  } as TracingContext;
+}
+
+afterEach(() => {
+  registerTracerProvider();
+});
+
+describe("getOrCreateOtelTracer", () => {
+  test("uses global provider when no provider is registered", () => {
+    const globalTracer = createMockTracer("global");
+    const spy = vi
+      .spyOn(trace, "getTracerProvider")
+      .mockReturnValue(createMockTracerProvider(globalTracer));
+
+    const tracer = getOrCreateOtelTracer();
+
+    expect(spy).toHaveBeenCalled();
+    expect((tracer as any).label).toBe("global");
+    spy.mockRestore();
+  });
+
+  test("uses registered provider before the global provider", () => {
+    const registeredTracer = createMockTracer("registered");
+    const spy = vi.spyOn(trace, "getTracerProvider");
+
+    registerTracerProvider(createMockTracerProvider(registeredTracer));
+    const tracer = getOrCreateOtelTracer();
+
+    expect(spy).not.toHaveBeenCalled();
+    expect((tracer as any).label).toBe("registered");
+    spy.mockRestore();
+  });
+});
+
+describe("TracingHook with registered TracerProvider", () => {
+  test("beforeRequest uses registered tracerProvider", async () => {
+    const hook = new TracingHook();
+    const registeredTracer = createMockTracer("registered");
+    const ctx = createHookContext();
+
+    registerTracerProvider(createMockTracerProvider(registeredTracer));
+
+    await hook.beforeRequest(ctx, createChatRequest());
+
+    expect((ctx[TRACING_TRACER_KEY] as any).label).toBe("registered");
+  });
+
+  test("beforeRequest falls back to global provider when no provider is registered", async () => {
+    const hook = new TracingHook();
+    const globalTracer = createMockTracer("global");
+    const spy = vi
+      .spyOn(trace, "getTracerProvider")
+      .mockReturnValue(createMockTracerProvider(globalTracer));
+
+    const ctx = createHookContext();
+    await hook.beforeRequest(ctx, createChatRequest());
+
+    expect(spy).toHaveBeenCalled();
+    expect((ctx[TRACING_TRACER_KEY] as any).label).toBe("global");
+    spy.mockRestore();
+  });
+});

package/tests/extra/observability/formatting.test.ts

@@ -0,0 +1,111 @@
+/**
+ * Unit tests for OTEL formatting helpers.
+ */
+
+import {
+  formatInputMessage,
+  formatOutputMessage,
+  formatToolDefinition,
+} from "../../../src/extra/observability/formatting.js";
+
+describe("formatInputMessage", () => {
+  test("user message with text content", () => {
+    const result = formatInputMessage({ role: "user", content: "hello" });
+    expect(result).toEqual({
+      role: "user",
+      parts: [{ type: "text", content: "hello" }],
+    });
+  });
+
+  test("assistant message with tool calls", () => {
+    const msg = {
+      role: "assistant",
+      content: "",
+      tool_calls: [{ id: "tc1", function: { name: "get_weather", arguments: '{"city":"Paris"}' } }],
+    };
+    const result = formatInputMessage(msg);
+    expect(result.role).toBe("assistant");
+    expect(result.parts).toContainEqual({
+      type: "tool_call",
+      name: "get_weather",
+      id: "tc1",
+      arguments: '{"city":"Paris"}',
+    });
+  });
+
+  test("tool message", () => {
+    const result = formatInputMessage({ role: "tool", content: "sunny", tool_call_id: "tc1" });
+    expect(result).toEqual({
+      role: "tool",
+      parts: [{ type: "tool_call_response", response: "sunny", id: "tc1" }],
+    });
+  });
+
+  test("function.result entry (conversations API)", () => {
+    const msg = { type: "function.result", result: '{"status":"ok"}', tool_call_id: "tc1" };
+    const result = formatInputMessage(msg);
+    expect(result).toEqual({
+      role: "tool",
+      parts: [{ type: "tool_call_response", response: '{"status":"ok"}', id: "tc1" }],
+    });
+  });
+
+  test("thinking chunk converts to reasoning", () => {
+    const content = [{ type: "thinking", thinking: [{ type: "text", text: "step 1" }] }];
+    const result = formatInputMessage({ role: "assistant", content });
+    expect(result.parts).toEqual([{ type: "reasoning", content: "step 1" }]);
+  });
+
+  test("image_url chunk", () => {
+    const content = [{ type: "image_url", image_url: { url: "https://example.com/img.png" } }];
+    const result = formatInputMessage({ role: "user", content });
+    expect(result.parts).toEqual([{ type: "uri", modality: "image", uri: "https://example.com/img.png" }]);
+  });
+});
+
+describe("formatOutputMessage", () => {
+  test("simple response", () => {
+    const choice = { message: { role: "assistant", content: "hello" }, finish_reason: "stop" };
+    const result = formatOutputMessage(choice);
+    expect(result).toEqual({
+      role: "assistant",
+      parts: [{ type: "text", content: "hello" }],
+      finish_reason: "stop",
+    });
+  });
+
+  test("tool calls response", () => {
+    const choice = {
+      message: {
+        role: "assistant",
+        content: null,
+        tool_calls: [{ id: "tc1", function: { name: "f", arguments: "{}" } }],
+      },
+      finish_reason: "tool_calls",
+    };
+    const result = formatOutputMessage(choice);
+    expect(result.finish_reason).toBe("tool_calls");
+    expect((result.parts as Array<Record<string, unknown>>)[0].type).toBe("tool_call");
+  });
+});
+
+describe("formatToolDefinition", () => {
+  test("full definition", () => {
+    const tool = {
+      type: "function",
+      function: { name: "get_weather", description: "Get weather", parameters: { type: "object" } },
+    };
+    const result = formatToolDefinition(tool);
+    expect(result).toEqual({
+      type: "function",
+      name: "get_weather",
+      description: "Get weather",
+      parameters: { type: "object" },
+    });
+  });
+
+  test("returns null when no function name", () => {
+    expect(formatToolDefinition({ type: "function" })).toBeNull();
+    expect(formatToolDefinition({ function: {} })).toBeNull();
+  });
+});

package/tests/extra/observability/helpers.ts

@@ -0,0 +1,62 @@
+import type { Span, Tracer } from "@opentelemetry/api";
+
+export type MockSpan = Span & {
+  attributes: Record<string, unknown>;
+  ended: boolean;
+  events: Array<{ name: string; attributes?: Record<string, unknown> }>;
+  name: string;
+  status?: unknown;
+};
+
+export type MockTracer = Tracer & {
+  label?: string;
+  spans: Array<{ name: string }>;
+};
+
+export function createMockSpan(name = "test"): MockSpan {
+  const attributes: Record<string, unknown> = {};
+  const events: Array<{ name: string; attributes?: Record<string, unknown> }> = [];
+  let spanName = name;
+  const span: MockSpan = {
+    attributes,
+    ended: false,
+    events,
+    get name() { return spanName; },
+    set name(n: string) { spanName = n; },
+    setAttributes(attrs) { Object.assign(attributes, attrs); return span; },
+    setAttribute(k, v) { attributes[k] = v; return span; },
+    updateName(n) { spanName = n; return span; },
+    spanContext: () => ({ traceId: "", spanId: "", traceFlags: 0 }),
+    setStatus(status) { span.status = status; return span; },
+    recordException: () => {},
+    addEvent(name, attrs) {
+      const event: { name: string; attributes?: Record<string, unknown> } = { name };
+      if (attrs) {
+        event.attributes = attrs as Record<string, unknown>;
+      }
+      events.push(event);
+      return span;
+    },
+    end: () => { span.ended = true; },
+    isRecording: () => true,
+    addLink: () => span,
+    addLinks: () => span,
+  } as MockSpan;
+  return span;
+}
+
+export function createMockTracer(label?: string): MockTracer {
+  const spans: Array<{ name: string }> = [];
+  const tracer = {
+    spans,
+    startSpan(name: string) {
+      spans.push({ name });
+      return createMockSpan(name);
+    },
+    startActiveSpan: () => undefined as never,
+  } as MockTracer;
+  if (label) {
+    tracer.label = label;
+  }
+  return tracer;
+}