@veruna/api-contracts 1.0.25 → 1.0.27

package/build/rest-api.d.ts

@@ -106,7 +106,8 @@ export declare const REST_API: {
         };
         readonly CHAT: {
             readonly UNREG: {
-                readonly GET_OR_CREATE: (pageId: string) => string;
+                readonly GET: (pageId: string) => string;
+                readonly CREATE: (pageId: string) => string;
             };
         };
         readonly MESSAGE: {

package/build/rest-api.js

@@ -123,7 +123,8 @@ exports.REST_API = {
         },
         CHAT: {
             UNREG: {
-                GET_OR_CREATE: (pageId) => `${exports.ROOT}/${controllers_1.CHAT_UNREG_CONTROLLER.replace(':pageId', pageId)}`,
+                GET: (pageId) => `${exports.ROOT}/${controllers_1.CHAT_UNREG_CONTROLLER.replace(':pageId', pageId)}`,
+                CREATE: (pageId) => `${exports.ROOT}/${controllers_1.CHAT_UNREG_CONTROLLER.replace(':pageId', pageId)}`,
             },
         },
         MESSAGE: {

package/build/routes/chat.routes.d.ts

@@ -2,5 +2,6 @@
  * Chat Routes
  */
 export declare const CHAT_UNREG_ROUTES: {
-    readonly GET_OR_CREATE: "";
+    readonly GET: "";
+    readonly CREATE: "";
 };

package/build/routes/chat.routes.js

@@ -5,5 +5,6 @@ exports.CHAT_UNREG_ROUTES = void 0;
  * Chat Routes
  */
 exports.CHAT_UNREG_ROUTES = {
-    GET_OR_CREATE: '',
+    GET: '',
+    CREATE: '',
 };

package/build/routes/message.routes.d.ts

@@ -1,3 +1,3 @@
 export declare const MESSAGE_UNREG_ROUTES: {
-    readonly CREATE: "";
+    readonly SEND: "";
 };

package/build/routes/message.routes.js

@@ -2,5 +2,5 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MESSAGE_UNREG_ROUTES = void 0;
 exports.MESSAGE_UNREG_ROUTES = {
-    CREATE: '',
+    SEND: '',
 };

package/build/v1/ai/ai.errors.d.ts

@@ -0,0 +1,16 @@
+import { ErrorMetadata } from '../../shared';
+export declare enum AIErrorCode {
+    GENERATION_FAILED = "GENERATION_FAILED",
+    GENERATION_TIMEOUT = "GENERATION_TIMEOUT",
+    CONTENT_FILTERED = "CONTENT_FILTERED",
+    CONTEXT_TOO_LONG = "CONTEXT_TOO_LONG",
+    MODEL_NOT_FOUND = "MODEL_NOT_FOUND",
+    MODEL_UNAVAILABLE = "MODEL_UNAVAILABLE",
+    NO_SUITABLE_MODEL = "NO_SUITABLE_MODEL",
+    INSUFFICIENT_BALANCE = "INSUFFICIENT_BALANCE",
+    COST_LIMIT_EXCEEDED = "COST_LIMIT_EXCEEDED",
+    PROVIDER_ERROR = "PROVIDER_ERROR",
+    PROVIDER_RATE_LIMIT = "PROVIDER_RATE_LIMIT",
+    PROVIDER_TIMEOUT = "PROVIDER_TIMEOUT"
+}
+export declare const AI_ERRORS: Record<AIErrorCode, ErrorMetadata>;

package/build/v1/ai/ai.errors.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AI_ERRORS = exports.AIErrorCode = void 0;
+var AIErrorCode;
+(function (AIErrorCode) {
+    // Generation
+    AIErrorCode["GENERATION_FAILED"] = "GENERATION_FAILED";
+    AIErrorCode["GENERATION_TIMEOUT"] = "GENERATION_TIMEOUT";
+    AIErrorCode["CONTENT_FILTERED"] = "CONTENT_FILTERED";
+    AIErrorCode["CONTEXT_TOO_LONG"] = "CONTEXT_TOO_LONG";
+    // Model
+    AIErrorCode["MODEL_NOT_FOUND"] = "MODEL_NOT_FOUND";
+    AIErrorCode["MODEL_UNAVAILABLE"] = "MODEL_UNAVAILABLE";
+    AIErrorCode["NO_SUITABLE_MODEL"] = "NO_SUITABLE_MODEL";
+    // Billing
+    AIErrorCode["INSUFFICIENT_BALANCE"] = "INSUFFICIENT_BALANCE";
+    AIErrorCode["COST_LIMIT_EXCEEDED"] = "COST_LIMIT_EXCEEDED";
+    // Provider
+    AIErrorCode["PROVIDER_ERROR"] = "PROVIDER_ERROR";
+    AIErrorCode["PROVIDER_RATE_LIMIT"] = "PROVIDER_RATE_LIMIT";
+    AIErrorCode["PROVIDER_TIMEOUT"] = "PROVIDER_TIMEOUT";
+})(AIErrorCode || (exports.AIErrorCode = AIErrorCode = {}));
+exports.AI_ERRORS = {
+    [AIErrorCode.GENERATION_FAILED]: {
+        code: AIErrorCode.GENERATION_FAILED,
+        statusCode: 500,
+    },
+    [AIErrorCode.GENERATION_TIMEOUT]: {
+        code: AIErrorCode.GENERATION_TIMEOUT,
+        statusCode: 504,
+    },
+    [AIErrorCode.CONTENT_FILTERED]: {
+        code: AIErrorCode.CONTENT_FILTERED,
+        statusCode: 400,
+    },
+    [AIErrorCode.CONTEXT_TOO_LONG]: {
+        code: AIErrorCode.CONTEXT_TOO_LONG,
+        statusCode: 400,
+    },
+    [AIErrorCode.MODEL_NOT_FOUND]: {
+        code: AIErrorCode.MODEL_NOT_FOUND,
+        statusCode: 404,
+    },
+    [AIErrorCode.MODEL_UNAVAILABLE]: {
+        code: AIErrorCode.MODEL_UNAVAILABLE,
+        statusCode: 503,
+    },
+    [AIErrorCode.NO_SUITABLE_MODEL]: {
+        code: AIErrorCode.NO_SUITABLE_MODEL,
+        statusCode: 400,
+    },
+    [AIErrorCode.INSUFFICIENT_BALANCE]: {
+        code: AIErrorCode.INSUFFICIENT_BALANCE,
+        statusCode: 402,
+    },
+    [AIErrorCode.COST_LIMIT_EXCEEDED]: {
+        code: AIErrorCode.COST_LIMIT_EXCEEDED,
+        statusCode: 402,
+    },
+    [AIErrorCode.PROVIDER_ERROR]: {
+        code: AIErrorCode.PROVIDER_ERROR,
+        statusCode: 502,
+    },
+    [AIErrorCode.PROVIDER_RATE_LIMIT]: {
+        code: AIErrorCode.PROVIDER_RATE_LIMIT,
+        statusCode: 429,
+    },
+    [AIErrorCode.PROVIDER_TIMEOUT]: {
+        code: AIErrorCode.PROVIDER_TIMEOUT,
+        statusCode: 504,
+    },
+};

package/build/v1/ai/index.d.ts

@@ -0,0 +1 @@
+export * from './ai.errors';

package/build/v1/ai/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./ai.errors"), exports);

package/build/v1/chat/commands/{get-or-create-unreg-chat.command.d.ts → create-unreg-chat.command.d.ts}

@@ -1,10 +1,10 @@
 import { z } from 'zod';
 import { HttpMethod } from '../../../shared/http-method';
 /**
- * Get or Create Unreg Chat Command
- * PUT /api/v1/unreg/page/:pageId/chat
+ * Create Unreg Chat Command
+ * POST /api/v1/unreg/page/:pageId/chat
  */
-export declare namespace GetOrCreateUnregChatCommand {
+export declare namespace CreateUnregChatCommand {
     const Request: z.ZodObject<{}, z.core.$strip>;
     const Response: z.ZodObject<{
         uuid: z.ZodString;
@@ -26,7 +26,7 @@ export declare namespace GetOrCreateUnregChatCommand {
         }, z.core.$strip>>;
     }, z.core.$strip>;
     const URL: (pageId: string) => string;
-    const METHOD = HttpMethod.PUT;
+    const METHOD = HttpMethod.POST;
     type RequestType = z.infer<typeof Request>;
     type ResponseType = z.infer<typeof Response>;
 }

package/build/v1/chat/commands/create-unreg-chat.command.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CreateUnregChatCommand = void 0;
+const zod_1 = require("zod");
+const schemas_1 = require("../schemas");
+const rest_api_1 = require("../../../rest-api");
+const http_method_1 = require("../../../shared/http-method");
+/**
+ * Create Unreg Chat Command
+ * POST /api/v1/unreg/page/:pageId/chat
+ */
+var CreateUnregChatCommand;
+(function (CreateUnregChatCommand) {
+    CreateUnregChatCommand.Request = zod_1.z.object({});
+    CreateUnregChatCommand.Response = schemas_1.ChatWithMessagesResponseSchema;
+    CreateUnregChatCommand.URL = (pageId) => rest_api_1.REST_API.V1.CHAT.UNREG.CREATE(pageId);
+    CreateUnregChatCommand.METHOD = http_method_1.HttpMethod.POST;
+})(CreateUnregChatCommand || (exports.CreateUnregChatCommand = CreateUnregChatCommand = {}));

package/build/v1/chat/commands/index.d.ts

@@ -1 +1 @@
-export { GetOrCreateUnregChatCommand } from './get-or-create-unreg-chat.command';
+export { CreateUnregChatCommand } from './create-unreg-chat.command';

package/build/v1/chat/commands/index.js

@@ -1,5 +1,5 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.GetOrCreateUnregChatCommand = void 0;
-var get_or_create_unreg_chat_command_1 = require("./get-or-create-unreg-chat.command");
-Object.defineProperty(exports, "GetOrCreateUnregChatCommand", { enumerable: true, get: function () { return get_or_create_unreg_chat_command_1.GetOrCreateUnregChatCommand; } });
+exports.CreateUnregChatCommand = void 0;
+var create_unreg_chat_command_1 = require("./create-unreg-chat.command");
+Object.defineProperty(exports, "CreateUnregChatCommand", { enumerable: true, get: function () { return create_unreg_chat_command_1.CreateUnregChatCommand; } });

package/build/v1/chat/index.d.ts

@@ -1,3 +1,4 @@
 export * from './schemas';
 export * from './commands';
+export * from './queries';
 export * from './chat.errors';

package/build/v1/chat/index.js

@@ -16,4 +16,5 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./schemas"), exports);
 __exportStar(require("./commands"), exports);
+__exportStar(require("./queries"), exports);
 __exportStar(require("./chat.errors"), exports);

package/build/v1/chat/queries/get-unreg-chat.query.d.ts

@@ -0,0 +1,32 @@
+import { z } from 'zod';
+import { HttpMethod } from '../../../shared/http-method';
+/**
+ * Get Unreg Chat Query
+ * GET /api/v1/unreg/page/:pageId/chat
+ */
+export declare namespace GetUnregChatQuery {
+    const Request: z.ZodObject<{}, z.core.$strip>;
+    const Response: z.ZodObject<{
+        uuid: z.ZodString;
+        title: z.ZodString;
+        status: z.ZodEnum<typeof import("../schemas").ChatStatus>;
+        pageId: z.ZodNullable<z.ZodString>;
+        folderId: z.ZodNullable<z.ZodString>;
+        createdAt: z.ZodString;
+        updatedAt: z.ZodString;
+        messages: z.ZodArray<z.ZodObject<{
+            uuid: z.ZodString;
+            role: z.ZodEnum<typeof import("../..").MessageRole>;
+            status: z.ZodEnum<typeof import("../..").MessageStatus>;
+            content: z.ZodString;
+            aiModelId: z.ZodNullable<z.ZodString>;
+            userRating: z.ZodNullable<z.ZodEnum<typeof import("../..").UserRating>>;
+            createdAt: z.ZodString;
+            updatedAt: z.ZodString;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+    const URL: (pageId: string) => string;
+    const METHOD = HttpMethod.GET;
+    type RequestType = z.infer<typeof Request>;
+    type ResponseType = z.infer<typeof Response>;
+}

package/build/v1/chat/queries/get-unreg-chat.query.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GetUnregChatQuery = void 0;
+const zod_1 = require("zod");
+const schemas_1 = require("../schemas");
+const rest_api_1 = require("../../../rest-api");
+const http_method_1 = require("../../../shared/http-method");
+/**
+ * Get Unreg Chat Query
+ * GET /api/v1/unreg/page/:pageId/chat
+ */
+var GetUnregChatQuery;
+(function (GetUnregChatQuery) {
+    GetUnregChatQuery.Request = zod_1.z.object({});
+    GetUnregChatQuery.Response = schemas_1.ChatWithMessagesResponseSchema;
+    GetUnregChatQuery.URL = (pageId) => rest_api_1.REST_API.V1.CHAT.UNREG.GET(pageId);
+    GetUnregChatQuery.METHOD = http_method_1.HttpMethod.GET;
+})(GetUnregChatQuery || (exports.GetUnregChatQuery = GetUnregChatQuery = {}));

package/build/v1/chat/queries/index.d.ts

@@ -0,0 +1 @@
+export { GetUnregChatQuery } from './get-unreg-chat.query';

package/build/v1/chat/queries/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GetUnregChatQuery = void 0;
+var get_unreg_chat_query_1 = require("./get-unreg-chat.query");
+Object.defineProperty(exports, "GetUnregChatQuery", { enumerable: true, get: function () { return get_unreg_chat_query_1.GetUnregChatQuery; } });

package/build/v1/chat/schemas/chat-status.enum.d.ts

@@ -4,5 +4,6 @@
 export declare enum ChatStatus {
     NEW = "new",
     ACTIVE = "active",
+    REPLACED = "replaced",
     DELETED = "deleted"
 }

package/build/v1/chat/schemas/chat-status.enum.js

@@ -8,5 +8,6 @@ var ChatStatus;
 (function (ChatStatus) {
     ChatStatus["NEW"] = "new";
     ChatStatus["ACTIVE"] = "active";
+    ChatStatus["REPLACED"] = "replaced";
     ChatStatus["DELETED"] = "deleted";
 })(ChatStatus || (exports.ChatStatus = ChatStatus = {}));

package/build/v1/index.d.ts

@@ -10,3 +10,4 @@ export * from './ai-model';
 export * from './chat-project';
 export * from './chat';
 export * from './message';
+export * from './ai';

package/build/v1/index.js

@@ -26,3 +26,4 @@ __exportStar(require("./ai-model"), exports);
 __exportStar(require("./chat-project"), exports);
 __exportStar(require("./chat"), exports);
 __exportStar(require("./message"), exports);
+__exportStar(require("./ai"), exports);

package/build/v1/message/commands/create-message.command.d.ts

@@ -1,15 +1,94 @@
 import { z } from 'zod';
 import { HttpMethod } from '../../../shared/http-method';
+/**
+ * Send message and get AI response as NDJSON stream
+ *
+ * Response format: application/x-ndjson
+ * Each line is a JSON object that can be parsed with JSON.parse()
+ *
+ * @example
+ * ```typescript
+ * const response = await fetch(url, { method: 'POST', body: JSON.stringify(request) });
+ * const reader = response.body.getReader();
+ * const decoder = new TextDecoder();
+ * let buffer = '';
+ *
+ * while (true) {
+ *   const { done, value } = await reader.read();
+ *   if (done) break;
+ *
+ *   buffer += decoder.decode(value, { stream: true });
+ *   const lines = buffer.split('\n');
+ *   buffer = lines.pop()!;
+ *
+ *   for (const line of lines) {
+ *     if (line.trim()) {
+ *       const event: CreateMessageCommand.StreamEventType = JSON.parse(line);
+ *       switch (event.type) {
+ *         case 'chunk': console.log(event.content); break;
+ *         case 'done': console.log('Complete!'); break;
+ *         case 'error': console.error('Error!'); break;
+ *       }
+ *     }
+ *   }
+ * }
+ * ```
+ */
 export declare namespace CreateMessageCommand {
     const Request: z.ZodObject<{
         aiModelId: z.ZodString;
         text: z.ZodString;
     }, z.core.$strip>;
-    const Response: z.ZodObject<{
+    /** Discriminated union of all stream events */
+    const StreamEvent: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        id: z.ZodNumber;
+        chatId: z.ZodString;
         messageId: z.ZodString;
+        type: z.ZodLiteral<import("../schemas").StreamEventType.CHUNK>;
+        content: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        id: z.ZodNumber;
+        chatId: z.ZodString;
+        messageId: z.ZodString;
+        type: z.ZodLiteral<import("../schemas").StreamEventType.DONE>;
+        content: z.ZodLiteral<"">;
+    }, z.core.$strip>, z.ZodObject<{
+        id: z.ZodNumber;
+        chatId: z.ZodString;
+        messageId: z.ZodString;
+        type: z.ZodLiteral<import("../schemas").StreamEventType.ERROR>;
+        content: z.ZodLiteral<"">;
+    }, z.core.$strip>], "type">;
+    const ChunkEvent: z.ZodObject<{
+        id: z.ZodNumber;
+        chatId: z.ZodString;
+        messageId: z.ZodString;
+        type: z.ZodLiteral<import("../schemas").StreamEventType.CHUNK>;
+        content: z.ZodString;
+    }, z.core.$strip>;
+    const DoneEvent: z.ZodObject<{
+        id: z.ZodNumber;
+        chatId: z.ZodString;
+        messageId: z.ZodString;
+        type: z.ZodLiteral<import("../schemas").StreamEventType.DONE>;
+        content: z.ZodLiteral<"">;
+    }, z.core.$strip>;
+    const ErrorEvent: z.ZodObject<{
+        id: z.ZodNumber;
+        chatId: z.ZodString;
+        messageId: z.ZodString;
+        type: z.ZodLiteral<import("../schemas").StreamEventType.ERROR>;
+        content: z.ZodLiteral<"">;
     }, z.core.$strip>;
     const URL: (pageId: string, chatId: string) => string;
     const METHOD = HttpMethod.POST;
+    /** Response content type */
+    const CONTENT_TYPE: "application/x-ndjson";
+    /** This endpoint returns a stream, not a single response */
+    const IS_STREAM: true;
     type RequestType = z.infer<typeof Request>;
-    type ResponseType = z.infer<typeof Response>;
+    type StreamEventType = z.infer<typeof StreamEvent>;
+    type ChunkEventType = z.infer<typeof ChunkEvent>;
+    type DoneEventType = z.infer<typeof DoneEvent>;
+    type ErrorEventType = z.infer<typeof ErrorEvent>;
 }

package/build/v1/message/commands/create-message.command.js

@@ -4,10 +4,52 @@ exports.CreateMessageCommand = void 0;
 const schemas_1 = require("../schemas");
 const rest_api_1 = require("../../../rest-api");
 const http_method_1 = require("../../../shared/http-method");
+/**
+ * Send message and get AI response as NDJSON stream
+ *
+ * Response format: application/x-ndjson
+ * Each line is a JSON object that can be parsed with JSON.parse()
+ *
+ * @example
+ * ```typescript
+ * const response = await fetch(url, { method: 'POST', body: JSON.stringify(request) });
+ * const reader = response.body.getReader();
+ * const decoder = new TextDecoder();
+ * let buffer = '';
+ *
+ * while (true) {
+ *   const { done, value } = await reader.read();
+ *   if (done) break;
+ *
+ *   buffer += decoder.decode(value, { stream: true });
+ *   const lines = buffer.split('\n');
+ *   buffer = lines.pop()!;
+ *
+ *   for (const line of lines) {
+ *     if (line.trim()) {
+ *       const event: CreateMessageCommand.StreamEventType = JSON.parse(line);
+ *       switch (event.type) {
+ *         case 'chunk': console.log(event.content); break;
+ *         case 'done': console.log('Complete!'); break;
+ *         case 'error': console.error('Error!'); break;
+ *       }
+ *     }
+ *   }
+ * }
+ * ```
+ */
 var CreateMessageCommand;
 (function (CreateMessageCommand) {
     CreateMessageCommand.Request = schemas_1.CreateMessageRequestSchema;
-    CreateMessageCommand.Response = schemas_1.CreateMessageResponseSchema;
+    /** Discriminated union of all stream events */
+    CreateMessageCommand.StreamEvent = schemas_1.StreamEventSchema;
+    CreateMessageCommand.ChunkEvent = schemas_1.StreamChunkEventSchema;
+    CreateMessageCommand.DoneEvent = schemas_1.StreamDoneEventSchema;
+    CreateMessageCommand.ErrorEvent = schemas_1.StreamErrorEventSchema;
     CreateMessageCommand.URL = (pageId, chatId) => rest_api_1.REST_API.V1.MESSAGE.UNREG.CREATE(pageId, chatId);
     CreateMessageCommand.METHOD = http_method_1.HttpMethod.POST;
+    /** Response content type */
+    CreateMessageCommand.CONTENT_TYPE = 'application/x-ndjson';
+    /** This endpoint returns a stream, not a single response */
+    CreateMessageCommand.IS_STREAM = true;
 })(CreateMessageCommand || (exports.CreateMessageCommand = CreateMessageCommand = {}));

package/build/v1/message/schemas/index.d.ts

@@ -4,3 +4,4 @@ export { UserRating } from './user-rating.enum';
 export { CreateMessageRequestSchema } from './create-message-request.schema';
 export { CreateMessageResponseSchema } from './create-message-response.schema';
 export { MessageResponseSchema } from './message-response.schema';
+export { StreamEventType, StreamEventSchema, StreamChunkEventSchema, StreamDoneEventSchema, StreamErrorEventSchema, } from './stream-events.schema';

package/build/v1/message/schemas/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.MessageResponseSchema = exports.CreateMessageResponseSchema = exports.CreateMessageRequestSchema = exports.UserRating = exports.MessageStatus = exports.MessageRole = void 0;
+exports.StreamErrorEventSchema = exports.StreamDoneEventSchema = exports.StreamChunkEventSchema = exports.StreamEventSchema = exports.StreamEventType = exports.MessageResponseSchema = exports.CreateMessageResponseSchema = exports.CreateMessageRequestSchema = exports.UserRating = exports.MessageStatus = exports.MessageRole = void 0;
 var message_role_enum_1 = require("./message-role.enum");
 Object.defineProperty(exports, "MessageRole", { enumerable: true, get: function () { return message_role_enum_1.MessageRole; } });
 var message_status_enum_1 = require("./message-status.enum");
@@ -13,3 +13,9 @@ var create_message_response_schema_1 = require("./create-message-response.schema
 Object.defineProperty(exports, "CreateMessageResponseSchema", { enumerable: true, get: function () { return create_message_response_schema_1.CreateMessageResponseSchema; } });
 var message_response_schema_1 = require("./message-response.schema");
 Object.defineProperty(exports, "MessageResponseSchema", { enumerable: true, get: function () { return message_response_schema_1.MessageResponseSchema; } });
+var stream_events_schema_1 = require("./stream-events.schema");
+Object.defineProperty(exports, "StreamEventType", { enumerable: true, get: function () { return stream_events_schema_1.StreamEventType; } });
+Object.defineProperty(exports, "StreamEventSchema", { enumerable: true, get: function () { return stream_events_schema_1.StreamEventSchema; } });
+Object.defineProperty(exports, "StreamChunkEventSchema", { enumerable: true, get: function () { return stream_events_schema_1.StreamChunkEventSchema; } });
+Object.defineProperty(exports, "StreamDoneEventSchema", { enumerable: true, get: function () { return stream_events_schema_1.StreamDoneEventSchema; } });
+Object.defineProperty(exports, "StreamErrorEventSchema", { enumerable: true, get: function () { return stream_events_schema_1.StreamErrorEventSchema; } });

package/build/v1/message/schemas/stream-events.schema.d.ts

@@ -0,0 +1,65 @@
+import { z } from 'zod';
+/**
+ * Stream Event Types for message streaming (NDJSON format)
+ */
+export declare enum StreamEventType {
+    /** Content chunk from AI */
+    CHUNK = "chunk",
+    /** Stream completed successfully */
+    DONE = "done",
+    /** Error occurred during streaming */
+    ERROR = "error"
+}
+/**
+ * Content chunk event - contains partial AI response
+ */
+export declare const StreamChunkEventSchema: z.ZodObject<{
+    id: z.ZodNumber;
+    chatId: z.ZodString;
+    messageId: z.ZodString;
+    type: z.ZodLiteral<StreamEventType.CHUNK>;
+    content: z.ZodString;
+}, z.core.$strip>;
+/**
+ * Done event - stream completed successfully
+ */
+export declare const StreamDoneEventSchema: z.ZodObject<{
+    id: z.ZodNumber;
+    chatId: z.ZodString;
+    messageId: z.ZodString;
+    type: z.ZodLiteral<StreamEventType.DONE>;
+    content: z.ZodLiteral<"">;
+}, z.core.$strip>;
+/**
+ * Error event - error occurred during streaming
+ */
+export declare const StreamErrorEventSchema: z.ZodObject<{
+    id: z.ZodNumber;
+    chatId: z.ZodString;
+    messageId: z.ZodString;
+    type: z.ZodLiteral<StreamEventType.ERROR>;
+    content: z.ZodLiteral<"">;
+}, z.core.$strip>;
+/**
+ * Discriminated union of all stream events
+ * Use `type` field to narrow the type
+ */
+export declare const StreamEventSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    id: z.ZodNumber;
+    chatId: z.ZodString;
+    messageId: z.ZodString;
+    type: z.ZodLiteral<StreamEventType.CHUNK>;
+    content: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    id: z.ZodNumber;
+    chatId: z.ZodString;
+    messageId: z.ZodString;
+    type: z.ZodLiteral<StreamEventType.DONE>;
+    content: z.ZodLiteral<"">;
+}, z.core.$strip>, z.ZodObject<{
+    id: z.ZodNumber;
+    chatId: z.ZodString;
+    messageId: z.ZodString;
+    type: z.ZodLiteral<StreamEventType.ERROR>;
+    content: z.ZodLiteral<"">;
+}, z.core.$strip>], "type">;

package/build/v1/message/schemas/stream-events.schema.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StreamEventSchema = exports.StreamErrorEventSchema = exports.StreamDoneEventSchema = exports.StreamChunkEventSchema = exports.StreamEventType = void 0;
+const zod_1 = require("zod");
+/**
+ * Stream Event Types for message streaming (NDJSON format)
+ */
+var StreamEventType;
+(function (StreamEventType) {
+    /** Content chunk from AI */
+    StreamEventType["CHUNK"] = "chunk";
+    /** Stream completed successfully */
+    StreamEventType["DONE"] = "done";
+    /** Error occurred during streaming */
+    StreamEventType["ERROR"] = "error";
+})(StreamEventType || (exports.StreamEventType = StreamEventType = {}));
+// ============================================================================
+// Base Event Schema
+// ============================================================================
+const BaseStreamEventSchema = zod_1.z.object({
+    /** Sequential event ID (starts from 1) */
+    id: zod_1.z.number().int().positive(),
+    /** Chat UUID */
+    chatId: zod_1.z.string().uuid(),
+    /** AI Message UUID */
+    messageId: zod_1.z.string().uuid(),
+});
+// ============================================================================
+// Specific Event Schemas
+// ============================================================================
+/**
+ * Content chunk event - contains partial AI response
+ */
+exports.StreamChunkEventSchema = BaseStreamEventSchema.extend({
+    type: zod_1.z.literal(StreamEventType.CHUNK),
+    /** Partial content from AI */
+    content: zod_1.z.string().min(1),
+});
+/**
+ * Done event - stream completed successfully
+ */
+exports.StreamDoneEventSchema = BaseStreamEventSchema.extend({
+    type: zod_1.z.literal(StreamEventType.DONE),
+    /** Always empty for done event */
+    content: zod_1.z.literal(''),
+});
+/**
+ * Error event - error occurred during streaming
+ */
+exports.StreamErrorEventSchema = BaseStreamEventSchema.extend({
+    type: zod_1.z.literal(StreamEventType.ERROR),
+    /** Always empty for error event */
+    content: zod_1.z.literal(''),
+});
+// ============================================================================
+// Union Schema
+// ============================================================================
+/**
+ * Discriminated union of all stream events
+ * Use `type` field to narrow the type
+ */
+exports.StreamEventSchema = zod_1.z.discriminatedUnion('type', [
+    exports.StreamChunkEventSchema,
+    exports.StreamDoneEventSchema,
+    exports.StreamErrorEventSchema,
+]);

package/build/v1/unregistered-users/unregistered-users.errors.d.ts

@@ -2,6 +2,7 @@ import { ErrorMetadata } from '../../shared/error-metadata';
 export declare enum UnregUserErrorCode {
     INVALID_TOKEN = "INVALID_TOKEN",
     TOKEN_EXPIRED = "TOKEN_EXPIRED",
+    USER_NOT_FOUND = "USER_NOT_FOUND",
     IP_MISMATCH = "IP_MISMATCH",
     FRAUD_DETECTED = "FRAUD_DETECTED",
     TOKEN_VERSION_MISMATCH = "TOKEN_VERSION_MISMATCH",

package/build/v1/unregistered-users/unregistered-users.errors.js

@@ -5,6 +5,7 @@ var UnregUserErrorCode;
 (function (UnregUserErrorCode) {
     UnregUserErrorCode["INVALID_TOKEN"] = "INVALID_TOKEN";
     UnregUserErrorCode["TOKEN_EXPIRED"] = "TOKEN_EXPIRED";
+    UnregUserErrorCode["USER_NOT_FOUND"] = "USER_NOT_FOUND";
     UnregUserErrorCode["IP_MISMATCH"] = "IP_MISMATCH";
     UnregUserErrorCode["FRAUD_DETECTED"] = "FRAUD_DETECTED";
     UnregUserErrorCode["TOKEN_VERSION_MISMATCH"] = "TOKEN_VERSION_MISMATCH";
@@ -17,6 +18,7 @@ var UnregUserErrorCode;
 exports.UNREG_USER_ERRORS = {
     [UnregUserErrorCode.INVALID_TOKEN]: { code: UnregUserErrorCode.INVALID_TOKEN, statusCode: 401 },
     [UnregUserErrorCode.TOKEN_EXPIRED]: { code: UnregUserErrorCode.TOKEN_EXPIRED, statusCode: 401 },
+    [UnregUserErrorCode.USER_NOT_FOUND]: { code: UnregUserErrorCode.USER_NOT_FOUND, statusCode: 404 },
     [UnregUserErrorCode.IP_MISMATCH]: { code: UnregUserErrorCode.IP_MISMATCH, statusCode: 403 },
     [UnregUserErrorCode.FRAUD_DETECTED]: { code: UnregUserErrorCode.FRAUD_DETECTED, statusCode: 403 },
     [UnregUserErrorCode.TOKEN_VERSION_MISMATCH]: { code: UnregUserErrorCode.TOKEN_VERSION_MISMATCH, statusCode: 401 },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@veruna/api-contracts",
-  "version": "1.0.25",
+  "version": "1.0.27",
   "description": "API contracts for Veruna project - Zod schemas, types, and paths",
   "main": "./build/index.js",
   "types": "./build/index.d.ts",

package/build/v1/chat/commands/get-or-create-unreg-chat.command.js

@@ -1,18 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.GetOrCreateUnregChatCommand = void 0;
-const zod_1 = require("zod");
-const schemas_1 = require("../schemas");
-const rest_api_1 = require("../../../rest-api");
-const http_method_1 = require("../../../shared/http-method");
-/**
- * Get or Create Unreg Chat Command
- * PUT /api/v1/unreg/page/:pageId/chat
- */
-var GetOrCreateUnregChatCommand;
-(function (GetOrCreateUnregChatCommand) {
-    GetOrCreateUnregChatCommand.Request = zod_1.z.object({});
-    GetOrCreateUnregChatCommand.Response = schemas_1.ChatWithMessagesResponseSchema;
-    GetOrCreateUnregChatCommand.URL = (pageId) => rest_api_1.REST_API.V1.CHAT.UNREG.GET_OR_CREATE(pageId);
-    GetOrCreateUnregChatCommand.METHOD = http_method_1.HttpMethod.PUT;
-})(GetOrCreateUnregChatCommand || (exports.GetOrCreateUnregChatCommand = GetOrCreateUnregChatCommand = {}));