@blazingagents/sdk 0.23.0 → 0.25.0

package/dist/contracts/entities/agents.js

@@ -42,7 +42,7 @@ const providerModelPairMessage = "Provider and model must either both be set or
 function hasProviderModelPair(input) {
     return (input.model === null) === (input.providerId === null);
 }
-export const agentSchema = z
+export const agentResponseSchema = z
     .object({
     ...approvalFields,
     id: agentIdSchema,
@@ -75,8 +75,7 @@ export const agentSchema = z
     message: providerModelPairMessage,
     path: ["providerId"],
 });
-export const agentsResponseSchema = paginatedResponseSchema(agentSchema);
-export const agentResponseSchema = agentSchema;
+export const agentsResponseSchema = paginatedResponseSchema(agentResponseSchema);
 export const agentsListQuerySchema = z
     .object({
     cursor: cursorSchema.optional(),
@@ -93,17 +92,17 @@ export const agentsListQuerySchema = z
 export const agentConfigSchema = z
     .object({
     ...approvalFields,
-    name: agentSchema.shape.name,
-    model: agentSchema.shape.model,
-    thinkingLevel: agentSchema.shape.thinkingLevel,
-    providerId: agentSchema.shape.providerId,
-    autoCompaction: agentSchema.shape.autoCompaction,
-    compactionReserveTokens: agentSchema.shape.compactionReserveTokens,
-    memoryInjectionEnabled: agentSchema.shape.memoryInjectionEnabled,
-    tools: agentSchema.shape.tools,
-    instructions: agentSchema.shape.instructions,
-    metadata: agentSchema.shape.metadata,
-    mcpConnectionIds: agentSchema.shape.mcpConnectionIds,
+    name: agentResponseSchema.shape.name,
+    model: agentResponseSchema.shape.model,
+    thinkingLevel: agentResponseSchema.shape.thinkingLevel,
+    providerId: agentResponseSchema.shape.providerId,
+    autoCompaction: agentResponseSchema.shape.autoCompaction,
+    compactionReserveTokens: agentResponseSchema.shape.compactionReserveTokens,
+    memoryInjectionEnabled: agentResponseSchema.shape.memoryInjectionEnabled,
+    tools: agentResponseSchema.shape.tools,
+    instructions: agentResponseSchema.shape.instructions,
+    metadata: agentResponseSchema.shape.metadata,
+    mcpConnectionIds: agentResponseSchema.shape.mcpConnectionIds,
 })
     .strip()
     .refine(hasProviderModelPair, {
@@ -120,7 +119,7 @@ export const createAgentBodySchema = z
     workspaceId: workspaceIdSchema.optional(),
     workspaceTier: workspaceTierSchema.optional(),
     autoCompaction: z.boolean().default(true),
-    compactionReserveTokens: agentSchema.shape.compactionReserveTokens.default(16_384),
+    compactionReserveTokens: agentResponseSchema.shape.compactionReserveTokens.default(16_384),
     memoryInjectionEnabled: z.boolean().default(false),
     tools: agentToolsSchema.default([]),
     instructions: agentInstructionsSchema.default(""),
@@ -147,7 +146,7 @@ export const updateAgentBodySchema = z
     providerId: providerIdSchema.nullable().optional(),
     workspaceId: workspaceIdSchema.optional(),
     autoCompaction: z.boolean().optional(),
-    compactionReserveTokens: agentSchema.shape.compactionReserveTokens.optional(),
+    compactionReserveTokens: agentResponseSchema.shape.compactionReserveTokens.optional(),
     memoryInjectionEnabled: z.boolean().optional(),
     tools: agentToolsSchema.optional(),
     instructions: agentInstructionsSchema.optional(),

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

@@ -32,40 +32,10 @@ export declare const artifactsListResponseSchema: z.ZodObject<{
     }, z.core.$strip>>;
     nextCursor: z.ZodNullable<z.ZodString>;
 }, z.core.$strip>;
-export declare const artifactsListQuerySchema: z.ZodObject<{
-    agentId: z.ZodOptional<z.ZodString>;
-    sessionId: z.ZodOptional<z.ZodString>;
-    cursor: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-}, z.core.$strict>;
-export declare const publishArtifactsInputSchema: z.ZodObject<{
-    paths: z.ZodArray<z.ZodString>;
-}, z.core.$strict>;
-export declare const publishArtifactResultSchema: z.ZodUnion<readonly [z.ZodObject<{
-    artifactId: z.ZodString;
-    path: z.ZodString;
-}, z.core.$strip>, z.ZodObject<{
-    error: z.ZodLiteral<true>;
-    message: z.ZodString;
-    path: z.ZodString;
-}, z.core.$strip>]>;
-export declare const publishArtifactsOutputSchema: z.ZodObject<{
-    results: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
-        artifactId: z.ZodString;
-        path: z.ZodString;
-    }, z.core.$strip>, z.ZodObject<{
-        error: z.ZodLiteral<true>;
-        message: z.ZodString;
-        path: z.ZodString;
-    }, z.core.$strip>]>>;
-}, z.core.$strip>;
 export declare const artifactDownloadUrlResponseSchema: z.ZodObject<{
     url: z.ZodURL;
     expiresAt: z.ZodISODateTime;
 }, z.core.$strip>;
 export type ArtifactListItem = z.infer<typeof artifactListItemSchema>;
 export type ArtifactsListResponse = z.infer<typeof artifactsListResponseSchema>;
-export type ArtifactsListQuery = z.infer<typeof artifactsListQuerySchema>;
-export type PublishArtifactsInput = z.infer<typeof publishArtifactsInputSchema>;
-export type PublishArtifactResult = z.infer<typeof publishArtifactResultSchema>;
-export type PublishArtifactsOutput = z.infer<typeof publishArtifactsOutputSchema>;
 export type ArtifactDownloadUrlResponse = z.infer<typeof artifactDownloadUrlResponseSchema>;

package/dist/contracts/entities/artifacts.js

@@ -1,7 +1,7 @@
 import { z } from "zod";
 import { paginatedResponseSchema } from "../api.js";
 import { agentIdSchema, artifactIdSchema, sessionIdSchema, tenantIdSchema, } from "../ids.js";
-import { MAX_ARTIFACT_BYTES, MAX_ARTIFACT_PUBLICATIONS_PER_CALL, } from "../limitations.js";
+import { MAX_ARTIFACT_BYTES } from "../limitations.js";
 import { metadataSchema, userIdSchema } from "./attribution.js";
 export const artifactFilenameSchema = z
     .string()
@@ -28,41 +28,6 @@ export const artifactListItemSchema = z
 })
     .strip();
 export const artifactsListResponseSchema = paginatedResponseSchema(artifactListItemSchema);
-export const artifactsListQuerySchema = z
-    .object({
-    agentId: agentIdSchema.optional(),
-    sessionId: sessionIdSchema.optional(),
-    cursor: z.string().nullable().optional(),
-})
-    .strict();
-export const publishArtifactsInputSchema = z
-    .object({
-    paths: z
-        .array(z.string().trim().min(1))
-        .min(1)
-        .max(MAX_ARTIFACT_PUBLICATIONS_PER_CALL),
-})
-    .strict();
-export const publishArtifactResultSchema = z.union([
-    z
-        .object({
-        artifactId: artifactIdSchema,
-        path: z.string().trim().min(1),
-    })
-        .strip(),
-    z
-        .object({
-        error: z.literal(true),
-        message: z.string().trim().min(1),
-        path: z.string().trim().min(1),
-    })
-        .strip(),
-]);
-export const publishArtifactsOutputSchema = z
-    .object({
-    results: z.array(publishArtifactResultSchema).min(1),
-})
-    .strip();
 export const artifactDownloadUrlResponseSchema = z
     .object({
     url: z.url(),

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

@@ -23,5 +23,3 @@ export declare const attributionCreateInputSchema: z.ZodObject<{
     userId: z.ZodDefault<z.ZodString>;
     metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
 }, z.core.$strict>;
-export type UserId = z.infer<typeof userIdSchema>;
-export type Metadata = z.infer<typeof metadataSchema>;

package/dist/contracts/entities/chat-connections.d.ts

@@ -56,9 +56,6 @@ export declare const updateChatConnectionBodySchema: z.ZodObject<{
         channelIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
     }, z.core.$strict>>;
 }, z.core.$strict>;
-export declare const chatConnectionParamsSchema: z.ZodObject<{
-    id: z.ZodString;
-}, z.core.$strip>;
 export declare const chatHealthCheckSchema: z.ZodObject<{
     code: z.ZodString;
     status: z.ZodEnum<{

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

@@ -90,9 +90,6 @@ export const updateChatConnectionBodySchema = z
     .refine((body) => body.name !== undefined ||
     (body.configuration !== undefined &&
         Object.keys(body.configuration).length > 0), { message: "Provide a name or a configuration change" });
-export const chatConnectionParamsSchema = z.object({
-    id: chatConnectionIdSchema,
-});
 export const chatHealthCheckSchema = z
     .object({
     code: z.string(),

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

@@ -3,7 +3,6 @@ import { z } from "zod";
  * Re-exported AI SDK types — every service, the SDK, and the dashboard
  * consume these from one place.
  */
-export type { UIMessage, UIMessageChunk } from "ai";
 export declare const chatModeSchema: z.ZodEnum<{
     create: "create";
     resume: "resume";
@@ -311,24 +310,8 @@ export declare const generationRequestBodySchema: z.ZodObject<{
     userId?: string | undefined;
     metadata?: Record<string, unknown> | undefined;
 }>>;
-/**
- * Mid-stream error chunk — the AI SDK native `{ type: 'error', errorText }`
- * shape (docs/adr/0003-ai-sdk-native-wire-protocol.md). `errorText` is a plain string:
- * safe human-readable prose produced by our server-side `onError` mapping —
- * no JSON stuffed in the string, no client-side parsing. `useChat` routes it
- * to `onError`, never into the transcript.
- */
-export declare const chatStreamErrorChunkSchema: z.ZodObject<{
-    type: z.ZodLiteral<"error">;
-    errorText: z.ZodString;
-}, z.core.$strip>;
-export type ChatMode = z.infer<typeof chatModeSchema>;
-export type ChatTrigger = z.infer<typeof chatTriggerSchema>;
 export type UsageSummary = z.infer<typeof usageSummarySchema>;
 export type BlazingAgentsChatMessageMetadata = z.infer<typeof blazingAgentsChatMessageMetadataSchema>;
-export type ChatRequestBody = z.infer<typeof chatRequestBodySchema>;
-export type GenerationRequestBody = z.infer<typeof generationRequestBodySchema>;
-export type ChatStreamErrorChunk = z.infer<typeof chatStreamErrorChunkSchema>;
 export type PromptVariables = z.infer<typeof promptVariablesSchema>;
 export type ChatFunctionDefinition = z.infer<typeof chatFunctionDefinitionSchema>;
 export type ChatFunctionDefinitions = z.infer<typeof chatFunctionDefinitionsSchema>;
@@ -336,3 +319,4 @@ export type ChatFunctionCallEvent = z.infer<typeof chatFunctionCallEventSchema>;
 export type ChatFunctionOutcome = z.infer<typeof chatFunctionOutcomeSchema>;
 export type ClaimChatFunctionBody = z.infer<typeof claimChatFunctionBodySchema>;
 export type ResolveChatFunctionBody = z.infer<typeof resolveChatFunctionBodySchema>;
+export {};

package/dist/contracts/entities/chat.js

@@ -3,6 +3,10 @@ import { agentIdSchema, functionCallIdSchema, promptIdSchema, sessionIdSchema, t
 import { chatFunctionNameSchema } from "./agent-tools.js";
 import { agentModelIdSchema } from "./agents.js";
 import { metadataSchema, userIdSchema } from "./attribution.js";
+/**
+ * Re-exported AI SDK types — every service, the SDK, and the dashboard
+ * consume these from one place.
+ */
 export const chatModeSchema = z.enum(["create", "resume"]);
 export const chatTriggerSchema = z.enum([
     "submit-message",
@@ -249,16 +253,3 @@ export const generationRequestBodySchema = z
     message: "Provide either `prompt` or `promptId` (+`variables`); they are mutually exclusive, and `variables` is only allowed with `promptId`.",
     path: ["prompt"],
 });
-/**
- * Mid-stream error chunk — the AI SDK native `{ type: 'error', errorText }`
- * shape (docs/adr/0003-ai-sdk-native-wire-protocol.md). `errorText` is a plain string:
- * safe human-readable prose produced by our server-side `onError` mapping —
- * no JSON stuffed in the string, no client-side parsing. `useChat` routes it
- * to `onError`, never into the transcript.
- */
-export const chatStreamErrorChunkSchema = z
-    .object({
-    type: z.literal("error"),
-    errorText: z.string(),
-})
-    .strip();

package/dist/contracts/entities/mcp-connections.d.ts

@@ -16,165 +16,6 @@ export declare const mcpConnectionTestErrorCodeSchema: z.ZodEnum<{
     MCP_CONNECTION_INVALID: "MCP_CONNECTION_INVALID";
     MCP_CONNECTION_UNREACHABLE: "MCP_CONNECTION_UNREACHABLE";
 }>;
-/**
- * Mirrors the MCP SDK's SEP-2352 issuer-identity comparison.
- */
-export declare function mcpOauthIssuersMatch(a: string, b: string): boolean;
-export declare const mcpOauthClientCredentialsBundleSchema: z.ZodObject<{
-    clientInformation: z.ZodObject<{
-        client_id: z.ZodString;
-        issuer: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
-        client_secret: z.ZodString;
-    }, z.core.$loose>;
-    discoveryState: z.ZodNullable<z.ZodObject<{
-        authorizationServerMetadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-        authorizationServerUrl: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
-        resourceMetadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-        resourceMetadataUrl: z.ZodOptional<z.ZodString>;
-    }, z.core.$loose>>;
-    scope: z.ZodNullable<z.ZodString>;
-    tokens: z.ZodNullable<z.ZodObject<{
-        access_token: z.ZodString;
-        expires_in: z.ZodOptional<z.ZodNumber>;
-        issuer: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
-        refresh_token: z.ZodOptional<z.ZodString>;
-        scope: z.ZodOptional<z.ZodString>;
-        token_type: z.ZodString;
-    }, z.core.$strict>>;
-    type: z.ZodLiteral<"oauth_client_credentials">;
-    version: z.ZodLiteral<1>;
-}, z.core.$strict>;
-export declare const mcpOauthAuthorizationCodeBundleSchema: z.ZodObject<{
-    clientInformation: z.ZodNullable<z.ZodObject<{
-        client_id: z.ZodString;
-        client_secret: z.ZodOptional<z.ZodString>;
-        issuer: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
-    }, z.core.$loose>>;
-    discoveryState: z.ZodNullable<z.ZodObject<{
-        authorizationServerMetadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-        authorizationServerUrl: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
-        resourceMetadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-        resourceMetadataUrl: z.ZodOptional<z.ZodString>;
-    }, z.core.$loose>>;
-    scope: z.ZodNullable<z.ZodString>;
-    tokens: z.ZodNullable<z.ZodObject<{
-        access_token: z.ZodString;
-        expires_in: z.ZodOptional<z.ZodNumber>;
-        issuer: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
-        refresh_token: z.ZodOptional<z.ZodString>;
-        scope: z.ZodOptional<z.ZodString>;
-        token_type: z.ZodString;
-    }, z.core.$strict>>;
-    type: z.ZodLiteral<"oauth_authorization_code">;
-    version: z.ZodLiteral<1>;
-}, z.core.$strict>;
-export declare const mcpOauthAuthorizationTransactionBundleSchema: z.ZodObject<{
-    clientInformation: z.ZodNullable<z.ZodObject<{
-        client_id: z.ZodString;
-        client_secret: z.ZodOptional<z.ZodString>;
-        issuer: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
-    }, z.core.$loose>>;
-    codeVerifier: z.ZodNullable<z.ZodString>;
-    credentialVersion: z.ZodNumber;
-    discoveryState: z.ZodNullable<z.ZodObject<{
-        authorizationServerMetadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-        authorizationServerUrl: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
-        resourceMetadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-        resourceMetadataUrl: z.ZodOptional<z.ZodString>;
-    }, z.core.$loose>>;
-    expectedIssuer: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
-    expectedResource: z.ZodString;
-    redirectUri: z.ZodString;
-    scope: z.ZodNullable<z.ZodString>;
-    type: z.ZodLiteral<"oauth_authorization_code_transaction">;
-    version: z.ZodLiteral<1>;
-}, z.core.$strict>;
-export declare const mcpBearerCredentialBundleSchema: z.ZodObject<{
-    bearerToken: z.ZodString;
-    type: z.ZodLiteral<"bearer">;
-    version: z.ZodLiteral<1>;
-}, z.core.$strict>;
-export declare const mcpCredentialBundleSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
-    bearerToken: z.ZodString;
-    type: z.ZodLiteral<"bearer">;
-    version: z.ZodLiteral<1>;
-}, z.core.$strict>, z.ZodObject<{
-    clientInformation: z.ZodNullable<z.ZodObject<{
-        client_id: z.ZodString;
-        client_secret: z.ZodOptional<z.ZodString>;
-        issuer: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
-    }, z.core.$loose>>;
-    discoveryState: z.ZodNullable<z.ZodObject<{
-        authorizationServerMetadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-        authorizationServerUrl: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
-        resourceMetadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-        resourceMetadataUrl: z.ZodOptional<z.ZodString>;
-    }, z.core.$loose>>;
-    scope: z.ZodNullable<z.ZodString>;
-    tokens: z.ZodNullable<z.ZodObject<{
-        access_token: z.ZodString;
-        expires_in: z.ZodOptional<z.ZodNumber>;
-        issuer: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
-        refresh_token: z.ZodOptional<z.ZodString>;
-        scope: z.ZodOptional<z.ZodString>;
-        token_type: z.ZodString;
-    }, z.core.$strict>>;
-    type: z.ZodLiteral<"oauth_authorization_code">;
-    version: z.ZodLiteral<1>;
-}, z.core.$strict>, z.ZodObject<{
-    clientInformation: z.ZodObject<{
-        client_id: z.ZodString;
-        issuer: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
-        client_secret: z.ZodString;
-    }, z.core.$loose>;
-    discoveryState: z.ZodNullable<z.ZodObject<{
-        authorizationServerMetadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-        authorizationServerUrl: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
-        resourceMetadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-        resourceMetadataUrl: z.ZodOptional<z.ZodString>;
-    }, z.core.$loose>>;
-    scope: z.ZodNullable<z.ZodString>;
-    tokens: z.ZodNullable<z.ZodObject<{
-        access_token: z.ZodString;
-        expires_in: z.ZodOptional<z.ZodNumber>;
-        issuer: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
-        refresh_token: z.ZodOptional<z.ZodString>;
-        scope: z.ZodOptional<z.ZodString>;
-        token_type: z.ZodString;
-    }, z.core.$strict>>;
-    type: z.ZodLiteral<"oauth_client_credentials">;
-    version: z.ZodLiteral<1>;
-}, z.core.$strict>], "type">;
-export declare const mcpConnectionSchema: z.ZodObject<{
-    id: z.ZodString;
-    tenantId: z.ZodString;
-    name: z.ZodString;
-    url: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
-    authType: z.ZodEnum<{
-        bearer: "bearer";
-        none: "none";
-        oauth_authorization_code: "oauth_authorization_code";
-        oauth_client_credentials: "oauth_client_credentials";
-    }>;
-    status: z.ZodEnum<{
-        connected: "connected";
-        error: "error";
-        needs_auth: "needs_auth";
-    }>;
-    credentialVersion: z.ZodNumber;
-    credentialFragment: z.ZodNullable<z.ZodString>;
-    lastAuthErrorCode: z.ZodNullable<z.ZodEnum<{
-        MCP_CONNECTION_AUTHENTICATION_FAILED: "MCP_CONNECTION_AUTHENTICATION_FAILED";
-        MCP_CONNECTION_DISCOVERY_FAILED: "MCP_CONNECTION_DISCOVERY_FAILED";
-        MCP_CONNECTION_INVALID: "MCP_CONNECTION_INVALID";
-        MCP_CONNECTION_UNREACHABLE: "MCP_CONNECTION_UNREACHABLE";
-    }>>;
-    oauthIssuer: z.ZodNullable<z.ZodString>;
-    oauthResource: z.ZodNullable<z.ZodString>;
-    tokenExpiresAt: z.ZodNullable<z.ZodISODateTime>;
-    createdAt: z.ZodISODateTime;
-    updatedAt: z.ZodISODateTime;
-}, z.core.$strict>;
 export declare const mcpConnectionResponseSchema: z.ZodObject<{
     id: z.ZodString;
     name: z.ZodString;
@@ -400,14 +241,7 @@ export declare const mcpConnectionReconnectResultSchema: z.ZodDiscriminatedUnion
     }, z.core.$strip>;
 }, z.core.$strip>], "status">;
 export type McpConnectionAuthType = z.infer<typeof mcpConnectionAuthTypeSchema>;
-export type McpCredentialBundle = z.infer<typeof mcpCredentialBundleSchema>;
-export type McpOauthClientCredentialsBundle = z.infer<typeof mcpOauthClientCredentialsBundleSchema>;
-export type McpOauthAuthorizationCodeBundle = z.infer<typeof mcpOauthAuthorizationCodeBundleSchema>;
-export type McpOauthAuthorizationTransactionBundle = z.infer<typeof mcpOauthAuthorizationTransactionBundleSchema>;
 export type McpConnectionStatus = z.infer<typeof mcpConnectionStatusSchema>;
-export type McpConnectionTestErrorCode = z.infer<typeof mcpConnectionTestErrorCodeSchema>;
-export type McpConnectionLiveDetails = z.infer<typeof mcpConnectionLiveDetailsSchema>;
-export type McpConnection = z.infer<typeof mcpConnectionSchema>;
 export type McpConnectionResponse = z.infer<typeof mcpConnectionResponseSchema>;
 export type McpConnectionsResponse = z.infer<typeof mcpConnectionsResponseSchema>;
 export type CreateMcpConnectionBody = z.infer<typeof createMcpConnectionBodySchema>;
@@ -416,8 +250,6 @@ export type ReconnectMcpConnectionBody = z.infer<typeof reconnectMcpConnectionBo
 export type McpConnectionTestResponse = z.infer<typeof mcpConnectionTestResponseSchema>;
 export type McpConnectionReconnectResult = z.infer<typeof mcpConnectionReconnectResultSchema>;
 export type McpConnectionOauthConnectResponse = z.infer<typeof mcpConnectionOauthConnectResponseSchema>;
-export type ApproveMcpOauthAuthorizationBody = z.infer<typeof approveMcpOauthAuthorizationBodySchema>;
-export type McpOauthAuthorizationLaunchResponse = z.infer<typeof mcpOauthAuthorizationLaunchResponseSchema>;
 export type McpAttachmentResponse = z.infer<typeof mcpAttachmentResponseSchema>;
 export type McpAttachmentsResponse = z.infer<typeof mcpAttachmentsResponseSchema>;
 export type UpdateMcpAttachmentBody = z.infer<typeof updateMcpAttachmentBodySchema>;

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

@@ -1,5 +1,5 @@
 import { z } from "zod";
-import { mcpConnectionIdSchema, tenantIdSchema } from "../ids.js";
+import { mcpConnectionIdSchema } 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}$/;
@@ -40,165 +40,13 @@ const oauthClientSecretSchema = z
     .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()
@@ -220,24 +68,6 @@ const mcpConnectionUrlSchema = z
     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,

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

@@ -35,12 +35,6 @@ export declare const memoriesListResponseSchema: z.ZodObject<{
     }, z.core.$strip>>;
     nextCursor: z.ZodNullable<z.ZodString>;
 }, z.core.$strip>;
-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>;
@@ -48,9 +42,7 @@ export declare const createMemoryBodySchema: z.ZodObject<{
 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>;