@orq-ai/node 4.10.0-rc.88 → 4.10.0

package/packages/orq-rc/src/sdk/agents.ts

@@ -0,0 +1,216 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import { agentsCreate } from "../funcs/agentsCreate.js";
+import { agentsDelete } from "../funcs/agentsDelete.js";
+import { agentsInvoke } from "../funcs/agentsInvoke.js";
+import { agentsList } from "../funcs/agentsList.js";
+import { agentsPostV2AgentsKeyCardRefresh } from "../funcs/agentsPostV2AgentsKeyCardRefresh.js";
+import { agentsRetrieve } from "../funcs/agentsRetrieve.js";
+import { agentsRun } from "../funcs/agentsRun.js";
+import { agentsStream } from "../funcs/agentsStream.js";
+import { agentsStreamRun } from "../funcs/agentsStreamRun.js";
+import { agentsUpdate } from "../funcs/agentsUpdate.js";
+import { EventStream } from "../lib/event-streams.js";
+import { ClientSDK, RequestOptions } from "../lib/sdks.js";
+import * as operations from "../models/operations/index.js";
+import { unwrapAsync } from "../types/fp.js";
+import { OrqResponses } from "./orqresponses.js";
+
+export class Agents extends ClientSDK {
+  private _responses?: OrqResponses;
+  get responses(): OrqResponses {
+    return (this._responses ??= new OrqResponses(this._options));
+  }
+
+  /**
+   * Create agent
+   *
+   * @remarks
+   * Creates a new agent with the specified configuration, including model selection, instructions, tools, and knowledge bases. Agents are intelligent assistants that can execute tasks, interact with tools, and maintain context through memory stores. The agent can be configured with a primary model and optional fallback models for automatic failover, custom instructions for behavior control, and various settings to control execution limits and tool usage.
+   */
+  async create(
+    request: operations.CreateAgentRequestRequestBody,
+    options?: RequestOptions,
+  ): Promise<operations.CreateAgentRequestResponseBody> {
+    return unwrapAsync(agentsCreate(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * List agents
+   *
+   * @remarks
+   * Retrieves a comprehensive list of agents configured in your workspace. Supports pagination for large datasets and returns agents sorted by creation date (newest first). Each agent in the response includes its complete configuration: model settings with fallback options, instructions, tools, knowledge bases, memory stores, and execution parameters. Use pagination parameters to efficiently navigate through large collections of agents.
+   */
+  async list(
+    limit?: number | undefined,
+    startingAfter?: string | undefined,
+    endingBefore?: string | undefined,
+    type?: operations.QueryParamType | undefined,
+    options?: RequestOptions,
+  ): Promise<operations.ListAgentsResponseBody> {
+    return unwrapAsync(agentsList(
+      this,
+      limit,
+      startingAfter,
+      endingBefore,
+      type,
+      options,
+    ));
+  }
+
+  /**
+   * Delete agent
+   *
+   * @remarks
+   * Permanently removes an agent from the workspace. This operation is irreversible and will delete all associated configuration including model assignments, tools, knowledge bases, memory stores, and cached data. Active agent sessions will be terminated, and the agent key will become available for reuse.
+   */
+  async delete(
+    agentKey: string,
+    options?: RequestOptions,
+  ): Promise<void> {
+    return unwrapAsync(agentsDelete(
+      this,
+      agentKey,
+      options,
+    ));
+  }
+
+  /**
+   * Retrieve agent
+   *
+   * @remarks
+   * Retrieves detailed information about a specific agent identified by its unique key or identifier. Returns the complete agent manifest including configuration settings, model assignments (primary and fallback), tools, knowledge bases, memory stores, instructions, and execution parameters. Use this endpoint to fetch the current state and configuration of an individual agent.
+   */
+  async retrieve(
+    agentKey: string,
+    options?: RequestOptions,
+  ): Promise<operations.RetrieveAgentRequestResponseBody> {
+    return unwrapAsync(agentsRetrieve(
+      this,
+      agentKey,
+      options,
+    ));
+  }
+
+  /**
+   * Update agent
+   *
+   * @remarks
+   * Modifies an existing agent's configuration with partial updates. Supports updating any aspect of the agent including model assignments (primary and fallback), instructions, tools, knowledge bases, memory stores, and execution parameters. Only the fields provided in the request body will be updated; all other fields remain unchanged. Changes take effect immediately for new agent invocations.
+   */
+  async update(
+    requestBody: operations.UpdateAgentRequestBody,
+    agentKey: string,
+    options?: RequestOptions,
+  ): Promise<operations.UpdateAgentResponseBody> {
+    return unwrapAsync(agentsUpdate(
+      this,
+      requestBody,
+      agentKey,
+      options,
+    ));
+  }
+
+  /**
+   * Execute an agent task
+   *
+   * @remarks
+   * Invokes an agent to perform a task with the provided input message. The agent will process the request using its configured model and tools, maintaining context through memory stores if configured. Supports automatic model fallback on primary model failure, tool execution, knowledge base retrieval, and continuation of previous conversations. Returns a task response that can be used to track execution status and retrieve results.
+   *
+   * @deprecated method: This will be removed in a future release, please migrate away from it as soon as possible.
+   */
+  async invoke(
+    key: string,
+    requestBody?: operations.InvokeAgentRequestBody | undefined,
+    options?: RequestOptions,
+  ): Promise<operations.InvokeAgentA2ATaskResponse> {
+    return unwrapAsync(agentsInvoke(
+      this,
+      key,
+      requestBody,
+      options,
+    ));
+  }
+
+  /**
+   * Run an agent with configuration
+   *
+   * @remarks
+   * Executes an agent using inline configuration or references an existing agent. Supports dynamic agent creation where the system automatically manages agent versioning - reusing existing agents with matching configurations or creating new versions when configurations differ. Ideal for programmatic agent execution with flexible configuration management. The agent processes messages in A2A format with support for memory context, tool execution, and automatic model fallback on failure.
+   *
+   * @deprecated method: This will be removed in a future release, please migrate away from it as soon as possible.
+   */
+  async run(
+    request: operations.RunAgentRequestBody,
+    options?: RequestOptions,
+  ): Promise<operations.RunAgentA2ATaskResponse> {
+    return unwrapAsync(agentsRun(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Run agent with streaming response
+   *
+   * @remarks
+   * Dynamically configures and executes an agent while streaming the interaction in real-time via Server-Sent Events (SSE). Intelligently manages agent versioning by reusing existing agents with matching configurations or creating new versions when configurations differ. Combines the flexibility of inline configuration with real-time streaming, making it ideal for dynamic agent interactions with live feedback. The stream provides continuous updates including message chunks, tool executions, and status changes until completion or timeout.
+   *
+   * @deprecated method: This will be removed in a future release, please migrate away from it as soon as possible.
+   */
+  async streamRun(
+    request: operations.StreamRunAgentRequestBody,
+    options?: RequestOptions,
+  ): Promise<EventStream<operations.StreamRunAgentResponseBody>> {
+    return unwrapAsync(agentsStreamRun(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Stream agent execution in real-time
+   *
+   * @remarks
+   * Executes an agent and streams the interaction in real-time using Server-Sent Events (SSE). Provides live updates as the agent processes the request, including message chunks, tool calls, and execution status. Perfect for building responsive chat interfaces and monitoring agent progress. The stream continues until the agent completes its task, encounters an error, or reaches the configured timeout (default 30 minutes, configurable 1-3600 seconds).
+   *
+   * @deprecated method: This will be removed in a future release, please migrate away from it as soon as possible.
+   */
+  async stream(
+    requestBody: operations.StreamAgentRequestBody,
+    key: string,
+    options?: RequestOptions,
+  ): Promise<EventStream<operations.StreamAgentResponseBody>> {
+    return unwrapAsync(agentsStream(
+      this,
+      requestBody,
+      key,
+      options,
+    ));
+  }
+
+  /**
+   * Refresh A2A agent card
+   *
+   * @remarks
+   * Fetches the latest agent card from the external A2A agent and updates the cached card in the database. Similar to MCP server refresh functionality.
+   */
+  async postV2AgentsKeyCardRefresh(
+    request: operations.PostV2AgentsKeyCardRefreshRequest,
+    options?: RequestOptions,
+  ): Promise<operations.PostV2AgentsKeyCardRefreshResponseBody> {
+    return unwrapAsync(agentsPostV2AgentsKeyCardRefresh(
+      this,
+      request,
+      options,
+    ));
+  }
+}

package/packages/orq-rc/src/sdk/annotations.ts

@@ -0,0 +1,45 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import { annotationsCreate } from "../funcs/annotationsCreate.js";
+import { annotationsDelete } from "../funcs/annotationsDelete.js";
+import { ClientSDK, RequestOptions } from "../lib/sdks.js";
+import * as operations from "../models/operations/index.js";
+import { unwrapAsync } from "../types/fp.js";
+
+export class Annotations extends ClientSDK {
+  /**
+   * Annotate a span
+   *
+   * @remarks
+   * Attach one or more annotations to a specific span. Each annotation references an evaluator by key and supplies a value (string for text/single-select, number for range, array for multi-select).
+   */
+  async create(
+    request: operations.CreateAnnotationRequest,
+    options?: RequestOptions,
+  ): Promise<void> {
+    return unwrapAsync(annotationsCreate(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Remove an annotation from a span
+   *
+   * @remarks
+   * Remove one or more annotations from a specific span by their evaluator keys.
+   */
+  async delete(
+    request: operations.DeleteAnnotationRequest,
+    options?: RequestOptions,
+  ): Promise<void> {
+    return unwrapAsync(annotationsDelete(
+      this,
+      request,
+      options,
+    ));
+  }
+}

package/packages/orq-rc/src/sdk/apikeys.ts

@@ -0,0 +1,116 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import { apiKeysCreate } from "../funcs/apiKeysCreate.js";
+import { apiKeysDelete } from "../funcs/apiKeysDelete.js";
+import { apiKeysGet } from "../funcs/apiKeysGet.js";
+import { apiKeysList } from "../funcs/apiKeysList.js";
+import { apiKeysListCapabilities } from "../funcs/apiKeysListCapabilities.js";
+import { apiKeysUpdate } from "../funcs/apiKeysUpdate.js";
+import { ClientSDK, RequestOptions } from "../lib/sdks.js";
+import * as components from "../models/components/index.js";
+import * as operations from "../models/operations/index.js";
+import { unwrapAsync } from "../types/fp.js";
+
+export class ApiKeys extends ClientSDK {
+  /**
+   * List API keys
+   *
+   * @remarks
+   * Returns API keys visible to the current workspace, ordered by creation time with the newest key first. The `api_key` and `token_hash` fields are never returned by this endpoint; only `token_prefix` is included.
+   */
+  async list(
+    request?: operations.ApiKeyListRequest | undefined,
+    options?: RequestOptions,
+  ): Promise<components.ListApiKeysResponse> {
+    return unwrapAsync(apiKeysList(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Create a new API key
+   *
+   * @remarks
+   * Mints a new opaque API key (`sk-orq-<key_id>-<secret>`) in the workspace. The raw secret is returned ONCE in the response and is never retrievable afterwards. The stored record retains only `token_prefix` and a SHA-256 `token_hash`.
+   */
+  async create(
+    request: components.CreateApiKeyRequest,
+    options?: RequestOptions,
+  ): Promise<components.CreateApiKeyResponse> {
+    return unwrapAsync(apiKeysCreate(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * List capability catalog
+   *
+   * @remarks
+   * Returns the capability catalog: the set of permission domains that can be granted to an API key. Each entry includes the domain id, display name, group, allowed project scopes, and the read / write verb sets resolved at authorize() time. Drives the permissions UI in the dashboard.
+   */
+  async listCapabilities(
+    options?: RequestOptions,
+  ): Promise<components.ListCapabilitiesResponse> {
+    return unwrapAsync(apiKeysListCapabilities(
+      this,
+      options,
+    ));
+  }
+
+  /**
+   * Retrieve an API key
+   *
+   * @remarks
+   * Retrieves the metadata for an existing API key by its unique identifier. The raw secret is never returned — only `token_prefix`, `permission_mode`, `project_scope`, and lifecycle fields.
+   */
+  async get(
+    request: operations.ApiKeyGetRequest,
+    options?: RequestOptions,
+  ): Promise<components.GetApiKeyResponse> {
+    return unwrapAsync(apiKeysGet(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Delete an API key
+   *
+   * @remarks
+   * Permanently deletes an API key. Cache entries in `API_KEYS_KV` are invalidated immediately so an in-flight token cannot ride out the TTL. The response body is empty on success.
+   */
+  async delete(
+    request: operations.ApiKeyDeleteRequest,
+    options?: RequestOptions,
+  ): Promise<components.DeleteApiKeyResponse> {
+    return unwrapAsync(apiKeysDelete(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Update an API key
+   *
+   * @remarks
+   * Updates mutable fields of an API key: display name, status (active / disabled / revoked), permission mode and access map, project scope, and constraints (budget / rate limit / expiry). Omitted fields keep their current values.
+   */
+  async update(
+    request: operations.ApiKeyUpdateRequest,
+    options?: RequestOptions,
+  ): Promise<components.UpdateApiKeyResponse> {
+    return unwrapAsync(apiKeysUpdate(
+      this,
+      request,
+      options,
+    ));
+  }
+}

package/packages/orq-rc/src/sdk/audio.ts

@@ -0,0 +1,25 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import { ClientSDK } from "../lib/sdks.js";
+import { Speech } from "./speech.js";
+import { Transcriptions } from "./transcriptions.js";
+import { Translations } from "./translations.js";
+
+export class Audio extends ClientSDK {
+  private _speech?: Speech;
+  get speech(): Speech {
+    return (this._speech ??= new Speech(this._options));
+  }
+
+  private _transcriptions?: Transcriptions;
+  get transcriptions(): Transcriptions {
+    return (this._transcriptions ??= new Transcriptions(this._options));
+  }
+
+  private _translations?: Translations;
+  get translations(): Translations {
+    return (this._translations ??= new Translations(this._options));
+  }
+}

package/packages/orq-rc/src/sdk/chat.ts

@@ -0,0 +1,13 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import { ClientSDK } from "../lib/sdks.js";
+import { OrqCompletions } from "./orqcompletions.js";
+
+export class Chat extends ClientSDK {
+  private _completions?: OrqCompletions;
+  get completions(): OrqCompletions {
+    return (this._completions ??= new OrqCompletions(this._options));
+  }
+}

package/packages/orq-rc/src/sdk/chunking.ts

@@ -0,0 +1,27 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import { chunkingParse } from "../funcs/chunkingParse.js";
+import { ClientSDK, RequestOptions } from "../lib/sdks.js";
+import * as operations from "../models/operations/index.js";
+import { unwrapAsync } from "../types/fp.js";
+
+export class Chunking extends ClientSDK {
+  /**
+   * Parse text
+   *
+   * @remarks
+   * Split large text documents into smaller, manageable chunks using different chunking strategies optimized for RAG (Retrieval-Augmented Generation) workflows. This endpoint supports multiple chunking algorithms including token-based, sentence-based, recursive, semantic, and specialized strategies.
+   */
+  async parse(
+    request: operations.ParseChunkingRequest,
+    options?: RequestOptions,
+  ): Promise<operations.ParseResponseBody> {
+    return unwrapAsync(chunkingParse(
+      this,
+      request,
+      options,
+    ));
+  }
+}

package/packages/orq-rc/src/sdk/completions.ts

@@ -0,0 +1,32 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import {
+  CreateAcceptEnum,
+  routerCompletionsCreate,
+} from "../funcs/routerCompletionsCreate.js";
+import { ClientSDK, RequestOptions } from "../lib/sdks.js";
+import * as operations from "../models/operations/index.js";
+import { unwrapAsync } from "../types/fp.js";
+
+export { CreateAcceptEnum } from "../funcs/routerCompletionsCreate.js";
+
+export class Completions extends ClientSDK {
+  /**
+   * Create completion
+   *
+   * @remarks
+   * For sending requests to legacy completion models
+   */
+  async create(
+    request: operations.CreateCompletionRequestBody,
+    options?: RequestOptions & { acceptHeaderOverride?: CreateAcceptEnum },
+  ): Promise<operations.CreateCompletionResponse> {
+    return unwrapAsync(routerCompletionsCreate(
+      this,
+      request,
+      options,
+    ));
+  }
+}

package/packages/orq-rc/src/sdk/datasets.ts

@@ -0,0 +1,204 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import { datasetsClear } from "../funcs/datasetsClear.js";
+import { datasetsCreate } from "../funcs/datasetsCreate.js";
+import { datasetsCreateDatapoint } from "../funcs/datasetsCreateDatapoint.js";
+import { datasetsDelete } from "../funcs/datasetsDelete.js";
+import { datasetsDeleteDatapoint } from "../funcs/datasetsDeleteDatapoint.js";
+import { datasetsList } from "../funcs/datasetsList.js";
+import { datasetsListDatapoints } from "../funcs/datasetsListDatapoints.js";
+import { datasetsRetrieve } from "../funcs/datasetsRetrieve.js";
+import { datasetsRetrieveDatapoint } from "../funcs/datasetsRetrieveDatapoint.js";
+import { datasetsUpdate } from "../funcs/datasetsUpdate.js";
+import { datasetsUpdateDatapoint } from "../funcs/datasetsUpdateDatapoint.js";
+import { ClientSDK, RequestOptions } from "../lib/sdks.js";
+import * as operations from "../models/operations/index.js";
+import { unwrapAsync } from "../types/fp.js";
+
+export class Datasets extends ClientSDK {
+  /**
+   * List datasets
+   *
+   * @remarks
+   * Retrieves a paginated list of datasets for the current workspace. Results can be paginated using cursor-based pagination.
+   */
+  async list(
+    request?: operations.ListDatasetsRequest | undefined,
+    options?: RequestOptions,
+  ): Promise<operations.ListDatasetsResponseBody> {
+    return unwrapAsync(datasetsList(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Create a dataset
+   *
+   * @remarks
+   * Creates a new dataset in the specified project.
+   */
+  async create(
+    request?: operations.CreateDatasetRequestBody | undefined,
+    options?: RequestOptions,
+  ): Promise<operations.CreateDatasetResponseBody> {
+    return unwrapAsync(datasetsCreate(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Retrieve a dataset
+   *
+   * @remarks
+   * Retrieves a specific dataset by its unique identifier
+   */
+  async retrieve(
+    request: operations.RetrieveDatasetRequest,
+    options?: RequestOptions,
+  ): Promise<operations.RetrieveDatasetResponseBody> {
+    return unwrapAsync(datasetsRetrieve(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Update a dataset
+   *
+   * @remarks
+   * Update a dataset
+   */
+  async update(
+    request: operations.UpdateDatasetRequest,
+    options?: RequestOptions,
+  ): Promise<operations.UpdateDatasetResponseBody> {
+    return unwrapAsync(datasetsUpdate(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Delete a dataset
+   *
+   * @remarks
+   * Permanently deletes a dataset and all its datapoints. This action is irreversible.
+   */
+  async delete(
+    request: operations.DeleteDatasetRequest,
+    options?: RequestOptions,
+  ): Promise<void> {
+    return unwrapAsync(datasetsDelete(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * List datapoints
+   *
+   * @remarks
+   * Retrieves a paginated list of datapoints from a specific dataset.
+   */
+  async listDatapoints(
+    request: operations.ListDatasetDatapointsRequest,
+    options?: RequestOptions,
+  ): Promise<operations.ListDatasetDatapointsResponseBody> {
+    return unwrapAsync(datasetsListDatapoints(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Create a datapoint
+   *
+   * @remarks
+   * Creates a new datapoint in the specified dataset.
+   */
+  async createDatapoint(
+    request: operations.CreateDatasetItemRequest,
+    options?: RequestOptions,
+  ): Promise<Array<operations.CreateDatasetItemResponseBody>> {
+    return unwrapAsync(datasetsCreateDatapoint(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Retrieve a datapoint
+   *
+   * @remarks
+   * Retrieves a datapoint object
+   */
+  async retrieveDatapoint(
+    request: operations.RetrieveDatapointRequest,
+    options?: RequestOptions,
+  ): Promise<operations.RetrieveDatapointResponseBody> {
+    return unwrapAsync(datasetsRetrieveDatapoint(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Update a datapoint
+   */
+  async updateDatapoint(
+    request: operations.UpdateDatapointRequest,
+    options?: RequestOptions,
+  ): Promise<operations.UpdateDatapointResponseBody> {
+    return unwrapAsync(datasetsUpdateDatapoint(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Delete a datapoint
+   *
+   * @remarks
+   * Permanently deletes a specific datapoint from a dataset.
+   */
+  async deleteDatapoint(
+    request: operations.DeleteDatapointRequest,
+    options?: RequestOptions,
+  ): Promise<void> {
+    return unwrapAsync(datasetsDeleteDatapoint(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Delete all datapoints
+   *
+   * @remarks
+   * Delete all datapoints from a dataset. This action is irreversible.
+   */
+  async clear(
+    request: operations.ClearDatasetRequest,
+    options?: RequestOptions,
+  ): Promise<void> {
+    return unwrapAsync(datasetsClear(
+      this,
+      request,
+      options,
+    ));
+  }
+}