raijin-labs-lucid-ai 0.0.1 → 0.1.2

package/src/lib/security.ts

@@ -0,0 +1,237 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+type OAuth2PasswordFlow = {
+  username: string;
+  password: string;
+  clientID?: string | undefined;
+  clientSecret?: string | undefined;
+  tokenURL: string;
+};
+
+export enum SecurityErrorCode {
+  Incomplete = "incomplete",
+  UnrecognisedSecurityType = "unrecognized_security_type",
+}
+
+export class SecurityError extends Error {
+  constructor(
+    public code: SecurityErrorCode,
+    message: string,
+  ) {
+    super(message);
+    this.name = "SecurityError";
+  }
+
+  static incomplete(): SecurityError {
+    return new SecurityError(
+      SecurityErrorCode.Incomplete,
+      "Security requirements not met in order to perform the operation",
+    );
+  }
+  static unrecognizedType(type: string): SecurityError {
+    return new SecurityError(
+      SecurityErrorCode.UnrecognisedSecurityType,
+      `Unrecognised security type: ${type}`,
+    );
+  }
+}
+
+export type SecurityState = {
+  basic: { username?: string | undefined; password?: string | undefined };
+  headers: Record<string, string>;
+  queryParams: Record<string, string>;
+  cookies: Record<string, string>;
+  oauth2: ({ type: "password" } & OAuth2PasswordFlow) | { type: "none" };
+};
+
+type SecurityInputBasic = {
+  type: "http:basic";
+  value:
+    | { username?: string | undefined; password?: string | undefined }
+    | null
+    | undefined;
+};
+
+type SecurityInputBearer = {
+  type: "http:bearer";
+  value: string | null | undefined;
+  fieldName: string;
+};
+
+type SecurityInputAPIKey = {
+  type: "apiKey:header" | "apiKey:query" | "apiKey:cookie";
+  value: string | null | undefined;
+  fieldName: string;
+};
+
+type SecurityInputOIDC = {
+  type: "openIdConnect";
+  value: string | null | undefined;
+  fieldName: string;
+};
+
+type SecurityInputOAuth2 = {
+  type: "oauth2";
+  value: string | null | undefined;
+  fieldName: string;
+};
+
+type SecurityInputOAuth2ClientCredentials = {
+  type: "oauth2:client_credentials";
+  value:
+    | {
+      clientID?: string | undefined;
+      clientSecret?: string | undefined;
+    }
+    | null
+    | string
+    | undefined;
+  fieldName?: string;
+};
+
+type SecurityInputOAuth2PasswordCredentials = {
+  type: "oauth2:password";
+  value:
+    | string
+    | null
+    | undefined;
+  fieldName?: string;
+};
+
+type SecurityInputCustom = {
+  type: "http:custom";
+  value: any | null | undefined;
+  fieldName?: string;
+};
+
+export type SecurityInput =
+  | SecurityInputBasic
+  | SecurityInputBearer
+  | SecurityInputAPIKey
+  | SecurityInputOAuth2
+  | SecurityInputOAuth2ClientCredentials
+  | SecurityInputOAuth2PasswordCredentials
+  | SecurityInputOIDC
+  | SecurityInputCustom;
+
+export function resolveSecurity(
+  ...options: SecurityInput[][]
+): SecurityState | null {
+  const state: SecurityState = {
+    basic: {},
+    headers: {},
+    queryParams: {},
+    cookies: {},
+    oauth2: { type: "none" },
+  };
+
+  const option = options.find((opts) => {
+    return opts.every((o) => {
+      if (o.value == null) {
+        return false;
+      } else if (o.type === "http:basic") {
+        return o.value.username != null || o.value.password != null;
+      } else if (o.type === "http:custom") {
+        return null;
+      } else if (o.type === "oauth2:password") {
+        return (
+          typeof o.value === "string" && !!o.value
+        );
+      } else if (o.type === "oauth2:client_credentials") {
+        if (typeof o.value == "string") {
+          return !!o.value;
+        }
+        return o.value.clientID != null || o.value.clientSecret != null;
+      } else if (typeof o.value === "string") {
+        return !!o.value;
+      } else {
+        throw new Error(
+          `Unrecognized security type: ${o.type} (value type: ${typeof o
+            .value})`,
+        );
+      }
+    });
+  });
+  if (option == null) {
+    return null;
+  }
+
+  option.forEach((spec) => {
+    if (spec.value == null) {
+      return;
+    }
+
+    const { type } = spec;
+
+    switch (type) {
+      case "apiKey:header":
+        state.headers[spec.fieldName] = spec.value;
+        break;
+      case "apiKey:query":
+        state.queryParams[spec.fieldName] = spec.value;
+        break;
+      case "apiKey:cookie":
+        state.cookies[spec.fieldName] = spec.value;
+        break;
+      case "http:basic":
+        applyBasic(state, spec);
+        break;
+      case "http:custom":
+        break;
+      case "http:bearer":
+        applyBearer(state, spec);
+        break;
+      case "oauth2":
+        applyBearer(state, spec);
+        break;
+      case "oauth2:password":
+        applyBearer(state, spec);
+        break;
+      case "oauth2:client_credentials":
+        break;
+      case "openIdConnect":
+        applyBearer(state, spec);
+        break;
+      default:
+        spec satisfies never;
+        throw SecurityError.unrecognizedType(type);
+    }
+  });
+
+  return state;
+}
+
+function applyBasic(
+  state: SecurityState,
+  spec: SecurityInputBasic,
+) {
+  if (spec.value == null) {
+    return;
+  }
+
+  state.basic = spec.value;
+}
+
+function applyBearer(
+  state: SecurityState,
+  spec:
+    | SecurityInputBearer
+    | SecurityInputOAuth2
+    | SecurityInputOIDC
+    | SecurityInputOAuth2PasswordCredentials,
+) {
+  if (typeof spec.value !== "string" || !spec.value) {
+    return;
+  }
+
+  let value = spec.value;
+  if (value.slice(0, 7).toLowerCase() !== "bearer ") {
+    value = `Bearer ${value}`;
+  }
+
+  if (spec.fieldName !== undefined) {
+    state.headers[spec.fieldName] = value;
+  }
+}

package/src/lib/url.ts

@@ -0,0 +1,33 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+const hasOwn = Object.prototype.hasOwnProperty;
+
+export type Params = Partial<Record<string, string | number>>;
+
+export function pathToFunc(
+  pathPattern: string,
+  options?: { charEncoding?: "percent" | "none" },
+): (params?: Params) => string {
+  const paramRE = /\{([a-zA-Z0-9_][a-zA-Z0-9_-]*?)\}/g;
+
+  return function buildURLPath(params: Record<string, unknown> = {}): string {
+    return pathPattern.replace(paramRE, function (_, placeholder) {
+      if (!hasOwn.call(params, placeholder)) {
+        throw new Error(`Parameter '${placeholder}' is required`);
+      }
+
+      const value = params[placeholder];
+      if (typeof value !== "string" && typeof value !== "number") {
+        throw new Error(
+          `Parameter '${placeholder}' must be a string or number`,
+        );
+      }
+
+      return options?.charEncoding === "percent"
+        ? encodeURIComponent(`${value}`)
+        : `${value}`;
+    });
+  };
+}

package/src/models/chatcompletionrequest.ts

@@ -0,0 +1,84 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v4-mini";
+import { remap as remap$ } from "../lib/primitives.js";
+import { smartUnion } from "../types/smartUnion.js";
+import {
+  ChatMessage,
+  ChatMessage$Outbound,
+  ChatMessage$outboundSchema,
+} from "./chatmessage.js";
+import { Policy, Policy$Outbound, Policy$outboundSchema } from "./policy.js";
+
+export type Stop = string | Array<string>;
+
+export type ChatCompletionRequest = {
+  model: string;
+  messages: Array<ChatMessage>;
+  maxTokens?: number | undefined;
+  temperature?: number | undefined;
+  topP?: number | undefined;
+  stop?: string | Array<string> | undefined;
+  stream?: boolean | undefined;
+  policy?: Policy | undefined;
+  traceId?: string | undefined;
+};
+
+/** @internal */
+export type Stop$Outbound = string | Array<string>;
+
+/** @internal */
+export const Stop$outboundSchema: z.ZodMiniType<Stop$Outbound, Stop> =
+  smartUnion([z.string(), z.array(z.string())]);
+
+export function stopToJSON(stop: Stop): string {
+  return JSON.stringify(Stop$outboundSchema.parse(stop));
+}
+
+/** @internal */
+export type ChatCompletionRequest$Outbound = {
+  model: string;
+  messages: Array<ChatMessage$Outbound>;
+  max_tokens?: number | undefined;
+  temperature?: number | undefined;
+  top_p?: number | undefined;
+  stop?: string | Array<string> | undefined;
+  stream?: boolean | undefined;
+  policy?: Policy$Outbound | undefined;
+  trace_id?: string | undefined;
+};
+
+/** @internal */
+export const ChatCompletionRequest$outboundSchema: z.ZodMiniType<
+  ChatCompletionRequest$Outbound,
+  ChatCompletionRequest
+> = z.pipe(
+  z.object({
+    model: z.string(),
+    messages: z.array(ChatMessage$outboundSchema),
+    maxTokens: z.optional(z.int()),
+    temperature: z.optional(z.number()),
+    topP: z.optional(z.number()),
+    stop: z.optional(smartUnion([z.string(), z.array(z.string())])),
+    stream: z.optional(z.boolean()),
+    policy: z.optional(Policy$outboundSchema),
+    traceId: z.optional(z.string()),
+  }),
+  z.transform((v) => {
+    return remap$(v, {
+      maxTokens: "max_tokens",
+      topP: "top_p",
+      traceId: "trace_id",
+    });
+  }),
+);
+
+export function chatCompletionRequestToJSON(
+  chatCompletionRequest: ChatCompletionRequest,
+): string {
+  return JSON.stringify(
+    ChatCompletionRequest$outboundSchema.parse(chatCompletionRequest),
+  );
+}

package/src/models/chatcompletionresponse.ts

@@ -0,0 +1,105 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v4-mini";
+import { remap as remap$ } from "../lib/primitives.js";
+import { safeParse } from "../lib/schemas.js";
+import { Result as SafeParseResult } from "../types/fp.js";
+import * as types from "../types/primitives.js";
+import { ChatMessage, ChatMessage$inboundSchema } from "./chatmessage.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+
+export type Choice = {
+  index?: number | undefined;
+  message?: ChatMessage | undefined;
+  finishReason?: string | null | undefined;
+};
+
+export type Usage = {
+  promptTokens: number;
+  completionTokens: number;
+  totalTokens: number;
+};
+
+export type ChatCompletionResponse = {
+  id: string;
+  object: string;
+  created: number;
+  model: string;
+  choices: Array<Choice>;
+  usage: Usage;
+};
+
+/** @internal */
+export const Choice$inboundSchema: z.ZodMiniType<Choice, unknown> = z.pipe(
+  z.object({
+    index: types.optional(types.number()),
+    message: types.optional(ChatMessage$inboundSchema),
+    finish_reason: z.optional(z.nullable(types.string())),
+  }),
+  z.transform((v) => {
+    return remap$(v, {
+      "finish_reason": "finishReason",
+    });
+  }),
+);
+
+export function choiceFromJSON(
+  jsonString: string,
+): SafeParseResult<Choice, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Choice$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Choice' from JSON`,
+  );
+}
+
+/** @internal */
+export const Usage$inboundSchema: z.ZodMiniType<Usage, unknown> = z.pipe(
+  z.object({
+    prompt_tokens: types.number(),
+    completion_tokens: types.number(),
+    total_tokens: types.number(),
+  }),
+  z.transform((v) => {
+    return remap$(v, {
+      "prompt_tokens": "promptTokens",
+      "completion_tokens": "completionTokens",
+      "total_tokens": "totalTokens",
+    });
+  }),
+);
+
+export function usageFromJSON(
+  jsonString: string,
+): SafeParseResult<Usage, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Usage$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Usage' from JSON`,
+  );
+}
+
+/** @internal */
+export const ChatCompletionResponse$inboundSchema: z.ZodMiniType<
+  ChatCompletionResponse,
+  unknown
+> = z.object({
+  id: types.string(),
+  object: types.string(),
+  created: types.number(),
+  model: types.string(),
+  choices: z.array(z.lazy(() => Choice$inboundSchema)),
+  usage: z.lazy(() => Usage$inboundSchema),
+});
+
+export function chatCompletionResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<ChatCompletionResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ChatCompletionResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ChatCompletionResponse' from JSON`,
+  );
+}

package/src/models/chatmessage.ts

@@ -0,0 +1,127 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v4-mini";
+import { remap as remap$ } from "../lib/primitives.js";
+import { safeParse } from "../lib/schemas.js";
+import * as openEnums from "../types/enums.js";
+import { OpenEnum } from "../types/enums.js";
+import { Result as SafeParseResult } from "../types/fp.js";
+import * as types from "../types/primitives.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+
+export const Role = {
+  System: "system",
+  User: "user",
+  Assistant: "assistant",
+  Function: "function",
+} as const;
+export type Role = OpenEnum<typeof Role>;
+
+export type FunctionCall = {
+  name?: string | undefined;
+  arguments?: string | undefined;
+};
+
+export type ChatMessage = {
+  role: Role;
+  content: string;
+  name?: string | undefined;
+  functionCall?: FunctionCall | undefined;
+};
+
+/** @internal */
+export const Role$inboundSchema: z.ZodMiniType<Role, unknown> = openEnums
+  .inboundSchema(Role);
+/** @internal */
+export const Role$outboundSchema: z.ZodMiniType<string, Role> = openEnums
+  .outboundSchema(Role);
+
+/** @internal */
+export const FunctionCall$inboundSchema: z.ZodMiniType<FunctionCall, unknown> =
+  z.object({
+    name: types.optional(types.string()),
+    arguments: types.optional(types.string()),
+  });
+/** @internal */
+export type FunctionCall$Outbound = {
+  name?: string | undefined;
+  arguments?: string | undefined;
+};
+
+/** @internal */
+export const FunctionCall$outboundSchema: z.ZodMiniType<
+  FunctionCall$Outbound,
+  FunctionCall
+> = z.object({
+  name: z.optional(z.string()),
+  arguments: z.optional(z.string()),
+});
+
+export function functionCallToJSON(functionCall: FunctionCall): string {
+  return JSON.stringify(FunctionCall$outboundSchema.parse(functionCall));
+}
+export function functionCallFromJSON(
+  jsonString: string,
+): SafeParseResult<FunctionCall, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => FunctionCall$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'FunctionCall' from JSON`,
+  );
+}
+
+/** @internal */
+export const ChatMessage$inboundSchema: z.ZodMiniType<ChatMessage, unknown> = z
+  .pipe(
+    z.object({
+      role: Role$inboundSchema,
+      content: types.string(),
+      name: types.optional(types.string()),
+      function_call: types.optional(z.lazy(() => FunctionCall$inboundSchema)),
+    }),
+    z.transform((v) => {
+      return remap$(v, {
+        "function_call": "functionCall",
+      });
+    }),
+  );
+/** @internal */
+export type ChatMessage$Outbound = {
+  role: string;
+  content: string;
+  name?: string | undefined;
+  function_call?: FunctionCall$Outbound | undefined;
+};
+
+/** @internal */
+export const ChatMessage$outboundSchema: z.ZodMiniType<
+  ChatMessage$Outbound,
+  ChatMessage
+> = z.pipe(
+  z.object({
+    role: Role$outboundSchema,
+    content: z.string(),
+    name: z.optional(z.string()),
+    functionCall: z.optional(z.lazy(() => FunctionCall$outboundSchema)),
+  }),
+  z.transform((v) => {
+    return remap$(v, {
+      functionCall: "function_call",
+    });
+  }),
+);
+
+export function chatMessageToJSON(chatMessage: ChatMessage): string {
+  return JSON.stringify(ChatMessage$outboundSchema.parse(chatMessage));
+}
+export function chatMessageFromJSON(
+  jsonString: string,
+): SafeParseResult<ChatMessage, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ChatMessage$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ChatMessage' from JSON`,
+  );
+}

package/src/models/computeheartbeat.ts

@@ -0,0 +1,66 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v4-mini";
+import { remap as remap$ } from "../lib/primitives.js";
+import { ClosedEnum } from "../types/enums.js";
+
+export const ComputeHeartbeatStatus = {
+  Healthy: "healthy",
+  Degraded: "degraded",
+  Down: "down",
+} as const;
+export type ComputeHeartbeatStatus = ClosedEnum<typeof ComputeHeartbeatStatus>;
+
+export type ComputeHeartbeat = {
+  computePassportId: string;
+  status: ComputeHeartbeatStatus;
+  queueDepth?: number | undefined;
+  pricePer1kTokensEstimate?: number | undefined;
+  p95MsEstimate?: number | undefined;
+};
+
+/** @internal */
+export const ComputeHeartbeatStatus$outboundSchema: z.ZodMiniEnum<
+  typeof ComputeHeartbeatStatus
+> = z.enum(ComputeHeartbeatStatus);
+
+/** @internal */
+export type ComputeHeartbeat$Outbound = {
+  compute_passport_id: string;
+  status: string;
+  queue_depth?: number | undefined;
+  price_per_1k_tokens_estimate?: number | undefined;
+  p95_ms_estimate?: number | undefined;
+};
+
+/** @internal */
+export const ComputeHeartbeat$outboundSchema: z.ZodMiniType<
+  ComputeHeartbeat$Outbound,
+  ComputeHeartbeat
+> = z.pipe(
+  z.object({
+    computePassportId: z.string(),
+    status: ComputeHeartbeatStatus$outboundSchema,
+    queueDepth: z.optional(z.int()),
+    pricePer1kTokensEstimate: z.optional(z.number()),
+    p95MsEstimate: z.optional(z.number()),
+  }),
+  z.transform((v) => {
+    return remap$(v, {
+      computePassportId: "compute_passport_id",
+      queueDepth: "queue_depth",
+      pricePer1kTokensEstimate: "price_per_1k_tokens_estimate",
+      p95MsEstimate: "p95_ms_estimate",
+    });
+  }),
+);
+
+export function computeHeartbeatToJSON(
+  computeHeartbeat: ComputeHeartbeat,
+): string {
+  return JSON.stringify(
+    ComputeHeartbeat$outboundSchema.parse(computeHeartbeat),
+  );
+}

package/src/models/createpassportrequest.ts

@@ -0,0 +1,49 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v4-mini";
+import { PassportType, PassportType$outboundSchema } from "./passporttype.js";
+
+export type CreatePassportRequest = {
+  type: PassportType;
+  owner: string;
+  metadata: { [k: string]: any };
+  name?: string | undefined;
+  description?: string | undefined;
+  version?: string | undefined;
+  tags?: Array<string> | undefined;
+};
+
+/** @internal */
+export type CreatePassportRequest$Outbound = {
+  type: string;
+  owner: string;
+  metadata: { [k: string]: any };
+  name?: string | undefined;
+  description?: string | undefined;
+  version?: string | undefined;
+  tags?: Array<string> | undefined;
+};
+
+/** @internal */
+export const CreatePassportRequest$outboundSchema: z.ZodMiniType<
+  CreatePassportRequest$Outbound,
+  CreatePassportRequest
+> = z.object({
+  type: PassportType$outboundSchema,
+  owner: z.string(),
+  metadata: z.record(z.string(), z.any()),
+  name: z.optional(z.string()),
+  description: z.optional(z.string()),
+  version: z.optional(z.string()),
+  tags: z.optional(z.array(z.string())),
+});
+
+export function createPassportRequestToJSON(
+  createPassportRequest: CreatePassportRequest,
+): string {
+  return JSON.stringify(
+    CreatePassportRequest$outboundSchema.parse(createPassportRequest),
+  );
+}