@blazingagents/sdk 0.1.0

package/dist/contracts/entities/mcp-connections.js

@@ -0,0 +1,473 @@
+import { z } from "zod";
+import { mcpConnectionIdSchema, tenantIdSchema } from "../ids.js";
+import { MAX_MCP_ATTACHMENT_METADATA_KEY_LENGTH, MAX_MCP_ATTACHMENT_METADATA_KEYS, MAX_MCP_BEARER_TOKEN_LENGTH, MAX_MCP_CONNECTION_NAME_LENGTH, MAX_MCP_CONNECTION_TEST_LATENCY_MS, MAX_MCP_CONNECTION_URL_LENGTH, MAX_MCP_OAUTH_CLIENT_ID_LENGTH, MAX_MCP_OAUTH_CLIENT_SECRET_LENGTH, MAX_MCP_OAUTH_SCOPE_LENGTH, MAX_MCP_SERVER_NAME_LENGTH, MAX_MCP_SERVER_VERSION_LENGTH, MAX_MCP_TOOL_NAME_LENGTH, MAX_MCP_TOOLS_PER_CONNECTION, } from "../limitations.js";
+import { atLeastOneFieldMessage, hasObjectKeys, hasUniqueValues, } from "../utils.js";
+const OPAQUE_MCP_OAUTH_TOKEN_PATTERN = /^[A-Za-z0-9_-]{43}$/;
+export const mcpConnectionAuthTypeSchema = z.enum([
+    "none",
+    "bearer",
+    "oauth_authorization_code",
+    "oauth_client_credentials",
+]);
+export const mcpConnectionStatusSchema = z.enum([
+    "connected",
+    "needs_auth",
+    "error",
+]);
+export const mcpConnectionTestErrorCodeSchema = z.enum([
+    "MCP_CONNECTION_AUTHENTICATION_FAILED",
+    "MCP_CONNECTION_INVALID",
+    "MCP_CONNECTION_UNREACHABLE",
+    "MCP_CONNECTION_DISCOVERY_FAILED",
+]);
+const mcpConnectionNameSchema = z
+    .string()
+    .trim()
+    .min(1)
+    .max(MAX_MCP_CONNECTION_NAME_LENGTH);
+const bearerTokenSchema = z
+    .string()
+    .min(1)
+    .max(MAX_MCP_BEARER_TOKEN_LENGTH)
+    .regex(/^[!-~]+$/, "Bearer token must contain visible ASCII characters only");
+const oauthClientIdSchema = z
+    .string()
+    .min(1)
+    .max(MAX_MCP_OAUTH_CLIENT_ID_LENGTH)
+    .regex(/^[!-~]+$/, "Client ID must contain visible ASCII characters only");
+const oauthClientSecretSchema = z
+    .string()
+    .min(1)
+    .max(MAX_MCP_OAUTH_CLIENT_SECRET_LENGTH)
+    .regex(/^[!-~]+$/, "Client secret must contain visible ASCII characters only");
+const storedOauthClientIdSchema = z
+    .string()
+    .min(1)
+    .max(MAX_MCP_OAUTH_CLIENT_ID_LENGTH);
+const storedOauthClientSecretSchema = z
+    .string()
+    .min(1)
+    .max(MAX_MCP_OAUTH_CLIENT_SECRET_LENGTH);
+const oauthScopeSchema = z
+    .string()
+    .trim()
+    .min(1)
+    .max(MAX_MCP_OAUTH_SCOPE_LENGTH)
+    .regex(/^[\x20-\x7e]+$/, "Scope must contain printable ASCII characters only");
+const oauthIssuerSchema = z
+    .string()
+    .trim()
+    .url()
+    .refine((value) => {
+    try {
+        const url = new URL(value);
+        return ((url.protocol === "http:" || url.protocol === "https:") &&
+            url.username === "" &&
+            url.password === "" &&
+            url.search === "" &&
+            url.hash === "");
+    }
+    catch {
+        return false;
+    }
+}, {
+    message: "OAuth issuer must be an http(s) URL without credentials, query, or fragment",
+})
+    .transform((value) => new URL(value).toString());
+const credentialFragmentSchema = z.string().min(1).max(4).nullable();
+/** Mirrors the MCP SDK's SEP-2352 issuer-identity comparison. */
+export function mcpOauthIssuersMatch(a, b) {
+    return (a === b ||
+        (a.endsWith("/") && a.slice(0, -1) === b) ||
+        (b.endsWith("/") && b.slice(0, -1) === a));
+}
+const oauthClientInformationSchema = z.looseObject({
+    client_id: storedOauthClientIdSchema,
+    client_secret: storedOauthClientSecretSchema.optional(),
+    issuer: oauthIssuerSchema,
+});
+const oauthConfidentialClientInformationSchema = oauthClientInformationSchema.safeExtend({
+    client_secret: oauthClientSecretSchema,
+});
+const oauthTokensSchema = z
+    .object({
+    access_token: z.string().min(1),
+    expires_in: z.number().positive().optional(),
+    issuer: oauthIssuerSchema,
+    refresh_token: z.string().optional(),
+    scope: z.string().optional(),
+    token_type: z.string().min(1),
+})
+    .strict();
+const oauthDiscoveryStateSchema = z.looseObject({
+    authorizationServerMetadata: z.record(z.string(), z.unknown()).optional(),
+    authorizationServerUrl: oauthIssuerSchema,
+    resourceMetadata: z.record(z.string(), z.unknown()).optional(),
+    resourceMetadataUrl: z.string().url().optional(),
+});
+export const mcpOauthClientCredentialsBundleSchema = z
+    .object({
+    clientInformation: oauthConfidentialClientInformationSchema,
+    discoveryState: oauthDiscoveryStateSchema.nullable(),
+    scope: oauthScopeSchema.nullable(),
+    tokens: oauthTokensSchema.nullable(),
+    type: z.literal("oauth_client_credentials"),
+    version: z.literal(1),
+})
+    .strict()
+    .superRefine((bundle, context) => {
+    if (bundle.tokens &&
+        bundle.tokens.issuer !== bundle.clientInformation.issuer) {
+        context.addIssue({
+            code: "custom",
+            message: "OAuth token issuer must match the client issuer",
+            path: ["tokens", "issuer"],
+        });
+    }
+});
+export const mcpOauthAuthorizationCodeBundleSchema = z
+    .object({
+    clientInformation: oauthClientInformationSchema.nullable(),
+    discoveryState: oauthDiscoveryStateSchema.nullable(),
+    scope: oauthScopeSchema.nullable(),
+    tokens: oauthTokensSchema.nullable(),
+    type: z.literal("oauth_authorization_code"),
+    version: z.literal(1),
+})
+    .strict()
+    .superRefine((bundle, context) => {
+    if (bundle.tokens && !bundle.clientInformation) {
+        context.addIssue({
+            code: "custom",
+            message: "OAuth tokens require client information",
+            path: ["clientInformation"],
+        });
+        return;
+    }
+    if (bundle.tokens &&
+        bundle.tokens.issuer !== bundle.clientInformation?.issuer) {
+        context.addIssue({
+            code: "custom",
+            message: "OAuth token issuer must match the client issuer",
+            path: ["tokens", "issuer"],
+        });
+    }
+});
+export const mcpOauthAuthorizationTransactionBundleSchema = z
+    .object({
+    clientInformation: oauthClientInformationSchema.nullable(),
+    codeVerifier: z.string().min(1).max(1024).nullable(),
+    credentialVersion: z.number().int().nonnegative(),
+    discoveryState: oauthDiscoveryStateSchema.nullable(),
+    expectedIssuer: oauthIssuerSchema,
+    expectedResource: z.string().url(),
+    redirectUri: z.string().url(),
+    scope: oauthScopeSchema.nullable(),
+    type: z.literal("oauth_authorization_code_transaction"),
+    version: z.literal(1),
+})
+    .strict()
+    .superRefine((bundle, context) => {
+    if (bundle.clientInformation &&
+        bundle.clientInformation.issuer !== bundle.expectedIssuer) {
+        context.addIssue({
+            code: "custom",
+            message: "OAuth client issuer must match the expected issuer",
+            path: ["clientInformation", "issuer"],
+        });
+    }
+    if ((bundle.codeVerifier !== null || bundle.discoveryState !== null) &&
+        bundle.clientInformation === null) {
+        context.addIssue({
+            code: "custom",
+            message: "An active OAuth transaction requires client information",
+            path: ["clientInformation"],
+        });
+    }
+});
+export const mcpBearerCredentialBundleSchema = z
+    .object({
+    bearerToken: bearerTokenSchema,
+    type: z.literal("bearer"),
+    version: z.literal(1),
+})
+    .strict();
+export const mcpCredentialBundleSchema = z.discriminatedUnion("type", [
+    mcpBearerCredentialBundleSchema,
+    mcpOauthAuthorizationCodeBundleSchema,
+    mcpOauthClientCredentialsBundleSchema,
+]);
+const mcpConnectionUrlSchema = z
+    .string()
+    .trim()
+    .max(MAX_MCP_CONNECTION_URL_LENGTH)
+    .url()
+    .refine((value) => {
+    try {
+        const url = new URL(value);
+        return ((url.protocol === "http:" || url.protocol === "https:") &&
+            url.username === "" &&
+            url.password === "" &&
+            url.hash === "" &&
+            url.search === "");
+    }
+    catch {
+        return false;
+    }
+}, {
+    message: "URL must use http(s) without credentials, query, or fragment",
+})
+    .transform((value) => new URL(value).toString());
+export const mcpConnectionSchema = z
+    .object({
+    id: mcpConnectionIdSchema,
+    tenantId: tenantIdSchema,
+    name: mcpConnectionNameSchema,
+    url: mcpConnectionUrlSchema,
+    authType: mcpConnectionAuthTypeSchema,
+    status: mcpConnectionStatusSchema,
+    credentialVersion: z.number().int().nonnegative(),
+    credentialFragment: credentialFragmentSchema,
+    lastAuthErrorCode: mcpConnectionTestErrorCodeSchema.nullable(),
+    oauthIssuer: z.string().url().nullable(),
+    oauthResource: z.string().url().nullable(),
+    tokenExpiresAt: z.iso.datetime({ offset: true }).nullable(),
+    createdAt: z.iso.datetime({ offset: true }),
+    updatedAt: z.iso.datetime({ offset: true }),
+})
+    .strict();
+export const mcpConnectionResponseSchema = z
+    .object({
+    id: mcpConnectionIdSchema,
+    name: mcpConnectionNameSchema,
+    url: mcpConnectionUrlSchema,
+    authType: mcpConnectionAuthTypeSchema,
+    status: mcpConnectionStatusSchema,
+    credentialFragment: credentialFragmentSchema,
+    lastAuthErrorCode: mcpConnectionTestErrorCodeSchema.nullable(),
+    oauthIssuer: z.string().url().nullable(),
+    oauthResource: z.string().url().nullable(),
+    tokenExpiresAt: z.iso.datetime({ offset: true }).nullable(),
+    createdAt: z.iso.datetime({ offset: true }),
+    updatedAt: z.iso.datetime({ offset: true }),
+})
+    .strict();
+export const mcpConnectionsResponseSchema = z
+    .object({
+    mcpConnections: z.array(mcpConnectionResponseSchema),
+})
+    .strict();
+export const forwardedMetadataKeysSchema = z
+    .array(z.string().min(1).max(MAX_MCP_ATTACHMENT_METADATA_KEY_LENGTH))
+    .max(MAX_MCP_ATTACHMENT_METADATA_KEYS)
+    .refine(hasUniqueValues, {
+    message: "Forwarded metadata keys must be unique.",
+});
+export const mcpAttachmentResponseSchema = z
+    .object({
+    mcpConnectionId: mcpConnectionIdSchema,
+    forwardUserId: z.boolean(),
+    forwardedMetadataKeys: forwardedMetadataKeysSchema,
+    createdAt: z.iso.datetime({ offset: true }),
+    updatedAt: z.iso.datetime({ offset: true }),
+})
+    .strict();
+export const mcpAttachmentsResponseSchema = z
+    .object({
+    mcpAttachments: z.array(mcpAttachmentResponseSchema),
+})
+    .strict();
+export const updateMcpAttachmentBodySchema = z
+    .object({
+    forwardUserId: z.boolean().optional(),
+    forwardedMetadataKeys: forwardedMetadataKeysSchema.optional(),
+})
+    .strict()
+    .refine(hasObjectKeys, {
+    message: atLeastOneFieldMessage,
+});
+const createNoneMcpConnectionBodySchema = z
+    .object({
+    name: mcpConnectionNameSchema,
+    url: mcpConnectionUrlSchema,
+    authType: z.literal("none"),
+})
+    .strict();
+const createBearerMcpConnectionBodySchema = z
+    .object({
+    name: mcpConnectionNameSchema,
+    url: mcpConnectionUrlSchema,
+    authType: z.literal("bearer"),
+    bearerToken: bearerTokenSchema,
+})
+    .strict();
+const oauthClientCredentialsFields = {
+    authType: z.literal("oauth_client_credentials"),
+    clientId: oauthClientIdSchema,
+    clientSecret: oauthClientSecretSchema,
+    scope: oauthScopeSchema.optional(),
+    url: mcpConnectionUrlSchema,
+};
+const oauthAuthorizationCodeFields = {
+    authType: z.literal("oauth_authorization_code"),
+    clientId: oauthClientIdSchema.optional(),
+    clientSecret: oauthClientSecretSchema.optional(),
+    scope: oauthScopeSchema.optional(),
+    url: mcpConnectionUrlSchema,
+};
+const createOauthAuthorizationCodeMcpConnectionBodySchema = z
+    .object({
+    ...oauthAuthorizationCodeFields,
+    name: mcpConnectionNameSchema,
+})
+    .strict();
+const createOauthClientCredentialsMcpConnectionBodySchema = z
+    .object({
+    ...oauthClientCredentialsFields,
+    name: mcpConnectionNameSchema,
+})
+    .strict();
+export const createMcpConnectionBodySchema = z
+    .discriminatedUnion("authType", [
+    createNoneMcpConnectionBodySchema,
+    createBearerMcpConnectionBodySchema,
+    createOauthAuthorizationCodeMcpConnectionBodySchema,
+    createOauthClientCredentialsMcpConnectionBodySchema,
+])
+    .superRefine((body, context) => {
+    if (body.authType === "oauth_authorization_code" &&
+        (body.clientId === undefined) !== (body.clientSecret === undefined)) {
+        context.addIssue({
+            code: "custom",
+            message: "OAuth client ID and secret must be provided together",
+            path: [body.clientId === undefined ? "clientId" : "clientSecret"],
+        });
+    }
+});
+export const updateMcpConnectionBodySchema = z
+    .object({
+    name: mcpConnectionNameSchema.optional(),
+})
+    .strict()
+    .refine(hasObjectKeys, {
+    message: atLeastOneFieldMessage,
+});
+export const reconnectMcpConnectionBodySchema = z
+    .discriminatedUnion("authType", [
+    z
+        .object({
+        authType: z.literal("none"),
+        url: mcpConnectionUrlSchema,
+    })
+        .strict(),
+    z
+        .object({
+        authType: z.literal("bearer"),
+        bearerToken: bearerTokenSchema,
+        url: mcpConnectionUrlSchema,
+    })
+        .strict(),
+    z.object(oauthAuthorizationCodeFields).strict(),
+    z.object(oauthClientCredentialsFields).strict(),
+])
+    .superRefine((body, context) => {
+    if (body.authType === "oauth_authorization_code" &&
+        (body.clientId === undefined) !== (body.clientSecret === undefined)) {
+        context.addIssue({
+            code: "custom",
+            message: "OAuth client ID and secret must be provided together",
+            path: [body.clientId === undefined ? "clientId" : "clientSecret"],
+        });
+    }
+});
+export const mcpConnectionOauthConnectResponseSchema = z
+    .object({
+    authorizationUrl: z
+        .string()
+        .url()
+        .refine((value) => {
+        const url = new URL(value);
+        return (url.pathname === "/app/mcp-connections" &&
+            url.username === "" &&
+            url.password === "" &&
+            url.hash === "" &&
+            url.searchParams.size === 1 &&
+            OPAQUE_MCP_OAUTH_TOKEN_PATTERN.test(url.searchParams.get("mcpOAuthSetup") ?? ""));
+    }),
+})
+    .strict();
+export const mcpOauthAuthorizationLaunchResponseSchema = z
+    .object({
+    authorizationUrl: z
+        .string()
+        .url()
+        .refine((value) => {
+        const url = new URL(value);
+        return (url.pathname === "/v1/mcp/oauth/authorize" &&
+            url.username === "" &&
+            url.password === "" &&
+            url.hash === "" &&
+            url.searchParams.size === 1 &&
+            OPAQUE_MCP_OAUTH_TOKEN_PATTERN.test(url.searchParams.get("setup") ?? ""));
+    }),
+})
+    .strict();
+export const approveMcpOauthAuthorizationBodySchema = z
+    .object({ setupToken: z.string().regex(OPAQUE_MCP_OAUTH_TOKEN_PATTERN) })
+    .strict();
+export const mcpConnectionLiveDetailsSchema = z
+    .object({
+    server: z
+        .object({
+        name: z.string().trim().min(1).max(MAX_MCP_SERVER_NAME_LENGTH),
+        version: z.string().trim().min(1).max(MAX_MCP_SERVER_VERSION_LENGTH),
+    })
+        .strict(),
+    toolNames: z
+        .array(z.string().trim().min(1).max(MAX_MCP_TOOL_NAME_LENGTH))
+        .max(MAX_MCP_TOOLS_PER_CONNECTION),
+})
+    .strict();
+const mcpConnectionTestOkResponseSchema = mcpConnectionLiveDetailsSchema
+    .extend({
+    ok: z.literal(true),
+    latencyMs: z
+        .number()
+        .int()
+        .nonnegative()
+        .max(MAX_MCP_CONNECTION_TEST_LATENCY_MS),
+    toolCount: z.number().int().nonnegative().max(MAX_MCP_TOOLS_PER_CONNECTION),
+})
+    .strict()
+    .refine((result) => result.toolCount === result.toolNames.length, {
+    message: "toolCount must match toolNames length",
+});
+const mcpConnectionTestFailResponseSchema = z
+    .object({
+    ok: z.literal(false),
+    error: z
+        .object({
+        code: mcpConnectionTestErrorCodeSchema,
+        message: z.string().trim().min(1).max(200),
+    })
+        .strict(),
+})
+    .strict();
+export const mcpConnectionTestResponseSchema = z.discriminatedUnion("ok", [
+    mcpConnectionTestOkResponseSchema,
+    mcpConnectionTestFailResponseSchema,
+]);
+export const mcpConnectionReconnectResultSchema = z.discriminatedUnion("status", [
+    z
+        .object({
+        status: z.literal("connected"),
+        connection: mcpConnectionResponseSchema,
+    })
+        .strict(),
+    z
+        .object({
+        status: z.literal("needs_auth"),
+        connection: mcpConnectionResponseSchema,
+    })
+        .strict(),
+]);

package/dist/contracts/entities/memories.d.ts

@@ -0,0 +1,56 @@
+import { z } from "zod";
+export declare const memoryTextSchema: z.ZodString;
+export declare const memorySchema: z.ZodObject<{
+    id: z.ZodString;
+    tenantId: z.ZodString;
+    agentId: z.ZodString;
+    userId: z.ZodString;
+    text: z.ZodString;
+    createdAt: z.ZodISODateTime;
+    updatedAt: z.ZodISODateTime;
+    lastAccessedAt: z.ZodISODateTime;
+}, z.core.$strict>;
+export declare const memoryResponseSchema: z.ZodObject<{
+    memory: z.ZodObject<{
+        id: z.ZodString;
+        tenantId: z.ZodString;
+        agentId: z.ZodString;
+        userId: z.ZodString;
+        text: z.ZodString;
+        createdAt: z.ZodISODateTime;
+        updatedAt: z.ZodISODateTime;
+        lastAccessedAt: z.ZodISODateTime;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export declare const memoriesListResponseSchema: z.ZodObject<{
+    data: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        tenantId: z.ZodString;
+        agentId: z.ZodString;
+        userId: z.ZodString;
+        text: z.ZodString;
+        createdAt: z.ZodISODateTime;
+        updatedAt: z.ZodISODateTime;
+        lastAccessedAt: z.ZodISODateTime;
+    }, z.core.$strict>>;
+    nextCursor: z.ZodNullable<z.ZodString>;
+}, z.core.$strict>;
+export declare const memoriesListQuerySchema: z.ZodObject<{
+    userId: z.ZodOptional<z.ZodString>;
+    search: z.ZodOptional<z.ZodString>;
+    cursor: z.ZodOptional<z.ZodString>;
+    limit: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+}, z.core.$strict>;
+export declare const createMemoryBodySchema: z.ZodObject<{
+    text: z.ZodString;
+    userId: z.ZodDefault<z.ZodString>;
+}, z.core.$strict>;
+export declare const updateMemoryBodySchema: z.ZodObject<{
+    text: z.ZodString;
+}, z.core.$strict>;
+export type Memory = z.infer<typeof memorySchema>;
+export type MemoryResponse = z.infer<typeof memoryResponseSchema>;
+export type MemoriesListQuery = z.infer<typeof memoriesListQuerySchema>;
+export type MemoriesListResponse = z.infer<typeof memoriesListResponseSchema>;
+export type CreateMemoryBody = z.input<typeof createMemoryBodySchema>;
+export type UpdateMemoryBody = z.infer<typeof updateMemoryBodySchema>;

package/dist/contracts/entities/memories.js

@@ -0,0 +1,62 @@
+import { z } from "zod";
+import { cursorSchema, paginatedResponseSchema } from "../api.js";
+import { agentIdSchema, memoryIdSchema, tenantIdSchema } from "../ids.js";
+import { DEFAULT_MEMORIES_LIST_LIMIT, MAX_MEMORIES_LIST_LIMIT, MAX_MEMORY_TEXT_BYTES, } from "../limitations.js";
+import { userIdSchema } from "./attribution.js";
+/**
+ * Memory — a single Agent-owned text row (Agent Memories PRD). `userId` is
+ * optional Attribution: `''` marks an Agent-general row, stamped at creation
+ * and immutable. The record is the full tenant-facing shape; the generated
+ * `searchVector` never leaves the database. Text is capped at 10 KiB
+ * (bytes, not characters) here for a clean 4xx — the DB `octet_length`
+ * check is the hard backstop.
+ */
+const textEncoder = new TextEncoder();
+export const memoryTextSchema = z
+    .string()
+    .min(1)
+    .refine((text) => textEncoder.encode(text).length <= MAX_MEMORY_TEXT_BYTES, {
+    message: `Memory text must be at most ${MAX_MEMORY_TEXT_BYTES} bytes.`,
+});
+export const memorySchema = z
+    .object({
+    id: memoryIdSchema,
+    tenantId: tenantIdSchema,
+    agentId: agentIdSchema,
+    userId: userIdSchema,
+    text: memoryTextSchema,
+    createdAt: z.iso.datetime({ offset: true }),
+    updatedAt: z.iso.datetime({ offset: true }),
+    lastAccessedAt: z.iso.datetime({ offset: true }),
+})
+    .strict();
+export const memoryResponseSchema = z
+    .object({
+    memory: memorySchema,
+})
+    .strict();
+export const memoriesListResponseSchema = paginatedResponseSchema(memorySchema);
+export const memoriesListQuerySchema = z
+    .object({
+    userId: userIdSchema.optional(),
+    search: z.string().trim().min(1).optional(),
+    cursor: cursorSchema.optional(),
+    limit: z.coerce
+        .number()
+        .int()
+        .min(1)
+        .max(MAX_MEMORIES_LIST_LIMIT)
+        .default(DEFAULT_MEMORIES_LIST_LIMIT),
+})
+    .strict();
+export const createMemoryBodySchema = z
+    .object({
+    text: memoryTextSchema,
+    userId: userIdSchema.default(""),
+})
+    .strict();
+export const updateMemoryBodySchema = z
+    .object({
+    text: memoryTextSchema,
+})
+    .strict();

package/dist/contracts/entities/prompts.d.ts

@@ -0,0 +1,61 @@
+import { z } from "zod";
+export interface PromptVariableParseResult {
+    invalidVariableNames: string[];
+    variables: string[];
+}
+export declare const promptVariableTokenPattern: RegExp;
+export declare const promptVariableNamePattern: RegExp;
+export declare function parsePromptVariables(template: string): PromptVariableParseResult;
+export declare const promptTemplateSchema: z.ZodString;
+export declare const promptSchema: z.ZodObject<{
+    id: z.ZodString;
+    tenantId: z.ZodString;
+    name: z.ZodString;
+    template: z.ZodString;
+    variables: z.ZodArray<z.ZodString>;
+    userId: z.ZodString;
+    metadata: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    createdAt: z.ZodISODateTime;
+    updatedAt: z.ZodISODateTime;
+}, z.core.$strict>;
+export declare const promptsResponseSchema: z.ZodObject<{
+    prompts: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        tenantId: z.ZodString;
+        name: z.ZodString;
+        template: z.ZodString;
+        variables: z.ZodArray<z.ZodString>;
+        userId: z.ZodString;
+        metadata: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        createdAt: z.ZodISODateTime;
+        updatedAt: z.ZodISODateTime;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export declare const promptResponseSchema: z.ZodObject<{
+    id: z.ZodString;
+    tenantId: z.ZodString;
+    name: z.ZodString;
+    template: z.ZodString;
+    variables: z.ZodArray<z.ZodString>;
+    userId: z.ZodString;
+    metadata: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    createdAt: z.ZodISODateTime;
+    updatedAt: z.ZodISODateTime;
+}, z.core.$strict>;
+export declare const createPromptBodySchema: z.ZodObject<{
+    name: z.ZodString;
+    template: z.ZodString;
+    userId: z.ZodDefault<z.ZodString>;
+    metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strict>;
+export declare const updatePromptBodySchema: z.ZodObject<{
+    name: z.ZodOptional<z.ZodString>;
+    template: z.ZodOptional<z.ZodString>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strict>;
+export declare function renderPromptTemplate(template: string, values: Record<string, string>): string;
+export type Prompt = z.infer<typeof promptSchema>;
+export type PromptsResponse = z.infer<typeof promptsResponseSchema>;
+export type PromptResponse = z.infer<typeof promptResponseSchema>;
+export type CreatePromptBody = z.input<typeof createPromptBodySchema>;
+export type UpdatePromptBody = z.infer<typeof updatePromptBodySchema>;