@ragbits/api-client 1.4.0-dev.202512021005 → 1.4.0-dev.202512050236

package/__tests__/mocks/handlers.ts

@@ -1,5 +1,6 @@
 import { http, HttpResponse } from 'msw'
 import { defaultConfigResponse } from '../utils'
+import { ChatResponse } from '../../src'
 
 export const handlers = [
     // Config endpoint with conditional error handling
@@ -65,11 +66,14 @@ export const handlers = [
 
         const stream = new ReadableStream({
             start(controller) {
-                const messages = [
-                    { type: 'text', content: 'Hello there!' },
-                    { type: 'text', content: 'How can I help you?' },
-                    { type: 'message_id', content: 'msg-123' },
-                    { type: 'conversation_id', content: 'conv-456' },
+                const messages: ChatResponse[] = [
+                    { type: 'text', content: { text: 'Hello there!' } },
+                    { type: 'text', content: { text: 'How can I help you?' } },
+                    { type: 'message_id', content: { message_id: 'msg-123' } },
+                    {
+                        type: 'conversation_id',
+                        content: { conversation_id: 'conv-456' },
+                    },
                 ]
 
                 messages.forEach((message, index) => {

package/dist/autogen.types.d.ts

@@ -60,6 +60,12 @@ export interface ChatContext {
     };
     user: User | null;
     session_id: string | null;
+    /**
+     * List of confirmed/declined tools from the frontend
+     */
+    confirmed_tools: {
+        [k: string]: unknown;
+    }[] | null;
     [k: string]: unknown;
 }
 /**
@@ -164,6 +170,17 @@ export interface Task {
     full_response: string | null;
     dependencies: string[];
 }
+/**
+ * Represents a tool confirmation request sent to the user.
+ */
+export interface ConfirmationRequest {
+    confirmation_id: string;
+    tool_name: string;
+    tool_description: string;
+    arguments: {
+        [k: string]: unknown;
+    };
+}
 /**
  * Text content wrapper.
  */
@@ -208,6 +225,12 @@ export interface UsageContent {
 export interface TodoItemContent {
     task: Task;
 }
+/**
+ * Confirmation request content wrapper.
+ */
+export interface ConfirmationRequestContent {
+    confirmation_request: ConfirmationRequest;
+}
 /**
  * Customization for the header section of the UI.
  */
@@ -485,6 +508,10 @@ export interface ConversationSummaryResponse {
     type: 'conversation_summary';
     content: ConversationSummaryContent;
 }
+export interface ConfirmationRequestChatResponse {
+    type: 'confirmation_request';
+    content: ConfirmationRequestContent;
+}
 export interface ChunkedChatResponse {
     type: 'chunked_content';
     content: ChunkedContent;
@@ -492,4 +519,4 @@ export interface ChunkedChatResponse {
 /**
  * Typed chat response union
  */
-export type ChatResponse = TextChatResponse | ReferenceChatResponse | MessageIdChatResponse | ConversationIdChatResponse | StateUpdateChatResponse | LiveUpdateChatResponse | FollowupMessagesChatResponse | ImageChatResponse | MessageUsageChatResponse | ClearMessageChatResponse | TodoItemChatResonse | ConversationSummaryResponse;
+export type ChatResponse = TextChatResponse | ReferenceChatResponse | MessageIdChatResponse | ConversationIdChatResponse | StateUpdateChatResponse | LiveUpdateChatResponse | FollowupMessagesChatResponse | ImageChatResponse | MessageUsageChatResponse | ClearMessageChatResponse | TodoItemChatResonse | ConversationSummaryResponse | ConfirmationRequestChatResponse;

package/dist/index.cjs

@@ -120,10 +120,13 @@ var RagbitsClient = class {
    * @param endpoint - API endpoint path
    * @param options - Typed request options for the specific endpoint
    */
-  async makeRequest(endpoint, options) {
+  async makeRequest(endpoint, ...args) {
+    const options = args[0];
     const {
       method = "GET",
       body,
+      pathParams,
+      queryParams,
       headers = {},
       ...restOptions
     } = options || {};
@@ -131,15 +134,32 @@ var RagbitsClient = class {
       method,
       headers,
       ...restOptions
-      // This will include signal and other fetch options
     };
     if (body && method !== "GET") {
       requestOptions.body = typeof body === "string" ? body : JSON.stringify(body);
     }
-    const response = await this._makeRequest(
-      this._buildApiUrl(endpoint.toString()),
-      requestOptions
-    );
+    let url = endpoint.toString();
+    if (pathParams) {
+      url = url.replace(/:([^/]+)/g, (_, paramName) => {
+        if (paramName in pathParams) {
+          const value = pathParams[paramName];
+          return encodeURIComponent(String(value));
+        } else {
+          throw new Error(`Path parameter ${paramName} is required`);
+        }
+      });
+    }
+    if (queryParams && Object.keys(queryParams).length > 0) {
+      const searchParams = new URLSearchParams();
+      for (const [key, value] of Object.entries(queryParams)) {
+        if (value !== void 0 && value !== null) {
+          searchParams.append(key, String(value));
+        }
+      }
+      url += `?${searchParams.toString()}`;
+    }
+    url = this._buildApiUrl(url);
+    const response = await this._makeRequest(url, requestOptions);
     return response.json();
   }
   /**

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import type { ClientConfig, StreamCallbacks, BaseApiEndpoints, EndpointDefinition, EndpointResponse, RequestOptions, BaseStreamingEndpoints, EndpointRequest } from './types';
+import type { ClientConfig, StreamCallbacks, BaseApiEndpoints, EndpointDefinition, EndpointResponse, BaseStreamingEndpoints, EndpointRequest, MakeRequestOptions } from './types';
 /**
  * Client for communicating with the Ragbits API
  */
@@ -30,8 +30,8 @@ export declare class RagbitsClient {
      * @param options - Typed request options for the specific endpoint
      */
     makeRequest<Endpoints extends {
-        [K in keyof Endpoints]: EndpointDefinition;
-    } = BaseApiEndpoints, URL extends keyof Endpoints = keyof Endpoints>(endpoint: URL, options?: RequestOptions<URL, Endpoints>): Promise<EndpointResponse<URL, Endpoints>>;
+        [K in keyof Endpoints]: EndpointDefinition<any, any, any, any>;
+    } = BaseApiEndpoints, URL extends keyof Endpoints = keyof Endpoints>(endpoint: URL, ...args: MakeRequestOptions<URL, Endpoints>): Promise<EndpointResponse<URL, Endpoints>>;
     /**
      * Method for streaming requests to known endpoints only
      * @param endpoint - Streaming endpoint path
@@ -40,7 +40,7 @@ export declare class RagbitsClient {
      * @param signal - Optional AbortSignal for cancelling the request
      */
     makeStreamRequest<Endpoints extends {
-        [K in keyof Endpoints]: EndpointDefinition;
+        [K in keyof Endpoints]: EndpointDefinition<any, any, any, any>;
     } = BaseStreamingEndpoints, URL extends keyof Endpoints = keyof Endpoints>(endpoint: URL, data: EndpointRequest<URL, Endpoints>, callbacks: StreamCallbacks<EndpointResponse<URL, Endpoints>>, signal?: AbortSignal, customHeaders?: Record<string, string>): () => void;
     private normalizeHeaders;
     private handleChunkedContent;

package/dist/index.js

@@ -89,10 +89,13 @@ var RagbitsClient = class {
    * @param endpoint - API endpoint path
    * @param options - Typed request options for the specific endpoint
    */
-  async makeRequest(endpoint, options) {
+  async makeRequest(endpoint, ...args) {
+    const options = args[0];
     const {
       method = "GET",
       body,
+      pathParams,
+      queryParams,
       headers = {},
       ...restOptions
     } = options || {};
@@ -100,15 +103,32 @@ var RagbitsClient = class {
       method,
       headers,
       ...restOptions
-      // This will include signal and other fetch options
     };
     if (body && method !== "GET") {
       requestOptions.body = typeof body === "string" ? body : JSON.stringify(body);
     }
-    const response = await this._makeRequest(
-      this._buildApiUrl(endpoint.toString()),
-      requestOptions
-    );
+    let url = endpoint.toString();
+    if (pathParams) {
+      url = url.replace(/:([^/]+)/g, (_, paramName) => {
+        if (paramName in pathParams) {
+          const value = pathParams[paramName];
+          return encodeURIComponent(String(value));
+        } else {
+          throw new Error(`Path parameter ${paramName} is required`);
+        }
+      });
+    }
+    if (queryParams && Object.keys(queryParams).length > 0) {
+      const searchParams = new URLSearchParams();
+      for (const [key, value] of Object.entries(queryParams)) {
+        if (value !== void 0 && value !== null) {
+          searchParams.append(key, String(value));
+        }
+      }
+      url += `?${searchParams.toString()}`;
+    }
+    url = this._buildApiUrl(url);
+    const response = await this._makeRequest(url, requestOptions);
     return response.json();
   }
   /**

package/dist/types.d.ts

@@ -20,10 +20,12 @@ export interface StreamCallbacks<T, E = Error> {
     onError: (error: E) => void | Promise<void>;
     onClose?: () => void | Promise<void>;
 }
-export interface EndpointDefinition<Req = any, Res = any> {
+export interface EndpointDefinition<Req = any, Res = any, PathParams = never, QueryParams = never> {
     method: string;
     request: Req;
     response: Res;
+    pathParams: PathParams;
+    queryParams: QueryParams;
 }
 /**
  * Base predefined API endpoint definitions with their request/response types
@@ -45,34 +47,86 @@ export interface BaseStreamingEndpoints {
  * Extract endpoint paths as a union type
  */
 export type EndpointPath<Endpoints extends {
-    [K in keyof Endpoints]: EndpointDefinition;
+    [K in keyof Endpoints]: EndpointDefinition<any, any, any, any>;
 }> = keyof Endpoints;
 /**
  * Extract request type for a specific API endpoint
  */
 export type EndpointRequest<URL extends keyof Endpoints, Endpoints extends {
-    [K in keyof Endpoints]: EndpointDefinition;
+    [K in keyof Endpoints]: EndpointDefinition<any, any, any, any>;
 }> = Endpoints[URL]['request'];
 /**
  * Extract response type for a specific API endpoint
  */
 export type EndpointResponse<URL extends keyof Endpoints, Endpoints extends {
-    [K in keyof Endpoints]: EndpointDefinition;
+    [K in keyof Endpoints]: EndpointDefinition<any, any, any, any>;
 }> = Endpoints[URL]['response'];
 /**
  * Extract HTTP method for a specific API endpoint
  */
 export type EndpointMethod<URL extends keyof Endpoints, Endpoints extends {
-    [K in keyof Endpoints]: EndpointDefinition;
+    [K in keyof Endpoints]: EndpointDefinition<any, any, any, any>;
 }> = Endpoints[URL]['method'];
 /**
- * Generic request options for API endpoints with typed methods and body
+ * Check if an object type has any required properties
+ * - {} extends T means all properties are optional → false
+ * - {} doesn't extend T means at least one property is required → true
  */
-export interface RequestOptions<URL extends keyof Endpoints, Endpoints extends {
-    [K in keyof Endpoints]: EndpointDefinition;
-}> {
+export type HasRequiredKeys<T> = [T] extends [never] ? false : {} extends T ? false : true;
+/**
+ * Generic request options for API endpoints with typed methods, path params, query params, and body
+ * - pathParams is REQUIRED when PathParams is not never
+ * - queryParams is REQUIRED when it has required keys inside
+ * - queryParams is OPTIONAL when all keys are optional or it's never
+ * - body is REQUIRED when it's a specific type (not never, not undefined)
+ * - body is OPTIONAL when it's never or undefined
+ */
+export type RequestOptions<URL extends keyof Endpoints, Endpoints extends {
+    [K in keyof Endpoints]: EndpointDefinition<any, any, any, any>;
+}> = {
     method?: Endpoints[URL]['method'];
-    body?: Endpoints[URL]['request'] extends never ? undefined : Endpoints[URL]['request'];
     headers?: Record<string, string>;
     signal?: AbortSignal;
-}
+} & (Endpoints[URL]['pathParams'] extends never ? {
+    pathParams?: never;
+} : {
+    pathParams: Endpoints[URL]['pathParams'];
+}) & (Endpoints[URL]['queryParams'] extends never ? {
+    queryParams?: never;
+} : HasRequiredKeys<Endpoints[URL]['queryParams']> extends true ? {
+    queryParams: Endpoints[URL]['queryParams'];
+} : {
+    queryParams?: Endpoints[URL]['queryParams'];
+}) & // All properties optional
+(Endpoints[URL]['request'] extends never ? {
+    body?: never;
+} : Endpoints[URL]['request'] extends undefined ? {
+    body?: Endpoints[URL]['request'];
+} : {
+    body: Endpoints[URL]['request'];
+});
+/**
+ * Check if a type is not never and not undefined
+ */
+export type IsRequired<T> = [T] extends [never] ? false : T extends undefined ? false : true;
+/**
+ * Check if an endpoint has any required parameters
+ * Returns true if any of these conditions are met:
+ * - pathParams is defined (not never), OR
+ * - queryParams has any required keys inside, OR
+ * - body/request is required (not never, not undefined)
+ */
+export type HasRequiredParams<URL extends keyof Endpoints, Endpoints extends {
+    [K in keyof Endpoints]: EndpointDefinition<any, any, any, any>;
+}> = Endpoints[URL]['pathParams'] extends never ? HasRequiredKeys<Endpoints[URL]['queryParams']> extends true ? true : IsRequired<Endpoints[URL]['request']> : true;
+/**
+ * Conditional options parameter for makeRequest
+ * - Required if endpoint has:
+ *   - pathParams, OR
+ *   - queryParams with specific type (not undefined), OR
+ *   - body with specific type (not undefined)
+ * - Optional otherwise
+ */
+export type MakeRequestOptions<URL extends keyof Endpoints, Endpoints extends {
+    [K in keyof Endpoints]: EndpointDefinition<any, any, any, any>;
+}> = HasRequiredParams<URL, Endpoints> extends true ? [options: RequestOptions<URL, Endpoints>] : [options?: RequestOptions<URL, Endpoints>];

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@ragbits/api-client",
-    "version": "1.4.0-dev.202512021005",
+    "version": "1.4.0-dev.202512050236",
     "description": "JavaScript client for the Ragbits API",
     "repository": {
         "type": "git",