@thinkhive/sdk 4.1.0 → 4.2.1

package/dist/api/sessions.js

@@ -0,0 +1,49 @@
+"use strict";
+/**
+ * ThinkHive SDK - Sessions API
+ *
+ * Trace session grouping for multi-turn conversation tracking
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = exports.sessions = void 0;
+const client_1 = require("../core/client");
+// ============================================================================
+// SESSIONS API CLIENT
+// ============================================================================
+/**
+ * Sessions API client for trace session grouping
+ */
+exports.sessions = {
+    /**
+     * List sessions for an agent
+     *
+     * @param agentId - The agent ID
+     * @param opts - Pagination options
+     * @returns List of sessions
+     */
+    async list(agentId, opts) {
+        const params = new URLSearchParams({ agentId });
+        if (opts?.limit !== undefined)
+            params.set('limit', String(opts.limit));
+        if (opts?.offset !== undefined)
+            params.set('offset', String(opts.offset));
+        return (0, client_1.apiRequestWithData)(`/traces/sessions?${params}`, {
+            apiVersion: 'none',
+        });
+    },
+    /**
+     * Get traces for a specific session
+     *
+     * @param sessionId - The session ID
+     * @param agentId - The agent ID
+     * @returns List of traces in the session
+     */
+    async getTraces(sessionId, agentId) {
+        const params = new URLSearchParams({ agentId, sessionId });
+        return (0, client_1.apiRequestWithData)(`/traces?${params}`, {
+            apiVersion: 'none',
+        });
+    },
+};
+exports.default = exports.sessions;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/api/shadow-tests.d.ts

@@ -0,0 +1,78 @@
+/**
+ * ThinkHive SDK - Shadow Tests API
+ *
+ * Shadow test execution for validating proposed fixes
+ */
+/** Data for creating a shadow test */
+export interface CreateShadowTestData {
+    fixId: string;
+    agentId: string;
+    testName: string;
+    inputData: unknown;
+    expectedOutput: unknown;
+}
+/** Data for updating a shadow test */
+export interface UpdateShadowTestData {
+    testName?: string;
+    status?: string;
+    actualOutput?: unknown;
+    passed?: boolean;
+    metadata?: Record<string, unknown>;
+}
+/** A shadow test record */
+export interface ShadowTest {
+    id: string;
+    fixId: string;
+    agentId: string;
+    testName: string;
+    inputData: unknown;
+    expectedOutput: unknown;
+    actualOutput?: unknown;
+    status: string;
+    passed?: boolean;
+    createdAt: string;
+    completedAt?: string;
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Shadow tests API client for managing shadow test execution
+ */
+export declare const shadowTests: {
+    /**
+     * List shadow tests for an agent
+     *
+     * @param agentId - The agent ID
+     * @returns List of shadow tests
+     */
+    list(agentId: string): Promise<ShadowTest[]>;
+    /**
+     * Get a shadow test by ID
+     *
+     * @param id - The shadow test ID
+     * @returns The shadow test details
+     */
+    get(id: string): Promise<ShadowTest>;
+    /**
+     * Get shadow tests for a specific fix
+     *
+     * @param fixId - The fix ID
+     * @returns List of shadow tests for the fix
+     */
+    getByFix(fixId: string): Promise<ShadowTest[]>;
+    /**
+     * Create a new shadow test
+     *
+     * @param data - Shadow test configuration
+     * @returns The created shadow test
+     */
+    create(data: CreateShadowTestData): Promise<ShadowTest>;
+    /**
+     * Update a shadow test
+     *
+     * @param id - The shadow test ID to update
+     * @param data - Fields to update
+     * @returns The updated shadow test
+     */
+    update(id: string, data: UpdateShadowTestData): Promise<ShadowTest>;
+};
+export { shadowTests as default };

package/dist/api/shadow-tests.js

@@ -0,0 +1,80 @@
+"use strict";
+/**
+ * ThinkHive SDK - Shadow Tests API
+ *
+ * Shadow test execution for validating proposed fixes
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = exports.shadowTests = void 0;
+const client_1 = require("../core/client");
+// ============================================================================
+// SHADOW TESTS API CLIENT
+// ============================================================================
+/**
+ * Shadow tests API client for managing shadow test execution
+ */
+exports.shadowTests = {
+    /**
+     * List shadow tests for an agent
+     *
+     * @param agentId - The agent ID
+     * @returns List of shadow tests
+     */
+    async list(agentId) {
+        const params = new URLSearchParams({ agentId });
+        return (0, client_1.apiRequestWithData)(`/shadow-tests?${params}`, {
+            apiVersion: 'none',
+        });
+    },
+    /**
+     * Get a shadow test by ID
+     *
+     * @param id - The shadow test ID
+     * @returns The shadow test details
+     */
+    async get(id) {
+        return (0, client_1.apiRequestWithData)(`/shadow-tests/${id}`, {
+            apiVersion: 'none',
+        });
+    },
+    /**
+     * Get shadow tests for a specific fix
+     *
+     * @param fixId - The fix ID
+     * @returns List of shadow tests for the fix
+     */
+    async getByFix(fixId) {
+        return (0, client_1.apiRequestWithData)(`/fixes/${fixId}/shadow-tests`, {
+            apiVersion: 'none',
+        });
+    },
+    /**
+     * Create a new shadow test
+     *
+     * @param data - Shadow test configuration
+     * @returns The created shadow test
+     */
+    async create(data) {
+        return (0, client_1.apiRequestWithData)('/shadow-tests', {
+            method: 'POST',
+            body: data,
+            apiVersion: 'none',
+        });
+    },
+    /**
+     * Update a shadow test
+     *
+     * @param id - The shadow test ID to update
+     * @param data - Fields to update
+     * @returns The updated shadow test
+     */
+    async update(id, data) {
+        return (0, client_1.apiRequestWithData)(`/shadow-tests/${id}`, {
+            method: 'PATCH',
+            body: data,
+            apiVersion: 'none',
+        });
+    },
+};
+exports.default = exports.shadowTests;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/api/signals.d.ts

@@ -0,0 +1,177 @@
+/**
+ * ThinkHive SDK - Signals API
+ *
+ * Behavioral signal management for detecting patterns in agent interactions
+ */
+/** Signal detection configuration */
+export interface DetectionConfig {
+    type: string;
+    threshold?: number;
+    pattern?: string;
+    [key: string]: unknown;
+}
+/** Options for creating a signal */
+export interface CreateSignalOptions {
+    description?: string;
+    isEnabled?: boolean;
+    severity?: string;
+}
+/** Options for updating a signal */
+export interface UpdateSignalOptions {
+    name?: string;
+    group?: string;
+    description?: string;
+    detectionConfig?: DetectionConfig;
+    isEnabled?: boolean;
+    severity?: string;
+}
+/** Options for listing signals */
+export interface ListSignalsOptions {
+    group?: string;
+    source?: string;
+    isEnabled?: boolean;
+}
+/** Options for getting signal stats */
+export interface SignalStatsOptions {
+    startDate?: string;
+    endDate?: string;
+    agentId?: string;
+}
+/** Options for getting signal trends */
+export interface SignalTrendsOptions {
+    startDate?: string;
+    endDate?: string;
+    agentId?: string;
+    granularity?: 'hour' | 'day' | 'week' | 'month';
+}
+/** Options for getting signal traces */
+export interface SignalTracesOptions {
+    limit?: number;
+    offset?: number;
+    startDate?: string;
+    endDate?: string;
+    agentId?: string;
+}
+/** Options for getting signal events */
+export interface SignalEventsOptions {
+    limit?: number;
+    offset?: number;
+}
+/** A behavioral signal definition */
+export interface Signal {
+    id: string;
+    name: string;
+    group: string;
+    description?: string;
+    detectionConfig: DetectionConfig;
+    isEnabled: boolean;
+    severity?: string;
+    source?: string;
+    createdAt: string;
+    updatedAt: string;
+}
+/** Signal statistics */
+export interface SignalStats {
+    signalId: string;
+    name: string;
+    eventCount: number;
+    traceCount: number;
+    lastTriggeredAt?: string;
+}
+/** Signal trend data point */
+export interface SignalTrendPoint {
+    period: string;
+    eventCount: number;
+    traceCount: number;
+}
+/** A signal event occurrence */
+export interface SignalEvent {
+    id: string;
+    signalId: string;
+    traceId: string;
+    detectedAt: string;
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Signals API client for managing behavioral signal detection
+ */
+export declare const signals: {
+    /**
+     * List all signals with optional filters
+     *
+     * @param opts - Filter options for group, source, or enabled status
+     * @returns List of signals
+     */
+    list(opts?: ListSignalsOptions): Promise<Signal[]>;
+    /**
+     * Create a new behavioral signal
+     *
+     * @param name - Signal name
+     * @param group - Signal group/category
+     * @param detectionConfig - Detection configuration
+     * @param opts - Additional signal options
+     * @returns The created signal
+     */
+    create(name: string, group: string, detectionConfig: DetectionConfig, opts?: CreateSignalOptions): Promise<Signal>;
+    /**
+     * Update an existing signal
+     *
+     * @param id - Signal ID to update
+     * @param opts - Fields to update
+     * @returns The updated signal
+     */
+    update(id: string, opts: UpdateSignalOptions): Promise<Signal>;
+    /**
+     * Delete a signal
+     *
+     * @param id - Signal ID to delete
+     */
+    remove(id: string): Promise<void>;
+    /**
+     * Seed default signal definitions
+     *
+     * @returns List of seeded signals
+     */
+    seedDefaults(): Promise<Signal[]>;
+    /**
+     * Get signal statistics
+     *
+     * @param opts - Date range and agent filter options
+     * @returns Signal statistics
+     */
+    getStats(opts?: SignalStatsOptions): Promise<SignalStats[]>;
+    /**
+     * Get signal trend data over time
+     *
+     * @param opts - Date range, agent, and granularity options
+     * @returns Signal trend data points
+     */
+    getTrends(opts?: SignalTrendsOptions): Promise<SignalTrendPoint[]>;
+    /**
+     * Get traces that triggered a specific signal
+     *
+     * @param id - Signal ID
+     * @param opts - Pagination and filter options
+     * @returns Traces associated with the signal
+     */
+    getTraces(id: string, opts?: SignalTracesOptions): Promise<{
+        traces: any[];
+        limit: number;
+        offset: number;
+        hasMore: boolean;
+    }>;
+    /**
+     * Get events for a specific signal
+     *
+     * @param id - Signal ID
+     * @param opts - Pagination options
+     * @returns Signal events
+     */
+    getEvents(id: string, opts?: SignalEventsOptions): Promise<{
+        events: SignalEvent[];
+        limit: number;
+        offset: number;
+        hasMore: boolean;
+    }>;
+};
+export { signals as default };

package/dist/api/signals.js

@@ -0,0 +1,172 @@
+"use strict";
+/**
+ * ThinkHive SDK - Signals API
+ *
+ * Behavioral signal management for detecting patterns in agent interactions
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = exports.signals = void 0;
+const client_1 = require("../core/client");
+// ============================================================================
+// SIGNALS API CLIENT
+// ============================================================================
+/**
+ * Signals API client for managing behavioral signal detection
+ */
+exports.signals = {
+    /**
+     * List all signals with optional filters
+     *
+     * @param opts - Filter options for group, source, or enabled status
+     * @returns List of signals
+     */
+    async list(opts) {
+        const params = new URLSearchParams();
+        if (opts?.group)
+            params.set('group', opts.group);
+        if (opts?.source)
+            params.set('source', opts.source);
+        if (opts?.isEnabled !== undefined)
+            params.set('isEnabled', String(opts.isEnabled));
+        const query = params.toString();
+        return (0, client_1.apiRequestWithData)(`/signals/${query ? `?${query}` : ''}`, {
+            apiVersion: 'v1',
+        });
+    },
+    /**
+     * Create a new behavioral signal
+     *
+     * @param name - Signal name
+     * @param group - Signal group/category
+     * @param detectionConfig - Detection configuration
+     * @param opts - Additional signal options
+     * @returns The created signal
+     */
+    async create(name, group, detectionConfig, opts) {
+        return (0, client_1.apiRequestWithData)('/signals/', {
+            method: 'POST',
+            body: { name, group, detectionConfig, ...opts },
+            apiVersion: 'v1',
+        });
+    },
+    /**
+     * Update an existing signal
+     *
+     * @param id - Signal ID to update
+     * @param opts - Fields to update
+     * @returns The updated signal
+     */
+    async update(id, opts) {
+        return (0, client_1.apiRequestWithData)(`/signals/${id}`, {
+            method: 'PUT',
+            body: opts,
+            apiVersion: 'v1',
+        });
+    },
+    /**
+     * Delete a signal
+     *
+     * @param id - Signal ID to delete
+     */
+    async remove(id) {
+        return (0, client_1.apiRequest)(`/signals/${id}`, {
+            method: 'DELETE',
+            apiVersion: 'v1',
+        });
+    },
+    /**
+     * Seed default signal definitions
+     *
+     * @returns List of seeded signals
+     */
+    async seedDefaults() {
+        return (0, client_1.apiRequestWithData)('/signals/seed', {
+            method: 'POST',
+            apiVersion: 'v1',
+        });
+    },
+    /**
+     * Get signal statistics
+     *
+     * @param opts - Date range and agent filter options
+     * @returns Signal statistics
+     */
+    async getStats(opts) {
+        const params = new URLSearchParams();
+        if (opts?.startDate)
+            params.set('startDate', opts.startDate);
+        if (opts?.endDate)
+            params.set('endDate', opts.endDate);
+        if (opts?.agentId)
+            params.set('agentId', opts.agentId);
+        const query = params.toString();
+        return (0, client_1.apiRequestWithData)(`/signals/stats${query ? `?${query}` : ''}`, {
+            apiVersion: 'v1',
+        });
+    },
+    /**
+     * Get signal trend data over time
+     *
+     * @param opts - Date range, agent, and granularity options
+     * @returns Signal trend data points
+     */
+    async getTrends(opts) {
+        const params = new URLSearchParams();
+        if (opts?.startDate)
+            params.set('startDate', opts.startDate);
+        if (opts?.endDate)
+            params.set('endDate', opts.endDate);
+        if (opts?.agentId)
+            params.set('agentId', opts.agentId);
+        if (opts?.granularity)
+            params.set('granularity', opts.granularity);
+        const query = params.toString();
+        return (0, client_1.apiRequestWithData)(`/signals/trends${query ? `?${query}` : ''}`, {
+            apiVersion: 'v1',
+        });
+    },
+    /**
+     * Get traces that triggered a specific signal
+     *
+     * @param id - Signal ID
+     * @param opts - Pagination and filter options
+     * @returns Traces associated with the signal
+     */
+    async getTraces(id, opts) {
+        const params = new URLSearchParams();
+        if (opts?.limit !== undefined)
+            params.set('limit', String(opts.limit));
+        if (opts?.offset !== undefined)
+            params.set('offset', String(opts.offset));
+        if (opts?.startDate)
+            params.set('startDate', opts.startDate);
+        if (opts?.endDate)
+            params.set('endDate', opts.endDate);
+        if (opts?.agentId)
+            params.set('agentId', opts.agentId);
+        const query = params.toString();
+        return (0, client_1.apiRequestWithData)(`/signals/${id}/traces${query ? `?${query}` : ''}`, {
+            apiVersion: 'v1',
+        });
+    },
+    /**
+     * Get events for a specific signal
+     *
+     * @param id - Signal ID
+     * @param opts - Pagination options
+     * @returns Signal events
+     */
+    async getEvents(id, opts) {
+        const params = new URLSearchParams();
+        if (opts?.limit !== undefined)
+            params.set('limit', String(opts.limit));
+        if (opts?.offset !== undefined)
+            params.set('offset', String(opts.offset));
+        const query = params.toString();
+        return (0, client_1.apiRequestWithData)(`/signals/${id}/events${query ? `?${query}` : ''}`, {
+            apiVersion: 'v1',
+        });
+    },
+};
+exports.default = exports.signals;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"signals.js","sourceRoot":"","sources":["../../src/api/signals.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * ThinkHive SDK - Signals API\n *\n * Behavioral signal management for detecting patterns in agent interactions\n */\n\nimport { apiRequest, apiRequestWithData } from '../core/client';\n\n// ============================================================================\n// TYPES\n// ============================================================================\n\n/** Signal detection configuration */\nexport interface DetectionConfig {\n  type: string;\n  threshold?: number;\n  pattern?: string;\n  [key: string]: unknown;\n}\n\n/** Options for creating a signal */\nexport interface CreateSignalOptions {\n  description?: string;\n  isEnabled?: boolean;\n  severity?: string;\n}\n\n/** Options for updating a signal */\nexport interface UpdateSignalOptions {\n  name?: string;\n  group?: string;\n  description?: string;\n  detectionConfig?: DetectionConfig;\n  isEnabled?: boolean;\n  severity?: string;\n}\n\n/** Options for listing signals */\nexport interface ListSignalsOptions {\n  group?: string;\n  source?: string;\n  isEnabled?: boolean;\n}\n\n/** Options for getting signal stats */\nexport interface SignalStatsOptions {\n  startDate?: string;\n  endDate?: string;\n  agentId?: string;\n}\n\n/** Options for getting signal trends */\nexport interface SignalTrendsOptions {\n  startDate?: string;\n  endDate?: string;\n  agentId?: string;\n  granularity?: 'hour' | 'day' | 'week' | 'month';\n}\n\n/** Options for getting signal traces */\nexport interface SignalTracesOptions {\n  limit?: number;\n  offset?: number;\n  startDate?: string;\n  endDate?: string;\n  agentId?: string;\n}\n\n/** Options for getting signal events */\nexport interface SignalEventsOptions {\n  limit?: number;\n  offset?: number;\n}\n\n/** A behavioral signal definition */\nexport interface Signal {\n  id: string;\n  name: string;\n  group: string;\n  description?: string;\n  detectionConfig: DetectionConfig;\n  isEnabled: boolean;\n  severity?: string;\n  source?: string;\n  createdAt: string;\n  updatedAt: string;\n}\n\n/** Signal statistics */\nexport interface SignalStats {\n  signalId: string;\n  name: string;\n  eventCount: number;\n  traceCount: number;\n  lastTriggeredAt?: string;\n}\n\n/** Signal trend data point */\nexport interface SignalTrendPoint {\n  period: string;\n  eventCount: number;\n  traceCount: number;\n}\n\n/** A signal event occurrence */\nexport interface SignalEvent {\n  id: string;\n  signalId: string;\n  traceId: string;\n  detectedAt: string;\n  metadata?: Record<string, unknown>;\n}\n\n// ============================================================================\n// SIGNALS API CLIENT\n// ============================================================================\n\n/**\n * Signals API client for managing behavioral signal detection\n */\nexport const signals = {\n  /**\n   * List all signals with optional filters\n   *\n   * @param opts - Filter options for group, source, or enabled status\n   * @returns List of signals\n   */\n  async list(opts?: ListSignalsOptions): Promise<Signal[]> {\n    const params = new URLSearchParams();\n    if (opts?.group) params.set('group', opts.group);\n    if (opts?.source) params.set('source', opts.source);\n    if (opts?.isEnabled !== undefined) params.set('isEnabled', String(opts.isEnabled));\n\n    const query = params.toString();\n    return apiRequestWithData<Signal[]>(`/signals/${query ? `?${query}` : ''}`, {\n      apiVersion: 'v1',\n    });\n  },\n\n  /**\n   * Create a new behavioral signal\n   *\n   * @param name - Signal name\n   * @param group - Signal group/category\n   * @param detectionConfig - Detection configuration\n   * @param opts - Additional signal options\n   * @returns The created signal\n   */\n  async create(\n    name: string,\n    group: string,\n    detectionConfig: DetectionConfig,\n    opts?: CreateSignalOptions\n  ): Promise<Signal> {\n    return apiRequestWithData<Signal>('/signals/', {\n      method: 'POST',\n      body: { name, group, detectionConfig, ...opts },\n      apiVersion: 'v1',\n    });\n  },\n\n  /**\n   * Update an existing signal\n   *\n   * @param id - Signal ID to update\n   * @param opts - Fields to update\n   * @returns The updated signal\n   */\n  async update(id: string, opts: UpdateSignalOptions): Promise<Signal> {\n    return apiRequestWithData<Signal>(`/signals/${id}`, {\n      method: 'PUT',\n      body: opts,\n      apiVersion: 'v1',\n    });\n  },\n\n  /**\n   * Delete a signal\n   *\n   * @param id - Signal ID to delete\n   */\n  async remove(id: string): Promise<void> {\n    return apiRequest<void>(`/signals/${id}`, {\n      method: 'DELETE',\n      apiVersion: 'v1',\n    });\n  },\n\n  /**\n   * Seed default signal definitions\n   *\n   * @returns List of seeded signals\n   */\n  async seedDefaults(): Promise<Signal[]> {\n    return apiRequestWithData<Signal[]>('/signals/seed', {\n      method: 'POST',\n      apiVersion: 'v1',\n    });\n  },\n\n  /**\n   * Get signal statistics\n   *\n   * @param opts - Date range and agent filter options\n   * @returns Signal statistics\n   */\n  async getStats(opts?: SignalStatsOptions): Promise<SignalStats[]> {\n    const params = new URLSearchParams();\n    if (opts?.startDate) params.set('startDate', opts.startDate);\n    if (opts?.endDate) params.set('endDate', opts.endDate);\n    if (opts?.agentId) params.set('agentId', opts.agentId);\n\n    const query = params.toString();\n    return apiRequestWithData<SignalStats[]>(`/signals/stats${query ? `?${query}` : ''}`, {\n      apiVersion: 'v1',\n    });\n  },\n\n  /**\n   * Get signal trend data over time\n   *\n   * @param opts - Date range, agent, and granularity options\n   * @returns Signal trend data points\n   */\n  async getTrends(opts?: SignalTrendsOptions): Promise<SignalTrendPoint[]> {\n    const params = new URLSearchParams();\n    if (opts?.startDate) params.set('startDate', opts.startDate);\n    if (opts?.endDate) params.set('endDate', opts.endDate);\n    if (opts?.agentId) params.set('agentId', opts.agentId);\n    if (opts?.granularity) params.set('granularity', opts.granularity);\n\n    const query = params.toString();\n    return apiRequestWithData<SignalTrendPoint[]>(`/signals/trends${query ? `?${query}` : ''}`, {\n      apiVersion: 'v1',\n    });\n  },\n\n  /**\n   * Get traces that triggered a specific signal\n   *\n   * @param id - Signal ID\n   * @param opts - Pagination and filter options\n   * @returns Traces associated with the signal\n   */\n  async getTraces(id: string, opts?: SignalTracesOptions): Promise<{\n    traces: any[];\n    limit: number;\n    offset: number;\n    hasMore: boolean;\n  }> {\n    const params = new URLSearchParams();\n    if (opts?.limit !== undefined) params.set('limit', String(opts.limit));\n    if (opts?.offset !== undefined) params.set('offset', String(opts.offset));\n    if (opts?.startDate) params.set('startDate', opts.startDate);\n    if (opts?.endDate) params.set('endDate', opts.endDate);\n    if (opts?.agentId) params.set('agentId', opts.agentId);\n\n    const query = params.toString();\n    return apiRequestWithData(`/signals/${id}/traces${query ? `?${query}` : ''}`, {\n      apiVersion: 'v1',\n    });\n  },\n\n  /**\n   * Get events for a specific signal\n   *\n   * @param id - Signal ID\n   * @param opts - Pagination options\n   * @returns Signal events\n   */\n  async getEvents(id: string, opts?: SignalEventsOptions): Promise<{\n    events: SignalEvent[];\n    limit: number;\n    offset: number;\n    hasMore: boolean;\n  }> {\n    const params = new URLSearchParams();\n    if (opts?.limit !== undefined) params.set('limit', String(opts.limit));\n    if (opts?.offset !== undefined) params.set('offset', String(opts.offset));\n\n    const query = params.toString();\n    return apiRequestWithData(`/signals/${id}/events${query ? `?${query}` : ''}`, {\n      apiVersion: 'v1',\n    });\n  },\n};\n\nexport { signals as default };\n"]}

package/dist/core/client.d.ts

@@ -13,6 +13,8 @@ export interface RequestOptions {
     maxRetries?: number;
     /** Request timeout in milliseconds */
     timeout?: number;
+    /** Use path as-is without prepending /api/ prefix (for routes like /v1/guardrails/scan) */
+    rawPath?: boolean;
 }
 /**
  * Make an authenticated API request with retry logic