@indemn/cli 1.0.0

package/src/sdk/functions.ts

@@ -0,0 +1,103 @@
+import type { IndemnClient } from './client.js';
+import type { BotFunction, CreateFunctionInput, UpdateFunctionInput, FunctionParameter } from './types.js';
+
+export class FunctionsSDK {
+  constructor(private client: IndemnClient) {}
+
+  async listFunctions(agentId: string): Promise<BotFunction[]> {
+    return this.client.copilotGet<BotFunction[]>(
+      `/organization/:org_id/ai-studio/bots/${agentId}/functions`,
+    );
+  }
+
+  async createFunction(agentId: string, input: CreateFunctionInput): Promise<BotFunction> {
+    return this.client.copilotPost<BotFunction>(
+      `/organization/:org_id/ai-studio/bots/${agentId}/functions`,
+      input,
+    );
+  }
+
+  async updateFunction(agentId: string, funcId: string, input: UpdateFunctionInput): Promise<BotFunction> {
+    return this.client.copilotPut<BotFunction>(
+      `/organization/:org_id/ai-studio/bots/${agentId}/functions/${funcId}`,
+      input,
+    );
+  }
+
+  async deleteFunction(agentId: string, funcId: string): Promise<void> {
+    await this.client.copilotDelete(
+      `/organization/:org_id/ai-studio/bots/${agentId}/functions/${funcId}`,
+    );
+  }
+
+  async testFunction(agentId: string, funcId: string, params?: Record<string, unknown>): Promise<unknown> {
+    return this.client.copilotPost(
+      `/organization/:org_id/ai-studio/bots/${agentId}/functions/${funcId}/test-rest-api`,
+      params,
+    );
+  }
+
+  async exportFunctions(agentId: string): Promise<unknown> {
+    return this.client.copilotPost(
+      `/organization/:org_id/ai-studio/bots/${agentId}/functions/export`,
+    );
+  }
+
+  async importFunctions(agentId: string, url: string): Promise<unknown> {
+    return this.client.copilotPost(
+      `/organization/:org_id/ai-studio/bots/${agentId}/functions/import`,
+      { url },
+    );
+  }
+
+  async listParameters(agentId: string, funcId: string): Promise<FunctionParameter[]> {
+    return this.client.copilotGet<FunctionParameter[]>(
+      `/organization/:org_id/ai-studio/bots/${agentId}/functions/${funcId}/parameters`,
+    );
+  }
+
+  async addParameter(agentId: string, funcId: string, param: { name: string; type: string; description?: string; required?: boolean }): Promise<FunctionParameter> {
+    // Server expects an array of parameters
+    const payload = [{
+      name: param.name,
+      type: param.type,
+      description: param.description,
+      is_required: param.required ?? false,
+    }];
+    return this.client.copilotPost<FunctionParameter>(
+      `/organization/:org_id/ai-studio/bots/${agentId}/functions/${funcId}/parameters`,
+      payload,
+    );
+  }
+
+  async updateParameter(agentId: string, funcId: string, paramId: string, param: { name?: string; type?: string; description?: string; required?: boolean }): Promise<FunctionParameter> {
+    // Server uses POST upsert (no PUT /:id endpoint exists). Include the param id for upsert matching.
+    const payload = [{
+      id: paramId,
+      ...param,
+      is_required: param.required ?? false,
+    }];
+    return this.client.copilotPost<FunctionParameter>(
+      `/organization/:org_id/ai-studio/bots/${agentId}/functions/${funcId}/parameters`,
+      payload,
+    );
+  }
+
+  async deleteParameter(agentId: string, funcId: string, paramId: string): Promise<void> {
+    await this.client.copilotDelete(
+      `/organization/:org_id/ai-studio/bots/${agentId}/functions/${funcId}/parameters/${paramId}`,
+    );
+  }
+
+  async listMasterFunctions(): Promise<unknown[]> {
+    return this.client.copilotGet<unknown[]>(
+      '/organization/:org_id/ai-studio/master-functions',
+    );
+  }
+
+  async listLLMModels(): Promise<unknown[]> {
+    return this.client.copilotGet<unknown[]>(
+      '/organization/:org_id/ai-studio/llm-models',
+    );
+  }
+}

package/src/sdk/index.ts

@@ -0,0 +1,11 @@
+export { IndemnClient } from './client.js';
+export { login, logout, whoami } from './auth.js';
+export { AgentsSDK } from './agents.js';
+export { ConfigSDK } from './config.js';
+export { FunctionsSDK } from './functions.js';
+export { KBSDK } from './kb.js';
+export { RubricsSDK } from './rubrics.js';
+export { TestSetsSDK } from './test-sets.js';
+export { EvalSDK } from './eval.js';
+export { ChatSession } from './chat.js';
+export * from './types.js';

package/src/sdk/kb.ts

@@ -0,0 +1,183 @@
+import type { IndemnClient } from './client.js';
+import type {
+  KnowledgeBase,
+  CreateKBInput,
+  UpdateKBInput,
+  DataSource,
+  AddDataSourceInput,
+  KBMapping,
+} from './types.js';
+
+export class KBSDK {
+  constructor(private client: IndemnClient) {}
+
+  async listKBs(): Promise<KnowledgeBase[]> {
+    return this.client.copilotGet<KnowledgeBase[]>(
+      '/organization/:org_id/knowledge-bases',
+    );
+  }
+
+  async getKB(id: string): Promise<KnowledgeBase> {
+    const result = await this.client.copilotGet<KnowledgeBase | KnowledgeBase[]>(
+      `/organization/:org_id/knowledge-bases/${id}`,
+    );
+    // Server may return an array; extract the first element
+    return Array.isArray(result) ? result[0] : result;
+  }
+
+  async createKB(input: CreateKBInput): Promise<KnowledgeBase> {
+    return this.client.copilotPost<KnowledgeBase>(
+      '/organization/:org_id/knowledge-bases',
+      input,
+    );
+  }
+
+  async updateKB(id: string, input: UpdateKBInput): Promise<KnowledgeBase> {
+    return this.client.copilotPut<KnowledgeBase>(
+      `/organization/:org_id/knowledge-bases/${id}`,
+      input,
+    );
+  }
+
+  async deleteKB(id: string): Promise<void> {
+    await this.client.copilotDelete(
+      `/organization/:org_id/knowledge-bases/${id}`,
+    );
+  }
+
+  async listDataSources(
+    kbId: string,
+    query?: { page?: string; limit?: string },
+  ): Promise<{ dataSources: DataSource[]; total: number; page: number; pages: number }> {
+    return this.client.copilotGet<{ dataSources: DataSource[]; total: number; page: number; pages: number }>(
+      `/organization/:org_id/knowledge-bases/${kbId}/data-source`,
+      query as Record<string, string> | undefined,
+    );
+  }
+
+  async addDataSource(kbId: string, input: AddDataSourceInput): Promise<DataSource> {
+    if (input.source_url) {
+      // URL type — must use /import endpoint (data-source POST only supports text)
+      return this.client.copilotPost<DataSource>(
+        `/organization/:org_id/knowledge-bases/${kbId}/import`,
+        {
+          type: 'url',
+          sources: [{ url: input.source_url, crawl_mode: 'full' }],
+        },
+      );
+    }
+
+    // Text/QnA type
+    return this.client.copilotPost<DataSource>(
+      `/organization/:org_id/knowledge-bases/${kbId}/data-source`,
+      { type: 'text', payload: { question: input.question, answer: input.answer, isManual: true } },
+    );
+  }
+
+  async scrapeUrl(kbId: string, url: string, crawlMode: string = 'full'): Promise<unknown> {
+    return this.client.copilotPost(
+      `/organization/:org_id/knowledge-bases/${kbId}/import`,
+      {
+        type: 'url',
+        sources: [{ url, crawl_mode: crawlMode }],
+      },
+    );
+  }
+
+  async uploadFile(kbId: string, filePath: string): Promise<unknown> {
+    const fs = await import('fs');
+    const path = await import('path');
+
+    if (!fs.existsSync(filePath)) {
+      throw new Error(`File not found: ${filePath}`);
+    }
+
+    const fileBuffer = fs.readFileSync(filePath);
+    const fileName = path.basename(filePath);
+    const blob = new Blob([fileBuffer]);
+
+    const formData = new FormData();
+    formData.append('file', blob, fileName);
+
+    // Need a raw fetch since copilotPost sets Content-Type to JSON
+    const hosts = this.client.getHosts();
+    const orgId = this.client.getOrgId();
+    const apiKey = this.client.getApiKey();
+    const url_str = `${hosts.copilot}/organization/${orgId}/knowledge-bases/${kbId}/upload-urls`;
+
+    const res = await fetch(url_str, {
+      method: 'POST',
+      headers: {
+        'Authorization': `Bearer ${apiKey}`,
+      },
+      body: formData,
+    });
+
+    if (!res.ok) {
+      const text = await res.text();
+      throw new Error(`Upload failed (${res.status}): ${text}`);
+    }
+
+    const json = await res.json() as { data?: unknown };
+    return json.data || json;
+  }
+
+  async updateDataSource(
+    kbId: string,
+    sourceId: string,
+    input: Partial<AddDataSourceInput>,
+  ): Promise<DataSource> {
+    return this.client.copilotPut<DataSource>(
+      `/organization/:org_id/knowledge-bases/${kbId}/data-source/${sourceId}`,
+      { payload: { question: input.question, answer: input.answer, isManual: true } },
+    );
+  }
+
+  async deleteDataSource(kbId: string, sourceId: string): Promise<void> {
+    await this.client.copilotDelete(
+      `/organization/:org_id/knowledge-bases/${kbId}/data-source/${sourceId}`,
+    );
+  }
+
+  async linkKB(agentId: string, kbIds: string[]): Promise<unknown> {
+    return this.client.copilotPost(
+      `/organization/:org_id/ai-studio/bots/${agentId}/mappings`,
+      { id_kb: kbIds },
+    );
+  }
+
+  async unlinkKB(agentId: string, kbId: string): Promise<void> {
+    // Mappings response: [{ id: "kb_id", connectedBots: [{ id: "bot_id", id_mapping: "mapping_id" }] }]
+    const mappings = await this.client.copilotGet<Array<{
+      id: string;
+      connectedBots: Array<{ id: string; id_mapping: string }>;
+    }>>(
+      `/organization/:org_id/ai-studio/bots/${agentId}/mappings`,
+    );
+    const kbEntry = mappings.find((m) => m.id === kbId);
+    if (!kbEntry) {
+      throw new Error(`No mapping found for KB ${kbId} on agent ${agentId}`);
+    }
+    const botMapping = kbEntry.connectedBots.find((b) => b.id === agentId);
+    if (!botMapping) {
+      throw new Error(`No mapping found for KB ${kbId} on agent ${agentId}`);
+    }
+    await this.client.copilotDelete(
+      `/organization/:org_id/ai-studio/bots/${agentId}/mappings/${botMapping.id_mapping}`,
+    );
+  }
+
+  async exportKB(kbId: string, format: string): Promise<unknown> {
+    return this.client.copilotPost(
+      `/organization/:org_id/knowledge-bases/${kbId}/export`,
+      { type: format },
+    );
+  }
+
+  async importKB(kbId: string, data: unknown): Promise<unknown> {
+    return this.client.copilotPost(
+      `/organization/:org_id/knowledge-bases/${kbId}/import`,
+      data,
+    );
+  }
+}

package/src/sdk/rubrics.ts

@@ -0,0 +1,35 @@
+import type { IndemnClient } from './client.js';
+import type { Rubric, CreateRubricInput } from './types.js';
+
+export class RubricsSDK {
+  constructor(private client: IndemnClient) {}
+
+  async listRubrics(agentId?: string): Promise<Rubric[]> {
+    const query = agentId ? { agent_id: agentId } : undefined;
+    return this.client.evalsGet<Rubric[]>('/api/v1/rubrics', query);
+  }
+
+  async getRubric(id: string): Promise<Rubric> {
+    return this.client.evalsGet<Rubric>(`/api/v1/rubrics/${id}`);
+  }
+
+  async createRubric(input: CreateRubricInput): Promise<Rubric> {
+    return this.client.evalsPost<Rubric>('/api/v1/rubrics', input);
+  }
+
+  async updateRubric(id: string, input: Partial<CreateRubricInput>): Promise<Rubric> {
+    return this.client.evalsPut<Rubric>(`/api/v1/rubrics/${id}`, input);
+  }
+
+  async deleteRubric(id: string): Promise<void> {
+    await this.client.evalsDelete(`/api/v1/rubrics/${id}`);
+  }
+
+  async listVersions(id: string): Promise<Rubric[]> {
+    return this.client.evalsGet<Rubric[]>(`/api/v1/rubrics/${id}/versions`);
+  }
+
+  async getVersion(id: string, version: number): Promise<Rubric> {
+    return this.client.evalsGet<Rubric>(`/api/v1/rubrics/${id}/versions/${version}`);
+  }
+}

package/src/sdk/test-sets.ts

@@ -0,0 +1,35 @@
+import type { IndemnClient } from './client.js';
+import type { TestSet, CreateTestSetInput } from './types.js';
+
+export class TestSetsSDK {
+  constructor(private client: IndemnClient) {}
+
+  async listTestSets(agentId?: string): Promise<TestSet[]> {
+    const query = agentId ? { agent_id: agentId } : undefined;
+    return this.client.evalsGet<TestSet[]>('/api/v1/test-sets', query);
+  }
+
+  async getTestSet(id: string): Promise<TestSet> {
+    return this.client.evalsGet<TestSet>(`/api/v1/test-sets/${id}`);
+  }
+
+  async createTestSet(input: CreateTestSetInput): Promise<TestSet> {
+    return this.client.evalsPost<TestSet>('/api/v1/test-sets', input);
+  }
+
+  async updateTestSet(id: string, input: Partial<CreateTestSetInput>): Promise<TestSet> {
+    return this.client.evalsPut<TestSet>(`/api/v1/test-sets/${id}`, input);
+  }
+
+  async deleteTestSet(id: string): Promise<void> {
+    await this.client.evalsDelete(`/api/v1/test-sets/${id}`);
+  }
+
+  async listVersions(id: string): Promise<TestSet[]> {
+    return this.client.evalsGet<TestSet[]>(`/api/v1/test-sets/${id}/versions`);
+  }
+
+  async getVersion(id: string, version: number): Promise<TestSet> {
+    return this.client.evalsGet<TestSet>(`/api/v1/test-sets/${id}/versions/${version}`);
+  }
+}