@purpleschool/gptbot 0.13.21 → 0.14.1-stage-2

package/commands/b2b-compatible/anthropic-messages.command.ts

@@ -0,0 +1,244 @@
+import { z } from 'zod';
+import {
+    AnthropicErrorResponseSchema,
+    AnthropicHeadersSchema,
+    NullableStringSchema,
+} from './common.schemas';
+
+const AnthropicCacheControlSchema = z
+    .object({
+        type: z.string(),
+    })
+    .passthrough();
+
+const AnthropicTextBlockSchema = z
+    .object({
+        type: z.literal('text'),
+        text: z.string(),
+        cache_control: AnthropicCacheControlSchema.optional(),
+    })
+    .passthrough();
+
+const AnthropicBase64SourceSchema = z
+    .object({
+        type: z.literal('base64'),
+        media_type: z.string(),
+        data: z.string(),
+    })
+    .passthrough();
+
+const AnthropicUrlSourceSchema = z
+    .object({
+        type: z.literal('url'),
+        url: z.string(),
+    })
+    .passthrough();
+
+const AnthropicFileSourceSchema = z
+    .object({
+        type: z.literal('file'),
+        file_id: z.string(),
+    })
+    .passthrough();
+
+const AnthropicTextSourceSchema = z
+    .object({
+        type: z.literal('text'),
+        media_type: z.string().optional(),
+        data: z.string(),
+    })
+    .passthrough();
+
+const AnthropicImageBlockSchema = z
+    .object({
+        type: z.literal('image'),
+        source: z.discriminatedUnion('type', [
+            AnthropicBase64SourceSchema,
+            AnthropicUrlSourceSchema,
+            AnthropicFileSourceSchema,
+        ]),
+        cache_control: AnthropicCacheControlSchema.optional(),
+    })
+    .passthrough();
+
+const AnthropicDocumentBlockSchema = z
+    .object({
+        type: z.literal('document'),
+        source: z.discriminatedUnion('type', [
+            AnthropicBase64SourceSchema,
+            AnthropicUrlSourceSchema,
+            AnthropicFileSourceSchema,
+            AnthropicTextSourceSchema,
+        ]),
+        title: z.string().optional(),
+        cache_control: AnthropicCacheControlSchema.optional(),
+    })
+    .passthrough();
+
+const AnthropicUnknownContentBlockSchema = z
+    .object({
+        type: z.string(),
+    })
+    .passthrough();
+
+export const AnthropicMessageContentBlockSchema = z.union([
+    AnthropicTextBlockSchema,
+    AnthropicImageBlockSchema,
+    AnthropicDocumentBlockSchema,
+    AnthropicUnknownContentBlockSchema,
+]);
+
+export const AnthropicSystemContentBlockSchema = z.union([
+    AnthropicTextBlockSchema,
+    AnthropicUnknownContentBlockSchema,
+]);
+
+export const AnthropicMessageSchema = z
+    .object({
+        // `system` appears here (not just in the top-level `system` field) when the client
+        // uses the mid-conversation-system beta — Claude Code injects operator instructions
+        // as `{ role: 'system', content }` entries inside messages[].
+        role: z.enum(['user', 'assistant', 'system']),
+        content: z.union([z.string(), z.array(AnthropicMessageContentBlockSchema)]),
+    })
+    .passthrough();
+
+const AnthropicToolSchema = z
+    .object({
+        // Custom tools (the bulk of what the Claude CLI sends) are `{ name, description,
+        // input_schema }` with NO `type`. Only server tools (web_search_*, bash_*, …)
+        // carry a `type`. Requiring it here 400s every tool-bearing request.
+        type: z.string().optional(),
+        name: z.string().optional(),
+        user_location: z
+            .object({
+                type: z.literal('approximate').optional(),
+                country: z.string().optional(),
+                region: z.string().optional(),
+                city: z.string().optional(),
+            })
+            .passthrough()
+            .optional(),
+    })
+    .passthrough();
+
+const AnthropicThinkingSchema = z
+    .object({
+        type: z.string().optional(),
+    })
+    .passthrough();
+
+export namespace AnthropicMessagesCommand {
+    export const HeadersSchema = AnthropicHeadersSchema;
+
+    export const BodySchema = z
+        .object({
+            model: z.string(),
+            max_tokens: z.number().int().positive(),
+            messages: z.array(AnthropicMessageSchema).min(1),
+            system: z.union([z.string(), z.array(AnthropicSystemContentBlockSchema)]).optional(),
+            stream: z.boolean().optional(),
+            tools: z.array(AnthropicToolSchema).optional(),
+            container: z.unknown().optional(),
+            context_management: z.unknown().optional(),
+            mcp_servers: z.array(z.unknown()).optional(),
+            metadata: z.record(z.string(), z.unknown()).optional(),
+            service_tier: z.string().optional(),
+            stop_sequences: z.array(z.string()).optional(),
+            temperature: z.number().optional(),
+            thinking: AnthropicThinkingSchema.optional(),
+            tool_choice: z.unknown().optional(),
+            top_k: z.number().optional(),
+            top_p: z.number().optional(),
+        })
+        .passthrough();
+
+    export const UsageSchema = z
+        .object({
+            input_tokens: z.number().int().nonnegative(),
+            output_tokens: z.number().int().nonnegative(),
+            cache_creation_input_tokens: z.number().int().nonnegative().optional(),
+            cache_read_input_tokens: z.number().int().nonnegative().optional(),
+        })
+        .strict();
+
+    export const TextContentBlockResponseSchema = z
+        .object({
+            type: z.literal('text'),
+            text: z.string(),
+        })
+        .strict();
+
+    export const ResponseSchema = z
+        .object({
+            id: z.string(),
+            type: z.literal('message'),
+            role: z.literal('assistant'),
+            content: z.array(TextContentBlockResponseSchema),
+            model: z.string(),
+            stop_reason: NullableStringSchema,
+            stop_sequence: NullableStringSchema,
+            usage: UsageSchema,
+        })
+        .strict();
+
+    export const StreamEventSchema = z.union([
+        z
+            .object({
+                type: z.literal('message_start'),
+                message: ResponseSchema,
+            })
+            .strict(),
+        z
+            .object({
+                type: z.literal('content_block_start'),
+                index: z.number().int(),
+                content_block: TextContentBlockResponseSchema,
+            })
+            .strict(),
+        z
+            .object({
+                type: z.literal('content_block_delta'),
+                index: z.number().int(),
+                delta: z
+                    .object({
+                        type: z.literal('text_delta'),
+                        text: z.string(),
+                    })
+                    .strict(),
+            })
+            .strict(),
+        z
+            .object({
+                type: z.literal('content_block_stop'),
+                index: z.number().int(),
+            })
+            .strict(),
+        z
+            .object({
+                type: z.literal('message_delta'),
+                delta: z
+                    .object({
+                        stop_reason: NullableStringSchema.optional(),
+                        stop_sequence: NullableStringSchema.optional(),
+                    })
+                    .strict(),
+                usage: UsageSchema.partial().optional(),
+            })
+            .strict(),
+        z
+            .object({
+                type: z.literal('message_stop'),
+            })
+            .strict(),
+        AnthropicErrorResponseSchema,
+    ]);
+
+    export const ErrorResponseSchema = AnthropicErrorResponseSchema;
+
+    export type Headers = z.infer<typeof HeadersSchema>;
+    export type Body = z.infer<typeof BodySchema>;
+    export type Response = z.infer<typeof ResponseSchema>;
+    export type StreamEvent = z.infer<typeof StreamEventSchema>;
+    export type ErrorResponse = z.infer<typeof ErrorResponseSchema>;
+}

package/commands/b2b-compatible/anthropic-models.command.ts

@@ -0,0 +1,31 @@
+import { z } from 'zod';
+import { AnthropicErrorResponseSchema, AnthropicHeadersSchema } from './common.schemas';
+
+export namespace AnthropicModelsCommand {
+    export const HeadersSchema = AnthropicHeadersSchema;
+
+    export const ModelSchema = z
+        .object({
+            id: z.string(),
+            type: z.literal('model'),
+            display_name: z.string(),
+            created_at: z.string().datetime(),
+        })
+        .strict();
+
+    export const ResponseSchema = z
+        .object({
+            data: z.array(ModelSchema),
+            first_id: z.string().nullable(),
+            last_id: z.string().nullable(),
+            has_more: z.boolean(),
+        })
+        .strict();
+
+    export const ErrorResponseSchema = AnthropicErrorResponseSchema;
+
+    export type Headers = z.infer<typeof HeadersSchema>;
+    export type Model = z.infer<typeof ModelSchema>;
+    export type Response = z.infer<typeof ResponseSchema>;
+    export type ErrorResponse = z.infer<typeof ErrorResponseSchema>;
+}

package/commands/b2b-compatible/common.schemas.ts

@@ -0,0 +1,55 @@
+import { z } from 'zod';
+
+export const NullableStringSchema = z.string().nullable();
+
+export const OpenAIHeadersSchema = z
+    .object({
+        authorization: z.string(),
+    })
+    .strict();
+
+export const AnthropicHeadersSchema = z
+    .object({
+        'x-api-key': z.string(),
+        'anthropic-version': z.string().optional(),
+    })
+    .strict();
+
+export const OpenAIErrorResponseSchema = z
+    .object({
+        error: z
+            .object({
+                message: z.string(),
+                type: z.string(),
+                param: NullableStringSchema,
+                code: NullableStringSchema,
+            })
+            .strict(),
+    })
+    .strict();
+
+export const AnthropicErrorResponseSchema = z
+    .object({
+        type: z.literal('error'),
+        error: z
+            .object({
+                type: z.string(),
+                message: z.string(),
+            })
+            .strict(),
+    })
+    .strict();
+
+export const CompatibleFileUploadMetadataSchema = z
+    .object({
+        filename: z.string(),
+        mimetype: z.string(),
+        size: z.number().int().nonnegative(),
+    })
+    .strict();
+
+export type OpenAIHeaders = z.infer<typeof OpenAIHeadersSchema>;
+export type AnthropicHeaders = z.infer<typeof AnthropicHeadersSchema>;
+export type OpenAIErrorResponse = z.infer<typeof OpenAIErrorResponseSchema>;
+export type AnthropicErrorResponse = z.infer<typeof AnthropicErrorResponseSchema>;
+export type CompatibleFileUploadMetadata = z.infer<typeof CompatibleFileUploadMetadataSchema>;

package/commands/b2b-compatible/index.ts

@@ -0,0 +1,7 @@
+export * from './anthropic-files.command';
+export * from './anthropic-messages.command';
+export * from './anthropic-models.command';
+export * from './common.schemas';
+export * from './openai-files.command';
+export * from './openai-models.command';
+export * from './openai-responses.command';

package/commands/b2b-compatible/openai-files.command.ts

@@ -0,0 +1,37 @@
+import { z } from 'zod';
+import {
+    CompatibleFileUploadMetadataSchema,
+    OpenAIErrorResponseSchema,
+    OpenAIHeadersSchema,
+} from './common.schemas';
+
+export namespace OpenAIFilesCommand {
+    export const HeadersSchema = OpenAIHeadersSchema;
+
+    export const BodySchema = z
+        .object({
+            purpose: z.enum(['assistants', 'batch', 'fine-tune', 'vision', 'user_data', 'evals']),
+        })
+        .strict();
+
+    export const FileMetadataSchema = CompatibleFileUploadMetadataSchema;
+
+    export const ResponseSchema = z
+        .object({
+            id: z.string().uuid(),
+            object: z.literal('file'),
+            bytes: z.number().int().nonnegative(),
+            created_at: z.number().int(),
+            filename: z.string(),
+            purpose: BodySchema.shape.purpose,
+        })
+        .strict();
+
+    export const ErrorResponseSchema = OpenAIErrorResponseSchema;
+
+    export type Headers = z.infer<typeof HeadersSchema>;
+    export type Body = z.infer<typeof BodySchema>;
+    export type FileMetadata = z.infer<typeof FileMetadataSchema>;
+    export type Response = z.infer<typeof ResponseSchema>;
+    export type ErrorResponse = z.infer<typeof ErrorResponseSchema>;
+}

package/commands/b2b-compatible/openai-models.command.ts

@@ -0,0 +1,29 @@
+import { z } from 'zod';
+import { OpenAIErrorResponseSchema, OpenAIHeadersSchema } from './common.schemas';
+
+export namespace OpenAIModelsCommand {
+    export const HeadersSchema = OpenAIHeadersSchema;
+
+    export const ModelSchema = z
+        .object({
+            id: z.string(),
+            object: z.literal('model'),
+            created: z.number().int(),
+            owned_by: z.literal('rugpt'),
+        })
+        .strict();
+
+    export const ResponseSchema = z
+        .object({
+            object: z.literal('list'),
+            data: z.array(ModelSchema),
+        })
+        .strict();
+
+    export const ErrorResponseSchema = OpenAIErrorResponseSchema;
+
+    export type Headers = z.infer<typeof HeadersSchema>;
+    export type Model = z.infer<typeof ModelSchema>;
+    export type Response = z.infer<typeof ResponseSchema>;
+    export type ErrorResponse = z.infer<typeof ErrorResponseSchema>;
+}

package/commands/b2b-compatible/openai-responses.command.ts

@@ -0,0 +1,191 @@
+import { z } from 'zod';
+import { OpenAIErrorResponseSchema, OpenAIHeadersSchema } from './common.schemas';
+
+const OpenAIInputTextContentPartSchema = z
+    .object({
+        type: z.enum(['input_text', 'text', 'output_text']),
+        text: z.string(),
+    })
+    .passthrough();
+
+const OpenAIInputImageContentPartSchema = z
+    .object({
+        type: z.literal('input_image'),
+        image_url: z.string().optional(),
+        file_id: z.string().optional(),
+        detail: z.enum(['auto', 'low', 'high']).optional(),
+    })
+    .passthrough();
+
+const OpenAIInputFileContentPartSchema = z
+    .object({
+        type: z.literal('input_file'),
+        file_id: z.string().optional(),
+        file_data: z.string().optional(),
+        file_url: z.string().optional(),
+        filename: z.string().optional(),
+        mime_type: z.string().optional(),
+    })
+    .passthrough();
+
+export const OpenAIResponseInputContentPartSchema = z.discriminatedUnion('type', [
+    OpenAIInputTextContentPartSchema,
+    OpenAIInputImageContentPartSchema,
+    OpenAIInputFileContentPartSchema,
+]);
+
+export const OpenAIResponseInputMessageSchema = z
+    .object({
+        type: z.literal('message').optional(),
+        role: z.enum(['system', 'developer', 'user', 'assistant']),
+        content: z.union([z.string(), z.array(OpenAIResponseInputContentPartSchema)]),
+    })
+    .passthrough();
+
+const OpenAIAnyToolSchema = z
+    .object({
+        type: z.string(),
+    })
+    .passthrough();
+
+const OpenAIResponseMetadataSchema = z.record(z.string(), z.unknown());
+
+const OpenAIResponseReasoningSchema = z
+    .object({
+        effort: z.string().optional(),
+        summary: z.string().nullable().optional(),
+    })
+    .passthrough();
+
+const OpenAIResponseTextOptionsSchema = z
+    .object({
+        format: z.unknown().optional(),
+        verbosity: z.string().optional(),
+    })
+    .passthrough();
+
+const OpenAIResponseUsageSchema = z
+    .object({
+        input_tokens: z.number().int().nonnegative(),
+        output_tokens: z.number().int().nonnegative(),
+        total_tokens: z.number().int().nonnegative(),
+        input_tokens_details: z
+            .object({
+                cached_tokens: z.number().int().nonnegative().optional(),
+            })
+            .strict()
+            .optional(),
+    })
+    .strict();
+
+const OpenAIResponseOutputTextSchema = z
+    .object({
+        type: z.literal('output_text'),
+        text: z.string(),
+        annotations: z.array(z.unknown()),
+    })
+    .strict();
+
+const OpenAIResponseOutputMessageSchema = z
+    .object({
+        id: z.string(),
+        type: z.literal('message'),
+        status: z.literal('completed'),
+        role: z.literal('assistant'),
+        content: z.array(OpenAIResponseOutputTextSchema),
+    })
+    .strict();
+
+export namespace OpenAIResponsesCommand {
+    export const HeadersSchema = OpenAIHeadersSchema;
+
+    export const BodySchema = z
+        .object({
+            model: z.string(),
+            input: z.union([z.string(), z.array(OpenAIResponseInputMessageSchema).min(1)]),
+            instructions: z.string().optional(),
+            stream: z.boolean().optional(),
+            max_output_tokens: z.number().int().positive().optional(),
+            tools: z.array(OpenAIAnyToolSchema).optional(),
+            background: z.boolean().optional(),
+            include: z.array(z.string()).optional(),
+            max_tool_calls: z.number().int().positive().optional(),
+            metadata: OpenAIResponseMetadataSchema.nullable().optional(),
+            parallel_tool_calls: z.boolean().optional(),
+            previous_response_id: z.string().nullable().optional(),
+            prompt: z.unknown().optional(),
+            reasoning: OpenAIResponseReasoningSchema.nullable().optional(),
+            safety_identifier: z.string().optional(),
+            service_tier: z.string().optional(),
+            store: z.boolean().nullable().optional(),
+            stream_options: z.unknown().optional(),
+            temperature: z.number().optional(),
+            text: OpenAIResponseTextOptionsSchema.optional(),
+            tool_choice: z.unknown().optional(),
+            top_p: z.number().optional(),
+            truncation: z.string().optional(),
+            user: z.string().optional(),
+        })
+        .passthrough();
+
+    export const UsageSchema = OpenAIResponseUsageSchema;
+
+    export const ResponseSchema = z
+        .object({
+            id: z.string(),
+            object: z.literal('response'),
+            created_at: z.number().int(),
+            status: z.literal('completed'),
+            model: z.string(),
+            output: z.array(OpenAIResponseOutputMessageSchema),
+            output_text: z.string(),
+            usage: UsageSchema,
+        })
+        .strict();
+
+    export const StreamEventSchema = z.union([
+        z
+            .object({
+                type: z.literal('response.created'),
+                response: ResponseSchema.omit({ status: true }).extend({
+                    status: z.literal('in_progress'),
+                    output: z.array(z.never()),
+                    output_text: z.literal(''),
+                }),
+            })
+            .strict(),
+        z
+            .object({
+                type: z.literal('response.output_text.delta'),
+                response_id: z.string(),
+                output_index: z.number().int(),
+                content_index: z.number().int(),
+                delta: z.string(),
+            })
+            .strict(),
+        z
+            .object({
+                type: z.literal('response.output_text.done'),
+                response_id: z.string(),
+                output_index: z.number().int(),
+                content_index: z.number().int(),
+                text: z.string(),
+            })
+            .strict(),
+        z
+            .object({
+                type: z.literal('response.completed'),
+                response: ResponseSchema,
+            })
+            .strict(),
+        OpenAIErrorResponseSchema,
+    ]);
+
+    export const ErrorResponseSchema = OpenAIErrorResponseSchema;
+
+    export type Headers = z.infer<typeof HeadersSchema>;
+    export type Body = z.infer<typeof BodySchema>;
+    export type Response = z.infer<typeof ResponseSchema>;
+    export type StreamEvent = z.infer<typeof StreamEventSchema>;
+    export type ErrorResponse = z.infer<typeof ErrorResponseSchema>;
+}