@bagelink/sdk 1.15.558 → 1.15.562

package/dist/index.mjs

@@ -1,6 +1,262 @@
-import axios$1 from 'axios';
+import ax from 'axios';
 import { ref } from 'vue';
 
+class StreamController {
+  constructor(cleanup) {
+    this.cleanup = cleanup;
+  }
+  handlers = /* @__PURE__ */ new Map();
+  _closed = false;
+  /**
+   * Register an event handler (fully typed!)
+   * @param event - Event type to listen for
+   * @param handler - Handler function (data type inferred from event)
+   * @returns this (for chaining)
+   */
+  on(event, handler) {
+    if (!this.handlers.has(event)) {
+      this.handlers.set(event, /* @__PURE__ */ new Set());
+    }
+    this.handlers.get(event).add(handler);
+    return this;
+  }
+  /**
+   * Emit an event to all registered handlers
+   * @internal
+   */
+  emit(event, data) {
+    const handlers = this.handlers.get(event);
+    if (handlers) {
+      handlers.forEach((handler) => {
+        try {
+          handler(data);
+        } catch (error) {
+          console.error(`Error in ${event} handler:`, error);
+        }
+      });
+    }
+  }
+  /**
+   * Close the stream
+   */
+  close() {
+    if (!this._closed) {
+      this.cleanup();
+      this._closed = true;
+    }
+  }
+}
+
+async function resolveHeaders(headers) {
+  return typeof headers === "function" ? await headers() : headers ?? {};
+}
+function createSSEStream(url, options = {}) {
+  const {
+    headers,
+    withCredentials = true,
+    lastEventId: initialLastEventId,
+    maxReconnects = 5,
+    reconnectDelayMs = 1e3
+  } = options;
+  const controller = new AbortController();
+  const stream = new StreamController(() => {
+    controller.abort();
+  });
+  let lastEventId = initialLastEventId;
+  let reconnectAttempts = 0;
+  async function connect() {
+    if (controller.signal.aborted) return;
+    const resolvedHeaders = await resolveHeaders(headers);
+    const requestHeaders = {
+      "Accept": "text/event-stream",
+      "Cache-Control": "no-cache",
+      ...resolvedHeaders
+    };
+    if (lastEventId !== void 0) {
+      requestHeaders["Last-Event-ID"] = lastEventId;
+    }
+    let response;
+    try {
+      response = await fetch(url, {
+        method: "GET",
+        headers: requestHeaders,
+        credentials: withCredentials ? "include" : "same-origin",
+        signal: controller.signal,
+        keepalive: false
+      });
+    } catch (error) {
+      if (error?.name === "AbortError") return;
+      return handleDisconnect(error);
+    }
+    if (!response.ok) {
+      stream.emit("error", new Error(`HTTP ${response.status}: ${response.statusText}`));
+      return;
+    }
+    if (!response.body) {
+      stream.emit("error", new Error("Response body is null"));
+      return;
+    }
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+    let terminalEventReceived = false;
+    let currentEvent = "message";
+    let currentData = "";
+    let currentId;
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) {
+          if (!controller.signal.aborted && !terminalEventReceived) {
+            return handleDisconnect(new Error("Stream ended before a terminal event"));
+          }
+          return;
+        }
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split("\n");
+        buffer = lines.pop() || "";
+        for (const line of lines) {
+          if (line.startsWith("id:")) {
+            currentId = line.slice(3).trim();
+          } else if (line.startsWith("event:")) {
+            currentEvent = line.slice(6).trim();
+          } else if (line.startsWith("data:")) {
+            currentData = currentData ? `${currentData}
+${line.slice(5).trim()}` : line.slice(5).trim();
+          } else if (line === "" && currentData) {
+            if (currentId !== void 0) {
+              if (currentId !== lastEventId) reconnectAttempts = 0;
+              lastEventId = currentId;
+            }
+            try {
+              const parsed = JSON.parse(currentData);
+              stream.emit(currentEvent, parsed);
+              if (currentEvent === "done" || currentEvent === "error") {
+                terminalEventReceived = true;
+                stream.emit("complete", {});
+                controller.abort();
+                try {
+                  await reader.cancel();
+                } catch {
+                }
+                return;
+              }
+            } catch {
+              stream.emit(currentEvent, currentData);
+            }
+            currentEvent = "message";
+            currentData = "";
+            currentId = void 0;
+          }
+        }
+      }
+    } catch (error) {
+      if (error?.name !== "AbortError") {
+        return handleDisconnect(error);
+      }
+    } finally {
+      try {
+        reader.releaseLock();
+      } catch {
+      }
+    }
+  }
+  async function handleDisconnect(error) {
+    if (controller.signal.aborted) return;
+    if (reconnectAttempts >= maxReconnects) {
+      const msg = error?.message || "Stream connection lost";
+      stream.emit("error", new Error(`${msg} (gave up after ${maxReconnects} reconnects)`));
+      return;
+    }
+    reconnectAttempts++;
+    const delay = reconnectDelayMs * Math.pow(2, reconnectAttempts - 1);
+    await new Promise((resolve) => setTimeout(resolve, delay));
+    if (!controller.signal.aborted) await connect();
+  }
+  connect().catch(() => {
+  });
+  return stream;
+}
+function createSSEStreamPost(url, body, options = {}) {
+  const { headers, withCredentials = true } = options;
+  const controller = new AbortController();
+  const stream = new StreamController(() => {
+    controller.abort();
+  });
+  resolveHeaders(headers).then((resolvedHeaders) => fetch(url, {
+    method: "POST",
+    headers: {
+      "Accept": "text/event-stream",
+      "Content-Type": "application/json",
+      "Cache-Control": "no-cache",
+      ...resolvedHeaders
+    },
+    credentials: withCredentials ? "include" : "same-origin",
+    body: JSON.stringify(body),
+    signal: controller.signal,
+    // Disable keepalive for streaming
+    keepalive: false
+  })).then(async (response) => {
+    if (!response.ok) {
+      throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+    }
+    if (!response.body) {
+      throw new Error("Response body is null");
+    }
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+    let currentEvent = "message";
+    let currentData = "";
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) {
+          stream.emit("done", {});
+          stream.emit("complete", {});
+          break;
+        }
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split("\n");
+        buffer = lines.pop() || "";
+        for (const line of lines) {
+          if (line.startsWith("event:")) {
+            currentEvent = line.slice(6).trim();
+          } else if (line.startsWith("data:")) {
+            currentData = currentData ? `${currentData}
+${line.slice(5).trim()}` : line.slice(5).trim();
+          } else if (line === "" && currentData) {
+            try {
+              const parsed = JSON.parse(currentData);
+              stream.emit(currentEvent, parsed);
+            } catch {
+              stream.emit(currentEvent, currentData);
+            }
+            currentEvent = "message";
+            currentData = "";
+          }
+        }
+      }
+    } catch (error) {
+      if (error?.name !== "AbortError") {
+        const errorMessage = error?.message || "Stream connection error";
+        stream.emit("error", new Error(errorMessage));
+      }
+    } finally {
+      try {
+        reader.releaseLock();
+      } catch {
+      }
+    }
+  }).catch((error) => {
+    if (error?.name !== "AbortError") {
+      const errorMessage = error?.message || "Failed to establish stream connection";
+      stream.emit("error", new Error(errorMessage));
+    }
+  });
+  return stream;
+}
+
 function isSSEStream(operation) {
   const responses = operation.responses || {};
   for (const [statusCode, response] of Object.entries(responses)) {
@@ -605,7 +861,6 @@ function generateStreamFunction(method, path, formattedPath, allParams, requestB
     allParams = "";
   }
   const bodyVar = requestBodyPayload || "{}";
-  const baseUrlRef = "getStreamBaseURL()";
   const streamTypeName = generateStreamTypeName(path);
   if (eventTypes?.length) {
     streamEventTypes[streamTypeName] = eventTypes;
@@ -615,7 +870,6 @@ function generateStreamFunction(method, path, formattedPath, allParams, requestB
   const eventTypesExample = eventTypes?.length ? eventTypes.map((t) => `
    *   .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") {
@@ -632,14 +886,13 @@ function generateStreamFunction(method, path, formattedPath, allParams, requestB
    * stream.close()
    */
   stream: (${streamParams}): ${typeAnnotation} => {
-    const url = \`\${${baseUrlRef}}${pathForUrl}\`
-    return createSSEStreamPost<${streamTypeName}>(url, ${bodyVar}, options)
+    return __transport.createSSEStreamPost<${streamTypeName}>(${formattedPath}, ${bodyVar}, options)
   },
   /**
    * Regular POST request (non-streaming)
    */
   post: async (${regularParams}): Promise<AxiosResponse<any>> => {
-    return axios.post(${formattedPath}, ${bodyVar})
+    return __transport.axios.post(${formattedPath}, ${bodyVar})
   }
 }`;
   } else {
@@ -660,7 +913,7 @@ function generateStreamFunction(method, path, formattedPath, allParams, requestB
       ].join("\n    ");
     }
     const regularParamStr = queryParams?.length ? `, { params: {${queryParams.join(", ")}} }` : "";
-    const urlLine = queryParams?.length ? `const url = \`\${${baseUrlRef}}${pathForUrl}\` + __qsSuffix` : `const url = \`\${${baseUrlRef}}${pathForUrl}\``;
+    const urlLine = queryParams?.length ? `const url = ${formattedPath} + __qsSuffix` : `const url = ${formattedPath}`;
     const streamBody = queryParams?.length ? `
     ${queryStringCode}
     ${urlLine}` : `
@@ -678,13 +931,13 @@ function generateStreamFunction(method, path, formattedPath, allParams, requestB
    * stream.close()
    */
   stream: (${streamParams}): ${typeAnnotation} => {${streamBody}
-    return createSSEStream<${streamTypeName}>(url, options)
+    return __transport.createSSEStream<${streamTypeName}>(url, options)
   },
   /**
    * Regular GET request (non-streaming)
    */
   get: async (${regularParams}): Promise<AxiosResponse<any>> => {
-    return axios.get(${formattedPath}${regularParamStr})
+    return __transport.axios.get(${formattedPath}${regularParamStr})
   }
 }`;
   }
@@ -706,14 +959,14 @@ function generateAxiosFunction(method, formattedPath, allParams, responseTypeStr
         const formData = new FormData()
         formData.append('file', file)
 		formData.append('upload', file)
-        const response = await axios.${method}(${formattedPath}, formData, {
+        const response = await __transport.axios.${method}(${formattedPath}, formData, {
             headers: { 'Content-Type': 'multipart/form-data' },
             onUploadProgress: options?.onUploadProgress${paramStr ? `, ${paramStr}` : ""}
         })
         return ${returnExpression}`;
     } else {
       axiosFunction += `
-        const response = await axios.${method}(${formattedPath}, formData, {
+        const response = await __transport.axios.${method}(${formattedPath}, formData, {
             headers: { 'Content-Type': 'multipart/form-data' }${paramStr ? `, ${paramStr}` : ""}
         })
         return ${returnExpression}`;
@@ -722,7 +975,7 @@ function generateAxiosFunction(method, formattedPath, allParams, responseTypeStr
     const configParams = paramStr ? `, { ${paramStr} }` : "";
     const bodyVar = requestBodyPayload || "{}";
     axiosFunction += `
-        const response = await axios.${method}(${formattedPath}${["get", "delete"].includes(method) ? configParams : `, ${bodyVar}${configParams}`})
+        const response = await __transport.axios.${method}(${formattedPath}${["get", "delete"].includes(method) ? configParams : `, ${bodyVar}${configParams}`})
         return ${returnExpression}`;
   }
   axiosFunction += "}";
@@ -860,9 +1113,15 @@ function handlePathSegment(path, operation, existingObj = {}) {
   }
   return { ...obj, ...existingObj };
 }
-function generateFunctions(paths, baseUrl) {
+function generateFunctionsInternal(paths, baseUrl, moduleFactoryName) {
+  allTypes.length = 0;
+  pathOperations.length = 0;
+  for (const inventory of [functionsInventory, streamEventTypes, streamEventInfo, streamEventSchemas]) {
+    for (const key of Object.keys(inventory)) delete inventory[key];
+  }
   const body = {};
   const allPathsClean = Object.keys(paths).map(cleanPath);
+  const httpMethods = /* @__PURE__ */ new Set(["get", "put", "post", "delete", "options", "head", "patch", "trace"]);
   for (const [path, operation] of Object.entries(paths)) {
     const splitPath = path.split("/").filter((p) => p && !/\{|\}/.test(p));
     splitPath.reduce((acc, key, index, array) => {
@@ -870,7 +1129,8 @@ function generateFunctions(paths, baseUrl) {
       if (!objFuncKey) {
         return acc;
       }
-      const methods = Object.keys(operation);
+      const methods = Object.keys(operation).filter((method) => httpMethods.has(method));
+      if (methods.length === 0) return acc;
       const currentPathClean = cleanPath(path);
       const currentPathPrefix = splitPath.slice(0, index + 1).join("/");
       const prefixWithSlash = `${currentPathPrefix}/`;
@@ -891,14 +1151,14 @@ function generateFunctions(paths, baseUrl) {
       return acc[objFuncKey];
     }, body);
   }
-  let tsString = "";
+  let tsString = "function createEndpointNamespaces(__transport: ApiTransport) {\n";
   const apiObjectEntries = [];
   for (const [parent, object] of Object.entries(body)) {
     tsString += `
 /**
  * API functions for ${parent} endpoints
  */
-export const ${parent} = ${JSON.stringify(object, void 0, 2)};
+const ${parent} = ${JSON.stringify(object, void 0, 2)};
 `;
     apiObjectEntries.push(parent);
   }
@@ -906,14 +1166,22 @@ export const ${parent} = ${JSON.stringify(object, void 0, 2)};
 /**
  * Aggregated API object containing all endpoints
  */
-export const api = {
+const api = {
 ${apiObjectEntries.map((name) => `	${name},`).join("\n")}
 };
+return { api, ${apiObjectEntries.join(", ")} }
+}
 `;
   Object.entries(functionsInventory).forEach(([key, value]) => {
     tsString = tsString.replace(`"${key}"`, value);
   });
-  return fileTemplate(tsString, allTypes, baseUrl);
+  return moduleFactoryName ? moduleFileTemplate(tsString, allTypes, moduleFactoryName) : fileTemplate(tsString, allTypes, baseUrl, apiObjectEntries);
+}
+function generateFunctions(paths, baseUrl) {
+  return generateFunctionsInternal(paths, baseUrl);
+}
+function generateModuleFunctions(paths, baseUrl, moduleFactoryName) {
+  return generateFunctionsInternal(paths, baseUrl, moduleFactoryName);
 }
 function generateStreamEventTypeDefinitions() {
   if (Object.keys(streamEventTypes).length === 0) {
@@ -998,18 +1266,16 @@ function generateStreamEventTypeDefinitions() {
   }
   return typeDefs;
 }
-function fileTemplate(tsString, typeForImport, baseURL) {
+function fileTemplate(tsString, typeForImport, baseURL, apiObjectEntries) {
   const streamTypeDefs = generateStreamEventTypeDefinitions();
   const hasStreamEndpoints = Object.keys(streamEventTypes).length > 0;
-  const allFunctionBodies = Object.values(functionsInventory).join("\n");
-  const hasGetStreams = allFunctionBodies.includes("createSSEStream<");
-  const hasPostStreams = allFunctionBodies.includes("createSSEStreamPost<");
-  const streamImports = hasStreamEndpoints ? `${hasPostStreams ? "createSSEStreamPost, " : ""}${hasGetStreams ? "createSSEStream, " : ""}type StreamController, type SSEStreamOptions,` : "";
-  const templateCode = `import ax from 'axios';
-import type { AxiosResponse } from 'axios';
+  const streamImports = hasStreamEndpoints ? `type StreamController, type SSEStreamOptions,` : "";
+  const templateCode = `import type { AxiosResponse } from 'axios';
 import type { ${typeForImport.join(", ")} } from './types.d';
 import {
 	ApiResponse,
+	createApiTransport,
+	configureApiTransport,
 	parseApiError,
 	formatFieldErrors,
 	useApiRequest,
@@ -1024,9 +1290,10 @@ import {
 	type ApiRequestState,
 	type RequestInterceptor,
 	type ResponseInterceptor,
+	type ApiTransport,
 	type Unwrapped
 } from '@bagelink/sdk';
-import { ref, type Ref } from 'vue';
+import type { Ref } from 'vue';
 
 /**
  * Options for file upload operations
@@ -1042,22 +1309,29 @@ export interface UploadOptions {
 
 ${streamTypeDefs}
 
-/**
- * Configured axios instance for API requests
- */
-export const axios = ax.create({baseURL: '${baseURL}', withCredentials: true, paramsSerializer: { indexes: null }});
+const defaultTransport = createApiTransport({ baseURL: '${baseURL}' })
 
 ${tsString}
 
-// ============================================================================
+const defaultBindings = createEndpointNamespaces(defaultTransport)
+export const api = defaultBindings.api
+${apiObjectEntries.map((name) => `export const ${name} = defaultBindings.${name}`).join("\n")}
+export const axios = defaultTransport.axios
+
+/** Bind all generated endpoint namespaces to an isolated transport. */
+export function createApiClient(transport: ApiTransport) {
+	return createEndpointNamespaces(transport)
+}
+
+/** Resolve the default client's SSE base URL. */
+export function getStreamBaseURL(): string {
+	return defaultTransport.getStreamBaseURL()
+}
+
+// ============================================================================
 // API Instance & Configuration
 // ============================================================================
 
-/**
- * Last response metadata (accessible via useApi().$lastResponse)
- */
-const lastResponse = ref<AxiosResponse | null>(null)
-
 /**
  * API instance type with enhanced response objects
  */
@@ -1071,13 +1345,6 @@ type ApiInstance = typeof api & {
 
 // Global state
 let apiInstance: ApiInstance | null = null
-let apiConfig = ref<ApiConfig | null>(null)
-let _streamBaseURL: string | undefined
-
-/** Resolve base URL for SSE stream endpoints. Uses streamBaseURL if set, otherwise falls back to axios baseURL. */
-export function getStreamBaseURL(): string {
-	return _streamBaseURL || axios.defaults.baseURL || ""
-}
 
 /**
  * Create and configure the API instance
@@ -1085,77 +1352,17 @@ export function getStreamBaseURL(): string {
  * @returns Configured API instance
  */
 export function createApi(config: ApiConfig = {}): ApiInstance {
-	// Store config for access via useApi().$config
-	apiConfig.value = config
-
-	// Configure axios defaults
-	if (config.baseURL) {
-		axios.defaults.baseURL = config.baseURL
-	}
-	_streamBaseURL = config.streamBaseURL
-	if (config.withCredentials !== undefined) {
-		axios.defaults.withCredentials = config.withCredentials
-	}
-	if (config.axiosConfig) {
-		Object.assign(axios.defaults, config.axiosConfig)
-	}
-
-	// Clear existing interceptors
-	axios.interceptors.request.clear()
-	axios.interceptors.response.clear()
-
-	// Setup auth interceptor
-	if (config.auth) {
-		axios.interceptors.request.use(async (reqConfig) => {
-			const token = await config.auth!.getToken?.()
-			if (token) {
-				const prefix = config.auth!.tokenPrefix ?? 'Bearer'
-				reqConfig.headers.Authorization = \`\${prefix} \${token}\`
-			}
-			return reqConfig
-		})
-	}
-
-	// Setup custom request interceptor
-	if (config.interceptors?.request) {
-		axios.interceptors.request.use(config.interceptors.request)
-	}
-
-	// Setup response interceptor for error handling
-	axios.interceptors.response.use(
-		(response) => {
-			// Store last response for metadata access
-			lastResponse.value = response
-			
-			// Apply custom response interceptor if provided
-			if (config.interceptors?.response) {
-				return config.interceptors.response(response)
-			}
-			return response
-		},
-		async (error) => {
-			// Handle 401 Unauthorized
-			if (error.response?.status === 401) {
-				await config.auth?.onUnauthorized?.()
-			}
-
-			// Parse and handle error
-			const parsedError = parseApiError(error)
-			config.onError?.(parsedError, error)
-
-			throw error
-		}
-	)
+	configureApiTransport(defaultTransport, config)
 
 	// API already returns ApiResponse directly!
 	// Just add the special properties
 	apiInstance = {
 		...api,
 		$raw: api,
-		$lastResponse: lastResponse,
+		$lastResponse: defaultTransport.lastResponse,
 		$axios: axios,
 		$ApiResponse: ApiResponse,
-		$config: apiConfig
+		$config: defaultTransport.config
 	} as ApiInstance
 
 	return apiInstance
@@ -1202,6 +1409,35 @@ export {
 `;
   return templateCode.replace(/"([^"]+)":/g, "$1:");
 }
+function moduleFileTemplate(tsString, typeForImport, moduleFactoryName) {
+  const streamTypeDefs = generateStreamEventTypeDefinitions();
+  const hasStreamEndpoints = Object.keys(streamEventTypes).length > 0;
+  const streamImports = hasStreamEndpoints ? "type StreamController, type SSEStreamOptions," : "";
+  const typeImport = typeForImport.length ? `import type { ${typeForImport.join(", ")} } from './types.d';` : "";
+  const templateCode = `${typeImport}
+import {
+	ApiResponse,
+	${streamImports}
+	type ApiTransport
+} from '@bagelink/sdk';
+
+export interface UploadOptions {
+	onUploadProgress?: (progressEvent: any) => void
+	dirPath?: string
+	tags?: string[]
+}
+
+${streamTypeDefs}
+
+${tsString}
+
+/** Bind this module's generated endpoint namespaces to the app transport. */
+export function ${moduleFactoryName}(transport: ApiTransport) {
+	return createEndpointNamespaces(transport)
+}
+`;
+  return templateCode.replace(/"([^"]+)":/g, "$1:");
+}
 
 function generateTypes(schemas) {
   if (!schemas) {
@@ -1245,263 +1481,122 @@ function generateTypes(schemas) {
   }).join("\n");
 }
 
-class StreamController {
-  constructor(cleanup) {
-    this.cleanup = cleanup;
-  }
-  handlers = /* @__PURE__ */ new Map();
-  _closed = false;
-  /**
-   * Register an event handler (fully typed!)
-   * @param event - Event type to listen for
-   * @param handler - Handler function (data type inferred from event)
-   * @returns this (for chaining)
-   */
-  on(event, handler) {
-    if (!this.handlers.has(event)) {
-      this.handlers.set(event, /* @__PURE__ */ new Set());
+const METHODS = ["get", "put", "post", "delete", "options", "head", "patch", "trace"];
+function isReference(value) {
+  return Boolean(value && typeof value === "object" && "$ref" in value);
+}
+function operationOwners(path, operation, manifest) {
+  return manifest.modules.filter(
+    (module) => module.pathPrefixes?.some((prefix) => path === prefix || path.startsWith(`${prefix}/`)) || operation.tags?.some((tag) => module.tags?.includes(tag))
+  );
+}
+function collectSchemaRefs(value, refs) {
+  if (!value || typeof value !== "object") return;
+  if (isReference(value) && value.$ref.startsWith("#/components/schemas/")) {
+    refs.add(value.$ref.slice("#/components/schemas/".length));
+  }
+  for (const child of Object.values(value)) collectSchemaRefs(child, refs);
+}
+function schemaClosure(openApi, seed) {
+  const schemas = openApi.components?.schemas ?? {};
+  const result = new Set(seed);
+  const pending = [...result];
+  while (pending.length) {
+    const name = pending.pop();
+    const schema = schemas[name];
+    if (!schema) continue;
+    const refs = /* @__PURE__ */ new Set();
+    collectSchemaRefs(schema, refs);
+    for (const ref of refs) {
+      if (!result.has(ref)) {
+        result.add(ref);
+        pending.push(ref);
+      }
     }
-    this.handlers.get(event).add(handler);
-    return this;
   }
-  /**
-   * Emit an event to all registered handlers
-   * @internal
-   */
-  emit(event, data) {
-    const handlers = this.handlers.get(event);
-    if (handlers) {
-      handlers.forEach((handler) => {
-        try {
-          handler(data);
-        } catch (error) {
-          console.error(`Error in ${event} handler:`, error);
-        }
-      });
-    }
+  return [...result].sort();
+}
+function moduleFactoryName(name) {
+  return `create${name.split("-").filter(Boolean).map((part) => part[0].toUpperCase() + part.slice(1)).join("")}Api`;
+}
+function validateOwnershipManifest(openApi, manifest) {
+  const issues = [];
+  if (manifest.version !== 1) {
+    issues.push({ kind: "invalid-manifest", message: `Unsupported manifest version: ${manifest.version}` });
   }
-  /**
-   * Close the stream
-   */
-  close() {
-    if (!this._closed) {
-      this.cleanup();
-      this._closed = true;
-    }
+  const names = manifest.modules.map((module) => module.name);
+  for (const name of new Set(names.filter((name2, index) => names.indexOf(name2) !== index))) {
+    issues.push({ kind: "invalid-manifest", message: `Duplicate module name: ${name}` });
   }
-}
-
-function createSSEStream(url, options = {}) {
-  const {
-    headers = {},
-    withCredentials = true,
-    lastEventId: initialLastEventId,
-    maxReconnects = 5,
-    reconnectDelayMs = 1e3
-  } = options;
-  const controller = new AbortController();
-  const stream = new StreamController(() => {
-    controller.abort();
-  });
-  let lastEventId = initialLastEventId;
-  let reconnectAttempts = 0;
-  async function connect() {
-    if (controller.signal.aborted) return;
-    const requestHeaders = {
-      "Accept": "text/event-stream",
-      "Cache-Control": "no-cache",
-      ...headers
-    };
-    if (lastEventId !== void 0) {
-      requestHeaders["Last-Event-ID"] = lastEventId;
+  const schemas = openApi.components?.schemas ?? {};
+  for (const module of manifest.modules) {
+    if (!module.name || !/^[a-z][a-z0-9-]*$/.test(module.name)) {
+      issues.push({ kind: "invalid-manifest", message: `Invalid module name: ${module.name || "(empty)"}` });
     }
-    let response;
-    try {
-      response = await fetch(url, {
-        method: "GET",
-        headers: requestHeaders,
-        credentials: withCredentials ? "include" : "same-origin",
-        signal: controller.signal,
-        keepalive: false
-      });
-    } catch (error) {
-      if (error?.name === "AbortError") return;
-      return handleDisconnect(error);
-    }
-    if (!response.ok) {
-      stream.emit("error", new Error(`HTTP ${response.status}: ${response.statusText}`));
-      return;
-    }
-    if (!response.body) {
-      stream.emit("error", new Error("Response body is null"));
-      return;
+    if (!(module.tags?.length || module.pathPrefixes?.length)) {
+      issues.push({ kind: "invalid-manifest", message: `Module ${module.name} must own tags or pathPrefixes` });
     }
-    const reader = response.body.getReader();
-    const decoder = new TextDecoder();
-    let buffer = "";
-    let terminalEventReceived = false;
-    let currentEvent = "message";
-    let currentData = "";
-    let currentId;
-    try {
-      while (true) {
-        const { done, value } = await reader.read();
-        if (done) {
-          if (!controller.signal.aborted && !terminalEventReceived) {
-            return handleDisconnect(new Error("Stream ended before a terminal event"));
-          }
-          return;
-        }
-        buffer += decoder.decode(value, { stream: true });
-        const lines = buffer.split("\n");
-        buffer = lines.pop() || "";
-        for (const line of lines) {
-          if (line.startsWith("id:")) {
-            currentId = line.slice(3).trim();
-          } else if (line.startsWith("event:")) {
-            currentEvent = line.slice(6).trim();
-          } else if (line.startsWith("data:")) {
-            currentData = currentData ? `${currentData}
-${line.slice(5).trim()}` : line.slice(5).trim();
-          } else if (line === "" && currentData) {
-            if (currentId !== void 0) {
-              if (currentId !== lastEventId) reconnectAttempts = 0;
-              lastEventId = currentId;
-            }
-            try {
-              const parsed = JSON.parse(currentData);
-              stream.emit(currentEvent, parsed);
-              if (currentEvent === "done" || currentEvent === "error") {
-                terminalEventReceived = true;
-                stream.emit("complete", {});
-                controller.abort();
-                try {
-                  await reader.cancel();
-                } catch {
-                }
-                return;
-              }
-            } catch {
-              stream.emit(currentEvent, currentData);
-            }
-            currentEvent = "message";
-            currentData = "";
-            currentId = void 0;
-          }
-        }
-      }
-    } catch (error) {
-      if (error?.name !== "AbortError") {
-        return handleDisconnect(error);
-      }
-    } finally {
-      try {
-        reader.releaseLock();
-      } catch {
-      }
+    for (const schema of module.schemas ?? []) {
+      if (!schemas[schema]) issues.push({ kind: "unknown-schema", message: `Module ${module.name} owns unknown schema ${schema}` });
     }
   }
-  async function handleDisconnect(error) {
-    if (controller.signal.aborted) return;
-    if (reconnectAttempts >= maxReconnects) {
-      const msg = error?.message || "Stream connection lost";
-      stream.emit("error", new Error(`${msg} (gave up after ${maxReconnects} reconnects)`));
-      return;
+  for (const [path, item] of Object.entries(openApi.paths ?? {})) {
+    for (const method of METHODS) {
+      const operation = item[method];
+      if (!operation) continue;
+      const owners = operationOwners(path, operation, manifest);
+      if (owners.length === 0) {
+        issues.push({ kind: "unowned-operation", message: `${method.toUpperCase()} ${path} is not owned` });
+      } else if (owners.length > 1) {
+        issues.push({
+          kind: "multiply-owned-operation",
+          message: `${method.toUpperCase()} ${path} is owned by ${owners.map((owner) => owner.name).join(", ")}`
+        });
+      }
     }
-    reconnectAttempts++;
-    const delay = reconnectDelayMs * Math.pow(2, reconnectAttempts - 1);
-    await new Promise((resolve) => setTimeout(resolve, delay));
-    if (!controller.signal.aborted) await connect();
   }
-  connect().catch(() => {
-  });
-  return stream;
-}
-function createSSEStreamPost(url, body, options = {}) {
-  const { headers = {}, withCredentials = true } = options;
-  const controller = new AbortController();
-  const stream = new StreamController(() => {
-    controller.abort();
-  });
-  fetch(url, {
-    method: "POST",
-    headers: {
-      "Accept": "text/event-stream",
-      "Content-Type": "application/json",
-      "Cache-Control": "no-cache",
-      ...headers
-    },
-    credentials: withCredentials ? "include" : "same-origin",
-    body: JSON.stringify(body),
-    signal: controller.signal,
-    // Disable keepalive for streaming
-    keepalive: false
-  }).then(async (response) => {
-    if (!response.ok) {
-      throw new Error(`HTTP ${response.status}: ${response.statusText}`);
-    }
-    if (!response.body) {
-      throw new Error("Response body is null");
-    }
-    const reader = response.body.getReader();
-    const decoder = new TextDecoder();
-    let buffer = "";
-    let currentEvent = "message";
-    let currentData = "";
-    try {
-      while (true) {
-        const { done, value } = await reader.read();
-        if (done) {
-          stream.emit("done", {});
-          stream.emit("complete", {});
-          break;
-        }
-        buffer += decoder.decode(value, { stream: true });
-        const lines = buffer.split("\n");
-        buffer = lines.pop() || "";
-        for (const line of lines) {
-          if (line.startsWith("event:")) {
-            currentEvent = line.slice(6).trim();
-          } else if (line.startsWith("data:")) {
-            currentData = currentData ? `${currentData}
-${line.slice(5).trim()}` : line.slice(5).trim();
-          } else if (line === "" && currentData) {
-            try {
-              const parsed = JSON.parse(currentData);
-              stream.emit(currentEvent, parsed);
-            } catch {
-              stream.emit(currentEvent, currentData);
-            }
-            currentEvent = "message";
-            currentData = "";
-          }
+  return issues;
+}
+function generateModules(openApi, manifest, baseUrl) {
+  const issues = validateOwnershipManifest(openApi, manifest);
+  if (issues.length) throw new Error(issues.map((issue) => issue.message).join("\n"));
+  const schemas = openApi.components?.schemas ?? {};
+  return [...manifest.modules].sort((a, b) => a.name.localeCompare(b.name)).map((module) => {
+    const paths = {};
+    const refs = new Set(module.schemas ?? []);
+    for (const [path, item] of Object.entries(openApi.paths ?? {})) {
+      const ownedItem = {};
+      for (const method of METHODS) {
+        const operation = item[method];
+        if (operation && operationOwners(path, operation, manifest)[0]?.name === module.name) {
+          ownedItem[method] = operation;
+          collectSchemaRefs(operation, refs);
         }
       }
-    } catch (error) {
-      if (error?.name !== "AbortError") {
-        const errorMessage = error?.message || "Stream connection error";
-        stream.emit("error", new Error(errorMessage));
-      }
-    } finally {
-      try {
-        reader.releaseLock();
-      } catch {
+      if (Object.keys(ownedItem).length) {
+        if (item.parameters) ownedItem.parameters = item.parameters;
+        paths[path] = ownedItem;
       }
     }
-  }).catch((error) => {
-    if (error?.name !== "AbortError") {
-      const errorMessage = error?.message || "Failed to establish stream connection";
-      stream.emit("error", new Error(errorMessage));
-    }
+    const ownedSchemas = schemaClosure(openApi, refs);
+    const subset = Object.fromEntries(
+      ownedSchemas.map((name) => [name, schemas[name]]).filter((entry) => Boolean(entry[1]))
+    );
+    return {
+      name: module.name,
+      paths: Object.keys(paths).sort(),
+      schemas: ownedSchemas.map(formatType),
+      code: generateModuleFunctions(paths, baseUrl, moduleFactoryName(module.name)),
+      types: generateTypes(subset)
+    };
   });
-  return stream;
 }
 
 const basicAuthHeader = { Authorization: "Basic YmFnZWxfdXNlcm5hbWU6Tm90U2VjdXJlQGJhZ2Vs" };
 const index = async (openApiUrl, baseUrl) => {
   try {
     console.log(`Fetching OpenAPI spec from: ${openApiUrl}`);
-    const { data: openApi } = await axios$1.get(openApiUrl, { headers: basicAuthHeader });
+    const { data: openApi } = await ax.get(openApiUrl, { headers: basicAuthHeader });
     const schemas = openApi.components?.schemas;
     if (!schemas) {
       throw new Error("No schemas found in OpenAPI document");
@@ -1736,6 +1831,107 @@ function parseApiError(error) {
 function formatFieldErrors(fields) {
   return Object.entries(fields).map(([field, errors]) => `${field}: ${errors.join(", ")}`).join("\n");
 }
+function joinURL(baseURL, path) {
+  if (/^https?:\/\//i.test(path)) return path;
+  if (!baseURL) return path;
+  return `${baseURL.replace(/\/$/, "")}/${path.replace(/^\//, "")}`;
+}
+async function getTransportHeaders(config, options) {
+  const optionHeaders = typeof options.headers === "function" ? await options.headers() : options.headers ?? {};
+  const configuredHeaders = config.axiosConfig?.headers;
+  const headers = typeof configuredHeaders?.toJSON === "function" ? configuredHeaders.toJSON() : configuredHeaders ?? {};
+  const token = await config.auth?.getToken?.();
+  return {
+    ...headers,
+    ...token ? { Authorization: `${config.auth?.tokenPrefix ?? "Bearer"} ${token}` } : {},
+    ...optionHeaders
+  };
+}
+function createApiTransport(config = {}) {
+  const configRef = ref(null);
+  const lastResponse = ref(null);
+  const axios2 = ax.create({
+    baseURL: config.baseURL,
+    withCredentials: config.withCredentials ?? config.axiosConfig?.withCredentials ?? true,
+    paramsSerializer: { indexes: null },
+    ...config.axiosConfig
+  });
+  const streamOptions = async (options = {}) => {
+    const currentConfig = configRef.value ?? {};
+    return {
+      ...options,
+      withCredentials: options.withCredentials ?? currentConfig.withCredentials,
+      headers: await getTransportHeaders(currentConfig, options)
+    };
+  };
+  const streamURL = (path) => joinURL(
+    configRef.value?.streamBaseURL ?? axios2.defaults.baseURL ?? "",
+    path
+  );
+  const transport = {
+    axios: axios2,
+    config: configRef,
+    lastResponse,
+    getStreamBaseURL: () => configRef.value?.streamBaseURL ?? axios2.defaults.baseURL ?? "",
+    createSSEStream: (path, options = {}) => createSSEStream(streamURL(path), {
+      ...options,
+      headers: async () => (await streamOptions(options)).headers,
+      withCredentials: options.withCredentials ?? configRef.value?.withCredentials
+    }),
+    createSSEStreamPost: (path, body, options = {}) => createSSEStreamPost(streamURL(path), body, {
+      ...options,
+      headers: async () => (await streamOptions(options)).headers,
+      withCredentials: options.withCredentials ?? configRef.value?.withCredentials
+    })
+  };
+  return configureApiTransport(transport, config);
+}
+function configureApiTransport(transport, config = {}) {
+  const previousConfig = transport.config.value ?? {};
+  const resolvedConfig = {
+    ...previousConfig,
+    ...config,
+    axiosConfig: {
+      ...previousConfig.axiosConfig,
+      ...config.axiosConfig
+    },
+    withCredentials: config.withCredentials ?? config.axiosConfig?.withCredentials ?? previousConfig.withCredentials ?? true
+  };
+  transport.config.value = resolvedConfig;
+  transport.axios.defaults.baseURL = resolvedConfig.baseURL;
+  transport.axios.defaults.withCredentials = resolvedConfig.withCredentials;
+  if (resolvedConfig.axiosConfig) {
+    Object.assign(transport.axios.defaults, resolvedConfig.axiosConfig);
+  }
+  transport.axios.interceptors.request.clear();
+  transport.axios.interceptors.response.clear();
+  if (resolvedConfig.auth) {
+    transport.axios.interceptors.request.use(async (requestConfig) => {
+      const token = await resolvedConfig.auth.getToken?.();
+      if (token) {
+        requestConfig.headers.Authorization = `${resolvedConfig.auth.tokenPrefix ?? "Bearer"} ${token}`;
+      }
+      return requestConfig;
+    });
+  }
+  if (resolvedConfig.interceptors?.request) {
+    transport.axios.interceptors.request.use(resolvedConfig.interceptors.request);
+  }
+  transport.axios.interceptors.response.use(
+    (response) => {
+      transport.lastResponse.value = response;
+      return resolvedConfig.interceptors?.response?.(response) ?? response;
+    },
+    async (error) => {
+      if (error.response?.status === 401) {
+        await resolvedConfig.auth?.onUnauthorized?.();
+      }
+      resolvedConfig.onError?.(parseApiError(error), error);
+      throw error;
+    }
+  );
+  return transport;
+}
 function useApiRequest(requestFn, options = {}) {
   const loading = ref(false);
   const error = ref(null);
@@ -1821,7 +2017,7 @@ function wrapApiForDirectReturn(apiObj) {
   }
   return apiObj;
 }
-const axios = axios$1.create({
+const axios = ax.create({
   withCredentials: true
 });
 class DataRequest {
@@ -2091,4 +2287,4 @@ function createOptionsGetter(fetchFn, mapFn) {
   };
 }
 
-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 };
+export { ApiResponse, Bagel, StreamController, configureApiTransport, createApiTransport, createOptionsGetter, createSSEStream, createSSEStreamPost, dereference, extractSSEEventInfo, extractSSEEventSchemas, extractSSEEventTypes, formatAPIErrorMessage, formatFieldErrors, generateModules, getPath, isReferenceObject, isSSEStream, isSchemaObject, index as openAPI, parseApiError, unwrap, useApiRequest, useCancellableRequest, validateOwnershipManifest, wrapApiForDirectReturn };