ragatanga-mcp-sdk
Version:
SDK for integrating with the Ragatanga Management Control Plane (MCP) with Next.js 15, React 19, WebSocket and Arrow IPC support
201 lines (196 loc) • 6.2 kB
JavaScript
;
var zod = require('zod');
var __defProp = Object.defineProperty;
var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
var timestampSchema = zod.z.string().regex(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d+)?Z$/);
var uuidSchema = zod.z.string().uuid();
var ontologySummarySchema = zod.z.object({
id: uuidSchema,
name: zod.z.string().min(1),
createdAt: timestampSchema,
format: zod.z.string().optional()
});
var ontologyMetadataSchema = ontologySummarySchema.extend({
size: zod.z.number().nonnegative().optional(),
updatedAt: timestampSchema.optional(),
entityCount: zod.z.number().nonnegative().optional(),
owner: zod.z.string().optional()
});
var authSchema = zod.z.object({
token: zod.z.string(),
refreshToken: zod.z.string().optional(),
expiresAt: timestampSchema.optional(),
userId: zod.z.string().optional(),
permissions: zod.z.array(zod.z.string()).optional()
});
var contextSpecSchema = zod.z.object({
id: zod.z.string(),
parameters: zod.z.record(zod.z.unknown())
});
var contextRequestSchema = zod.z.object({
request_id: zod.z.string(),
current_query: zod.z.string(),
context_specs: zod.z.array(contextSpecSchema)
});
var contextResponseSchema = zod.z.object({
responses: zod.z.array(
zod.z.object({
id: zod.z.string(),
content: zod.z.object({
type: zod.z.string(),
value: zod.z.string()
}),
metadata: zod.z.object({
confidence: zod.z.number(),
source: zod.z.string(),
timestamp: timestampSchema
}).catchall(zod.z.unknown())
})
)
});
var errorResponseSchema = zod.z.object({
error: zod.z.string(),
message: zod.z.string(),
statusCode: zod.z.number().optional(),
code: zod.z.string().optional()
});
var paginationSchema = zod.z.object({
total: zod.z.number().nonnegative(),
page: zod.z.number().nonnegative(),
pageSize: zod.z.number().positive(),
totalPages: zod.z.number().nonnegative(),
hasMore: zod.z.boolean()
});
function createPaginatedSchema(itemSchema) {
return zod.z.object({
data: zod.z.array(itemSchema),
pagination: paginationSchema
});
}
__name(createPaginatedSchema, "createPaginatedSchema");
var apiLimitsSchema = zod.z.object({
limit: zod.z.number().positive(),
remaining: zod.z.number().nonnegative(),
reset: timestampSchema
});
// src/errors/index.ts
var _MCPError = class _MCPError extends Error {
constructor(message, options) {
super(message);
this.name = "MCPError";
this.status = options?.status;
this.code = options?.code;
this.cause = options?.cause;
Object.setPrototypeOf(this, _MCPError.prototype);
}
/**
* Creates a formatted error message with all available details
*/
toFormattedString() {
const parts = [
`[${this.name}] ${this.message}`,
this.code ? `Code: ${this.code}` : null,
this.status ? `Status: ${this.status}` : null,
this.cause ? `Cause: ${this.cause instanceof Error ? this.cause.message : String(this.cause)}` : null
].filter(Boolean);
return parts.join(" | ");
}
};
__name(_MCPError, "MCPError");
var MCPError = _MCPError;
var _ValidationError = class _ValidationError extends MCPError {
constructor(message, options) {
super(message, {
code: options?.code || "VALIDATION_ERROR",
cause: options?.cause
});
this.name = "ValidationError";
this.errors = options?.errors;
Object.setPrototypeOf(this, _ValidationError.prototype);
}
};
__name(_ValidationError, "ValidationError");
var ValidationError = _ValidationError;
// src/validators/validation.ts
function validate(schema, data) {
try {
return schema.parse(data);
} catch (error) {
if (error instanceof zod.z.ZodError) {
throw new ValidationError(
`Validation failed: ${error.errors.map((e) => e.message).join(", ")}`,
{ errors: error.format() }
);
}
throw error;
}
}
__name(validate, "validate");
function validateSafe(schema, data) {
try {
return {
success: true,
data: schema.parse(data)
};
} catch (error) {
if (error instanceof zod.z.ZodError) {
return {
success: false,
error: new ValidationError(
`Validation failed: ${error.errors.map((e) => e.message).join(", ")}`,
{ errors: error.format() }
)
};
}
if (error instanceof Error) {
return {
success: false,
error: new ValidationError(error.message, { cause: error })
};
}
return {
success: false,
error: new ValidationError(`Unknown validation error: ${String(error)}`)
};
}
}
__name(validateSafe, "validateSafe");
function createValidator(schema) {
return (data) => validate(schema, data);
}
__name(createValidator, "createValidator");
function createSafeValidator(schema) {
return (data) => validateSafe(schema, data);
}
__name(createSafeValidator, "createSafeValidator");
function validateArray(schema, data) {
const arraySchema = zod.z.array(schema);
return validate(arraySchema, data);
}
__name(validateArray, "validateArray");
function validateResponse(schema, data) {
const baseSchema = zod.z.object({}).required();
baseSchema.parse(data);
return validate(schema, data);
}
__name(validateResponse, "validateResponse");
exports.apiLimitsSchema = apiLimitsSchema;
exports.authSchema = authSchema;
exports.contextRequestSchema = contextRequestSchema;
exports.contextResponseSchema = contextResponseSchema;
exports.contextSpecSchema = contextSpecSchema;
exports.createPaginatedSchema = createPaginatedSchema;
exports.createSafeValidator = createSafeValidator;
exports.createValidator = createValidator;
exports.errorResponseSchema = errorResponseSchema;
exports.ontologyMetadataSchema = ontologyMetadataSchema;
exports.ontologySummarySchema = ontologySummarySchema;
exports.paginationSchema = paginationSchema;
exports.timestampSchema = timestampSchema;
exports.uuidSchema = uuidSchema;
exports.validate = validate;
exports.validateArray = validateArray;
exports.validateResponse = validateResponse;
exports.validateSafe = validateSafe;
//# sourceMappingURL=index.js.map
//# sourceMappingURL=index.js.map