roe-typescript 1.1.1 → 1.1.2

package/README.md

@@ -3,16 +3,15 @@
 TypeScript/Node SDK for the [Roe](https://www.roe-ai.com/) API.
 
 <!-- ROE-SDK:RELEASE-BANNER:START -->
-> **v1.1.1** - SDK operation coverage is synchronized across Python,
+> **v1.1.2** - SDK operation coverage is synchronized across Python,
 > TypeScript, and Go. See `SDK_EXAMPLES.md` for copy-ready examples and use
 > cases.
 <!-- ROE-SDK:RELEASE-BANNER:END -->
 
-> **v1.0.80** — `RoeHTTPClient`/axios were replaced by the generated
-> `openapi-fetch` client exposed as `client.raw`; use `components["schemas"]`
-> (or inferred types from the wrappers) where you need response shapes from
-> the OpenAPI definitions. Highlights and migration notes across releases live
-> in **[CHANGELOG.md](CHANGELOG.md)**.
+> **v1.0.80** - `RoeHTTPClient`/axios were replaced by an OpenAPI-backed
+> transport behind stable public methods such as `client.agents` and
+> `client.policies`. Highlights and migration notes across releases live in
+> **[CHANGELOG.md](CHANGELOG.md)**.
 
 ## Installation
 
@@ -108,22 +107,6 @@ result carries `result.status === JobStatus.FAILURE` and
 `result.error_message`. Transport / HTTP errors hit the typed hierarchy
 above.
 
-## Raw API Access
-
-The generated raw client is exposed as `client.raw`:
-
-```typescript
-import { RoeClient } from "roe-typescript";
-
-const client = new RoeClient({
-  apiKey: "your-api-key",
-  organizationId: "your-org-uuid",
-});
-
-const response = await client.raw.GET("/v1/users/current_user/");
-console.log(response.response.status);
-```
-
 <!-- ROE-SDK:GENERATED-FRIENDLY-APIS:START -->
 ## SDK Operation Groups
 
@@ -159,7 +142,7 @@ const agent = await client.agents.create({
   ],
   engineConfig: {
     url: "${url}",
-    model: "gpt-4.1-2025-04-14",
+    model: "gpt-5.5-2026-04-23",
     instruction: "Extract company information from this website.",
     vision_mode: false,
     crawl_config: {
@@ -201,8 +184,15 @@ await client.agents.delete(agent.id);
 ```typescript
 client.agents.list()                        // List agents
 client.agents.retrieve("agent-uuid")        // Get agent
-client.agents.create({ name, ... })         // Create agent
-client.agents.update("agent-uuid", { ... }) // Update agent
+client.agents.create({
+  name: "Agent",
+  engineClassId: "ResearchEngine",
+  inputDefinitions: [],
+  engineConfig: {},
+})                                          // Create agent
+client.agents.update("agent-uuid", {
+  name: "New name",
+})                                          // Update agent
 client.agents.delete("agent-uuid")          // Delete agent
 client.agents.duplicate("agent-uuid")       // Duplicate agent
 ```
@@ -226,8 +216,14 @@ client.agents.runVersion({ agentId, versionId, inputs })
 client.agents.versions.list(agentId)
 client.agents.versions.retrieve(agentId, versionId)
 client.agents.versions.retrieveCurrent(agentId)
-client.agents.versions.create({ agentId, ... })
-client.agents.versions.update(agentId, versionId, { ... })
+client.agents.versions.create({
+  agentId,
+  inputDefinitions: [],
+  engineConfig: {},
+})
+client.agents.versions.update(agentId, versionId, {
+  versionName: "v2",
+})
 client.agents.versions.delete(agentId, versionId)
 ```
 
@@ -245,8 +241,13 @@ client.agents.jobs.deleteData(jobId)
 ```typescript
 client.policies.list()                              // List policies
 client.policies.retrieve("policy-uuid")             // Get policy
-client.policies.create({ name, content, ... })      // Create policy
-client.policies.update("policy-uuid", { ... })      // Update policy
+client.policies.create({
+  name: "Policy",
+  content: {},
+})                                                  // Create policy
+client.policies.update("policy-uuid", {
+  name: "New policy name",
+})                                                  // Update policy
 client.policies.delete("policy-uuid")               // Delete policy
 ```
 
@@ -255,7 +256,11 @@ client.policies.delete("policy-uuid")               // Delete policy
 ```typescript
 client.policies.versions.list(policyId)
 client.policies.versions.retrieve(policyId, versionId)
-client.policies.versions.create({ policyId, content, ... })
+client.policies.versions.create({
+  policyId,
+  content: {},
+  versionName: "v2",
+})
 ```
 
 ## Rori Agents (Agentic Workflows)

package/dist/api/_generated.d.ts

@@ -1,11 +1,20 @@
 import type { RoeConfig } from "../config.js";
 import type { RoeRawClient } from "../generated/client.js";
+import { ConnectionsAPI } from "./connections.js";
+import { ConnectorsAPI } from "./connectors.js";
 import { DiscoveryAPI } from "./discovery.js";
+import { KnowledgeBaseAPI } from "./knowledge_base.js";
 import { TablesAPI } from "./tables.js";
+export { ConnectionsAPI } from "./connections.js";
+export { ConnectorsAPI } from "./connectors.js";
 export { DiscoveryAPI } from "./discovery.js";
+export { KnowledgeBaseAPI } from "./knowledge_base.js";
 export { TablesAPI } from "./tables.js";
 export type GeneratedApis = {
+    readonly connections: ConnectionsAPI;
+    readonly connectors: ConnectorsAPI;
     readonly discovery: DiscoveryAPI;
+    readonly knowledge_base: KnowledgeBaseAPI;
     readonly tables: TablesAPI;
 };
 export declare function createGeneratedApis(config: RoeConfig, raw: RoeRawClient): GeneratedApis;

package/dist/api/_generated.js

@@ -1,13 +1,22 @@
 // Auto-generated friendly API facades for the Roe SDK.
 // Generated by scripts/generate-sdk from openapi/wrappers.yml.
 // Do not edit by hand.
+import { ConnectionsAPI } from "./connections.js";
+import { ConnectorsAPI } from "./connectors.js";
 import { DiscoveryAPI } from "./discovery.js";
+import { KnowledgeBaseAPI } from "./knowledge_base.js";
 import { TablesAPI } from "./tables.js";
+export { ConnectionsAPI } from "./connections.js";
+export { ConnectorsAPI } from "./connectors.js";
 export { DiscoveryAPI } from "./discovery.js";
+export { KnowledgeBaseAPI } from "./knowledge_base.js";
 export { TablesAPI } from "./tables.js";
 export function createGeneratedApis(config, raw) {
     return {
+        connections: new ConnectionsAPI(config, raw),
+        connectors: new ConnectorsAPI(config, raw),
         discovery: new DiscoveryAPI(config, raw),
+        knowledge_base: new KnowledgeBaseAPI(config, raw),
         tables: new TablesAPI(config, raw),
     };
 }

package/dist/api/agents.d.ts

@@ -9,7 +9,10 @@ type AgentJobStatus = components["schemas"]["AgentJobSingleStatus"];
 type AgentJobBatchStatus = components["schemas"]["AgentJobStatus"];
 type AgentJobResultItem = components["schemas"]["AgentJobResultItem"];
 type AgentJobDeleteDataResponse = components["schemas"]["AgentJobDeleteDataResponse"];
+type AgentJobCancelAllResponse = components["schemas"]["AgentJobCancelAllResponse"];
+type AgentJobArtifactResult = components["schemas"]["AgentJobArtifactResult"];
 type AgentDatum = components["schemas"]["AgentDatum"];
+type MessageResponse = components["schemas"]["MessageResponse"];
 export declare class AgentVersionsAPI {
     private readonly agentsApi;
     constructor(agentsApi: AgentsAPI);
@@ -29,6 +32,10 @@ export declare class AgentVersionsAPI {
         versionName?: string;
         description?: string;
     }): Promise<void>;
+    replace(agentId: string, versionId: string, replacement: {
+        versionName?: string;
+        description?: string;
+    }): Promise<MessageResponse>;
     delete(agentId: string, versionId: string): Promise<void>;
 }
 export declare class AgentJobsAPI {
@@ -43,7 +50,8 @@ export declare class AgentJobsAPI {
     retrieveResultMany(jobIds: string[]): Promise<AgentJobResultItem[]>;
     downloadReference(jobId: string, resourceId: string, asAttachment?: boolean): Promise<Buffer>;
     cancel(jobId: string): Promise<void>;
-    cancelAll(agentId: string): Promise<void>;
+    cancelAll(agentId: string): Promise<AgentJobCancelAllResponse>;
+    retrieveArtifact(jobId: string, artifactKey: string): Promise<AgentJobArtifactResult>;
     deleteData(jobId: string): Promise<AgentJobDeleteDataResponse>;
     private iterChunks;
 }
@@ -72,6 +80,11 @@ export declare class AgentsAPI {
         disableCache?: boolean;
         cacheFailedJobs?: boolean;
     }): Promise<BaseAgent>;
+    replace(agentId: string, replacement: {
+        name?: string;
+        disableCache?: boolean;
+        cacheFailedJobs?: boolean;
+    }): Promise<BaseAgent>;
     delete(agentId: string): Promise<void>;
     duplicate(agentId: string): Promise<AgentVersion>;
     run(params: {

package/dist/api/agents.js

@@ -92,6 +92,23 @@ export class AgentVersionsAPI {
             body,
         });
     }
+    async replace(agentId, versionId, replacement) {
+        validateUuid(agentId, "agentId");
+        validateUuid(versionId, "versionId");
+        const body = {};
+        if (replacement.versionName !== undefined)
+            body.version_name = replacement.versionName;
+        if (replacement.description !== undefined)
+            body.description = replacement.description;
+        const { data } = await this.raw.PUT("/v1/agents/{agent_id}/versions/{agent_version_id}/", {
+            params: {
+                path: { agent_id: agentId, agent_version_id: versionId },
+                query: { organization_id: this.organizationId },
+            },
+            body,
+        });
+        return data;
+    }
     async delete(agentId, versionId) {
         validateUuid(agentId, "agentId");
         validateUuid(versionId, "versionId");
@@ -197,12 +214,26 @@ export class AgentJobsAPI {
     }
     async cancelAll(agentId) {
         validateUuid(agentId, "agentId");
-        await this.raw.POST("/v1/agents/{agent_id}/jobs/cancel-all/", {
+        const { data } = await this.raw.POST("/v1/agents/{agent_id}/jobs/cancel-all/", {
             params: {
                 path: { agent_id: agentId },
                 query: { organization_id: this.organizationId },
             },
         });
+        return data;
+    }
+    async retrieveArtifact(jobId, artifactKey) {
+        validateUuid(jobId, "jobId");
+        const { data } = await this.raw.GET("/v1/agents/jobs/{agent_job_id}/artifacts/result/", {
+            params: {
+                path: { agent_job_id: jobId },
+                query: {
+                    organization_id: this.organizationId,
+                    artifact_key: artifactKey,
+                },
+            },
+        });
+        return data;
     }
     async deleteData(jobId) {
         validateUuid(jobId, "jobId");
@@ -286,6 +317,24 @@ export class AgentsAPI {
         });
         return data;
     }
+    async replace(agentId, replacement) {
+        validateUuid(agentId, "agentId");
+        const body = {};
+        if (replacement.name !== undefined)
+            body.name = replacement.name;
+        if (replacement.disableCache !== undefined)
+            body.disable_cache = replacement.disableCache;
+        if (replacement.cacheFailedJobs !== undefined)
+            body.cache_failed_jobs = replacement.cacheFailedJobs;
+        const { data } = await this.raw.PUT("/v1/agents/{agent_id}/", {
+            params: {
+                path: { agent_id: agentId },
+                query: { organization_id: this.config.organizationId },
+            },
+            body,
+        });
+        return data;
+    }
     async delete(agentId) {
         validateUuid(agentId, "agentId");
         await this.raw.DELETE("/v1/agents/{agent_id}/", {

package/dist/api/connections.d.ts

@@ -0,0 +1,58 @@
+import type { RoeConfig } from "../config.js";
+import type { RoeRawClient } from "../generated/client.js";
+import type { components } from "../generated/schema.js";
+type Connection = components["schemas"]["Connection"];
+type CreateConnectionRequest = components["schemas"]["CreateConnectionRequest"];
+type PaginatedConnectionListList = components["schemas"]["PaginatedConnectionListList"];
+type TestConnection = components["schemas"]["TestConnection"];
+type TestConnectionCredentialsRequest = components["schemas"]["TestConnectionCredentialsRequest"];
+export declare class ConnectionsAPI {
+    readonly config: RoeConfig;
+    readonly raw: RoeRawClient;
+    /** API for managing external data connections. */
+    constructor(config: RoeConfig, raw: RoeRawClient);
+    protected get rawClient(): RoeRawClient;
+    protected get organizationId(): string;
+    /** List connections. */
+    list(params?: {
+        connectorType?: string;
+        search?: string;
+        page?: number;
+        pageSize?: number;
+    }): Promise<PaginatedConnectionListList>;
+    /** Create a connection. */
+    create(params: {
+        connectorType: CreateConnectionRequest["connector_type"];
+        name: string;
+        config: Record<string, unknown>;
+        description?: string;
+        authConfig?: Record<string, unknown>;
+    }): Promise<Connection>;
+    /** Test connection credentials without saving a connection. */
+    testCredentials(params: {
+        connectorType: TestConnectionCredentialsRequest["connector_type"];
+        config: Record<string, unknown>;
+        authConfig?: Record<string, unknown>;
+    }): Promise<TestConnection>;
+    /** Retrieve a connection. */
+    retrieve(connectionId: string): Promise<Connection>;
+    /** Update mutable connection fields. */
+    update(connectionId: string, updates: {
+        name?: string;
+        description?: string;
+        config?: Record<string, unknown>;
+        authConfig?: Record<string, unknown>;
+    }): Promise<Connection>;
+    /** Replace a connection. */
+    replace(connectionId: string, replacement: {
+        name?: string;
+        description?: string;
+        config?: Record<string, unknown>;
+        authConfig?: Record<string, unknown>;
+    }): Promise<Connection>;
+    /** Delete a connection. */
+    delete(connectionId: string): Promise<void>;
+    /** Test a saved connection. */
+    test(connectionId: string): Promise<TestConnection>;
+}
+export {};

package/dist/api/connections.js

@@ -0,0 +1,139 @@
+// Auto-generated friendly API facades for the Roe SDK.
+// Generated by scripts/generate-sdk from openapi/wrappers.yml.
+// Do not edit by hand.
+export class ConnectionsAPI {
+    /** API for managing external data connections. */
+    constructor(config, raw) {
+        this.config = config;
+        this.raw = raw;
+    }
+    get rawClient() {
+        return this.raw;
+    }
+    get organizationId() {
+        return this.config.organizationId;
+    }
+    /** List connections. */
+    async list(params) {
+        const { data } = await this.rawClient.GET("/v1/connections/", {
+            params: {
+                query: {
+                    organization_id: this.organizationId,
+                    ...(params?.connectorType !== undefined
+                        ? { connector_type: params?.connectorType }
+                        : {}),
+                    ...(params?.search !== undefined ? { search: params?.search } : {}),
+                    ...(params?.page !== undefined ? { page: params?.page } : {}),
+                    ...(params?.pageSize !== undefined
+                        ? { page_size: params?.pageSize }
+                        : {}),
+                },
+            },
+        });
+        return data;
+    }
+    /** Create a connection. */
+    async create(params) {
+        const body = {
+            connector_type: params.connectorType,
+            name: params.name,
+            config: params.config,
+            ...(params.description !== undefined
+                ? { description: params.description }
+                : {}),
+            ...(params.authConfig !== undefined
+                ? { auth_config: params.authConfig }
+                : {}),
+        };
+        const { data } = await this.rawClient.POST("/v1/connections/", {
+            params: { query: { organization_id: this.organizationId } },
+            body,
+        });
+        return data;
+    }
+    /** Test connection credentials without saving a connection. */
+    async testCredentials(params) {
+        const body = {
+            connector_type: params.connectorType,
+            config: params.config,
+            ...(params.authConfig !== undefined
+                ? { auth_config: params.authConfig }
+                : {}),
+        };
+        const { data } = await this.rawClient.POST("/v1/connections/test-credentials/", { body });
+        return data;
+    }
+    /** Retrieve a connection. */
+    async retrieve(connectionId) {
+        const { data } = await this.rawClient.GET("/v1/connections/{id}/", {
+            params: {
+                path: { id: connectionId },
+                query: { organization_id: this.organizationId },
+            },
+        });
+        return data;
+    }
+    /** Update mutable connection fields. */
+    async update(connectionId, updates) {
+        const body = {
+            ...(updates.name !== undefined ? { name: updates.name } : {}),
+            ...(updates.description !== undefined
+                ? { description: updates.description }
+                : {}),
+            ...(updates.config !== undefined ? { config: updates.config } : {}),
+            ...(updates.authConfig !== undefined
+                ? { auth_config: updates.authConfig }
+                : {}),
+        };
+        const { data } = await this.rawClient.PATCH("/v1/connections/{id}/", {
+            params: {
+                path: { id: connectionId },
+                query: { organization_id: this.organizationId },
+            },
+            body,
+        });
+        return data;
+    }
+    /** Replace a connection. */
+    async replace(connectionId, replacement) {
+        const body = {
+            ...(replacement.name !== undefined ? { name: replacement.name } : {}),
+            ...(replacement.description !== undefined
+                ? { description: replacement.description }
+                : {}),
+            ...(replacement.config !== undefined
+                ? { config: replacement.config }
+                : {}),
+            ...(replacement.authConfig !== undefined
+                ? { auth_config: replacement.authConfig }
+                : {}),
+        };
+        const { data } = await this.rawClient.PUT("/v1/connections/{id}/", {
+            params: {
+                path: { id: connectionId },
+                query: { organization_id: this.organizationId },
+            },
+            body,
+        });
+        return data;
+    }
+    /** Delete a connection. */
+    async delete(connectionId) {
+        await this.rawClient.DELETE("/v1/connections/{id}/", {
+            params: {
+                path: { id: connectionId },
+                query: { organization_id: this.organizationId },
+            },
+        });
+    }
+    /** Test a saved connection. */
+    async test(connectionId) {
+        const { data } = await this.rawClient.POST("/v1/connections/{id}/test/", {
+            params: {
+                path: { id: connectionId },
+                query: { organization_id: this.organizationId },
+            },
+        });
+        return data;
+    }
+}

package/dist/api/connectors.d.ts

@@ -0,0 +1,18 @@
+import type { RoeConfig } from "../config.js";
+import type { RoeRawClient } from "../generated/client.js";
+import type { components } from "../generated/schema.js";
+type ConnectorListResponse = components["schemas"]["ConnectorListResponse"];
+type ConnectorMetadata = components["schemas"]["ConnectorMetadata"];
+export declare class ConnectorsAPI {
+    readonly config: RoeConfig;
+    readonly raw: RoeRawClient;
+    /** API for discovering available connector types. */
+    constructor(config: RoeConfig, raw: RoeRawClient);
+    protected get rawClient(): RoeRawClient;
+    protected get organizationId(): string;
+    /** List available connector types. */
+    list(): Promise<ConnectorListResponse>;
+    /** Retrieve metadata for a connector type. */
+    retrieve(connectorType: string): Promise<ConnectorMetadata>;
+}
+export {};

package/dist/api/connectors.js

@@ -0,0 +1,26 @@
+// Auto-generated friendly API facades for the Roe SDK.
+// Generated by scripts/generate-sdk from openapi/wrappers.yml.
+// Do not edit by hand.
+export class ConnectorsAPI {
+    /** API for discovering available connector types. */
+    constructor(config, raw) {
+        this.config = config;
+        this.raw = raw;
+    }
+    get rawClient() {
+        return this.raw;
+    }
+    get organizationId() {
+        return this.config.organizationId;
+    }
+    /** List available connector types. */
+    async list() {
+        const { data } = await this.rawClient.GET("/v1/connectors/", {});
+        return data;
+    }
+    /** Retrieve metadata for a connector type. */
+    async retrieve(connectorType) {
+        const { data } = await this.rawClient.GET("/v1/connectors/{connector_type}/", { params: { path: { connector_type: connectorType } } });
+        return data;
+    }
+}

package/dist/api/knowledge_base.d.ts

@@ -0,0 +1,67 @@
+import type { RoeConfig } from "../config.js";
+import type { RoeRawClient } from "../generated/client.js";
+import type { components } from "../generated/schema.js";
+type CreateKnowledgeBase = components["schemas"]["CreateKnowledgeBase"];
+type Draft = components["schemas"]["Draft"];
+type KnowledgeBase = components["schemas"]["KnowledgeBase"];
+type PaginatedKnowledgeBaseList = components["schemas"]["PaginatedKnowledgeBaseList"];
+export declare class KnowledgeBaseAPI {
+    readonly config: RoeConfig;
+    readonly raw: RoeRawClient;
+    /** API for managing Knowledge Base lenses and drafts. */
+    constructor(config: RoeConfig, raw: RoeRawClient);
+    protected get rawClient(): RoeRawClient;
+    protected get organizationId(): string;
+    /** List all knowledge bases for the organisation. */
+    list(params?: {
+        page?: number;
+        pageSize?: number;
+    }): Promise<PaginatedKnowledgeBaseList>;
+    /** Create a new knowledge base draft (async generation). */
+    create(params: {
+        company: string;
+        brief: string;
+        name?: string;
+        productName?: string;
+        websiteUrl?: string;
+    }): Promise<CreateKnowledgeBase>;
+    /** Retrieve a single knowledge base record. */
+    retrieve(knowledgeBaseId: string): Promise<KnowledgeBase>;
+    /** Delete a knowledge base and its associated Atlas draft or lens. */
+    delete(knowledgeBaseId: string): Promise<void>;
+    /** Unlink a knowledge base locally, preserving the Atlas lens. */
+    unlink(knowledgeBaseId: string): Promise<void>;
+    /** Poll the Atlas draft status until ready or error. */
+    pollDraft(knowledgeBaseId: string): Promise<Draft>;
+    /** Patch the draft's typology/tactic selection. */
+    patchSelection(knowledgeBaseId: string, selection: {
+        refs: Record<string, unknown>[];
+        suggestedName?: string;
+    }): Promise<Draft>;
+    /** Kick off an async regeneration round with optional feedback. */
+    regenerate(knowledgeBaseId: string, params?: {
+        feedback?: string;
+    }): Promise<Draft>;
+    /** Approve or decline a pending regeneration proposal. */
+    resolve(knowledgeBaseId: string, params?: {
+        refs?: Record<string, unknown>[];
+        suggestedName?: string;
+        acceptSummary?: boolean;
+        discard?: boolean;
+    }): Promise<Draft>;
+    /** Commit the draft into a permanent Atlas lens. */
+    finalize(knowledgeBaseId: string, params?: {
+        name?: string;
+        mcpEnabled?: boolean;
+        public?: boolean;
+    }): Promise<KnowledgeBase>;
+    /** Sync the lens snapshot from Atlas (best-effort). */
+    sync(knowledgeBaseId: string): Promise<KnowledgeBase>;
+    /** Fetch the names-only typology and tactic catalog. */
+    catalog(): Promise<unknown>;
+    /** Fetch and optionally sync a lens by its Atlas ID. */
+    lensByAtlasId(atlasLensId: string): Promise<unknown>;
+    /** Import a finalized Atlas lens into roe-main by its atlas_lens_id. */
+    importLens(atlasLensId: string): Promise<KnowledgeBase>;
+}
+export {};

package/dist/api/knowledge_base.js

@@ -0,0 +1,202 @@
+import { BadRequestError } from "../exceptions.js";
+import { isUuidString } from "../utils/fileDetection.js";
+function validateUuid(value, fieldName) {
+    if (!isUuidString(value)) {
+        throw new BadRequestError(`Invalid ${fieldName}: "${value}" is not a valid UUID`, 400);
+    }
+}
+export class KnowledgeBaseAPI {
+    /** API for managing Knowledge Base lenses and drafts. */
+    constructor(config, raw) {
+        this.config = config;
+        this.raw = raw;
+    }
+    get rawClient() {
+        return this.raw;
+    }
+    get organizationId() {
+        return this.config.organizationId;
+    }
+    /** List all knowledge bases for the organisation. */
+    async list(params) {
+        const { data } = await this.rawClient.GET("/v1/knowledge-base/", {
+            params: {
+                query: {
+                    organization_id: this.organizationId,
+                    ...(params?.page !== undefined ? { page: params.page } : {}),
+                    ...(params?.pageSize !== undefined
+                        ? { page_size: params.pageSize }
+                        : {}),
+                },
+            },
+        });
+        return data;
+    }
+    /** Create a new knowledge base draft (async generation). */
+    async create(params) {
+        const body = {
+            company: params.company,
+            brief: params.brief,
+            ...(params.name !== undefined ? { name: params.name } : {}),
+            ...(params.productName !== undefined
+                ? { product_name: params.productName }
+                : {}),
+            ...(params.websiteUrl !== undefined
+                ? { website_url: params.websiteUrl }
+                : {}),
+        };
+        const { data } = await this.rawClient.POST("/v1/knowledge-base/", {
+            params: { query: { organization_id: this.organizationId } },
+            body,
+        });
+        return data;
+    }
+    /** Retrieve a single knowledge base record. */
+    async retrieve(knowledgeBaseId) {
+        validateUuid(knowledgeBaseId, "knowledgeBaseId");
+        const { data } = await this.rawClient.GET("/v1/knowledge-base/{id}/", {
+            params: {
+                path: { id: knowledgeBaseId },
+                query: { organization_id: this.organizationId },
+            },
+        });
+        return data;
+    }
+    /** Delete a knowledge base and its associated Atlas draft or lens. */
+    async delete(knowledgeBaseId) {
+        validateUuid(knowledgeBaseId, "knowledgeBaseId");
+        await this.rawClient.DELETE("/v1/knowledge-base/{id}/", {
+            params: {
+                path: { id: knowledgeBaseId },
+                query: { organization_id: this.organizationId },
+            },
+        });
+    }
+    /** Unlink a knowledge base locally, preserving the Atlas lens. */
+    async unlink(knowledgeBaseId) {
+        validateUuid(knowledgeBaseId, "knowledgeBaseId");
+        await this.rawClient.DELETE("/v1/knowledge-base/{id}/unlink/", {
+            params: {
+                path: { id: knowledgeBaseId },
+                query: { organization_id: this.organizationId },
+            },
+        });
+    }
+    /** Poll the Atlas draft status until ready or error. */
+    async pollDraft(knowledgeBaseId) {
+        validateUuid(knowledgeBaseId, "knowledgeBaseId");
+        const { data } = await this.rawClient.GET("/v1/knowledge-base/{id}/draft/", {
+            params: {
+                path: { id: knowledgeBaseId },
+                query: { organization_id: this.organizationId },
+            },
+        });
+        return data;
+    }
+    /** Patch the draft's typology/tactic selection. */
+    async patchSelection(knowledgeBaseId, selection) {
+        validateUuid(knowledgeBaseId, "knowledgeBaseId");
+        const body = {
+            refs: selection.refs,
+            ...(selection.suggestedName !== undefined
+                ? { suggested_name: selection.suggestedName }
+                : {}),
+        };
+        const { data } = await this.rawClient.PATCH("/v1/knowledge-base/{id}/selection/", {
+            params: {
+                path: { id: knowledgeBaseId },
+                query: { organization_id: this.organizationId },
+            },
+            body,
+        });
+        return data;
+    }
+    /** Kick off an async regeneration round with optional feedback. */
+    async regenerate(knowledgeBaseId, params) {
+        validateUuid(knowledgeBaseId, "knowledgeBaseId");
+        const body = {
+            ...(params?.feedback !== undefined ? { feedback: params.feedback } : {}),
+        };
+        const { data } = await this.rawClient.POST("/v1/knowledge-base/{id}/regenerate/", {
+            params: {
+                path: { id: knowledgeBaseId },
+                query: { organization_id: this.organizationId },
+            },
+            body,
+        });
+        return data;
+    }
+    /** Approve or decline a pending regeneration proposal. */
+    async resolve(knowledgeBaseId, params) {
+        validateUuid(knowledgeBaseId, "knowledgeBaseId");
+        const body = {
+            accept_summary: params?.acceptSummary ?? false,
+            discard: params?.discard ?? false,
+            ...(params?.refs !== undefined ? { refs: params.refs } : {}),
+            ...(params?.suggestedName !== undefined
+                ? { suggested_name: params.suggestedName }
+                : {}),
+        };
+        const { data } = await this.rawClient.POST("/v1/knowledge-base/{id}/resolve/", {
+            params: {
+                path: { id: knowledgeBaseId },
+                query: { organization_id: this.organizationId },
+            },
+            body,
+        });
+        return data;
+    }
+    /** Commit the draft into a permanent Atlas lens. */
+    async finalize(knowledgeBaseId, params) {
+        validateUuid(knowledgeBaseId, "knowledgeBaseId");
+        const body = {
+            mcp_enabled: params?.mcpEnabled ?? true,
+            public: params?.public ?? true,
+            ...(params?.name !== undefined ? { name: params.name } : {}),
+        };
+        const { data } = await this.rawClient.POST("/v1/knowledge-base/{id}/finalize/", {
+            params: {
+                path: { id: knowledgeBaseId },
+                query: { organization_id: this.organizationId },
+            },
+            body,
+        });
+        return data;
+    }
+    /** Sync the lens snapshot from Atlas (best-effort). */
+    async sync(knowledgeBaseId) {
+        validateUuid(knowledgeBaseId, "knowledgeBaseId");
+        const { data } = await this.rawClient.POST("/v1/knowledge-base/{id}/sync/", {
+            params: {
+                path: { id: knowledgeBaseId },
+                query: { organization_id: this.organizationId },
+            },
+        });
+        return data;
+    }
+    /** Fetch the names-only typology and tactic catalog. */
+    async catalog() {
+        const { data } = await this.rawClient.GET("/v1/knowledge-base/catalog/", {
+            params: { query: { organization_id: this.organizationId } },
+        });
+        return data;
+    }
+    /** Fetch and optionally sync a lens by its Atlas ID. */
+    async lensByAtlasId(atlasLensId) {
+        const { data } = await this.rawClient.GET("/v1/knowledge-base/lens/{atlas_lens_id}/", {
+            params: {
+                path: { atlas_lens_id: atlasLensId },
+                query: { organization_id: this.organizationId },
+            },
+        });
+        return data;
+    }
+    /** Import a finalized Atlas lens into roe-main by its atlas_lens_id. */
+    async importLens(atlasLensId) {
+        const { data } = await this.rawClient.POST("/v1/knowledge-base/import-lens/", {
+            params: { query: { organization_id: this.organizationId } },
+            body: { atlas_lens_id: atlasLensId },
+        });
+        return data;
+    }
+}

package/dist/api/policies.d.ts

@@ -51,6 +51,11 @@ export declare class PoliciesAPI {
         name?: string;
         description?: string;
     }): Promise<UpdatePolicy>;
+    /** Replace a policy. */
+    replace(policyId: string, replacement: {
+        name: string;
+        description?: string;
+    }): Promise<UpdatePolicy>;
     /** Delete a policy. */
     delete(policyId: string): Promise<void>;
 }

package/dist/api/policies.js

@@ -139,6 +139,24 @@ export class PoliciesAPI {
         });
         return data;
     }
+    /** Replace a policy. */
+    async replace(policyId, replacement) {
+        validateUuid(policyId, "policyId");
+        const body = {
+            name: replacement.name,
+            ...(replacement.description !== undefined
+                ? { description: replacement.description }
+                : {}),
+        };
+        const { data } = await this.rawClient.PUT("/v1/policies/{id}/", {
+            params: {
+                path: { id: policyId },
+                query: { organization_id: this.organizationId },
+            },
+            body,
+        });
+        return data;
+    }
     /** Delete a policy. */
     async delete(policyId) {
         validateUuid(policyId, "policyId");

package/dist/api/tables.d.ts

@@ -2,6 +2,11 @@ import type { RoeConfig } from "../config.js";
 import type { RoeRawClient } from "../generated/client.js";
 import type { components } from "../generated/schema.js";
 import type { FileUpload } from "../models/file.js";
+type TableDescribeResponse = components["schemas"]["TableDescribeResponse"];
+type TableListResponse = components["schemas"]["TableListResponse"];
+type TablePreviewResponse = components["schemas"]["TablePreviewResponse"];
+type TableQueryResultResponse = components["schemas"]["TableQueryResultResponse"];
+type TableQuerySubmitResponse = components["schemas"]["TableQuerySubmitResponse"];
 type TableUploadResponse = components["schemas"]["TableUploadResponse"];
 export type TableUploadFile = string | NodeJS.ReadableStream | FileUpload;
 export type TableUploadParams = {
@@ -13,11 +18,28 @@ export type TableUploadParams = {
 export declare class TablesAPI {
     readonly config: RoeConfig;
     readonly raw: RoeRawClient;
-    /** API for uploading CSV files into Roe tables. */
+    /** API for managing Roe tables. */
     constructor(config: RoeConfig, raw: RoeRawClient);
     protected get rawClient(): RoeRawClient;
     protected get organizationId(): string;
+    /** List Roe tables. */
+    list(): Promise<TableListResponse>;
     /** Upload a CSV file and create a Roe table. */
     upload(params: TableUploadParams): Promise<TableUploadResponse>;
+    /** Run a read-only query against Roe tables. */
+    query(params: {
+        sql: string;
+        limit?: number;
+    }): Promise<TableQuerySubmitResponse>;
+    /** Get the result for a submitted table query. */
+    queryResult(tableQueryId: string): Promise<TableQueryResultResponse>;
+    /** Describe a Roe table. */
+    describe(tableName: string): Promise<TableDescribeResponse>;
+    /** Preview rows from a Roe table. */
+    preview(tableName: string, options?: {
+        limit?: number;
+    }): Promise<TablePreviewResponse>;
+    /** Delete a Roe table. */
+    delete(tableName: string): Promise<void>;
 }
 export {};

package/dist/api/tables.js

@@ -4,7 +4,7 @@
 import { RoeAPIException } from "../exceptions.js";
 import { postDynamicInputs } from "../utils/dynamicInputs.js";
 export class TablesAPI {
-    /** API for uploading CSV files into Roe tables. */
+    /** API for managing Roe tables. */
     constructor(config, raw) {
         this.config = config;
         this.raw = raw;
@@ -15,6 +15,11 @@ export class TablesAPI {
     get organizationId() {
         return this.config.organizationId;
     }
+    /** List Roe tables. */
+    async list() {
+        const { data } = await this.rawClient.GET("/v1/tables/", {});
+        return data;
+    }
     /** Upload a CSV file and create a Roe table. */
     async upload(params) {
         const inputs = {
@@ -29,4 +34,41 @@ export class TablesAPI {
         }
         return data;
     }
+    /** Run a read-only query against Roe tables. */
+    async query(params) {
+        const body = {
+            sql: params.sql,
+            limit: params.limit ?? 1000,
+        };
+        const { data } = await this.rawClient.POST("/v1/tables/query/", { body });
+        return data;
+    }
+    /** Get the result for a submitted table query. */
+    async queryResult(tableQueryId) {
+        const { data } = await this.rawClient.GET("/v1/tables/query/{table_query_id}/result/", { params: { path: { table_query_id: tableQueryId } } });
+        return data;
+    }
+    /** Describe a Roe table. */
+    async describe(tableName) {
+        const { data } = await this.rawClient.GET("/v1/tables/{table_name}/describe/", { params: { path: { table_name: tableName } } });
+        return data;
+    }
+    /** Preview rows from a Roe table. */
+    async preview(tableName, options) {
+        const { data } = await this.rawClient.GET("/v1/tables/{table_name}/preview/", {
+            params: {
+                path: { table_name: tableName },
+                query: {
+                    ...(options?.limit !== undefined ? { limit: options?.limit } : {}),
+                },
+            },
+        });
+        return data;
+    }
+    /** Delete a Roe table. */
+    async delete(tableName) {
+        await this.rawClient.DELETE("/v1/tables/{table_name}/", {
+            params: { path: { table_name: tableName } },
+        });
+    }
 }

package/dist/index.js

@@ -12,5 +12,5 @@ export { Job, JobBatch, JobStatus } from "./models/job.js";
 // Hand-written response models removed in v1.0 (Agent, BaseAgent, Policy, PolicyVersion,
 // AgentVersion, AgentDatum, AgentJobResult, AgentJobStatus, Reference, JobDataDeleteResponse,
 // PaginatedResponse, UserInfo). Import the generated equivalents instead, e.g.:
-//   import type { components } from "@roe-ai/typescript";
+//   import type { components } from "roe-typescript";
 //   type Policy = components["schemas"]["Policy"];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "roe-typescript",
-  "version": "1.1.1",
+  "version": "1.1.2",
   "description": "TypeScript SDK for the Roe API (feature parity with roe-python).",
   "type": "module",
   "main": "dist/index.js",