@axiom-lattice/client-sdk 8.0.0 → 8.0.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -0,0 +1,11 @@
1
+ /**
2
+ * AbstractClient namespace and request coverage.
3
+ *
4
+ * Exercises the namespaces defined directly on the abstract client against a
5
+ * concrete `Client` with a deterministic global fetch mock. Specialized suites
6
+ * (thread-maintenance, tasks, info, thread-event-stream, ...) keep their own
7
+ * focused contracts; this suite targets the shared namespace/request plumbing
8
+ * and the currently uncovered helpers.
9
+ */
10
+ export {};
11
+ //# sourceMappingURL=abstract-client.namespaces.test.d.ts.map
@@ -0,0 +1 @@
1
+ {"version":3,"file":"abstract-client.namespaces.test.d.ts","sourceRoot":"","sources":["../../src/__tests__/abstract-client.namespaces.test.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG"}
@@ -0,0 +1,630 @@
1
+ /**
2
+ * AbstractClient namespace and request coverage.
3
+ *
4
+ * Exercises the namespaces defined directly on the abstract client against a
5
+ * concrete `Client` with a deterministic global fetch mock. Specialized suites
6
+ * (thread-maintenance, tasks, info, thread-event-stream, ...) keep their own
7
+ * focused contracts; this suite targets the shared namespace/request plumbing
8
+ * and the currently uncovered helpers.
9
+ */
10
+ import { Client } from "../client";
11
+ import { ApiError } from "../types";
12
+ const mockFetch = jest.fn();
13
+ global.fetch = mockFetch;
14
+ const BASE = "http://localhost:3000";
15
+ class ExposedClient extends Client {
16
+ buildStream(options) {
17
+ return this.buildStreamRequestParams(options);
18
+ }
19
+ }
20
+ function makeClient(overrides = {}) {
21
+ return new Client({
22
+ baseURL: BASE,
23
+ apiKey: "test-key",
24
+ assistantId: "agent-1",
25
+ transport: "sse",
26
+ ...overrides,
27
+ });
28
+ }
29
+ function jsonResponse(body, init = {}) {
30
+ return {
31
+ ok: init.ok ?? true,
32
+ status: init.status ?? 200,
33
+ json: async () => body,
34
+ };
35
+ }
36
+ function respond(body, init = {}) {
37
+ mockFetch.mockResolvedValueOnce(jsonResponse(body, init));
38
+ }
39
+ function callAt(index = -1) {
40
+ const calls = mockFetch.mock.calls;
41
+ const resolved = index < 0 ? calls.length + index : index;
42
+ return calls[resolved];
43
+ }
44
+ function urlOf(index = -1) {
45
+ return callAt(index)[0];
46
+ }
47
+ function initOf(index = -1) {
48
+ return (callAt(index)[1] ?? {});
49
+ }
50
+ function bodyOf(index = -1) {
51
+ const body = initOf(index).body;
52
+ return typeof body === "string" ? JSON.parse(body) : body;
53
+ }
54
+ function headersOf(index = -1) {
55
+ return (initOf(index).headers ?? {});
56
+ }
57
+ beforeEach(() => {
58
+ jest.clearAllMocks();
59
+ });
60
+ describe("AbstractClient.request", () => {
61
+ it("delegates to makeRequest with method, body, and headers", async () => {
62
+ const client = makeClient();
63
+ respond({ success: true, data: { records: [{ id: "tool-1" }] } });
64
+ await expect(client.request("/api/tools")).resolves.toEqual({ success: true, data: { records: [{ id: "tool-1" }] } });
65
+ expect(urlOf()).toBe(`${BASE}/api/tools`);
66
+ expect(initOf().method).toBe("GET");
67
+ respond({ ok: true });
68
+ await client.request("/api/anything", {
69
+ method: "POST",
70
+ body: { a: 1 },
71
+ headers: { "x-custom": "yes" },
72
+ });
73
+ expect(urlOf()).toBe(`${BASE}/api/anything`);
74
+ expect(initOf().method).toBe("POST");
75
+ expect(bodyOf()).toEqual({ a: 1 });
76
+ expect(headersOf()).toMatchObject({
77
+ Authorization: "Bearer test-key",
78
+ "Content-Type": "application/json",
79
+ "x-custom": "yes",
80
+ });
81
+ });
82
+ });
83
+ describe("AbstractClient.setAssistantId / clone", () => {
84
+ it("setAssistantId changes subsequent assistant-scoped URLs", async () => {
85
+ const client = makeClient();
86
+ client.setAssistantId("agent-2");
87
+ respond({ success: true, message: "", data: { id: "thread-1" } });
88
+ await client.getThread("thread-1");
89
+ expect(urlOf()).toBe(`${BASE}/api/assistants/agent-2/threads/thread-1`);
90
+ });
91
+ it("clone copies config/tenant/tools and shares workspace headers", async () => {
92
+ const client = makeClient({ headers: { "x-extra": "1" }, transport: "ws" });
93
+ client.setTenantId("tenant-9");
94
+ client.setWorkspaceContext("ws-1", "p-1");
95
+ client.tools.register({ name: "calc", schema: {}, handler: async () => 1 });
96
+ const clone = client.clone({ assistantId: "agent-2", baseURL: "http://other" });
97
+ expect(clone.assistantId).toBe("agent-2");
98
+ expect(clone.tenantId).toBe("tenant-9");
99
+ expect(clone.config.baseURL).toBe("http://other");
100
+ expect(clone.registeredTools.has("calc")).toBe(true);
101
+ // Workspace headers are shared by reference: a change on the clone is
102
+ // visible on the parent (and vice versa).
103
+ clone.setWorkspaceContext("ws-2", "");
104
+ expect(client.getWorkspaceHeaders()).toEqual({ "x-workspace-id": "ws-2" });
105
+ expect(client.getWorkspaceHeaders()["x-project-id"]).toBeUndefined();
106
+ });
107
+ });
108
+ describe("AbstractClient.serverTools", () => {
109
+ const tool = { id: "tool-1", name: "calc" };
110
+ it("lists, gets, creates, updates, and deletes tools", async () => {
111
+ const client = makeClient();
112
+ respond({ success: true, message: "", data: { records: [tool], total: 1 } });
113
+ await expect(client.serverTools.list()).resolves.toEqual([tool]);
114
+ expect(urlOf()).toBe(`${BASE}/api/tools`);
115
+ respond({ success: true, message: "", data: tool });
116
+ await expect(client.serverTools.get("tool-1")).resolves.toEqual(tool);
117
+ expect(urlOf()).toBe(`${BASE}/api/tools/tool-1`);
118
+ respond({ success: true, message: "", data: tool });
119
+ await expect(client.serverTools.create({ name: "calc" })).resolves.toEqual(tool);
120
+ expect(initOf().method).toBe("POST");
121
+ expect(urlOf()).toBe(`${BASE}/api/tools`);
122
+ expect(bodyOf()).toEqual({ name: "calc" });
123
+ respond({ success: true, message: "", data: tool });
124
+ await expect(client.serverTools.update("tool-1", { name: "calc2" })).resolves.toEqual(tool);
125
+ expect(initOf().method).toBe("PUT");
126
+ expect(urlOf()).toBe(`${BASE}/api/tools/tool-1`);
127
+ expect(bodyOf()).toEqual({ name: "calc2" });
128
+ respond({ success: true, message: "" });
129
+ await expect(client.serverTools.delete("tool-1")).resolves.toBeUndefined();
130
+ expect(initOf().method).toBe("DELETE");
131
+ expect(urlOf()).toBe(`${BASE}/api/tools/tool-1`);
132
+ expect(headersOf()["Content-Type"]).toBeUndefined();
133
+ });
134
+ it("maps missing data to an ApiError", async () => {
135
+ const client = makeClient();
136
+ respond({ success: false, message: "" });
137
+ await expect(client.serverTools.get("missing")).rejects.toMatchObject({
138
+ name: "ApiError",
139
+ message: "Tool not found",
140
+ statusCode: 404,
141
+ });
142
+ respond({ success: false, message: "" });
143
+ await expect(client.serverTools.create({ name: "x" })).rejects.toMatchObject({
144
+ name: "ApiError",
145
+ message: "Failed to create tool",
146
+ statusCode: 500,
147
+ });
148
+ });
149
+ });
150
+ describe("AbstractClient.databaseConfigs", () => {
151
+ const config = { id: "db-1", name: "warehouse" };
152
+ it("lists, gets, creates, updates, deletes, and tests database configs", async () => {
153
+ const client = makeClient();
154
+ respond({ success: true, message: "", data: { records: [config], total: 1 } });
155
+ await expect(client.databaseConfigs.list()).resolves.toEqual([config]);
156
+ expect(urlOf()).toBe(`${BASE}/api/database-configs`);
157
+ respond({ success: true, message: "", data: config });
158
+ await expect(client.databaseConfigs.get("db-1")).resolves.toEqual(config);
159
+ expect(urlOf()).toBe(`${BASE}/api/database-configs/db-1`);
160
+ respond({ success: true, message: "", data: config });
161
+ await expect(client.databaseConfigs.create({ name: "warehouse" })).resolves.toEqual(config);
162
+ expect(initOf().method).toBe("POST");
163
+ expect(bodyOf()).toEqual({ name: "warehouse" });
164
+ respond({ success: true, message: "", data: config });
165
+ await expect(client.databaseConfigs.update("db-1", { name: "new" })).resolves.toEqual(config);
166
+ expect(initOf().method).toBe("PUT");
167
+ expect(urlOf()).toBe(`${BASE}/api/database-configs/db-1`);
168
+ expect(bodyOf()).toEqual({ name: "new" });
169
+ respond({ success: true, message: "" });
170
+ await expect(client.databaseConfigs.delete("db-1")).resolves.toBeUndefined();
171
+ expect(initOf().method).toBe("DELETE");
172
+ respond({ success: true, message: "", data: { connected: true, latency: 12 } });
173
+ await expect(client.databaseConfigs.test("db-1")).resolves.toEqual({ success: true, message: "", data: { connected: true, latency: 12 } });
174
+ expect(initOf().method).toBe("POST");
175
+ expect(urlOf()).toBe(`${BASE}/api/database-configs/db-1/test`);
176
+ });
177
+ it("maps missing data to an ApiError", async () => {
178
+ const client = makeClient();
179
+ respond({ success: false, message: "" });
180
+ await expect(client.databaseConfigs.update("db-1", {})).rejects.toMatchObject({
181
+ name: "ApiError",
182
+ message: "Failed to update database config",
183
+ statusCode: 500,
184
+ });
185
+ });
186
+ });
187
+ describe("AbstractClient.modelProviders", () => {
188
+ const provider = { id: "openai/gpt 4", name: "OpenAI" };
189
+ it("lists and encodes ids on get/update/delete", async () => {
190
+ const client = makeClient();
191
+ respond({ success: true, data: { records: [provider], total: 1 } });
192
+ await expect(client.modelProviders.list()).resolves.toEqual([provider]);
193
+ expect(urlOf()).toBe(`${BASE}/api/model-providers`);
194
+ respond({ success: true, data: provider });
195
+ await expect(client.modelProviders.get("openai/gpt 4")).resolves.toEqual(provider);
196
+ expect(urlOf()).toBe(`${BASE}/api/model-providers/openai%2Fgpt%204`);
197
+ respond({ success: true, data: provider });
198
+ await expect(client.modelProviders.update("openai/gpt 4", { name: "OpenAI 2" })).resolves.toEqual(provider);
199
+ expect(initOf().method).toBe("PUT");
200
+ expect(urlOf()).toBe(`${BASE}/api/model-providers/openai%2Fgpt%204`);
201
+ expect(bodyOf()).toEqual({ name: "OpenAI 2" });
202
+ respond({ success: true });
203
+ await expect(client.modelProviders.delete("openai/gpt 4")).resolves.toBeUndefined();
204
+ expect(initOf().method).toBe("DELETE");
205
+ expect(urlOf()).toBe(`${BASE}/api/model-providers/openai%2Fgpt%204`);
206
+ });
207
+ it("creates, probes, selects models, discovers, and toggles one model", async () => {
208
+ const client = makeClient();
209
+ respond({ success: true, data: provider });
210
+ await expect(client.modelProviders.create({ name: "OpenAI", baseURL: "https://api.openai.com/v1", apiKey: "k" })).resolves.toEqual(provider);
211
+ expect(initOf().method).toBe("POST");
212
+ expect(urlOf()).toBe(`${BASE}/api/model-providers`);
213
+ respond({ success: true, data: { models: ["gpt-4"], latencyMs: 3 } });
214
+ await expect(client.modelProviders.probe({ baseURL: "https://api.openai.com/v1", apiKey: "k" })).resolves.toEqual({ models: ["gpt-4"], latencyMs: 3 });
215
+ expect(initOf().method).toBe("POST");
216
+ expect(urlOf()).toBe(`${BASE}/api/model-providers/probe`);
217
+ expect(bodyOf()).toEqual({ baseURL: "https://api.openai.com/v1", apiKey: "k" });
218
+ respond({ success: true, data: provider });
219
+ await expect(client.modelProviders.setModels("a/b", [{ modelId: "gpt-4", enabled: true }])).resolves.toEqual(provider);
220
+ expect(initOf().method).toBe("PUT");
221
+ expect(urlOf()).toBe(`${BASE}/api/model-providers/a%2Fb/models`);
222
+ expect(bodyOf()).toEqual({ models: [{ modelId: "gpt-4", enabled: true }] });
223
+ respond({ success: true, data: { models: ["gpt-4"] } });
224
+ await expect(client.modelProviders.discover("a/b")).resolves.toEqual({ models: ["gpt-4"] });
225
+ expect(initOf().method).toBe("POST");
226
+ expect(urlOf()).toBe(`${BASE}/api/model-providers/a%2Fb/discover`);
227
+ expect(bodyOf()).toEqual({});
228
+ respond({ success: true, data: provider });
229
+ await expect(client.modelProviders.setModelEnabled("a/b", "Qwen/Qwen2.5", false)).resolves.toEqual(provider);
230
+ expect(initOf().method).toBe("POST");
231
+ expect(urlOf()).toBe(`${BASE}/api/model-providers/a%2Fb/models/enabled`);
232
+ expect(bodyOf()).toEqual({ modelId: "Qwen/Qwen2.5", enabled: false });
233
+ });
234
+ it("maps missing data to an ApiError", async () => {
235
+ const client = makeClient();
236
+ respond({ success: false });
237
+ await expect(client.modelProviders.get("missing")).rejects.toMatchObject({
238
+ name: "ApiError",
239
+ message: "Model provider not found",
240
+ statusCode: 404,
241
+ });
242
+ });
243
+ });
244
+ describe("AbstractClient.tenantModels", () => {
245
+ it("reads the tenant model catalog", async () => {
246
+ const client = makeClient();
247
+ const catalog = { providers: [{ id: "p1", models: ["m1"] }] };
248
+ respond({ success: true, data: catalog });
249
+ await expect(client.tenantModels.list()).resolves.toEqual(catalog);
250
+ expect(urlOf()).toBe(`${BASE}/api/tenant-models`);
251
+ });
252
+ });
253
+ describe("AbstractClient.metricsConfigs", () => {
254
+ const config = { id: "metrics-1", name: "prom" };
255
+ it("lists, gets, creates, updates, deletes, tests, and reads datasources", async () => {
256
+ const client = makeClient();
257
+ respond({ success: true, message: "", data: { records: [config], total: 1 } });
258
+ await expect(client.metricsConfigs.list()).resolves.toEqual([config]);
259
+ expect(urlOf()).toBe(`${BASE}/api/metrics-configs`);
260
+ respond({ success: true, message: "", data: config });
261
+ await expect(client.metricsConfigs.get("metrics-1")).resolves.toEqual(config);
262
+ expect(urlOf()).toBe(`${BASE}/api/metrics-configs/metrics-1`);
263
+ respond({ success: true, message: "", data: config });
264
+ await expect(client.metricsConfigs.create({ name: "prom" })).resolves.toEqual(config);
265
+ expect(initOf().method).toBe("POST");
266
+ respond({ success: true, message: "", data: config });
267
+ await expect(client.metricsConfigs.update("metrics-1", { name: "new" })).resolves.toEqual(config);
268
+ expect(initOf().method).toBe("PUT");
269
+ expect(urlOf()).toBe(`${BASE}/api/metrics-configs/metrics-1`);
270
+ respond({ success: true, message: "" });
271
+ await expect(client.metricsConfigs.delete("metrics-1")).resolves.toBeUndefined();
272
+ expect(initOf().method).toBe("DELETE");
273
+ respond({ success: true, message: "", data: { connected: true } });
274
+ await expect(client.metricsConfigs.test("metrics-1")).resolves.toEqual({ success: true, message: "", data: { connected: true } });
275
+ expect(initOf().method).toBe("POST");
276
+ expect(urlOf()).toBe(`${BASE}/api/metrics-configs/metrics-1/test`);
277
+ respond({ success: true, message: "", data: { datasources: [{ name: "orders" }] } });
278
+ await expect(client.metricsConfigs.getDatasources("metrics-1")).resolves.toEqual([{ name: "orders" }]);
279
+ expect(urlOf()).toBe(`${BASE}/api/metrics-configs/metrics-1/datasources`);
280
+ });
281
+ it("falls back to an empty datasource list and maps missing data", async () => {
282
+ const client = makeClient();
283
+ respond({ success: true, message: "" });
284
+ await expect(client.metricsConfigs.getDatasources("metrics-1")).resolves.toEqual([]);
285
+ respond({ success: false, message: "" });
286
+ await expect(client.metricsConfigs.get("missing")).rejects.toMatchObject({
287
+ name: "ApiError",
288
+ message: "Metrics config not found",
289
+ statusCode: 404,
290
+ });
291
+ });
292
+ });
293
+ describe("AbstractClient.mcpServers", () => {
294
+ const server = { id: "mcp-1", name: "filesystem" };
295
+ it("lists, gets, creates, updates, deletes, tests, connects, and disconnects", async () => {
296
+ const client = makeClient();
297
+ respond({ success: true, message: "", data: { records: [server], total: 1 } });
298
+ await expect(client.mcpServers.list()).resolves.toEqual([server]);
299
+ expect(urlOf()).toBe(`${BASE}/api/mcp-servers`);
300
+ respond({ success: true, message: "", data: server });
301
+ await expect(client.mcpServers.get("mcp-1")).resolves.toEqual(server);
302
+ expect(urlOf()).toBe(`${BASE}/api/mcp-servers/mcp-1`);
303
+ respond({ success: true, message: "", data: server });
304
+ await expect(client.mcpServers.create({ name: "filesystem" })).resolves.toEqual(server);
305
+ expect(initOf().method).toBe("POST");
306
+ respond({ success: true, message: "", data: server });
307
+ await expect(client.mcpServers.update("mcp-1", { name: "new" })).resolves.toEqual(server);
308
+ expect(initOf().method).toBe("PUT");
309
+ expect(urlOf()).toBe(`${BASE}/api/mcp-servers/mcp-1`);
310
+ respond({ success: true, message: "" });
311
+ await expect(client.mcpServers.delete("mcp-1")).resolves.toBeUndefined();
312
+ expect(initOf().method).toBe("DELETE");
313
+ respond({ success: true, message: "", data: { connected: true, tools: [] } });
314
+ await expect(client.mcpServers.test("mcp-1")).resolves.toEqual({ success: true, message: "", data: { connected: true, tools: [] } });
315
+ expect(initOf().method).toBe("POST");
316
+ expect(urlOf()).toBe(`${BASE}/api/mcp-servers/mcp-1/test`);
317
+ respond({ success: true, message: "", data: server });
318
+ await expect(client.mcpServers.connect("mcp-1")).resolves.toEqual(server);
319
+ expect(initOf().method).toBe("POST");
320
+ expect(urlOf()).toBe(`${BASE}/api/mcp-servers/mcp-1/connect`);
321
+ respond({ success: true, message: "", data: server });
322
+ await expect(client.mcpServers.disconnect("mcp-1")).resolves.toEqual(server);
323
+ expect(initOf().method).toBe("POST");
324
+ expect(urlOf()).toBe(`${BASE}/api/mcp-servers/mcp-1/disconnect`);
325
+ });
326
+ it("maps missing data to an ApiError", async () => {
327
+ const client = makeClient();
328
+ respond({ success: false, message: "" });
329
+ await expect(client.mcpServers.connect("missing")).rejects.toMatchObject({
330
+ name: "ApiError",
331
+ message: "Failed to connect MCP server",
332
+ statusCode: 500,
333
+ });
334
+ });
335
+ });
336
+ describe("AbstractClient.connections", () => {
337
+ const connection = { key: "a/b", type: "smb server" };
338
+ it("encodes type/key query params and returns raw entries", async () => {
339
+ const client = makeClient();
340
+ respond({ success: true, data: { records: [connection] } });
341
+ await expect(client.connections.list("smb server")).resolves.toEqual([connection]);
342
+ expect(urlOf()).toBe(`${BASE}/api/connections?type=smb%20server`);
343
+ respond({ success: true, data: connection });
344
+ await expect(client.connections.create({ key: "a/b" })).resolves.toEqual({ success: true, data: connection });
345
+ expect(initOf().method).toBe("POST");
346
+ expect(urlOf()).toBe(`${BASE}/api/connections`);
347
+ expect(bodyOf()).toEqual({ key: "a/b" });
348
+ respond({ success: true, data: connection });
349
+ await expect(client.connections.update("smb server", "a/b", { host: "h" })).resolves.toEqual({
350
+ success: true,
351
+ data: connection,
352
+ });
353
+ expect(initOf().method).toBe("PUT");
354
+ expect(urlOf()).toBe(`${BASE}/api/connections/a%2Fb?type=smb%20server`);
355
+ expect(bodyOf()).toEqual({ host: "h" });
356
+ respond({ success: true });
357
+ await expect(client.connections.delete("smb server", "a/b")).resolves.toBeUndefined();
358
+ expect(initOf().method).toBe("DELETE");
359
+ expect(urlOf()).toBe(`${BASE}/api/connections/a%2Fb?type=smb%20server`);
360
+ });
361
+ });
362
+ describe("AbstractClient.tasks", () => {
363
+ const task = { id: "task-1", status: "pending" };
364
+ it("lists with and without query params", async () => {
365
+ const client = makeClient();
366
+ respond({ success: true, data: [task] });
367
+ await expect(client.tasks.list()).resolves.toEqual([task]);
368
+ expect(urlOf()).toBe(`${BASE}/api/tasks`);
369
+ respond({ success: true, data: [task] });
370
+ await expect(client.tasks.list({ status: "in_progress", limit: "10" })).resolves.toEqual([task]);
371
+ expect(urlOf()).toBe(`${BASE}/api/tasks?status=in_progress&limit=10`);
372
+ respond({ success: true });
373
+ await expect(client.tasks.list()).resolves.toEqual([]);
374
+ });
375
+ it("gets, creates, updates, deletes, completes, and commands tasks", async () => {
376
+ const client = makeClient();
377
+ respond({ success: true, data: task });
378
+ await expect(client.tasks.get("task-1")).resolves.toEqual(task);
379
+ expect(urlOf()).toBe(`${BASE}/api/tasks/task-1`);
380
+ respond({ success: true, data: task });
381
+ await expect(client.tasks.create({ title: "do it" })).resolves.toEqual(task);
382
+ expect(initOf().method).toBe("POST");
383
+ expect(bodyOf()).toEqual({ title: "do it" });
384
+ respond({ success: true, data: task });
385
+ await expect(client.tasks.update("task-1", { title: "renamed" })).resolves.toEqual(task);
386
+ expect(initOf().method).toBe("PUT");
387
+ expect(urlOf()).toBe(`${BASE}/api/tasks/task-1`);
388
+ respond({ success: true, message: "" });
389
+ await expect(client.tasks.delete("task-1")).resolves.toBeUndefined();
390
+ expect(initOf().method).toBe("DELETE");
391
+ respond({ success: true, data: task, evidenceId: "ev-1", eventKey: "completion:task-1" });
392
+ await expect(client.tasks.complete("task-1", { result: "done" })).resolves.toEqual({
393
+ success: true,
394
+ data: task,
395
+ evidenceId: "ev-1",
396
+ eventKey: "completion:task-1",
397
+ });
398
+ expect(initOf().method).toBe("PATCH");
399
+ expect(urlOf()).toBe(`${BASE}/api/tasks/task-1/complete`);
400
+ expect(bodyOf()).toEqual({ result: "done" });
401
+ respond({ success: true, data: task });
402
+ await expect(client.tasks.command("task-1", { type: "start" })).resolves.toEqual({
403
+ success: true,
404
+ data: task,
405
+ });
406
+ expect(initOf().method).toBe("POST");
407
+ expect(urlOf()).toBe(`${BASE}/api/tasks/task-1/commands`);
408
+ expect(bodyOf()).toEqual({ type: "start" });
409
+ });
410
+ it("builds work-items query params and maps missing data", async () => {
411
+ const client = makeClient();
412
+ respond({ success: true, data: [{ id: "wi-1" }] });
413
+ await expect(client.tasks.workItems.list("task-1")).resolves.toEqual([{ id: "wi-1" }]);
414
+ expect(urlOf()).toBe(`${BASE}/api/tasks/task-1/work-items`);
415
+ respond({ success: true, data: [] });
416
+ await expect(client.tasks.workItems.list("task-1", { action: "comment", limit: 5, offset: 2 })).resolves.toEqual([]);
417
+ expect(urlOf()).toBe(`${BASE}/api/tasks/task-1/work-items?action=comment&limit=5&offset=2`);
418
+ respond({ success: false });
419
+ await expect(client.tasks.get("missing")).rejects.toMatchObject({
420
+ name: "ApiError",
421
+ message: "Task not found",
422
+ statusCode: 404,
423
+ });
424
+ });
425
+ });
426
+ describe("AbstractClient.menu", () => {
427
+ const item = { id: "menu-1", label: "Home" };
428
+ it("lists with an optional target and manages items", async () => {
429
+ const client = makeClient();
430
+ respond({ success: true, message: "", data: { records: [item], total: 1 } });
431
+ await expect(client.menu.list()).resolves.toEqual([item]);
432
+ expect(urlOf()).toBe(`${BASE}/api/menu-items`);
433
+ respond({ success: true, message: "", data: { records: [item], total: 1 } });
434
+ await expect(client.menu.list("main")).resolves.toEqual([item]);
435
+ expect(urlOf()).toBe(`${BASE}/api/menu-items?menuTarget=main`);
436
+ respond({ success: true, message: "", data: item });
437
+ await expect(client.menu.get("menu-1")).resolves.toEqual(item);
438
+ expect(urlOf()).toBe(`${BASE}/api/menu-items/menu-1`);
439
+ respond({ success: true, message: "", data: item });
440
+ await expect(client.menu.create({ label: "Home" })).resolves.toEqual(item);
441
+ expect(initOf().method).toBe("POST");
442
+ respond({ success: true, message: "", data: item });
443
+ await expect(client.menu.update("menu-1", { label: "Start" })).resolves.toEqual(item);
444
+ expect(initOf().method).toBe("PUT");
445
+ expect(urlOf()).toBe(`${BASE}/api/menu-items/menu-1`);
446
+ respond({ success: true, message: "" });
447
+ await expect(client.menu.delete("menu-1")).resolves.toBeUndefined();
448
+ expect(initOf().method).toBe("DELETE");
449
+ respond({ success: true, message: "" });
450
+ await expect(client.menu.list()).resolves.toEqual([]);
451
+ });
452
+ it("throws a plain Error when data is missing", async () => {
453
+ const client = makeClient();
454
+ respond({ success: false, message: "" });
455
+ const error = await client.menu.get("missing").catch((caught) => caught);
456
+ expect(error).toBeInstanceOf(Error);
457
+ expect(error).not.toBeInstanceOf(ApiError);
458
+ expect(error.message).toBe("Menu item not found");
459
+ });
460
+ });
461
+ describe("HTTP error mapping", () => {
462
+ it("maps 401 to AuthenticationError and other statuses to ApiError", async () => {
463
+ const client = makeClient();
464
+ respond({}, { ok: false, status: 401 });
465
+ await expect(client.serverTools.list()).rejects.toMatchObject({
466
+ name: "AuthenticationError",
467
+ message: "Authentication failed",
468
+ });
469
+ respond({ error: "db down" }, { ok: false, status: 500 });
470
+ await expect(client.databaseConfigs.list()).rejects.toMatchObject({
471
+ name: "ApiError",
472
+ message: "db down",
473
+ statusCode: 500,
474
+ responseBody: { error: "db down" },
475
+ });
476
+ respond({}, { ok: false, status: 503 });
477
+ await expect(client.metricsConfigs.list()).rejects.toMatchObject({
478
+ name: "ApiError",
479
+ message: "API Error",
480
+ statusCode: 503,
481
+ });
482
+ });
483
+ });
484
+ describe("deprecated thread helpers", () => {
485
+ it("creates, gets, lists, and deletes threads", async () => {
486
+ const client = makeClient();
487
+ const thread = { id: "thread-1", assistantId: "agent-1", metadata: {} };
488
+ respond({ success: true, message: "", data: thread });
489
+ await expect(client.createThread({ metadata: { foo: "bar" } })).resolves.toBe("thread-1");
490
+ expect(initOf().method).toBe("POST");
491
+ expect(urlOf()).toBe(`${BASE}/api/assistants/agent-1/threads`);
492
+ expect(bodyOf()).toEqual({ metadata: { foo: "bar" } });
493
+ respond({ success: true, message: "", data: thread });
494
+ await expect(client.getThread("thread-1")).resolves.toEqual(thread);
495
+ expect(urlOf()).toBe(`${BASE}/api/assistants/agent-1/threads/thread-1`);
496
+ respond({ success: true, message: "", data: { records: [thread], total: 1 } });
497
+ await expect(client.listThreads({ limit: 10, offset: 0 })).resolves.toEqual([thread]);
498
+ expect(urlOf()).toBe(`${BASE}/api/assistants/agent-1/threads`);
499
+ respond({ success: true, message: "" });
500
+ await expect(client.deleteThread("thread-1")).resolves.toBeUndefined();
501
+ expect(initOf().method).toBe("DELETE");
502
+ expect(urlOf()).toBe(`${BASE}/api/assistants/agent-1/threads/thread-1`);
503
+ });
504
+ it("maps missing thread data to an ApiError", async () => {
505
+ const client = makeClient();
506
+ respond({ success: false, message: "" });
507
+ await expect(client.getThread("missing")).rejects.toMatchObject({
508
+ name: "ApiError",
509
+ message: "Thread not found",
510
+ statusCode: 404,
511
+ });
512
+ respond({ success: false, message: "" });
513
+ await expect(client.createThread({})).rejects.toMatchObject({
514
+ name: "ApiError",
515
+ message: "Failed to create thread",
516
+ statusCode: 500,
517
+ });
518
+ });
519
+ });
520
+ describe("getMessages URL assembly", () => {
521
+ it("appends limit/after/reverse and always the assistantId", async () => {
522
+ const client = makeClient();
523
+ respond([]);
524
+ await client.getMessages({ threadId: "thread-1" });
525
+ expect(urlOf()).toBe(`${BASE}/api/assistants/agent-1/thread-1/memory?assistantId=agent-1`);
526
+ respond([]);
527
+ await client.getMessages({ threadId: "thread-1", limit: 5 });
528
+ expect(urlOf()).toBe(`${BASE}/api/assistants/agent-1/thread-1/memory?limit=5&assistantId=agent-1`);
529
+ respond([]);
530
+ await client.getMessages({ threadId: "thread-1", after: "m-1" });
531
+ expect(urlOf()).toBe(`${BASE}/api/assistants/agent-1/thread-1/memory?after=m-1&assistantId=agent-1`);
532
+ respond([]);
533
+ await client.getMessages({ threadId: "thread-1", reverse: false });
534
+ expect(urlOf()).toBe(`${BASE}/api/assistants/agent-1/thread-1/memory?reverse=false&assistantId=agent-1`);
535
+ respond([]);
536
+ await client.getMessages({ threadId: "thread-1", limit: 5, after: "m-1", reverse: true });
537
+ expect(urlOf()).toBe(`${BASE}/api/assistants/agent-1/thread-1/memory?limit=5&after=m-1&reverse=true&assistantId=agent-1`);
538
+ });
539
+ });
540
+ describe("agent state/graph and non-streaming run", () => {
541
+ it("reads agent state and graph image", async () => {
542
+ const client = makeClient();
543
+ const state = { values: { messages: [] }, tasks: [] };
544
+ respond(state);
545
+ await expect(client.getAgentState("thread-1")).resolves.toEqual(state);
546
+ expect(urlOf()).toBe(`${BASE}/api/assistants/agent-1/thread-1/state`);
547
+ respond({ image: "graphviz-data" });
548
+ await expect(client.getAgentGraph()).resolves.toBe("graphviz-data");
549
+ expect(urlOf()).toBe(`${BASE}/api/assistants/agent-1/graph`);
550
+ });
551
+ it("posts a non-streaming run body and honors assistant overrides", async () => {
552
+ const client = makeClient();
553
+ const response = { messages: [{ role: "ai", content: "hi" }] };
554
+ respond(response);
555
+ await expect(client.run({
556
+ threadId: "thread-1",
557
+ message: "hello",
558
+ files: [{ id: "file-1" }],
559
+ command: { type: "go" },
560
+ background: true,
561
+ custom_run_config: { temperature: 0 },
562
+ extra: "kept",
563
+ streaming: false,
564
+ })).resolves.toEqual(response);
565
+ expect(initOf().method).toBe("POST");
566
+ expect(urlOf()).toBe(`${BASE}/api/runs`);
567
+ expect(bodyOf()).toEqual({
568
+ assistant_id: "agent-1",
569
+ thread_id: "thread-1",
570
+ message: "hello",
571
+ files: [{ id: "file-1" }],
572
+ command: { type: "go" },
573
+ streaming: false,
574
+ background: true,
575
+ custom_run_config: { temperature: 0 },
576
+ extra: "kept",
577
+ });
578
+ respond(response);
579
+ await client.run({ threadId: "thread-2", message: "hi", assistantId: "agent-2", streaming: false });
580
+ expect(bodyOf()).toMatchObject({ assistant_id: "agent-2", background: false });
581
+ });
582
+ it("rejects streaming runs without callbacks before any request", async () => {
583
+ const client = makeClient();
584
+ await expect(client.run({ threadId: "thread-1", message: "hi", streaming: true })).rejects.toThrow("Streaming without callbacks is not supported. Use chat.stream with callbacks instead.");
585
+ expect(mockFetch).not.toHaveBeenCalled();
586
+ });
587
+ it("builds streaming request params via the protected helper", () => {
588
+ const client = new ExposedClient({
589
+ baseURL: BASE,
590
+ apiKey: "test-key",
591
+ assistantId: "agent-1",
592
+ transport: "sse",
593
+ });
594
+ expect(client.buildStream({
595
+ threadId: "thread-1",
596
+ message: "hello",
597
+ messageId: "m-1",
598
+ files: [{ id: "f-1" }],
599
+ command: { type: "go" },
600
+ background: true,
601
+ custom_run_config: { temperature: 0 },
602
+ extra: "kept",
603
+ streaming: true,
604
+ })).toEqual({
605
+ url: "/api/runs",
606
+ method: "POST",
607
+ body: {
608
+ assistant_id: "agent-1",
609
+ thread_id: "thread-1",
610
+ message: "hello",
611
+ message_id: "m-1",
612
+ files: [{ id: "f-1" }],
613
+ command: { type: "go" },
614
+ streaming: true,
615
+ background: true,
616
+ custom_run_config: { temperature: 0 },
617
+ extra: "kept",
618
+ },
619
+ });
620
+ });
621
+ });
622
+ describe("getThreadHistory default query", () => {
623
+ it("omits the query string when no options are supplied", async () => {
624
+ const client = makeClient();
625
+ respond({ success: true, data: { history: [] } });
626
+ await expect(client.getThreadHistory("thread-1")).resolves.toEqual([]);
627
+ expect(urlOf()).toBe(`${BASE}/api/assistants/agent-1/threads/thread-1/history`);
628
+ });
629
+ });
630
+ //# sourceMappingURL=abstract-client.namespaces.test.js.map