@inferencesh/sdk 0.6.15 → 0.6.19

package/dist/api/api-keys.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/api/api-keys.test.js

@@ -1,44 +0,0 @@
-import { HttpClient } from '../http/client';
-import { ApiKeysAPI } from './api-keys';
-const mockFetch = jest.fn();
-global.fetch = mockFetch;
-function mockJsonResponse(body) {
-    mockFetch.mockResolvedValueOnce({
-        ok: true,
-        status: 200,
-        text: () => Promise.resolve(JSON.stringify(body)),
-    });
-}
-describe('ApiKeysAPI', () => {
-    beforeEach(() => {
-        jest.clearAllMocks();
-    });
-    const api = () => new ApiKeysAPI(new HttpClient({ apiKey: 'test-key' }));
-    it('should POST /apikeys/list for list()', async () => {
-        const page = { items: [{ id: 'key-1', name: 'CI' }], next_cursor: null };
-        mockJsonResponse(page);
-        const result = await api().list();
-        expect(result).toEqual(page);
-        const [url, init] = mockFetch.mock.calls[0];
-        expect(url).toContain('/apikeys/list');
-        expect(init.method).toBe('POST');
-    });
-    it('should POST /apikeys for create()', async () => {
-        const payload = { name: 'deploy-bot', scopes: ['tasks:read'] };
-        const key = { id: 'key-new', ...payload, key: 'inf_sk_abc' };
-        mockJsonResponse(key);
-        const result = await api().create(payload);
-        expect(result).toEqual(key);
-        const [url, init] = mockFetch.mock.calls[0];
-        expect(url).toContain('/apikeys');
-        expect(init.method).toBe('POST');
-        expect(JSON.parse(init.body)).toEqual(payload);
-    });
-    it('should DELETE /apikeys/{id} for delete()', async () => {
-        mockJsonResponse(null);
-        await api().delete('key-9');
-        const [url, init] = mockFetch.mock.calls[0];
-        expect(url).toContain('/apikeys/key-9');
-        expect(init.method).toBe('DELETE');
-    });
-});

package/dist/api/apps.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/api/apps.test.js

@@ -1,135 +0,0 @@
-import { HttpClient } from '../http/client';
-import { AppsAPI } from './apps';
-const mockFetch = jest.fn();
-global.fetch = mockFetch;
-function mockJsonResponse(body) {
-    mockFetch.mockResolvedValueOnce({
-        ok: true,
-        status: 200,
-        text: () => Promise.resolve(JSON.stringify(body)),
-    });
-}
-describe('AppsAPI', () => {
-    beforeEach(() => {
-        jest.clearAllMocks();
-    });
-    const api = () => new AppsAPI(new HttpClient({ apiKey: 'test-key' }));
-    it('should POST /apps/list for list()', async () => {
-        const apps = { items: [{ id: 'app-1' }], next_cursor: null };
-        mockJsonResponse(apps);
-        const result = await api().list({ limit: 10 });
-        expect(result).toEqual(apps);
-        const [url, init] = mockFetch.mock.calls[0];
-        expect(url).toContain('/apps/list');
-        expect(init.method).toBe('POST');
-        expect(JSON.parse(init.body)).toEqual({ limit: 10 });
-    });
-    it('should GET /apps/{name} for getByName()', async () => {
-        const app = { id: 'app-1', name: 'inference/claude-haiku' };
-        mockJsonResponse(app);
-        const result = await api().getByName('inference/claude-haiku');
-        expect(result).toEqual(app);
-        const [url] = mockFetch.mock.calls[0];
-        expect(url).toContain('/apps/inference/claude-haiku');
-    });
-    it('should POST transfer with team_id for transferOwnership()', async () => {
-        const app = { id: 'app-1' };
-        mockJsonResponse(app);
-        await api().transferOwnership('app-1', 'team-99');
-        const [url, init] = mockFetch.mock.calls[0];
-        expect(url).toContain('/apps/app-1/transfer');
-        expect(JSON.parse(init.body)).toEqual({ team_id: 'team-99' });
-    });
-    it('should POST license payload for saveLicense()', async () => {
-        const license = { app_id: 'app-1', license: 'key-abc' };
-        mockJsonResponse(license);
-        const result = await api().saveLicense('app-1', 'key-abc');
-        expect(result).toEqual(license);
-        const [, init] = mockFetch.mock.calls[0];
-        expect(JSON.parse(init.body)).toEqual({ license: 'key-abc' });
-    });
-    it('should PUT /apps/{id}/versions/{versionId}/current for setCurrentVersion()', async () => {
-        const app = { id: 'app-1', current_version_id: 'ver-2' };
-        mockJsonResponse(app);
-        await api().setCurrentVersion('app-1', 'ver-2');
-        const [url, init] = mockFetch.mock.calls[0];
-        expect(url).toContain('/apps/app-1/versions/ver-2/current');
-        expect(init.method).toBe('PUT');
-    });
-    it('should POST /apps/{id}/duplicate for duplicate()', async () => {
-        const app = { id: 'app-copy' };
-        mockJsonResponse(app);
-        const result = await api().duplicate('app-1');
-        expect(result).toEqual(app);
-        const [url, init] = mockFetch.mock.calls[0];
-        expect(url).toContain('/apps/app-1/duplicate');
-        expect(init.method).toBe('POST');
-    });
-    it('should GET /apps/{id} for get()', async () => {
-        const app = { id: 'app-1', name: 'demo' };
-        mockJsonResponse(app);
-        const result = await api().get('app-1');
-        expect(result).toEqual(app);
-        const [url, init] = mockFetch.mock.calls[0];
-        expect(url).toContain('/apps/app-1');
-        expect(init.method).toBe('GET');
-    });
-    it('should GET versioned app for getByVersionId()', async () => {
-        const app = { id: 'app-1', version_id: 'ver-1' };
-        mockJsonResponse(app);
-        const result = await api().getByVersionId('app-1', 'ver-1');
-        expect(result).toEqual(app);
-        const [url] = mockFetch.mock.calls[0];
-        expect(url).toContain('/apps/app-1/versions/ver-1');
-    });
-    it('should POST /apps for create()', async () => {
-        const app = { id: 'app-new', name: 'New App' };
-        mockJsonResponse(app);
-        const result = await api().create({ name: 'New App' });
-        expect(result).toEqual(app);
-        const [url, init] = mockFetch.mock.calls[0];
-        expect(url).toContain('/apps');
-        expect(init.method).toBe('POST');
-        expect(JSON.parse(init.body)).toEqual({ name: 'New App' });
-    });
-    it('should POST /apps/{id} for update()', async () => {
-        const app = { id: 'app-1', description: 'updated' };
-        mockJsonResponse(app);
-        const result = await api().update('app-1', { description: 'updated' });
-        expect(result).toEqual(app);
-        const [url, init] = mockFetch.mock.calls[0];
-        expect(url).toContain('/apps/app-1');
-        expect(JSON.parse(init.body)).toEqual({ description: 'updated' });
-    });
-    it('should DELETE /apps/{id} for delete()', async () => {
-        mockJsonResponse(null);
-        await api().delete('app-1');
-        const [url, init] = mockFetch.mock.calls[0];
-        expect(url).toContain('/apps/app-1');
-        expect(init.method).toBe('DELETE');
-    });
-    it('should POST /apps/{id}/versions/list for listVersions()', async () => {
-        const versions = { items: [{ id: 'ver-1' }], next_cursor: null };
-        mockJsonResponse(versions);
-        const result = await api().listVersions('app-1', { limit: 20 });
-        expect(result).toEqual(versions);
-        const [url, init] = mockFetch.mock.calls[0];
-        expect(url).toContain('/apps/app-1/versions/list');
-        expect(JSON.parse(init.body)).toEqual({ limit: 20 });
-    });
-    it('should POST visibility for updateVisibility()', async () => {
-        const app = { id: 'app-1', visibility: 'private' };
-        mockJsonResponse(app);
-        await api().updateVisibility('app-1', 'private');
-        const [, init] = mockFetch.mock.calls[0];
-        expect(JSON.parse(init.body)).toEqual({ visibility: 'private' });
-    });
-    it('should GET /apps/{id}/license for getLicense()', async () => {
-        const license = { app_id: 'app-1', license: 'MIT' };
-        mockJsonResponse(license);
-        const result = await api().getLicense('app-1');
-        expect(result).toEqual(license);
-        const [url] = mockFetch.mock.calls[0];
-        expect(url).toContain('/apps/app-1/license');
-    });
-});

package/dist/api/chats.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/api/chats.test.js

@@ -1,85 +0,0 @@
-import { HttpClient } from '../http/client';
-import { ChatsAPI } from './chats';
-const mockFetch = jest.fn();
-global.fetch = mockFetch;
-function mockJsonResponse(body) {
-    mockFetch.mockResolvedValueOnce({
-        ok: true,
-        status: 200,
-        text: () => Promise.resolve(JSON.stringify(body)),
-    });
-}
-describe('ChatsAPI', () => {
-    beforeEach(() => {
-        jest.clearAllMocks();
-    });
-    const api = () => new ChatsAPI(new HttpClient({ apiKey: 'test-key' }));
-    it('should GET /chats/{id}/trace for getTrace()', async () => {
-        const trace = { chat_id: 'chat-1', spans: [] };
-        mockJsonResponse(trace);
-        const result = await api().getTrace('chat-1');
-        expect(result).toEqual(trace);
-        const [url, init] = mockFetch.mock.calls[0];
-        expect(url).toContain('/chats/chat-1/trace');
-        expect(init.method).toBe('GET');
-    });
-    it('should DELETE /chats/{id} for delete()', async () => {
-        mockJsonResponse(null);
-        await api().delete('chat-9');
-        const [url, init] = mockFetch.mock.calls[0];
-        expect(url).toContain('/chats/chat-9');
-        expect(init.method).toBe('DELETE');
-    });
-    it('should POST /chats/list for list()', async () => {
-        const page = { items: [{ id: 'chat-1' }], next_cursor: null };
-        mockJsonResponse(page);
-        const result = await api().list({ limit: 25 });
-        expect(result).toEqual(page);
-        const [url, init] = mockFetch.mock.calls[0];
-        expect(url).toContain('/chats/list');
-        expect(init.method).toBe('POST');
-        expect(JSON.parse(init.body)).toEqual({ limit: 25 });
-    });
-    it('should GET /chats/{id} for get()', async () => {
-        const chat = { id: 'chat-1', status: 'open' };
-        mockJsonResponse(chat);
-        const result = await api().get('chat-1');
-        expect(result).toEqual(chat);
-        const [url, init] = mockFetch.mock.calls[0];
-        expect(url).toContain('/chats/chat-1');
-        expect(init.method).toBe('GET');
-    });
-    it('should POST /chats/{id} for update()', async () => {
-        const chat = { id: 'chat-1', name: 'Renamed' };
-        mockJsonResponse(chat);
-        const result = await api().update('chat-1', { name: 'Renamed' });
-        expect(result).toEqual(chat);
-        const [, init] = mockFetch.mock.calls[0];
-        expect(JSON.parse(init.body)).toEqual({ name: 'Renamed' });
-    });
-    it('should GET /chats/{id}/status for getStatus()', async () => {
-        mockJsonResponse({ status: 'busy' });
-        const result = await api().getStatus('chat-1');
-        expect(result).toEqual({ status: 'busy' });
-        const [url, init] = mockFetch.mock.calls[0];
-        expect(url).toContain('/chats/chat-1/status');
-        expect(init.method).toBe('GET');
-    });
-    it('should POST /chats/{id}/stop for stop()', async () => {
-        mockJsonResponse(null);
-        await api().stop('chat-1');
-        const [url, init] = mockFetch.mock.calls[0];
-        expect(url).toContain('/chats/chat-1/stop');
-        expect(init.method).toBe('POST');
-    });
-    it('should open SSE on /chats/{id}/stream for stream()', async () => {
-        const http = new HttpClient({ apiKey: 'test-key' });
-        const createEventSource = jest
-            .spyOn(http, 'createEventSource')
-            .mockResolvedValue(null);
-        const chats = new ChatsAPI(http);
-        await chats.stream('chat-42');
-        expect(createEventSource).toHaveBeenCalledWith('/chats/chat-42/stream');
-        createEventSource.mockRestore();
-    });
-});

package/dist/api/engines.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/api/engines.test.js

@@ -1,133 +0,0 @@
-import { HttpClient } from '../http/client';
-import { EnginesAPI } from './engines';
-const mockFetch = jest.fn();
-global.fetch = mockFetch;
-function mockJsonResponse(body) {
-    mockFetch.mockResolvedValueOnce({
-        ok: true,
-        status: 200,
-        text: () => Promise.resolve(JSON.stringify(body)),
-    });
-}
-describe('EnginesAPI', () => {
-    beforeEach(() => {
-        jest.clearAllMocks();
-    });
-    const api = () => new EnginesAPI(new HttpClient({ apiKey: 'test-key' }));
-    it('should POST resource ids for getForResources()', async () => {
-        const engines = [{ id: 'eng-1' }];
-        mockJsonResponse(engines);
-        const result = await api().getForResources({
-            app_ids: ['app-1'],
-            agent_ids: ['agent-1'],
-        });
-        expect(result).toEqual(engines);
-        const [url, init] = mockFetch.mock.calls[0];
-        expect(url).toContain('/engines/resources');
-        expect(JSON.parse(init.body)).toEqual({
-            app_ids: ['app-1'],
-            agent_ids: ['agent-1'],
-        });
-    });
-    it('should POST /engines/{id}/stop for stop()', async () => {
-        mockJsonResponse(null);
-        await api().stop('eng-1');
-        const [url, init] = mockFetch.mock.calls[0];
-        expect(url).toContain('/engines/eng-1/stop');
-        expect(init.method).toBe('POST');
-    });
-    it('should POST /engines/{id}/restart for restart()', async () => {
-        mockJsonResponse(null);
-        await api().restart('eng-1');
-        const [url] = mockFetch.mock.calls[0];
-        expect(url).toContain('/engines/eng-1/restart');
-    });
-    it('should open SSE on /engines/{id}/stream for stream()', async () => {
-        const http = new HttpClient({ apiKey: 'test-key' });
-        const createEventSource = jest
-            .spyOn(http, 'createEventSource')
-            .mockResolvedValue(null);
-        const engines = new EnginesAPI(http);
-        await engines.stream('eng-7');
-        expect(createEventSource).toHaveBeenCalledWith('/engines/eng-7/stream');
-        createEventSource.mockRestore();
-    });
-    it('should POST /engines/list for list()', async () => {
-        const page = { items: [{ id: 'eng-1' }], next_cursor: null };
-        mockJsonResponse(page);
-        const result = await api().list();
-        expect(result).toEqual(page);
-        const [url, init] = mockFetch.mock.calls[0];
-        expect(url).toContain('/engines/list');
-        expect(init.method).toBe('POST');
-    });
-    it('should GET /engines/{id} for get()', async () => {
-        const engine = { id: 'eng-1' };
-        mockJsonResponse(engine);
-        const result = await api().get('eng-1');
-        expect(result).toEqual(engine);
-        const [url, init] = mockFetch.mock.calls[0];
-        expect(url).toContain('/engines/eng-1');
-        expect(init.method).toBe('GET');
-    });
-    it('should POST /engines for create()', async () => {
-        const engine = { id: 'eng-new', name: 'worker' };
-        mockJsonResponse(engine);
-        const result = await api().create({ name: 'worker' });
-        expect(result).toEqual(engine);
-        const [url, init] = mockFetch.mock.calls[0];
-        expect(url).toContain('/engines');
-        expect(init.method).toBe('POST');
-        expect(JSON.parse(init.body)).toEqual({ name: 'worker' });
-    });
-    it('should POST /engines/{id} for update()', async () => {
-        const engine = { id: 'eng-1', name: 'updated' };
-        mockJsonResponse(engine);
-        const result = await api().update('eng-1', { name: 'updated' });
-        expect(result).toEqual(engine);
-        const [, init] = mockFetch.mock.calls[0];
-        expect(JSON.parse(init.body)).toEqual({ name: 'updated' });
-    });
-    it('should DELETE /engines/{id} for delete()', async () => {
-        mockJsonResponse(null);
-        await api().delete('eng-1');
-        const [url, init] = mockFetch.mock.calls[0];
-        expect(url).toContain('/engines/eng-1');
-        expect(init.method).toBe('DELETE');
-    });
-    it('should POST visibility for updateVisibility()', async () => {
-        const engine = { id: 'eng-1', visibility: 'team' };
-        mockJsonResponse(engine);
-        await api().updateVisibility('eng-1', 'team');
-        const [, init] = mockFetch.mock.calls[0];
-        expect(JSON.parse(init.body)).toEqual({ visibility: 'team' });
-    });
-    it('should POST transfer with team_id for transferOwnership()', async () => {
-        const engine = { id: 'eng-1' };
-        mockJsonResponse(engine);
-        await api().transferOwnership('eng-1', 'team-7');
-        const [, init] = mockFetch.mock.calls[0];
-        expect(JSON.parse(init.body)).toEqual({ team_id: 'team-7' });
-    });
-    it('should POST /engines/{id}/extend for extend()', async () => {
-        mockJsonResponse(null);
-        await api().extend('eng-1');
-        const [url, init] = mockFetch.mock.calls[0];
-        expect(url).toContain('/engines/eng-1/extend');
-        expect(init.method).toBe('POST');
-    });
-    it('should POST /engines/{id}/drain for drain()', async () => {
-        mockJsonResponse(null);
-        await api().drain('eng-1');
-        const [url, init] = mockFetch.mock.calls[0];
-        expect(url).toContain('/engines/eng-1/drain');
-        expect(init.method).toBe('POST');
-    });
-    it('should POST /engines/{id}/update for updateBinary()', async () => {
-        mockJsonResponse(null);
-        await api().updateBinary('eng-1');
-        const [url, init] = mockFetch.mock.calls[0];
-        expect(url).toContain('/engines/eng-1/update');
-        expect(init.method).toBe('POST');
-    });
-});

package/dist/api/files.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/api/files.test.js

@@ -1,256 +0,0 @@
-import { HttpClient } from '../http/client';
-import { FilesAPI } from './files';
-const mockFetch = jest.fn();
-global.fetch = mockFetch;
-function mockJsonResponse(body) {
-    mockFetch.mockResolvedValueOnce({
-        ok: true,
-        status: 200,
-        text: () => Promise.resolve(JSON.stringify(body)),
-    });
-}
-describe('FilesAPI', () => {
-    beforeEach(() => {
-        jest.clearAllMocks();
-    });
-    const api = () => new FilesAPI(new HttpClient({ apiKey: 'test-key' }));
-    it('should POST /files/list for list()', async () => {
-        const page = { items: [{ id: 'file-1' }], next_cursor: null };
-        mockJsonResponse(page);
-        const result = await api().list({ limit: 10 });
-        expect(result).toEqual(page);
-        const [url, init] = mockFetch.mock.calls[0];
-        expect(url).toContain('/files/list');
-        expect(init.method).toBe('POST');
-        expect(JSON.parse(init.body)).toEqual({ limit: 10 });
-    });
-    it('should GET /files/{id} for get()', async () => {
-        const file = { id: 'file-1', uri: 'inf://files/abc' };
-        mockJsonResponse(file);
-        const result = await api().get('file-1');
-        expect(result).toEqual(file);
-        const [url, init] = mockFetch.mock.calls[0];
-        expect(url).toContain('/files/file-1');
-        expect(init.method).toBe('GET');
-    });
-    it('should DELETE /files/{id} for delete()', async () => {
-        mockJsonResponse(null);
-        await api().delete('file-1');
-        const [url, init] = mockFetch.mock.calls[0];
-        expect(url).toContain('/files/file-1');
-        expect(init.method).toBe('DELETE');
-    });
-    describe('processInput', () => {
-        it('should return falsy inputs unchanged without uploading', async () => {
-            await expect(api().processInput(null)).resolves.toBeNull();
-            await expect(api().processInput(undefined)).resolves.toBeUndefined();
-            await expect(api().processInput(0)).resolves.toBe(0);
-            await expect(api().processInput(false)).resolves.toBe(false);
-            await expect(api().processInput('')).resolves.toBe('');
-            expect(mockFetch).not.toHaveBeenCalled();
-        });
-        it('should not treat short plain strings as base64 file uploads', async () => {
-            const result = await api().processInput({ key: 'key1', note: 'hello' });
-            expect(result).toEqual({ key: 'key1', note: 'hello' });
-            expect(mockFetch).not.toHaveBeenCalled();
-        });
-        it('should upload data URIs embedded in nested objects', async () => {
-            const fileRecord = {
-                id: 'file-1',
-                uri: 'inf://files/abc',
-                upload_url: 'https://upload.example.com/put',
-                content_type: 'image/png',
-            };
-            mockJsonResponse([fileRecord]);
-            mockFetch.mockResolvedValueOnce({ ok: true, status: 200 });
-            const input = {
-                prompt: 'draw',
-                image: 'data:image/png;base64,iVBORw0KGgo=',
-            };
-            const result = (await api().processInput(input));
-            expect(result.prompt).toBe('draw');
-            expect(result.image).toBe('inf://files/abc');
-            expect(mockFetch).toHaveBeenCalledTimes(2);
-        });
-        it('should upload top-level Blob values', async () => {
-            const fileRecord = {
-                id: 'file-blob',
-                uri: 'inf://files/blob',
-                upload_url: 'https://upload.example.com/put',
-                content_type: 'image/png',
-            };
-            mockJsonResponse([fileRecord]);
-            mockFetch.mockResolvedValueOnce({ ok: true, status: 200 });
-            const blob = new Blob(['png-bytes'], { type: 'image/png' });
-            const result = await api().processInput(blob);
-            expect(result).toBe('inf://files/blob');
-            expect(mockFetch).toHaveBeenCalledTimes(2);
-        });
-        it('should process arrays recursively', async () => {
-            const fileRecord = {
-                id: 'file-arr',
-                uri: 'inf://files/arr',
-                upload_url: 'https://upload.example.com/put',
-                content_type: 'image/png',
-            };
-            mockJsonResponse([fileRecord]);
-            mockFetch.mockResolvedValueOnce({ ok: true, status: 200 });
-            const input = ['plain', 'data:image/png;base64,iVBORw0KGgo='];
-            const result = (await api().processInput(input));
-            expect(result[0]).toBe('plain');
-            expect(result[1]).toBe('inf://files/arr');
-        });
-        it('should upload long raw base64 strings', async () => {
-            const fileRecord = {
-                id: 'file-b64',
-                uri: 'inf://files/b64',
-                upload_url: 'https://upload.example.com/put',
-                content_type: 'application/octet-stream',
-            };
-            mockJsonResponse([fileRecord]);
-            mockFetch.mockResolvedValueOnce({ ok: true, status: 200 });
-            const rawBase64 = 'A'.repeat(64);
-            const result = await api().processInput(rawBase64);
-            expect(result).toBe('inf://files/b64');
-            expect(mockFetch).toHaveBeenCalledTimes(2);
-        });
-    });
-    describe('upload', () => {
-        it('should reject invalid data URI format when uploading content', async () => {
-            mockJsonResponse([{ id: 'file-x', uri: '', upload_url: 'https://upload.example.com/put' }]);
-            await expect(api().upload('data:invalid')).rejects.toThrow('Invalid data URI format');
-        });
-        it('should decode URL-encoded (non-base64) data URIs', async () => {
-            const fileRecord = {
-                id: 'file-3',
-                uri: 'inf://files/url-encoded',
-                upload_url: 'https://upload.example.com/put',
-                content_type: 'text/plain',
-            };
-            mockJsonResponse([fileRecord]);
-            mockFetch.mockResolvedValueOnce({ ok: true, status: 200 });
-            const result = await api().upload('data:text/plain,Hello%20World');
-            expect(result.uri).toBe('inf://files/url-encoded');
-            const putCall = mockFetch.mock.calls[1];
-            expect(putCall[1]?.headers).toMatchObject({ 'Content-Type': 'text/plain' });
-        });
-        it('should default media type to text/plain for data URIs without explicit type', async () => {
-            const fileRecord = {
-                id: 'file-4',
-                uri: 'inf://files/default-mt',
-                upload_url: 'https://upload.example.com/put',
-                content_type: 'text/plain',
-            };
-            mockJsonResponse([fileRecord]);
-            mockFetch.mockResolvedValueOnce({ ok: true, status: 200 });
-            await api().upload('data:;base64,SGVsbG8=');
-            const putCall = mockFetch.mock.calls[1];
-            expect(putCall[1]?.headers).toMatchObject({ 'Content-Type': 'text/plain' });
-        });
-        it('should throw when server does not return upload_url', async () => {
-            mockJsonResponse([{ id: 'file-x', uri: '', upload_url: undefined }]);
-            await expect(api().upload('data:text/plain,hello')).rejects.toThrow('No upload URL provided by the server');
-        });
-        it('should throw when PUT to upload_url fails', async () => {
-            const fileRecord = {
-                id: 'file-5',
-                uri: 'inf://files/fail-put',
-                upload_url: 'https://upload.example.com/put',
-                content_type: 'text/plain',
-            };
-            mockJsonResponse([fileRecord]);
-            mockFetch.mockResolvedValueOnce({
-                ok: false,
-                status: 500,
-                statusText: 'Internal Server Error',
-            });
-            await expect(api().upload('data:text/plain,hello')).rejects.toThrow('Failed to upload file content');
-        });
-        it('should upload Blob content with inferred content type and size', async () => {
-            const fileRecord = {
-                id: 'file-blob',
-                uri: 'inf://files/blob-direct',
-                upload_url: 'https://upload.example.com/put',
-                content_type: 'image/jpeg',
-            };
-            mockJsonResponse([fileRecord]);
-            mockFetch.mockResolvedValueOnce({ ok: true, status: 200 });
-            const blob = new Blob(['jpeg-bytes'], { type: 'image/jpeg' });
-            const result = await api().upload(blob, { filename: 'photo.jpg' });
-            expect(result.uri).toBe('inf://files/blob-direct');
-            const [, createInit] = mockFetch.mock.calls[0];
-            const createBody = JSON.parse(createInit.body);
-            expect(createBody.files[0]).toMatchObject({
-                filename: 'photo.jpg',
-                content_type: 'image/jpeg',
-                size: blob.size,
-            });
-            const [, putInit] = mockFetch.mock.calls[1];
-            expect(putInit.method).toBe('PUT');
-            expect(putInit.body).toBe(blob);
-            expect(putInit.headers).toMatchObject({ 'Content-Type': 'image/jpeg' });
-        });
-        it('should extract filename from File objects when options.filename is omitted', async () => {
-            const fileRecord = {
-                id: 'file-named',
-                uri: 'inf://files/named',
-                upload_url: 'https://upload.example.com/put',
-                content_type: 'application/pdf',
-            };
-            mockJsonResponse([fileRecord]);
-            mockFetch.mockResolvedValueOnce({ ok: true, status: 200 });
-            const file = new File(['pdf-bytes'], 'report.pdf', { type: 'application/pdf' });
-            await api().upload(file);
-            const [, createInit] = mockFetch.mock.calls[0];
-            const createBody = JSON.parse(createInit.body);
-            expect(createBody.files[0].filename).toBe('report.pdf');
-            expect(createBody.files[0].content_type).toBe('application/pdf');
-        });
-        it('should use explicit contentType when Blob type is empty', async () => {
-            const fileRecord = {
-                id: 'file-octet',
-                uri: 'inf://files/octet',
-                upload_url: 'https://upload.example.com/put',
-                content_type: 'application/octet-stream',
-            };
-            mockJsonResponse([fileRecord]);
-            mockFetch.mockResolvedValueOnce({ ok: true, status: 200 });
-            const blob = new Blob(['raw']);
-            await api().upload(blob, { contentType: 'application/octet-stream' });
-            const [, createInit] = mockFetch.mock.calls[0];
-            const createBody = JSON.parse(createInit.body);
-            expect(createBody.files[0].content_type).toBe('application/octet-stream');
-        });
-        it('should upload clean base64 strings without a data URI prefix', async () => {
-            const fileRecord = {
-                id: 'file-b64-direct',
-                uri: 'inf://files/b64-direct',
-                upload_url: 'https://upload.example.com/put',
-                content_type: 'text/plain',
-            };
-            mockJsonResponse([fileRecord]);
-            mockFetch.mockResolvedValueOnce({ ok: true, status: 200 });
-            const result = await api().upload('SGVsbG8=', { contentType: 'text/plain' });
-            expect(result.uri).toBe('inf://files/b64-direct');
-            const [, putInit] = mockFetch.mock.calls[1];
-            expect(putInit.headers).toMatchObject({ 'Content-Type': 'text/plain' });
-        });
-        it('should decode URL-safe base64 in data URIs', async () => {
-            const fileRecord = {
-                id: 'file-2',
-                uri: 'inf://files/def',
-                upload_url: 'https://upload.example.com/put',
-                content_type: 'text/plain',
-            };
-            mockJsonResponse([fileRecord]);
-            mockFetch.mockResolvedValueOnce({ ok: true, status: 200 });
-            // "SGVsbG8" is "Hello" in standard base64; URL-safe variant uses '-' instead of '+'
-            const dataUri = 'data:text/plain;base64,SGVsbG8';
-            const result = await api().upload(dataUri);
-            expect(result.uri).toBe('inf://files/def');
-            const putCall = mockFetch.mock.calls[1];
-            expect(putCall[0]).toBe('https://upload.example.com/put');
-            expect(putCall[1]?.method).toBe('PUT');
-        });
-    });
-});