@bagelink/sdk 1.12.47 → 1.12.51

package/dist/index.cjs

@@ -60,6 +60,24 @@ function extractSSEEventTypes(operation) {
   }
   return types.size > 0 ? Array.from(types).sort() : void 0;
 }
+function extractSSEEventSchemas(operation) {
+  const responses = operation.responses || {};
+  for (const [statusCode, response] of Object.entries(responses)) {
+    if (!statusCode.startsWith("2")) continue;
+    if ("$ref" in response) continue;
+    const eventStream = response.content?.["text/event-stream"];
+    const schemas = eventStream?.["x-event-schemas"];
+    if (schemas && Object.keys(schemas).length > 0) {
+      return Object.fromEntries(
+        Object.entries(schemas).map(([event, ref]) => [
+          event,
+          ref.replace(/^#\/components\/schemas\//, "")
+        ])
+      );
+    }
+  }
+  return void 0;
+}
 function extractSSEEventInfo(operation) {
   const description = operation.description || "";
   const eventInfos = [];
@@ -397,6 +415,7 @@ const functionsInventory = {};
 const pathOperations = [];
 const streamEventTypes = {};
 const streamEventInfo = {};
+const streamEventSchemas = {};
 function collectTypeForImportStatement(typeName) {
   typeName = typeName.trim().replace("[]", "");
   if (typeName.includes("|")) {
@@ -603,6 +622,8 @@ function generateStreamFunction(method, path, formattedPath, allParams, requestB
    *   .on('${t}', (data) => console.log(data))`).join("") : "\n   *   .on('message', (data) => console.log(data))";
   const typeAnnotation = eventTypes?.length ? `StreamController<${streamTypeName}>` : "StreamController";
   const pathForUrl = formattedPath.startsWith("`") ? formattedPath.slice(1, -1) : formattedPath.slice(1, -1);
+  const streamParams = allParams ? `${allParams}, options?: SSEStreamOptions` : `options?: SSEStreamOptions`;
+  const regularParams = allParams;
   if (method === "post") {
     return `{
   /**
@@ -616,14 +637,14 @@ function generateStreamFunction(method, path, formattedPath, allParams, requestB
    * // Close stream when needed
    * stream.close()
    */
-  stream: (${allParams}, options?: SSEStreamOptions): ${typeAnnotation} => {
+  stream: (${streamParams}): ${typeAnnotation} => {
     const url = \`\${${baseUrlRef}}${pathForUrl}\`
     return createSSEStreamPost<${streamTypeName}>(url, ${bodyVar}, options)
   },
   /**
    * Regular POST request (non-streaming)
    */
-  post: async (${allParams}): Promise<AxiosResponse<any>> => {
+  post: async (${regularParams}): Promise<AxiosResponse<any>> => {
     return axios.post(${formattedPath}, ${bodyVar})
   }
 }`;
@@ -640,14 +661,14 @@ function generateStreamFunction(method, path, formattedPath, allParams, requestB
    * // Close stream when needed
    * stream.close()
    */
-  stream: (${allParams}, options?: SSEStreamOptions): ${typeAnnotation} => {
+  stream: (${streamParams}): ${typeAnnotation} => {
     const url = \`\${${baseUrlRef}}${pathForUrl}\`
     return createSSEStream<${streamTypeName}>(url, options)
   },
   /**
    * Regular GET request (non-streaming)
    */
-  get: async (${allParams}): Promise<AxiosResponse<any>> => {
+  get: async (${regularParams}): Promise<AxiosResponse<any>> => {
     return axios.get(${formattedPath})
   }
 }`;
@@ -751,10 +772,15 @@ function generateFunctionForOperation(method, path, operation) {
   if (isStream) {
     const eventTypes = extractSSEEventTypes(operation);
     const eventInfo = extractSSEEventInfo(operation);
+    const eventSchemas = extractSSEEventSchemas(operation);
     const streamTypeName = generateStreamTypeName(path);
     if (eventInfo?.length) {
       streamEventInfo[streamTypeName] = eventInfo;
     }
+    if (eventSchemas && Object.keys(eventSchemas).length > 0) {
+      streamEventSchemas[streamTypeName] = eventSchemas;
+      Object.values(eventSchemas).forEach((tsType) => collectTypeForImportStatement(tsType));
+    }
     return functionComment + generateStreamFunction(
       method,
       path,
@@ -878,6 +904,7 @@ function generateStreamEventTypeDefinitions() {
   typeDefs += "// ============================================================================\n\n";
   for (const [typeName, events] of Object.entries(streamEventTypes)) {
     const eventInfo = streamEventInfo[typeName];
+    const eventSchemas = streamEventSchemas[typeName];
     typeDefs += `/**
  * Event types for ${typeName.replace("StreamEvents", "")} stream
 `;
@@ -895,7 +922,22 @@ function generateStreamEventTypeDefinitions() {
 `;
     typeDefs += `export interface ${typeName} {
 `;
-    if (eventInfo?.length) {
+    if (eventSchemas && Object.keys(eventSchemas).length > 0) {
+      for (const event of events) {
+        const tsType = eventSchemas[event];
+        if (tsType) {
+          typeDefs += `  /** ${event} event \u2014 payload shape defined by ${tsType} */
+`;
+          typeDefs += `  ${event}: ${tsType}
+`;
+        } else {
+          typeDefs += `  /** ${event} event data */
+`;
+          typeDefs += `  ${event}: any
+`;
+        }
+      }
+    } else if (eventInfo?.length) {
       for (const info of eventInfo) {
         typeDefs += `  /**
    * ${info.description || info.name}
@@ -1976,6 +2018,7 @@ exports.createSSEStream = createSSEStream;
 exports.createSSEStreamPost = createSSEStreamPost;
 exports.dereference = dereference;
 exports.extractSSEEventInfo = extractSSEEventInfo;
+exports.extractSSEEventSchemas = extractSSEEventSchemas;
 exports.extractSSEEventTypes = extractSSEEventTypes;
 exports.formatAPIErrorMessage = formatAPIErrorMessage;
 exports.formatFieldErrors = formatFieldErrors;

package/dist/index.d.cts

@@ -480,6 +480,17 @@ interface SSEEventTypeInfo {
  * @returns Array of event types or undefined
  */
 declare function extractSSEEventTypes(operation: OperationObject): string[] | undefined;
+/**
+ * Extracts typed schema refs from the x-event-schemas OpenAPI extension.
+ *
+ * Server sets this via sse_openapi_response(event_types={"created": MyModel}).
+ * Returns a map of { event_name: TypeScript type name } derived from the $ref,
+ * e.g. { "connection_created": "ConferenceConnectionOut" }.
+ *
+ * @param operation - The OpenAPI operation object
+ * @returns Map of event name → TS type name, or undefined if not present
+ */
+declare function extractSSEEventSchemas(operation: OperationObject): Record<string, string> | undefined;
 /**
  * Extracts detailed SSE event information including field definitions
  *
@@ -790,5 +801,5 @@ declare function createOptionsGetter<T>(fetchFn: () => Promise<T[]>, mapFn?: (it
     value: string;
 }[]>;
 
-export { ApiResponse, Bagel, StreamController, createOptionsGetter, createSSEStream, createSSEStreamPost, dereference, extractSSEEventInfo, extractSSEEventTypes, formatAPIErrorMessage, formatFieldErrors, getPath, isReferenceObject, isSSEStream, isSchemaObject, _default as openAPI, parseApiError, unwrap, useApiRequest, useCancellableRequest, wrapApiForDirectReturn };
+export { ApiResponse, Bagel, StreamController, createOptionsGetter, createSSEStream, createSSEStreamPost, dereference, extractSSEEventInfo, extractSSEEventSchemas, extractSSEEventTypes, formatAPIErrorMessage, formatFieldErrors, getPath, isReferenceObject, isSSEStream, isSchemaObject, _default as openAPI, parseApiError, unwrap, useApiRequest, useCancellableRequest, wrapApiForDirectReturn };
 export type { ApiConfig, ApiRequestState, BaseParameterObject, CallbackObject, CallbacksObject, ComponentsObject, ContactObject, ContentObject, DiscriminatorObject, EncodingObject, EncodingPropertyObject, ExampleObject, ExamplesObject, ExternalDocumentationObject, FastAPIErrorResponse, FastAPIValidationError, HeaderObject, HeadersObject, InfoObject, LicenseObject, LinkObject, LinkParametersObject, LinksObject, MediaTypeObject, OAuthFlowObject, OAuthFlowsObject, OpenAPIObject, OperationObject, ParameterLocation, ParameterObject, ParameterStyle, ParsedError, PathItemObject, PathsObject, ReferenceObject, RequestBodyObject, RequestInterceptor, ResponseInterceptor, ResponseMetadata, ResponseObject, ResponsesObject, SSEEventTypeInfo, SSEStreamOptions, SchemaObject, SchemaObjectType, SchemasObject, ScopesObject, SecurityRequirementObject, SecuritySchemeObject, SecuritySchemeType, ServerObject, ServerVariableObject, StreamEventMap, TableToTypeMapping, Tables, TagObject, TypeFormatT, Unwrap, Unwrapped, UploadOptions, User, XmlObject };

package/dist/index.d.mts

@@ -480,6 +480,17 @@ interface SSEEventTypeInfo {
  * @returns Array of event types or undefined
  */
 declare function extractSSEEventTypes(operation: OperationObject): string[] | undefined;
+/**
+ * Extracts typed schema refs from the x-event-schemas OpenAPI extension.
+ *
+ * Server sets this via sse_openapi_response(event_types={"created": MyModel}).
+ * Returns a map of { event_name: TypeScript type name } derived from the $ref,
+ * e.g. { "connection_created": "ConferenceConnectionOut" }.
+ *
+ * @param operation - The OpenAPI operation object
+ * @returns Map of event name → TS type name, or undefined if not present
+ */
+declare function extractSSEEventSchemas(operation: OperationObject): Record<string, string> | undefined;
 /**
  * Extracts detailed SSE event information including field definitions
  *
@@ -790,5 +801,5 @@ declare function createOptionsGetter<T>(fetchFn: () => Promise<T[]>, mapFn?: (it
     value: string;
 }[]>;
 
-export { ApiResponse, Bagel, StreamController, createOptionsGetter, createSSEStream, createSSEStreamPost, dereference, extractSSEEventInfo, extractSSEEventTypes, formatAPIErrorMessage, formatFieldErrors, getPath, isReferenceObject, isSSEStream, isSchemaObject, _default as openAPI, parseApiError, unwrap, useApiRequest, useCancellableRequest, wrapApiForDirectReturn };
+export { ApiResponse, Bagel, StreamController, createOptionsGetter, createSSEStream, createSSEStreamPost, dereference, extractSSEEventInfo, extractSSEEventSchemas, extractSSEEventTypes, formatAPIErrorMessage, formatFieldErrors, getPath, isReferenceObject, isSSEStream, isSchemaObject, _default as openAPI, parseApiError, unwrap, useApiRequest, useCancellableRequest, wrapApiForDirectReturn };
 export type { ApiConfig, ApiRequestState, BaseParameterObject, CallbackObject, CallbacksObject, ComponentsObject, ContactObject, ContentObject, DiscriminatorObject, EncodingObject, EncodingPropertyObject, ExampleObject, ExamplesObject, ExternalDocumentationObject, FastAPIErrorResponse, FastAPIValidationError, HeaderObject, HeadersObject, InfoObject, LicenseObject, LinkObject, LinkParametersObject, LinksObject, MediaTypeObject, OAuthFlowObject, OAuthFlowsObject, OpenAPIObject, OperationObject, ParameterLocation, ParameterObject, ParameterStyle, ParsedError, PathItemObject, PathsObject, ReferenceObject, RequestBodyObject, RequestInterceptor, ResponseInterceptor, ResponseMetadata, ResponseObject, ResponsesObject, SSEEventTypeInfo, SSEStreamOptions, SchemaObject, SchemaObjectType, SchemasObject, ScopesObject, SecurityRequirementObject, SecuritySchemeObject, SecuritySchemeType, ServerObject, ServerVariableObject, StreamEventMap, TableToTypeMapping, Tables, TagObject, TypeFormatT, Unwrap, Unwrapped, UploadOptions, User, XmlObject };

package/dist/index.d.ts

@@ -480,6 +480,17 @@ interface SSEEventTypeInfo {
  * @returns Array of event types or undefined
  */
 declare function extractSSEEventTypes(operation: OperationObject): string[] | undefined;
+/**
+ * Extracts typed schema refs from the x-event-schemas OpenAPI extension.
+ *
+ * Server sets this via sse_openapi_response(event_types={"created": MyModel}).
+ * Returns a map of { event_name: TypeScript type name } derived from the $ref,
+ * e.g. { "connection_created": "ConferenceConnectionOut" }.
+ *
+ * @param operation - The OpenAPI operation object
+ * @returns Map of event name → TS type name, or undefined if not present
+ */
+declare function extractSSEEventSchemas(operation: OperationObject): Record<string, string> | undefined;
 /**
  * Extracts detailed SSE event information including field definitions
  *
@@ -790,5 +801,5 @@ declare function createOptionsGetter<T>(fetchFn: () => Promise<T[]>, mapFn?: (it
     value: string;
 }[]>;
 
-export { ApiResponse, Bagel, StreamController, createOptionsGetter, createSSEStream, createSSEStreamPost, dereference, extractSSEEventInfo, extractSSEEventTypes, formatAPIErrorMessage, formatFieldErrors, getPath, isReferenceObject, isSSEStream, isSchemaObject, _default as openAPI, parseApiError, unwrap, useApiRequest, useCancellableRequest, wrapApiForDirectReturn };
+export { ApiResponse, Bagel, StreamController, createOptionsGetter, createSSEStream, createSSEStreamPost, dereference, extractSSEEventInfo, extractSSEEventSchemas, extractSSEEventTypes, formatAPIErrorMessage, formatFieldErrors, getPath, isReferenceObject, isSSEStream, isSchemaObject, _default as openAPI, parseApiError, unwrap, useApiRequest, useCancellableRequest, wrapApiForDirectReturn };
 export type { ApiConfig, ApiRequestState, BaseParameterObject, CallbackObject, CallbacksObject, ComponentsObject, ContactObject, ContentObject, DiscriminatorObject, EncodingObject, EncodingPropertyObject, ExampleObject, ExamplesObject, ExternalDocumentationObject, FastAPIErrorResponse, FastAPIValidationError, HeaderObject, HeadersObject, InfoObject, LicenseObject, LinkObject, LinkParametersObject, LinksObject, MediaTypeObject, OAuthFlowObject, OAuthFlowsObject, OpenAPIObject, OperationObject, ParameterLocation, ParameterObject, ParameterStyle, ParsedError, PathItemObject, PathsObject, ReferenceObject, RequestBodyObject, RequestInterceptor, ResponseInterceptor, ResponseMetadata, ResponseObject, ResponsesObject, SSEEventTypeInfo, SSEStreamOptions, SchemaObject, SchemaObjectType, SchemasObject, ScopesObject, SecurityRequirementObject, SecuritySchemeObject, SecuritySchemeType, ServerObject, ServerVariableObject, StreamEventMap, TableToTypeMapping, Tables, TagObject, TypeFormatT, Unwrap, Unwrapped, UploadOptions, User, XmlObject };

package/dist/index.mjs

@@ -54,6 +54,24 @@ function extractSSEEventTypes(operation) {
   }
   return types.size > 0 ? Array.from(types).sort() : void 0;
 }
+function extractSSEEventSchemas(operation) {
+  const responses = operation.responses || {};
+  for (const [statusCode, response] of Object.entries(responses)) {
+    if (!statusCode.startsWith("2")) continue;
+    if ("$ref" in response) continue;
+    const eventStream = response.content?.["text/event-stream"];
+    const schemas = eventStream?.["x-event-schemas"];
+    if (schemas && Object.keys(schemas).length > 0) {
+      return Object.fromEntries(
+        Object.entries(schemas).map(([event, ref]) => [
+          event,
+          ref.replace(/^#\/components\/schemas\//, "")
+        ])
+      );
+    }
+  }
+  return void 0;
+}
 function extractSSEEventInfo(operation) {
   const description = operation.description || "";
   const eventInfos = [];
@@ -391,6 +409,7 @@ const functionsInventory = {};
 const pathOperations = [];
 const streamEventTypes = {};
 const streamEventInfo = {};
+const streamEventSchemas = {};
 function collectTypeForImportStatement(typeName) {
   typeName = typeName.trim().replace("[]", "");
   if (typeName.includes("|")) {
@@ -597,6 +616,8 @@ function generateStreamFunction(method, path, formattedPath, allParams, requestB
    *   .on('${t}', (data) => console.log(data))`).join("") : "\n   *   .on('message', (data) => console.log(data))";
   const typeAnnotation = eventTypes?.length ? `StreamController<${streamTypeName}>` : "StreamController";
   const pathForUrl = formattedPath.startsWith("`") ? formattedPath.slice(1, -1) : formattedPath.slice(1, -1);
+  const streamParams = allParams ? `${allParams}, options?: SSEStreamOptions` : `options?: SSEStreamOptions`;
+  const regularParams = allParams;
   if (method === "post") {
     return `{
   /**
@@ -610,14 +631,14 @@ function generateStreamFunction(method, path, formattedPath, allParams, requestB
    * // Close stream when needed
    * stream.close()
    */
-  stream: (${allParams}, options?: SSEStreamOptions): ${typeAnnotation} => {
+  stream: (${streamParams}): ${typeAnnotation} => {
     const url = \`\${${baseUrlRef}}${pathForUrl}\`
     return createSSEStreamPost<${streamTypeName}>(url, ${bodyVar}, options)
   },
   /**
    * Regular POST request (non-streaming)
    */
-  post: async (${allParams}): Promise<AxiosResponse<any>> => {
+  post: async (${regularParams}): Promise<AxiosResponse<any>> => {
     return axios.post(${formattedPath}, ${bodyVar})
   }
 }`;
@@ -634,14 +655,14 @@ function generateStreamFunction(method, path, formattedPath, allParams, requestB
    * // Close stream when needed
    * stream.close()
    */
-  stream: (${allParams}, options?: SSEStreamOptions): ${typeAnnotation} => {
+  stream: (${streamParams}): ${typeAnnotation} => {
     const url = \`\${${baseUrlRef}}${pathForUrl}\`
     return createSSEStream<${streamTypeName}>(url, options)
   },
   /**
    * Regular GET request (non-streaming)
    */
-  get: async (${allParams}): Promise<AxiosResponse<any>> => {
+  get: async (${regularParams}): Promise<AxiosResponse<any>> => {
     return axios.get(${formattedPath})
   }
 }`;
@@ -745,10 +766,15 @@ function generateFunctionForOperation(method, path, operation) {
   if (isStream) {
     const eventTypes = extractSSEEventTypes(operation);
     const eventInfo = extractSSEEventInfo(operation);
+    const eventSchemas = extractSSEEventSchemas(operation);
     const streamTypeName = generateStreamTypeName(path);
     if (eventInfo?.length) {
       streamEventInfo[streamTypeName] = eventInfo;
     }
+    if (eventSchemas && Object.keys(eventSchemas).length > 0) {
+      streamEventSchemas[streamTypeName] = eventSchemas;
+      Object.values(eventSchemas).forEach((tsType) => collectTypeForImportStatement(tsType));
+    }
     return functionComment + generateStreamFunction(
       method,
       path,
@@ -872,6 +898,7 @@ function generateStreamEventTypeDefinitions() {
   typeDefs += "// ============================================================================\n\n";
   for (const [typeName, events] of Object.entries(streamEventTypes)) {
     const eventInfo = streamEventInfo[typeName];
+    const eventSchemas = streamEventSchemas[typeName];
     typeDefs += `/**
  * Event types for ${typeName.replace("StreamEvents", "")} stream
 `;
@@ -889,7 +916,22 @@ function generateStreamEventTypeDefinitions() {
 `;
     typeDefs += `export interface ${typeName} {
 `;
-    if (eventInfo?.length) {
+    if (eventSchemas && Object.keys(eventSchemas).length > 0) {
+      for (const event of events) {
+        const tsType = eventSchemas[event];
+        if (tsType) {
+          typeDefs += `  /** ${event} event \u2014 payload shape defined by ${tsType} */
+`;
+          typeDefs += `  ${event}: ${tsType}
+`;
+        } else {
+          typeDefs += `  /** ${event} event data */
+`;
+          typeDefs += `  ${event}: any
+`;
+        }
+      }
+    } else if (eventInfo?.length) {
       for (const info of eventInfo) {
         typeDefs += `  /**
    * ${info.description || info.name}
@@ -1962,4 +2004,4 @@ function createOptionsGetter(fetchFn, mapFn) {
   };
 }
 
-export { ApiResponse, Bagel, StreamController, createOptionsGetter, createSSEStream, createSSEStreamPost, dereference, extractSSEEventInfo, extractSSEEventTypes, formatAPIErrorMessage, formatFieldErrors, getPath, isReferenceObject, isSSEStream, isSchemaObject, index as openAPI, parseApiError, unwrap, useApiRequest, useCancellableRequest, wrapApiForDirectReturn };
+export { ApiResponse, Bagel, StreamController, createOptionsGetter, createSSEStream, createSSEStreamPost, dereference, extractSSEEventInfo, extractSSEEventSchemas, extractSSEEventTypes, formatAPIErrorMessage, formatFieldErrors, getPath, isReferenceObject, isSSEStream, isSchemaObject, index as openAPI, parseApiError, unwrap, useApiRequest, useCancellableRequest, wrapApiForDirectReturn };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@bagelink/sdk",
   "type": "module",
-  "version": "1.12.47",
+  "version": "1.12.51",
   "description": "Bagel core sdk packages",
   "author": {
     "name": "Bagel Studio",

package/src/openAPITools/functionGenerator.ts

@@ -1,8 +1,4 @@
-/* eslint-disable ts/strict-boolean-expressions */
-/* eslint-disable ts/no-unnecessary-condition */
-/* eslint-disable jsdoc/check-param-names */
-/* eslint-disable ts/no-non-null-assertion */
-/* eslint-disable prefer-destructuring */
+
 import type { SSEEventTypeInfo } from './streamDetector'
 import type {
 	OperationObject as OpenAPIOperation,
@@ -14,7 +10,7 @@ import type {
 	ReferenceObject,
 	SchemaObject,
 } from './types'
-import { isSSEStream, extractSSEEventTypes, extractSSEEventInfo } from './streamDetector'
+import { isSSEStream, extractSSEEventTypes, extractSSEEventInfo, extractSSEEventSchemas } from './streamDetector'
 import { dereference, isReferenceObject } from './types/utils'
 import {
 	cleanPath,
@@ -63,6 +59,7 @@ const functionsInventory: Record<string, string> = {}
 const pathOperations: PathOperation[] = []
 const streamEventTypes: Record<string, string[]> = {} // Track stream endpoints and their event types
 const streamEventInfo: Record<string, SSEEventTypeInfo[]> = {} // Track detailed event info for type generation
+const streamEventSchemas: Record<string, Record<string, string>> = {} // Track typed schemas: streamTypeName → {event → TSType}
 
 /**
  * Collects non-primitive types for import statements
@@ -448,6 +445,9 @@ function generateStreamFunction(
 		? formattedPath.slice(1, -1) // Remove backticks to get the content
 		: formattedPath.slice(1, -1) // Remove quotes to get the content
 
+	const streamParams = allParams ? `${allParams}, options?: SSEStreamOptions` : `options?: SSEStreamOptions`
+	const regularParams = allParams
+
 	if (method === 'post') {
 		return `{
   /**
@@ -461,14 +461,14 @@ function generateStreamFunction(
    * // Close stream when needed
    * stream.close()
    */
-  stream: (${allParams}, options?: SSEStreamOptions): ${typeAnnotation} => {
+  stream: (${streamParams}): ${typeAnnotation} => {
     const url = \`\${${baseUrlRef}}${pathForUrl}\`
     return createSSEStreamPost<${streamTypeName}>(url, ${bodyVar}, options)
   },
   /**
    * Regular POST request (non-streaming)
    */
-  post: async (${allParams}): Promise<AxiosResponse<any>> => {
+  post: async (${regularParams}): Promise<AxiosResponse<any>> => {
     return axios.post(${formattedPath}, ${bodyVar})
   }
 }`
@@ -485,14 +485,14 @@ function generateStreamFunction(
    * // Close stream when needed
    * stream.close()
    */
-  stream: (${allParams}, options?: SSEStreamOptions): ${typeAnnotation} => {
+  stream: (${streamParams}): ${typeAnnotation} => {
     const url = \`\${${baseUrlRef}}${pathForUrl}\`
     return createSSEStream<${streamTypeName}>(url, options)
   },
   /**
    * Regular GET request (non-streaming)
    */
-  get: async (${allParams}): Promise<AxiosResponse<any>> => {
+  get: async (${regularParams}): Promise<AxiosResponse<any>> => {
     return axios.get(${formattedPath})
   }
 }`
@@ -677,12 +677,18 @@ function generateFunctionForOperation(
 	if (isStream) {
 		const eventTypes = extractSSEEventTypes(operation)
 		const eventInfo = extractSSEEventInfo(operation)
+		const eventSchemas = extractSSEEventSchemas(operation)
 
-		// Store detailed event info for type generation
+		// Store detailed event info and typed schemas for type generation
 		const streamTypeName = generateStreamTypeName(path)
 		if (eventInfo?.length) {
 			streamEventInfo[streamTypeName] = eventInfo
 		}
+		if (eventSchemas && Object.keys(eventSchemas).length > 0) {
+			streamEventSchemas[streamTypeName] = eventSchemas
+			// Collect schema type names for import statements
+			Object.values(eventSchemas).forEach(tsType => collectTypeForImportStatement(tsType))
+		}
 
 		return functionComment + generateStreamFunction(
 			method,
@@ -895,11 +901,11 @@ function generateStreamEventTypeDefinitions(): string {
 
 	for (const [typeName, events] of Object.entries(streamEventTypes)) {
 		const eventInfo = streamEventInfo[typeName]
+		const eventSchemas = streamEventSchemas[typeName] // {event_name: "TSTypeName"} or undefined
 
 		typeDefs += `/**\n * Event types for ${typeName.replace('StreamEvents', '')} stream\n`
 		typeDefs += ` * Events: ${events.map(e => `"${e}"`).join(', ')}\n`
 
-		// Add event descriptions if available
 		if (eventInfo?.length) {
 			typeDefs += ` *\n`
 			for (const info of eventInfo) {
@@ -910,20 +916,28 @@ function generateStreamEventTypeDefinitions(): string {
 		typeDefs += ` */\n`
 		typeDefs += `export interface ${typeName} {\n`
 
-		// Generate event type definitions with field information if available
-		if (eventInfo?.length) {
+		if (eventSchemas && Object.keys(eventSchemas).length > 0) {
+			// Fully typed: each event maps to its Pydantic model's TypeScript type
+			for (const event of events) {
+				const tsType = eventSchemas[event]
+				if (tsType) {
+					typeDefs += `  /** ${event} event — payload shape defined by ${tsType} */\n`
+					typeDefs += `  ${event}: ${tsType}\n`
+				} else {
+					typeDefs += `  /** ${event} event data */\n`
+					typeDefs += `  ${event}: any\n`
+				}
+			}
+		} else if (eventInfo?.length) {
+			// Field-level info from markdown docs but no schema refs
 			for (const info of eventInfo) {
 				typeDefs += `  /**\n   * ${info.description || info.name}\n`
-
 				if (info.fields?.length) {
-					info.fields.forEach((field) => {
+					info.fields.forEach(field => {
 						typeDefs += `   * - \`${field.name}\`: ${field.description || 'Field data'}\n`
 					})
 				}
-
 				typeDefs += `   */\n`
-
-				// Generate interface for this event
 				if (info.fields?.length) {
 					typeDefs += `  ${info.name}: {\n`
 					for (const field of info.fields) {
@@ -936,7 +950,7 @@ function generateStreamEventTypeDefinitions(): string {
 				}
 			}
 		} else {
-			// Fallback: simple event list without field info
+			// Fallback: no type info at all
 			for (const event of events) {
 				typeDefs += `  /** ${event} event data */\n`
 				typeDefs += `  ${event}: any\n`

package/src/openAPITools/streamDetector.ts

@@ -122,6 +122,36 @@ export function extractSSEEventTypes(operation: OpenAPIOperation): string[] | un
 	return types.size > 0 ? Array.from(types).sort() : undefined
 }
 
+/**
+ * Extracts typed schema refs from the x-event-schemas OpenAPI extension.
+ *
+ * Server sets this via sse_openapi_response(event_types={"created": MyModel}).
+ * Returns a map of { event_name: TypeScript type name } derived from the $ref,
+ * e.g. { "connection_created": "ConferenceConnectionOut" }.
+ *
+ * @param operation - The OpenAPI operation object
+ * @returns Map of event name → TS type name, or undefined if not present
+ */
+export function extractSSEEventSchemas(operation: OpenAPIOperation): Record<string, string> | undefined {
+	const responses = operation.responses || {}
+	for (const [statusCode, response] of Object.entries(responses)) {
+		if (!statusCode.startsWith('2')) continue
+		if ('$ref' in response) continue
+		const eventStream = (response as any).content?.['text/event-stream']
+		const schemas = eventStream?.['x-event-schemas'] as Record<string, string> | undefined
+		if (schemas && Object.keys(schemas).length > 0) {
+			// Convert $ref paths like "#/components/schemas/MyModel" → "MyModel"
+			return Object.fromEntries(
+				Object.entries(schemas).map(([event, ref]) => [
+					event,
+					ref.replace(/^#\/components\/schemas\//, ''),
+				])
+			)
+		}
+	}
+	return undefined
+}
+
 /**
  * Extracts detailed SSE event information including field definitions
  *