insforge 1.3.0 → 1.4.8

package/shared-schemas/src/ai-api.schema.ts

@@ -1,143 +1,251 @@
-import { z } from 'zod';
-import { aiConfigurationSchema, aiUsageRecordSchema, modalitySchema } from './ai.schema';
-
-// ============= Chat Completion Schemas =============
-
-// OpenAI-compatible content schemas
-export const textContentSchema = z.object({
-  type: z.literal('text'),
-  text: z.string(),
-});
-
-export const imageContentSchema = z.object({
-  type: z.literal('image_url'),
-  // eslint-disable-next-line @typescript-eslint/naming-convention
-  image_url: z.object({
-    // URL can be either a public URL or base64-encoded data URI
-    // Examples:
-    // - Public URL: "https://example.com/image.jpg"
-    // - Base64: "data:image/jpeg;base64,/9j/4AAQ..."
-    url: z.string(),
-    detail: z.enum(['auto', 'low', 'high']).optional(),
-  }),
-});
-
-export const contentSchema = z.union([textContentSchema, imageContentSchema]);
-
-// Chat message supports both OpenAI format and legacy format for backward compatibility
-export const chatMessageSchema = z.object({
-  role: z.enum(['user', 'assistant', 'system']),
-  // New format: content can be string or array of content parts (OpenAI-compatible)
-  content: z.union([z.string(), z.array(contentSchema)]),
-  // Legacy format: separate images field (deprecated but supported for backward compatibility)
-  images: z.array(z.object({ url: z.string() })).optional(),
-});
-
-export const chatCompletionRequestSchema = z.object({
-  model: z.string(),
-  messages: z.array(chatMessageSchema),
-  temperature: z.number().min(0).max(2).optional(),
-  maxTokens: z.number().positive().optional(),
-  topP: z.number().min(0).max(1).optional(),
-  stream: z.boolean().optional(),
-});
-
-export const chatCompletionResponseSchema = z.object({
-  text: z.string(),
-  metadata: z
-    .object({
-      model: z.string(),
-      usage: z
-        .object({
-          promptTokens: z.number().optional(),
-          completionTokens: z.number().optional(),
-          totalTokens: z.number().optional(),
-        })
-        .optional(),
-    })
-    .optional(),
-});
-
-// ============= Image Generation Schemas =============
-
-export const imageGenerationRequestSchema = z.object({
-  model: z.string(),
-  prompt: z.string(),
-  images: z
-    .array(
-      z.object({
-        url: z.string(),
-      })
-    )
-    .optional(),
-});
-
-export const imageGenerationResponseSchema = z.object({
-  text: z.string().optional(),
-  images: z.array(
-    z.object({
-      type: z.literal('imageUrl'),
-      imageUrl: z.string(),
-    })
-  ),
-  metadata: z
-    .object({
-      model: z.string(),
-      usage: z
-        .object({
-          promptTokens: z.number().optional(),
-          completionTokens: z.number().optional(),
-          totalTokens: z.number().optional(),
-        })
-        .optional(),
-    })
-    .optional(),
-});
-
-export const aiModelSchema = z.object({
-  id: z.string(),
-  inputModality: z.array(modalitySchema).min(1),
-  outputModality: z.array(modalitySchema).min(1),
-  provider: z.string(),
-  modelId: z.string(),
-  priceLevel: z.number().min(0).max(3).optional(),
-});
-
-export const createAIConfigurationRequestSchema = aiConfigurationSchema.omit({
-  id: true,
-});
-
-export const updateAIConfigurationRequestSchema = z.object({
-  systemPrompt: z.string().nullable(),
-});
-
-export const listAIUsageResponseSchema = z.object({
-  records: z.array(aiUsageRecordSchema),
-  total: z.number(),
-});
-
-export const getAIUsageRequestSchema = z.object({
-  startDate: z.string().datetime().optional(),
-  endDate: z.string().datetime().optional(),
-  limit: z.string().regex(/^\d+$/).default('50'),
-  offset: z.string().regex(/^\d+$/).default('0'),
-});
-
-export const getAIUsageSummaryRequestSchema = z.object({
-  configId: z.string().uuid().optional(),
-  startDate: z.string().datetime().optional(),
-  endDate: z.string().datetime().optional(),
-});
-
-// Export types
-export type ChatMessageSchema = z.infer<typeof chatMessageSchema>;
-export type ChatCompletionRequest = z.infer<typeof chatCompletionRequestSchema>;
-export type ChatCompletionResponse = z.infer<typeof chatCompletionResponseSchema>;
-export type ImageGenerationRequest = z.infer<typeof imageGenerationRequestSchema>;
-export type ImageGenerationResponse = z.infer<typeof imageGenerationResponseSchema>;
-export type AIModelSchema = z.infer<typeof aiModelSchema>;
-export type CreateAIConfigurationRequest = z.infer<typeof createAIConfigurationRequestSchema>;
-export type UpdateAIConfigurationRequest = z.infer<typeof updateAIConfigurationRequestSchema>;
-export type ListAIUsageResponse = z.infer<typeof listAIUsageResponseSchema>;
-export type GetAIUsageRequest = z.infer<typeof getAIUsageRequestSchema>;
-export type GetAIUsageSummaryRequest = z.infer<typeof getAIUsageSummaryRequestSchema>;
+import { z } from 'zod';
+import { aiConfigurationSchema, aiUsageRecordSchema, modalitySchema } from './ai.schema';
+
+// ============= Chat Completion Schemas =============
+
+// OpenAI-compatible content schemas
+export const textContentSchema = z.object({
+  type: z.literal('text'),
+  text: z.string(),
+});
+
+export const imageContentSchema = z.object({
+  type: z.literal('image_url'),
+  // eslint-disable-next-line @typescript-eslint/naming-convention
+  image_url: z.object({
+    // URL can be either a public URL or base64-encoded data URI
+    // Examples:
+    // - Public URL: "https://example.com/image.jpg"
+    // - Base64: "data:image/jpeg;base64,/9j/4AAQ..."
+    url: z.string(),
+    detail: z.enum(['auto', 'low', 'high']).optional(),
+  }),
+});
+
+export const audioContentSchema = z.object({
+  type: z.literal('input_audio'),
+  // eslint-disable-next-line @typescript-eslint/naming-convention
+  input_audio: z.object({
+    // Base64-encoded audio data (direct URLs not supported for audio)
+    data: z.string(),
+    format: z.enum(['wav', 'mp3', 'aiff', 'aac', 'ogg', 'flac', 'm4a']),
+  }),
+});
+
+// File content schema for PDFs and other documents (OpenRouter format)
+export const fileContentSchema = z.object({
+  type: z.literal('file'),
+  file: z.object({
+    // Filename with extension (e.g., "document.pdf")
+    filename: z.string(),
+    // File data can be:
+    // - Public URL: "https://example.com/document.pdf"
+    // - Base64 data URL: "data:application/pdf;base64,..."
+    // eslint-disable-next-line @typescript-eslint/naming-convention
+    file_data: z.string(),
+  }),
+});
+
+export const contentSchema = z.union([
+  textContentSchema,
+  imageContentSchema,
+  audioContentSchema,
+  fileContentSchema,
+]);
+
+// Chat message supports both OpenAI format and legacy format for backward compatibility
+export const chatMessageSchema = z.object({
+  role: z.enum(['user', 'assistant', 'system']),
+  // New format: content can be string or array of content parts (OpenAI-compatible)
+  content: z.union([z.string(), z.array(contentSchema)]),
+  // Legacy format: separate images field (deprecated but supported for backward compatibility)
+  images: z.array(z.object({ url: z.string() })).optional(),
+});
+
+// Web Search Plugin configuration for OpenRouter
+export const webSearchPluginSchema = z.object({
+  enabled: z.boolean(),
+  // Engine selection:
+  // - "native": Always use provider's built-in web search (OpenAI, Anthropic, Perplexity, xAI)
+  // - "exa": Use Exa's search API
+  // - undefined: Auto-select (native if available, otherwise Exa)
+  engine: z.enum(['native', 'exa']).optional(),
+  // Maximum number of search results (1-10, default: 5)
+  maxResults: z.number().min(1).max(10).optional(),
+  // Custom prompt for attaching search results to the message
+  searchPrompt: z.string().optional(),
+});
+
+// File Parser Plugin configuration for OpenRouter PDF processing
+export const fileParserPluginSchema = z.object({
+  enabled: z.boolean(),
+  pdf: z
+    .object({
+      // PDF processing engine:
+      // - "pdf-text": Best for well-structured PDFs with clear text content (Free)
+      // - "mistral-ocr": Best for scanned documents or PDFs with images ($2 per 1,000 pages)
+      // - "native": Only available for models that support file input natively (charged as input tokens)
+      // If not specified, defaults to native if available, otherwise mistral-ocr
+      engine: z.enum(['pdf-text', 'mistral-ocr', 'native']).optional(),
+    })
+    .optional(),
+});
+
+export const chatCompletionRequestSchema = z.object({
+  model: z.string(),
+  messages: z.array(chatMessageSchema),
+  temperature: z.number().min(0).max(2).optional(),
+  maxTokens: z.number().positive().optional(),
+  topP: z.number().min(0).max(1).optional(),
+  stream: z.boolean().optional(),
+  // Web Search: Incorporate relevant web search results into the response
+  // Results are returned in the annotations field
+  webSearch: webSearchPluginSchema.optional(),
+  // File Parser: Configure PDF processing for file content in messages
+  // When files are included in messages, this controls how PDFs are parsed
+  fileParser: fileParserPluginSchema.optional(),
+  // Thinking/Reasoning mode: Enable extended reasoning capabilities
+  // Appends ":thinking" to the model ID for chain-of-thought reasoning
+  thinking: z.boolean().optional(),
+});
+
+// URL citation annotation from web search results
+export const urlCitationAnnotationSchema = z.object({
+  type: z.literal('url_citation'),
+  urlCitation: z.object({
+    url: z.string(),
+    title: z.string().optional(),
+    content: z.string().optional(),
+    // Character indices in the response text where this citation applies
+    startIndex: z.number().optional(),
+    endIndex: z.number().optional(),
+  }),
+});
+
+// File annotation from PDF parsing results
+// Can be passed back in subsequent requests to skip re-parsing costs
+export const fileAnnotationSchema = z.object({
+  type: z.literal('file'),
+  file: z.object({
+    filename: z.string(),
+    // Parsed content from the PDF (used for caching)
+    parsedContent: z.string().optional(),
+    // Additional metadata from the parser
+    metadata: z.record(z.unknown()).optional(),
+  }),
+});
+
+// Combined annotation schema for all annotation types
+export const annotationSchema = z.union([urlCitationAnnotationSchema, fileAnnotationSchema]);
+
+export const chatCompletionResponseSchema = z.object({
+  text: z.string(),
+  // Annotations from web search or file parsing (can be URL citations or file annotations)
+  annotations: z.array(annotationSchema).optional(),
+  metadata: z
+    .object({
+      model: z.string(),
+      usage: z
+        .object({
+          promptTokens: z.number().optional(),
+          completionTokens: z.number().optional(),
+          totalTokens: z.number().optional(),
+        })
+        .optional(),
+    })
+    .optional(),
+});
+
+// ============= Image Generation Schemas =============
+
+export const imageGenerationRequestSchema = z.object({
+  model: z.string(),
+  prompt: z.string(),
+  images: z
+    .array(
+      z.object({
+        url: z.string(),
+      })
+    )
+    .optional(),
+});
+
+export const imageGenerationResponseSchema = z.object({
+  text: z.string().optional(),
+  images: z.array(
+    z.object({
+      type: z.literal('imageUrl'),
+      imageUrl: z.string(),
+    })
+  ),
+  metadata: z
+    .object({
+      model: z.string(),
+      usage: z
+        .object({
+          promptTokens: z.number().optional(),
+          completionTokens: z.number().optional(),
+          totalTokens: z.number().optional(),
+        })
+        .optional(),
+    })
+    .optional(),
+});
+
+export const aiModelSchema = z.object({
+  id: z.string(),
+  inputModality: z.array(modalitySchema).min(1),
+  outputModality: z.array(modalitySchema).min(1),
+  provider: z.string(),
+  modelId: z.string(),
+  priceLevel: z.number().min(0).max(3).optional(),
+});
+
+export const createAIConfigurationRequestSchema = aiConfigurationSchema.omit({
+  id: true,
+});
+
+export const updateAIConfigurationRequestSchema = z.object({
+  systemPrompt: z.string().nullable(),
+});
+
+export const listAIUsageResponseSchema = z.object({
+  records: z.array(aiUsageRecordSchema),
+  total: z.number(),
+});
+
+export const getAIUsageRequestSchema = z.object({
+  startDate: z.string().datetime().optional(),
+  endDate: z.string().datetime().optional(),
+  limit: z.string().regex(/^\d+$/).default('50'),
+  offset: z.string().regex(/^\d+$/).default('0'),
+});
+
+export const getAIUsageSummaryRequestSchema = z.object({
+  configId: z.string().uuid().optional(),
+  startDate: z.string().datetime().optional(),
+  endDate: z.string().datetime().optional(),
+});
+
+// Export types
+export type TextContentSchema = z.infer<typeof textContentSchema>;
+export type ImageContentSchema = z.infer<typeof imageContentSchema>;
+export type AudioContentSchema = z.infer<typeof audioContentSchema>;
+export type FileContentSchema = z.infer<typeof fileContentSchema>;
+export type ContentSchema = z.infer<typeof contentSchema>;
+export type ChatMessageSchema = z.infer<typeof chatMessageSchema>;
+export type WebSearchPlugin = z.infer<typeof webSearchPluginSchema>;
+export type FileParserPlugin = z.infer<typeof fileParserPluginSchema>;
+export type UrlCitationAnnotation = z.infer<typeof urlCitationAnnotationSchema>;
+export type FileAnnotation = z.infer<typeof fileAnnotationSchema>;
+export type Annotation = z.infer<typeof annotationSchema>;
+export type ChatCompletionRequest = z.infer<typeof chatCompletionRequestSchema>;
+export type ChatCompletionResponse = z.infer<typeof chatCompletionResponseSchema>;
+export type ImageGenerationRequest = z.infer<typeof imageGenerationRequestSchema>;
+export type ImageGenerationResponse = z.infer<typeof imageGenerationResponseSchema>;
+export type AIModelSchema = z.infer<typeof aiModelSchema>;
+export type CreateAIConfigurationRequest = z.infer<typeof createAIConfigurationRequestSchema>;
+export type UpdateAIConfigurationRequest = z.infer<typeof updateAIConfigurationRequestSchema>;
+export type ListAIUsageResponse = z.infer<typeof listAIUsageResponseSchema>;
+export type GetAIUsageRequest = z.infer<typeof getAIUsageRequestSchema>;
+export type GetAIUsageSummaryRequest = z.infer<typeof getAIUsageSummaryRequestSchema>;

package/shared-schemas/src/ai.schema.ts

@@ -1,63 +1,63 @@
-import { z } from 'zod';
-
-// Core schemas - only text and image supported currently
-export const modalitySchema = z.enum(['text', 'image']);
-
-export const aiConfigurationInputSchema = z.object({
-  inputModality: z.array(modalitySchema).min(1),
-  outputModality: z.array(modalitySchema).min(1),
-  provider: z.string(),
-  modelId: z.string(),
-  systemPrompt: z.string().optional(),
-});
-
-export const aiConfigurationSchema = aiConfigurationInputSchema.extend({
-  id: z.string().uuid(),
-});
-
-export const aiConfigurationWithUsageSchema = aiConfigurationSchema.extend({
-  usageStats: z
-    .object({
-      totalInputTokens: z.number(),
-      totalOutputTokens: z.number(),
-      totalTokens: z.number(),
-      totalImageCount: z.number(),
-      totalRequests: z.number(),
-    })
-    .optional(),
-});
-
-export const aiUsageDataSchema = z.object({
-  configId: z.string().uuid(),
-  inputTokens: z.number().int().optional(),
-  outputTokens: z.number().int().optional(),
-  imageCount: z.number().int().optional(),
-  imageResolution: z.string().optional(),
-});
-
-export const aiUsageRecordSchema = aiUsageDataSchema.extend({
-  id: z.string().uuid(),
-  createdAt: z.date(),
-  modelId: z.string().nullable().optional(),
-  model: z.string().nullable(),
-  provider: z.string().nullable(),
-  inputModality: z.array(modalitySchema).nullable(),
-  outputModality: z.array(modalitySchema).nullable(),
-});
-
-export const aiUsageSummarySchema = z.object({
-  totalInputTokens: z.number(),
-  totalOutputTokens: z.number(),
-  totalTokens: z.number(),
-  totalImageCount: z.number(),
-  totalRequests: z.number(),
-});
-
-// Export types
-export type ModalitySchema = z.infer<typeof modalitySchema>;
-export type AIConfigurationInputSchema = z.infer<typeof aiConfigurationInputSchema>;
-export type AIConfigurationSchema = z.infer<typeof aiConfigurationSchema>;
-export type AIConfigurationWithUsageSchema = z.infer<typeof aiConfigurationWithUsageSchema>;
-export type AIUsageDataSchema = z.infer<typeof aiUsageDataSchema>;
-export type AIUsageRecordSchema = z.infer<typeof aiUsageRecordSchema>;
-export type AIUsageSummarySchema = z.infer<typeof aiUsageSummarySchema>;
+import { z } from 'zod';
+
+// Core schemas - text, image, and audio supported
+export const modalitySchema = z.enum(['text', 'image', 'audio']);
+
+export const aiConfigurationInputSchema = z.object({
+  inputModality: z.array(modalitySchema).min(1),
+  outputModality: z.array(modalitySchema).min(1),
+  provider: z.string(),
+  modelId: z.string(),
+  systemPrompt: z.string().optional(),
+});
+
+export const aiConfigurationSchema = aiConfigurationInputSchema.extend({
+  id: z.string().uuid(),
+});
+
+export const aiConfigurationWithUsageSchema = aiConfigurationSchema.extend({
+  usageStats: z
+    .object({
+      totalInputTokens: z.number(),
+      totalOutputTokens: z.number(),
+      totalTokens: z.number(),
+      totalImageCount: z.number(),
+      totalRequests: z.number(),
+    })
+    .optional(),
+});
+
+export const aiUsageDataSchema = z.object({
+  configId: z.string().uuid(),
+  inputTokens: z.number().int().optional(),
+  outputTokens: z.number().int().optional(),
+  imageCount: z.number().int().optional(),
+  imageResolution: z.string().optional(),
+});
+
+export const aiUsageRecordSchema = aiUsageDataSchema.extend({
+  id: z.string().uuid(),
+  createdAt: z.date(),
+  modelId: z.string().nullable().optional(),
+  model: z.string().nullable(),
+  provider: z.string().nullable(),
+  inputModality: z.array(modalitySchema).nullable(),
+  outputModality: z.array(modalitySchema).nullable(),
+});
+
+export const aiUsageSummarySchema = z.object({
+  totalInputTokens: z.number(),
+  totalOutputTokens: z.number(),
+  totalTokens: z.number(),
+  totalImageCount: z.number(),
+  totalRequests: z.number(),
+});
+
+// Export types
+export type ModalitySchema = z.infer<typeof modalitySchema>;
+export type AIConfigurationInputSchema = z.infer<typeof aiConfigurationInputSchema>;
+export type AIConfigurationSchema = z.infer<typeof aiConfigurationSchema>;
+export type AIConfigurationWithUsageSchema = z.infer<typeof aiConfigurationWithUsageSchema>;
+export type AIUsageDataSchema = z.infer<typeof aiUsageDataSchema>;
+export type AIUsageRecordSchema = z.infer<typeof aiUsageRecordSchema>;
+export type AIUsageSummarySchema = z.infer<typeof aiUsageSummarySchema>;

package/shared-schemas/src/auth-api.schema.ts

@@ -4,8 +4,8 @@ import {
   passwordSchema,
   nameSchema,
   userIdSchema,
-  roleSchema,
   userSchema,
+  profileSchema,
   oAuthConfigSchema,
   oAuthProvidersSchema,
   authConfigSchema,
@@ -23,6 +23,15 @@ export const paginationSchema = z.object({
   offset: z.string().optional(),
 });
 
+/**
+ * Shared options for auth requests (extensible for future parameters)
+ */
+export const authOptionsSchema = z
+  .object({
+    emailRedirectTo: z.string().url().optional(),
+  })
+  .optional();
+
 /**
  * POST /api/auth/users - Create user
  */
@@ -30,6 +39,7 @@ export const createUserRequestSchema = z.object({
   email: emailSchema,
   password: passwordSchema,
   name: nameSchema.optional(),
+  options: authOptionsSchema,
 });
 
 /**
@@ -65,11 +75,19 @@ export const deleteUsersRequestSchema = z.object({
   userIds: z.array(userIdSchema).min(1, 'At least one user ID is required'),
 });
 
+/**
+ * PATCH /api/auth/profiles/current - Update current user's profile
+ */
+export const updateProfileRequestSchema = z.object({
+  profile: z.record(z.unknown()),
+});
+
 /**
  * POST /api/auth/email/send-verification - Send verification email (code or link based on config)
  */
 export const sendVerificationEmailRequestSchema = z.object({
   email: emailSchema,
+  options: authOptionsSchema,
 });
 
 /**
@@ -189,11 +207,15 @@ export const createAdminSessionResponseSchema = createUserResponseSchema;
  * Response for GET /api/auth/sessions/current
  */
 export const getCurrentSessionResponseSchema = z.object({
-  user: z.object({
-    id: userIdSchema,
-    email: emailSchema,
-    role: roleSchema,
-  }),
+  user: userSchema,
+});
+
+/**
+ * Response for GET /api/auth/profiles/:userId - Get user profile
+ */
+export const getProfileResponseSchema = z.object({
+  id: userIdSchema,
+  profile: profileSchema.nullable(),
 });
 
 /**
@@ -315,12 +337,16 @@ export const authErrorResponseSchema = z.object({
 // Type exports
 // ============================================================================
 
+// Shared options type
+export type AuthOptions = z.infer<typeof authOptionsSchema>;
+
 // Request types for type-safe request handling
 export type CreateUserRequest = z.infer<typeof createUserRequestSchema>;
 export type CreateSessionRequest = z.infer<typeof createSessionRequestSchema>;
 export type CreateAdminSessionRequest = z.infer<typeof createAdminSessionRequestSchema>;
 export type ListUsersRequest = z.infer<typeof listUsersRequestSchema>;
 export type DeleteUsersRequest = z.infer<typeof deleteUsersRequestSchema>;
+export type UpdateProfileRequest = z.infer<typeof updateProfileRequestSchema>;
 export type CreateOAuthConfigRequest = z.infer<typeof createOAuthConfigRequestSchema>;
 export type UpdateOAuthConfigRequest = z.infer<typeof updateOAuthConfigRequestSchema>;
 export type UpdateAuthConfigRequest = z.infer<typeof updateAuthConfigRequestSchema>;
@@ -339,9 +365,11 @@ export type VerifyEmailResponse = z.infer<typeof verifyEmailResponseSchema>;
 export type ExchangeResetPasswordTokenResponse = z.infer<
   typeof exchangeResetPasswordTokenResponseSchema
 >;
+export type RefreshSessionResponse = z.infer<typeof refreshSessionResponseSchema>;
 export type ResetPasswordResponse = z.infer<typeof resetPasswordResponseSchema>;
 export type CreateAdminSessionResponse = z.infer<typeof createAdminSessionResponseSchema>;
 export type GetCurrentSessionResponse = z.infer<typeof getCurrentSessionResponseSchema>;
+export type GetProfileResponse = z.infer<typeof getProfileResponseSchema>;
 export type ListUsersResponse = z.infer<typeof listUsersResponseSchema>;
 export type DeleteUsersResponse = z.infer<typeof deleteUsersResponseSchema>;
 export type GetOauthUrlResponse = z.infer<typeof getOauthUrlResponseSchema>;