@deeprelay/sdk 0.2.0 → 0.3.0

package/src/models/SubscriptionUsage.ts

@@ -2,7 +2,7 @@
 /* eslint-disable */
 /**
  * deeprelay Public Developer API
- * Programmatic API for deeprelay. Authenticate with API keys minted from the dashboard. See https://deeprelay.ai/docs for details. 
+ * Programmatic API for deeprelay. Authenticate with API keys minted from the dashboard. See https://deeprelay.ai/docs for details.  Keys minted from the dashboard or `deeprelay login` belong to the Production server, https://api.deeprelay.ai/v1. The Demo server is an internal staging environment with its own key store.  Versioning: `/v1` is the API version. `info.version` is the revision of this `/v1` document, not a separate API.  OpenAI compatibility: chat completions follow the OpenAI request and response shapes, but not every OpenAI parameter is carried. Some are rejected with 400 `unsupported_parameter` and any parameter not declared in this spec is accepted and ignored. The full table is at https://deeprelay.ai/docs/api/inference#openai-compatibility. 
  *
  * The version of the OpenAPI document: 1.0.0
  * Contact: support@deeprelay.ai
@@ -13,6 +13,14 @@
  */
 
 import { mapValues } from '../runtime';
+import type { SubscriptionModelUsage } from './SubscriptionModelUsage';
+import {
+    SubscriptionModelUsageFromJSON,
+    SubscriptionModelUsageFromJSONTyped,
+    SubscriptionModelUsageToJSON,
+    SubscriptionModelUsageToJSONTyped,
+} from './SubscriptionModelUsage';
+
 /**
  * Consumption against the quota, from the same factor-weighted read the request-time gate evaluates — so this meter and enforcement cannot disagree.
  * 
@@ -47,17 +55,41 @@ export interface SubscriptionUsage {
      */
     weightedOutputTokens: number;
     /**
-     * Weighted input+output tokens over the trailing 7 days, against `quota.weekly_tokens`. A rolling figure, not a period one — it can be non-zero moments after a period rolls over.
+     * Weighted input tokens over the trailing 7 days, against `quota.weekly_input_tokens`. A rolling figure, not a period one — it can be non-zero moments after a period rolls over.
+     * @type {number}
+     * @memberof SubscriptionUsage
+     */
+    weeklyWeightedInputTokens: number;
+    /**
+     * Weighted output tokens over the trailing 7 days, against `quota.weekly_output_tokens`. A rolling figure, like `weekly_weighted_input_tokens`.
      * @type {number}
      * @memberof SubscriptionUsage
      */
-    weeklyWeightedTokens: number;
+    weeklyWeightedOutputTokens: number;
     /**
      * List-price metered cost of this period's plan traffic in micro-cents (1e-6 cent), against `quota.max_usage_micro_cents`.
      * @type {number}
      * @memberof SubscriptionUsage
      */
     costMicroCents: number;
+    /**
+     * Wallet-billed calls while subscribed, e.g. input-overshoot or quota-gate pay-as-you-go fallbacks and models the plan does not cover. Recent means the last 24 hours, clamped to the current period. Omitted when the count could not be read; its absence means unknown, not zero.
+     * @type {number}
+     * @memberof SubscriptionUsage
+     */
+    recentPaygCalls24h?: number;
+    /**
+     * This period's plan-covered usage split by model: the raw tokens each model served, its usage factor, and the weighted tokens they drew from the allowance. Heaviest weighted input first. Each model's weighted figures round down on their own, so they can sum to slightly less than `weighted_input_tokens` / `weighted_output_tokens`, which stay authoritative. Omitted when the breakdown could not be read or there is no covered usage.
+     * @type {Array<SubscriptionModelUsage>}
+     * @memberof SubscriptionUsage
+     */
+    byModel?: Array<SubscriptionModelUsage>;
+    /**
+     * The same breakdown over the trailing 7 days, against the weekly caps. Omitted under the same conditions as `by_model`.
+     * @type {Array<SubscriptionModelUsage>}
+     * @memberof SubscriptionUsage
+     */
+    weeklyByModel?: Array<SubscriptionModelUsage>;
 }
 
 /**
@@ -68,7 +100,8 @@ export function instanceOfSubscriptionUsage(value: object): value is Subscriptio
     if ((!('periodEnd' in (value as Record<string, any>)) && !('period_end' in (value as Record<string, any>))) || ((value as Record<string, any>)['periodEnd'] === undefined && (value as Record<string, any>)['period_end'] === undefined)) return false;
     if ((!('weightedInputTokens' in (value as Record<string, any>)) && !('weighted_input_tokens' in (value as Record<string, any>))) || ((value as Record<string, any>)['weightedInputTokens'] === undefined && (value as Record<string, any>)['weighted_input_tokens'] === undefined)) return false;
     if ((!('weightedOutputTokens' in (value as Record<string, any>)) && !('weighted_output_tokens' in (value as Record<string, any>))) || ((value as Record<string, any>)['weightedOutputTokens'] === undefined && (value as Record<string, any>)['weighted_output_tokens'] === undefined)) return false;
-    if ((!('weeklyWeightedTokens' in (value as Record<string, any>)) && !('weekly_weighted_tokens' in (value as Record<string, any>))) || ((value as Record<string, any>)['weeklyWeightedTokens'] === undefined && (value as Record<string, any>)['weekly_weighted_tokens'] === undefined)) return false;
+    if ((!('weeklyWeightedInputTokens' in (value as Record<string, any>)) && !('weekly_weighted_input_tokens' in (value as Record<string, any>))) || ((value as Record<string, any>)['weeklyWeightedInputTokens'] === undefined && (value as Record<string, any>)['weekly_weighted_input_tokens'] === undefined)) return false;
+    if ((!('weeklyWeightedOutputTokens' in (value as Record<string, any>)) && !('weekly_weighted_output_tokens' in (value as Record<string, any>))) || ((value as Record<string, any>)['weeklyWeightedOutputTokens'] === undefined && (value as Record<string, any>)['weekly_weighted_output_tokens'] === undefined)) return false;
     if ((!('costMicroCents' in (value as Record<string, any>)) && !('cost_micro_cents' in (value as Record<string, any>))) || ((value as Record<string, any>)['costMicroCents'] === undefined && (value as Record<string, any>)['cost_micro_cents'] === undefined)) return false;
     return true;
 }
@@ -87,8 +120,12 @@ export function SubscriptionUsageFromJSONTyped(json: any, ignoreDiscriminator: b
         'periodEnd': (new Date(json['period_end'])),
         'weightedInputTokens': json['weighted_input_tokens'],
         'weightedOutputTokens': json['weighted_output_tokens'],
-        'weeklyWeightedTokens': json['weekly_weighted_tokens'],
+        'weeklyWeightedInputTokens': json['weekly_weighted_input_tokens'],
+        'weeklyWeightedOutputTokens': json['weekly_weighted_output_tokens'],
         'costMicroCents': json['cost_micro_cents'],
+        'recentPaygCalls24h': json['recent_payg_calls_24h'] == null ? undefined : json['recent_payg_calls_24h'],
+        'byModel': json['by_model'] == null ? undefined : ((json['by_model'] as Array<any>).map(SubscriptionModelUsageFromJSON)),
+        'weeklyByModel': json['weekly_by_model'] == null ? undefined : ((json['weekly_by_model'] as Array<any>).map(SubscriptionModelUsageFromJSON)),
     };
 }
 
@@ -107,8 +144,12 @@ export function SubscriptionUsageToJSONTyped(value?: SubscriptionUsage | null, i
         'period_end': value['periodEnd'].toISOString(),
         'weighted_input_tokens': value['weightedInputTokens'],
         'weighted_output_tokens': value['weightedOutputTokens'],
-        'weekly_weighted_tokens': value['weeklyWeightedTokens'],
+        'weekly_weighted_input_tokens': value['weeklyWeightedInputTokens'],
+        'weekly_weighted_output_tokens': value['weeklyWeightedOutputTokens'],
         'cost_micro_cents': value['costMicroCents'],
+        'recent_payg_calls_24h': value['recentPaygCalls24h'],
+        'by_model': value['byModel'] == null ? undefined : ((value['byModel'] as Array<any>).map(SubscriptionModelUsageToJSON)),
+        'weekly_by_model': value['weeklyByModel'] == null ? undefined : ((value['weeklyByModel'] as Array<any>).map(SubscriptionModelUsageToJSON)),
     };
 }
 

package/src/models/Tool.ts

@@ -0,0 +1,95 @@
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * deeprelay Public Developer API
+ * Programmatic API for deeprelay. Authenticate with API keys minted from the dashboard. See https://deeprelay.ai/docs for details.  Keys minted from the dashboard or `deeprelay login` belong to the Production server, https://api.deeprelay.ai/v1. The Demo server is an internal staging environment with its own key store.  Versioning: `/v1` is the API version. `info.version` is the revision of this `/v1` document, not a separate API.  OpenAI compatibility: chat completions follow the OpenAI request and response shapes, but not every OpenAI parameter is carried. Some are rejected with 400 `unsupported_parameter` and any parameter not declared in this spec is accepted and ignored. The full table is at https://deeprelay.ai/docs/api/inference#openai-compatibility. 
+ *
+ * The version of the OpenAPI document: 1.0.0
+ * Contact: support@deeprelay.ai
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+
+import { mapValues } from '../runtime';
+import type { ToolFunction } from './ToolFunction';
+import {
+    ToolFunctionFromJSON,
+    ToolFunctionFromJSONTyped,
+    ToolFunctionToJSON,
+    ToolFunctionToJSONTyped,
+} from './ToolFunction';
+
+/**
+ * 
+ * @export
+ * @interface Tool
+ */
+export interface Tool {
+    /**
+     * 
+     * @type {ToolTypeEnum}
+     * @memberof Tool
+     */
+    type: ToolTypeEnum;
+    /**
+     * 
+     * @type {ToolFunction}
+     * @memberof Tool
+     */
+    _function: ToolFunction;
+}
+
+
+/**
+ * @export
+ */
+export const ToolTypeEnum = {
+    Function: 'function'
+} as const;
+export type ToolTypeEnum = typeof ToolTypeEnum[keyof typeof ToolTypeEnum];
+
+
+/**
+ * Check if a given object implements the Tool interface.
+ */
+export function instanceOfTool(value: object): value is Tool {
+    if (!('type' in value) || value['type'] === undefined) return false;
+    if (value['type'] !== 'function') return false;
+    
+    if ((!('_function' in (value as Record<string, any>)) && !('function' in (value as Record<string, any>))) || ((value as Record<string, any>)['_function'] === undefined && (value as Record<string, any>)['function'] === undefined)) return false;
+    return true;
+}
+
+export function ToolFromJSON(json: any): Tool {
+    return ToolFromJSONTyped(json, false);
+}
+
+export function ToolFromJSONTyped(json: any, ignoreDiscriminator: boolean): Tool {
+    if (json == null) {
+        return json;
+    }
+    return {
+        
+        'type': json['type'],
+        '_function': ToolFunctionFromJSON(json['function']),
+    };
+}
+
+export function ToolToJSON(json: any): Tool {
+    return ToolToJSONTyped(json, false);
+}
+
+export function ToolToJSONTyped(value?: Tool | null, ignoreDiscriminator: boolean = false): any {
+    if (value == null) {
+        return value;
+    }
+
+    return {
+        
+        'type': value['type'],
+        'function': ToolFunctionToJSON(value['_function']),
+    };
+}
+

package/src/models/ToolCall.ts

@@ -0,0 +1,110 @@
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * deeprelay Public Developer API
+ * Programmatic API for deeprelay. Authenticate with API keys minted from the dashboard. See https://deeprelay.ai/docs for details.  Keys minted from the dashboard or `deeprelay login` belong to the Production server, https://api.deeprelay.ai/v1. The Demo server is an internal staging environment with its own key store.  Versioning: `/v1` is the API version. `info.version` is the revision of this `/v1` document, not a separate API.  OpenAI compatibility: chat completions follow the OpenAI request and response shapes, but not every OpenAI parameter is carried. Some are rejected with 400 `unsupported_parameter` and any parameter not declared in this spec is accepted and ignored. The full table is at https://deeprelay.ai/docs/api/inference#openai-compatibility. 
+ *
+ * The version of the OpenAPI document: 1.0.0
+ * Contact: support@deeprelay.ai
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+
+import { mapValues } from '../runtime';
+import type { ToolCallFunction } from './ToolCallFunction';
+import {
+    ToolCallFunctionFromJSON,
+    ToolCallFunctionFromJSONTyped,
+    ToolCallFunctionToJSON,
+    ToolCallFunctionToJSONTyped,
+} from './ToolCallFunction';
+
+/**
+ * A function call the model emitted.
+ * @export
+ * @interface ToolCall
+ */
+export interface ToolCall {
+    /**
+     * Position among parallel calls. Present on streaming deltas, which key their fragments by it; absent on assembled messages.
+     * 
+     * @type {number}
+     * @memberof ToolCall
+     */
+    index?: number;
+    /**
+     * Identifier for this call. Echo it back as tool_call_id on the message carrying the result.
+     * 
+     * @type {string}
+     * @memberof ToolCall
+     */
+    id?: string;
+    /**
+     * 
+     * @type {ToolCallTypeEnum}
+     * @memberof ToolCall
+     */
+    type?: ToolCallTypeEnum;
+    /**
+     * 
+     * @type {ToolCallFunction}
+     * @memberof ToolCall
+     */
+    _function: ToolCallFunction;
+}
+
+
+/**
+ * @export
+ */
+export const ToolCallTypeEnum = {
+    Function: 'function'
+} as const;
+export type ToolCallTypeEnum = typeof ToolCallTypeEnum[keyof typeof ToolCallTypeEnum];
+
+
+/**
+ * Check if a given object implements the ToolCall interface.
+ */
+export function instanceOfToolCall(value: object): value is ToolCall {
+    if ((!('_function' in (value as Record<string, any>)) && !('function' in (value as Record<string, any>))) || ((value as Record<string, any>)['_function'] === undefined && (value as Record<string, any>)['function'] === undefined)) return false;
+    return true;
+}
+
+export function ToolCallFromJSON(json: any): ToolCall {
+    return ToolCallFromJSONTyped(json, false);
+}
+
+export function ToolCallFromJSONTyped(json: any, ignoreDiscriminator: boolean): ToolCall {
+    if (json == null) {
+        return json;
+    }
+    return {
+        
+        'index': json['index'] == null ? undefined : json['index'],
+        'id': json['id'] == null ? undefined : json['id'],
+        'type': json['type'] == null ? undefined : json['type'],
+        '_function': ToolCallFunctionFromJSON(json['function']),
+    };
+}
+
+export function ToolCallToJSON(json: any): ToolCall {
+    return ToolCallToJSONTyped(json, false);
+}
+
+export function ToolCallToJSONTyped(value?: ToolCall | null, ignoreDiscriminator: boolean = false): any {
+    if (value == null) {
+        return value;
+    }
+
+    return {
+        
+        'index': value['index'],
+        'id': value['id'],
+        'type': value['type'],
+        'function': ToolCallFunctionToJSON(value['_function']),
+    };
+}
+

package/src/models/ToolCallFunction.ts

@@ -0,0 +1,76 @@
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * deeprelay Public Developer API
+ * Programmatic API for deeprelay. Authenticate with API keys minted from the dashboard. See https://deeprelay.ai/docs for details.  Keys minted from the dashboard or `deeprelay login` belong to the Production server, https://api.deeprelay.ai/v1. The Demo server is an internal staging environment with its own key store.  Versioning: `/v1` is the API version. `info.version` is the revision of this `/v1` document, not a separate API.  OpenAI compatibility: chat completions follow the OpenAI request and response shapes, but not every OpenAI parameter is carried. Some are rejected with 400 `unsupported_parameter` and any parameter not declared in this spec is accepted and ignored. The full table is at https://deeprelay.ai/docs/api/inference#openai-compatibility. 
+ *
+ * The version of the OpenAPI document: 1.0.0
+ * Contact: support@deeprelay.ai
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+
+import { mapValues } from '../runtime';
+/**
+ * 
+ * @export
+ * @interface ToolCallFunction
+ */
+export interface ToolCallFunction {
+    /**
+     * 
+     * @type {string}
+     * @memberof ToolCallFunction
+     */
+    name: string;
+    /**
+     * The arguments as a JSON-encoded STRING, not an object — this is OpenAI's shape, and it is what lets a model stream partial arguments. Parse it before use, and do not assume it is valid JSON: a model can emit malformed arguments.
+     * 
+     * @type {string}
+     * @memberof ToolCallFunction
+     */
+    arguments: string;
+}
+
+/**
+ * Check if a given object implements the ToolCallFunction interface.
+ */
+export function instanceOfToolCallFunction(value: object): value is ToolCallFunction {
+    if (!('name' in value) || value['name'] === undefined) return false;
+    if (!('arguments' in value) || value['arguments'] === undefined) return false;
+    return true;
+}
+
+export function ToolCallFunctionFromJSON(json: any): ToolCallFunction {
+    return ToolCallFunctionFromJSONTyped(json, false);
+}
+
+export function ToolCallFunctionFromJSONTyped(json: any, ignoreDiscriminator: boolean): ToolCallFunction {
+    if (json == null) {
+        return json;
+    }
+    return {
+        
+        'name': json['name'],
+        'arguments': json['arguments'],
+    };
+}
+
+export function ToolCallFunctionToJSON(json: any): ToolCallFunction {
+    return ToolCallFunctionToJSONTyped(json, false);
+}
+
+export function ToolCallFunctionToJSONTyped(value?: ToolCallFunction | null, ignoreDiscriminator: boolean = false): any {
+    if (value == null) {
+        return value;
+    }
+
+    return {
+        
+        'name': value['name'],
+        'arguments': value['arguments'],
+    };
+}
+

package/src/models/ToolChoiceFunction.ts

@@ -0,0 +1,95 @@
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * deeprelay Public Developer API
+ * Programmatic API for deeprelay. Authenticate with API keys minted from the dashboard. See https://deeprelay.ai/docs for details.  Keys minted from the dashboard or `deeprelay login` belong to the Production server, https://api.deeprelay.ai/v1. The Demo server is an internal staging environment with its own key store.  Versioning: `/v1` is the API version. `info.version` is the revision of this `/v1` document, not a separate API.  OpenAI compatibility: chat completions follow the OpenAI request and response shapes, but not every OpenAI parameter is carried. Some are rejected with 400 `unsupported_parameter` and any parameter not declared in this spec is accepted and ignored. The full table is at https://deeprelay.ai/docs/api/inference#openai-compatibility. 
+ *
+ * The version of the OpenAPI document: 1.0.0
+ * Contact: support@deeprelay.ai
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+
+import { mapValues } from '../runtime';
+import type { ToolChoiceFunctionFunction } from './ToolChoiceFunctionFunction';
+import {
+    ToolChoiceFunctionFunctionFromJSON,
+    ToolChoiceFunctionFunctionFromJSONTyped,
+    ToolChoiceFunctionFunctionToJSON,
+    ToolChoiceFunctionFunctionToJSONTyped,
+} from './ToolChoiceFunctionFunction';
+
+/**
+ * 
+ * @export
+ * @interface ToolChoiceFunction
+ */
+export interface ToolChoiceFunction {
+    /**
+     * 
+     * @type {ToolChoiceFunctionTypeEnum}
+     * @memberof ToolChoiceFunction
+     */
+    type: ToolChoiceFunctionTypeEnum;
+    /**
+     * 
+     * @type {ToolChoiceFunctionFunction}
+     * @memberof ToolChoiceFunction
+     */
+    _function: ToolChoiceFunctionFunction;
+}
+
+
+/**
+ * @export
+ */
+export const ToolChoiceFunctionTypeEnum = {
+    Function: 'function'
+} as const;
+export type ToolChoiceFunctionTypeEnum = typeof ToolChoiceFunctionTypeEnum[keyof typeof ToolChoiceFunctionTypeEnum];
+
+
+/**
+ * Check if a given object implements the ToolChoiceFunction interface.
+ */
+export function instanceOfToolChoiceFunction(value: object): value is ToolChoiceFunction {
+    if (!('type' in value) || value['type'] === undefined) return false;
+    if (value['type'] !== 'function') return false;
+    
+    if ((!('_function' in (value as Record<string, any>)) && !('function' in (value as Record<string, any>))) || ((value as Record<string, any>)['_function'] === undefined && (value as Record<string, any>)['function'] === undefined)) return false;
+    return true;
+}
+
+export function ToolChoiceFunctionFromJSON(json: any): ToolChoiceFunction {
+    return ToolChoiceFunctionFromJSONTyped(json, false);
+}
+
+export function ToolChoiceFunctionFromJSONTyped(json: any, ignoreDiscriminator: boolean): ToolChoiceFunction {
+    if (json == null) {
+        return json;
+    }
+    return {
+        
+        'type': json['type'],
+        '_function': ToolChoiceFunctionFunctionFromJSON(json['function']),
+    };
+}
+
+export function ToolChoiceFunctionToJSON(json: any): ToolChoiceFunction {
+    return ToolChoiceFunctionToJSONTyped(json, false);
+}
+
+export function ToolChoiceFunctionToJSONTyped(value?: ToolChoiceFunction | null, ignoreDiscriminator: boolean = false): any {
+    if (value == null) {
+        return value;
+    }
+
+    return {
+        
+        'type': value['type'],
+        'function': ToolChoiceFunctionFunctionToJSON(value['_function']),
+    };
+}
+

package/src/models/ToolChoiceFunctionFunction.ts

@@ -0,0 +1,66 @@
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * deeprelay Public Developer API
+ * Programmatic API for deeprelay. Authenticate with API keys minted from the dashboard. See https://deeprelay.ai/docs for details.  Keys minted from the dashboard or `deeprelay login` belong to the Production server, https://api.deeprelay.ai/v1. The Demo server is an internal staging environment with its own key store.  Versioning: `/v1` is the API version. `info.version` is the revision of this `/v1` document, not a separate API.  OpenAI compatibility: chat completions follow the OpenAI request and response shapes, but not every OpenAI parameter is carried. Some are rejected with 400 `unsupported_parameter` and any parameter not declared in this spec is accepted and ignored. The full table is at https://deeprelay.ai/docs/api/inference#openai-compatibility. 
+ *
+ * The version of the OpenAPI document: 1.0.0
+ * Contact: support@deeprelay.ai
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+
+import { mapValues } from '../runtime';
+/**
+ * 
+ * @export
+ * @interface ToolChoiceFunctionFunction
+ */
+export interface ToolChoiceFunctionFunction {
+    /**
+     * 
+     * @type {string}
+     * @memberof ToolChoiceFunctionFunction
+     */
+    name: string;
+}
+
+/**
+ * Check if a given object implements the ToolChoiceFunctionFunction interface.
+ */
+export function instanceOfToolChoiceFunctionFunction(value: object): value is ToolChoiceFunctionFunction {
+    if (!('name' in value) || value['name'] === undefined) return false;
+    return true;
+}
+
+export function ToolChoiceFunctionFunctionFromJSON(json: any): ToolChoiceFunctionFunction {
+    return ToolChoiceFunctionFunctionFromJSONTyped(json, false);
+}
+
+export function ToolChoiceFunctionFunctionFromJSONTyped(json: any, ignoreDiscriminator: boolean): ToolChoiceFunctionFunction {
+    if (json == null) {
+        return json;
+    }
+    return {
+        
+        'name': json['name'],
+    };
+}
+
+export function ToolChoiceFunctionFunctionToJSON(json: any): ToolChoiceFunctionFunction {
+    return ToolChoiceFunctionFunctionToJSONTyped(json, false);
+}
+
+export function ToolChoiceFunctionFunctionToJSONTyped(value?: ToolChoiceFunctionFunction | null, ignoreDiscriminator: boolean = false): any {
+    if (value == null) {
+        return value;
+    }
+
+    return {
+        
+        'name': value['name'],
+    };
+}
+

package/src/models/ToolFunction.ts

@@ -0,0 +1,83 @@
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * deeprelay Public Developer API
+ * Programmatic API for deeprelay. Authenticate with API keys minted from the dashboard. See https://deeprelay.ai/docs for details.  Keys minted from the dashboard or `deeprelay login` belong to the Production server, https://api.deeprelay.ai/v1. The Demo server is an internal staging environment with its own key store.  Versioning: `/v1` is the API version. `info.version` is the revision of this `/v1` document, not a separate API.  OpenAI compatibility: chat completions follow the OpenAI request and response shapes, but not every OpenAI parameter is carried. Some are rejected with 400 `unsupported_parameter` and any parameter not declared in this spec is accepted and ignored. The full table is at https://deeprelay.ai/docs/api/inference#openai-compatibility. 
+ *
+ * The version of the OpenAPI document: 1.0.0
+ * Contact: support@deeprelay.ai
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+
+import { mapValues } from '../runtime';
+/**
+ * 
+ * @export
+ * @interface ToolFunction
+ */
+export interface ToolFunction {
+    /**
+     * The function name the model will emit when it calls this tool.
+     * @type {string}
+     * @memberof ToolFunction
+     */
+    name: string;
+    /**
+     * What the function does. The model reads this to decide when to call it.
+     * @type {string}
+     * @memberof ToolFunction
+     */
+    description?: string;
+    /**
+     * JSON Schema for the function's arguments. Forwarded to the model untouched; deeprelay does not interpret it.
+     * 
+     * @type {{ [key: string]: any; }}
+     * @memberof ToolFunction
+     */
+    parameters?: { [key: string]: any; };
+}
+
+/**
+ * Check if a given object implements the ToolFunction interface.
+ */
+export function instanceOfToolFunction(value: object): value is ToolFunction {
+    if (!('name' in value) || value['name'] === undefined) return false;
+    return true;
+}
+
+export function ToolFunctionFromJSON(json: any): ToolFunction {
+    return ToolFunctionFromJSONTyped(json, false);
+}
+
+export function ToolFunctionFromJSONTyped(json: any, ignoreDiscriminator: boolean): ToolFunction {
+    if (json == null) {
+        return json;
+    }
+    return {
+        
+        'name': json['name'],
+        'description': json['description'] == null ? undefined : json['description'],
+        'parameters': json['parameters'] == null ? undefined : json['parameters'],
+    };
+}
+
+export function ToolFunctionToJSON(json: any): ToolFunction {
+    return ToolFunctionToJSONTyped(json, false);
+}
+
+export function ToolFunctionToJSONTyped(value?: ToolFunction | null, ignoreDiscriminator: boolean = false): any {
+    if (value == null) {
+        return value;
+    }
+
+    return {
+        
+        'name': value['name'],
+        'description': value['description'],
+        'parameters': value['parameters'],
+    };
+}
+

package/src/models/UpdateSpendingLimitRequest.ts

@@ -2,7 +2,7 @@
 /* eslint-disable */
 /**
  * deeprelay Public Developer API
- * Programmatic API for deeprelay. Authenticate with API keys minted from the dashboard. See https://deeprelay.ai/docs for details. 
+ * Programmatic API for deeprelay. Authenticate with API keys minted from the dashboard. See https://deeprelay.ai/docs for details.  Keys minted from the dashboard or `deeprelay login` belong to the Production server, https://api.deeprelay.ai/v1. The Demo server is an internal staging environment with its own key store.  Versioning: `/v1` is the API version. `info.version` is the revision of this `/v1` document, not a separate API.  OpenAI compatibility: chat completions follow the OpenAI request and response shapes, but not every OpenAI parameter is carried. Some are rejected with 400 `unsupported_parameter` and any parameter not declared in this spec is accepted and ignored. The full table is at https://deeprelay.ai/docs/api/inference#openai-compatibility. 
  *
  * The version of the OpenAPI document: 1.0.0
  * Contact: support@deeprelay.ai