@blazingagents/sdk 0.24.0 → 0.26.0

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>;

package/dist/contracts/entities/memories.js

@@ -1,7 +1,7 @@
 import { z } from "zod";
-import { cursorSchema, paginatedResponseSchema } from "../api.js";
+import { 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 { MAX_MEMORY_TEXT_BYTES } from "../limitations.js";
 import { userIdSchema } from "./attribution.js";
 /**
  * Memory — a single Agent-owned text row (Agent Memories PRD). `userId` is
@@ -36,19 +36,6 @@ export const memoryResponseSchema = z
 })
     .strip();
 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,

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

@@ -113,11 +113,6 @@ export declare const merchantCustomerBindingSchema: z.ZodObject<{
     updatedAt: z.ZodISODateTime;
 }, z.core.$strip>;
 export type MerchantCustomerBinding = z.infer<typeof merchantCustomerBindingSchema>;
-export declare const merchantBindingsListQuerySchema: z.ZodObject<{
-    userId: z.ZodOptional<z.ZodString>;
-    cursor: z.ZodOptional<z.ZodString>;
-    limit: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
-}, z.core.$strict>;
 export declare const merchantBindingsResponseSchema: z.ZodObject<{
     bindings: z.ZodArray<z.ZodObject<{
         userId: z.ZodString;
@@ -291,20 +286,6 @@ export declare const merchantUsageEventResponseSchema: z.ZodObject<{
     }, z.core.$strip>;
 }, z.core.$strip>;
 export type MerchantUsageEventResponse = z.infer<typeof merchantUsageEventResponseSchema>;
-export declare const merchantUsageEventsListQuerySchema: z.ZodObject<{
-    status: z.ZodOptional<z.ZodEnum<{
-        accepted: "accepted";
-        discarded: "discarded";
-        expired: "expired";
-        failed: "failed";
-        incomplete: "incomplete";
-        pending: "pending";
-        uncertain: "uncertain";
-        unmapped: "unmapped";
-    }>>;
-    cursor: z.ZodOptional<z.ZodString>;
-    limit: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
-}, z.core.$strict>;
 export declare const merchantUsageEventsResponseSchema: z.ZodObject<{
     events: z.ZodArray<z.ZodObject<{
         id: z.ZodString;