@inferencesh/sdk 0.6.12 → 0.6.14

package/dist/api/mcp-servers.test.js

@@ -61,4 +61,38 @@ describe('MCPServersAPI', () => {
         expect(url).toContain('/mcp-servers/mcp-1');
         expect(init.method).toBe('PUT');
     });
+    it('should GET /mcps/{slug} for get()', async () => {
+        const server = { slug: 'filesystem', name: 'Filesystem MCP' };
+        mockJsonResponse(server);
+        const result = await api().get('filesystem');
+        expect(result).toEqual(server);
+        const [url, init] = mockFetch.mock.calls[0];
+        expect(url).toContain('/mcps/filesystem');
+        expect(init.method).toBe('GET');
+    });
+    it('should POST /mcp-servers/list for listOwned()', async () => {
+        const page = { items: [{ id: 'mcp-1' }], next_cursor: null };
+        mockJsonResponse(page);
+        const result = await api().listOwned({ limit: 5 });
+        expect(result).toEqual(page);
+        const [url, init] = mockFetch.mock.calls[0];
+        expect(url).toContain('/mcp-servers/list');
+        expect(init.method).toBe('POST');
+    });
+    it('should GET /mcp-servers/{id} for getOwned()', async () => {
+        const server = { id: 'mcp-1', name: 'My MCP' };
+        mockJsonResponse(server);
+        const result = await api().getOwned('mcp-1');
+        expect(result).toEqual(server);
+        const [url, init] = mockFetch.mock.calls[0];
+        expect(url).toContain('/mcp-servers/mcp-1');
+        expect(init.method).toBe('GET');
+    });
+    it('should DELETE /mcp-servers/{id} for delete()', async () => {
+        mockJsonResponse(null);
+        await api().delete('mcp-1');
+        const [url, init] = mockFetch.mock.calls[0];
+        expect(url).toContain('/mcp-servers/mcp-1');
+        expect(init.method).toBe('DELETE');
+    });
 });

package/dist/api/projects.test.js

@@ -49,4 +49,13 @@ describe('ProjectsAPI', () => {
         expect(url).toContain('/projects/proj-1');
         expect(init.method).toBe('DELETE');
     });
+    it('should POST /projects/{id} for update()', async () => {
+        const project = { id: 'proj-1', name: 'Renamed' };
+        mockJsonResponse(project);
+        const result = await api().update('proj-1', { name: 'Renamed' });
+        expect(result).toEqual(project);
+        const [url, init] = mockFetch.mock.calls[0];
+        expect(url).toContain('/projects/proj-1');
+        expect(JSON.parse(init.body)).toEqual({ name: 'Renamed' });
+    });
 });

package/dist/api/search.test.js

@@ -25,6 +25,17 @@ describe('SearchAPI', () => {
         expect(init.method).toBe('POST');
         expect(JSON.parse(init.body)).toEqual(payload);
     });
+    it('should forward conversation context in suggest() body', async () => {
+        const payload = {
+            query: 'flux',
+            context: 'previous conversation about image generation',
+            limit: 5,
+        };
+        mockJsonResponse({ results: [] });
+        await api().suggest(payload);
+        const [, init] = mockFetch.mock.calls[0];
+        expect(JSON.parse(init.body)).toEqual(payload);
+    });
     it('should POST /search for search()', async () => {
         const payload = { q: 'claude', type: 'apps', limit: 5 };
         const response = { hits: [{ id: 'app-1' }] };

package/dist/api/sessions.test.js

@@ -23,6 +23,18 @@ describe('SessionsAPI', () => {
         expect(url).toContain('/sessions/sess_1');
         expect(init.method).toBe('GET');
     });
+    it('should GET /sessions and return session list', async () => {
+        const sessions = [
+            { id: 'sess_1', status: 'active' },
+            { id: 'sess_2', status: 'active' },
+        ];
+        mockJsonResponse(sessions);
+        const result = await api().list();
+        expect(result).toEqual(sessions);
+        const [url, init] = mockFetch.mock.calls[0];
+        expect(url).toContain('/sessions');
+        expect(init.method).toBe('GET');
+    });
     it('should return an empty array when list() response is null', async () => {
         mockJsonResponse(null);
         const result = await api().list();

package/dist/api/tasks.test.js

@@ -188,6 +188,23 @@ describe('TasksAPI.run (streaming mode)', () => {
         ]);
         await expect(api().run({ app: 'test-app', input: {} }, {}, { wait: true })).rejects.toThrow('task cancelled');
     });
+    it('should reject when the NDJSON stream connection fails', async () => {
+        mockFetch.mockImplementation((url) => {
+            if (url.includes('/apps/run')) {
+                return Promise.resolve({
+                    ok: true,
+                    status: 200,
+                    text: () => Promise.resolve(JSON.stringify(makeTask())),
+                });
+            }
+            return Promise.resolve({
+                ok: false,
+                status: 503,
+                text: () => Promise.resolve('service unavailable'),
+            });
+        });
+        await expect(api().run({ app: 'test-app', input: {} }, {}, { wait: true })).rejects.toThrow('HTTP 503');
+    });
     it('should handle partial updates via onPartialUpdate', async () => {
         setupStreamMocks([
             `${JSON.stringify({
@@ -200,6 +217,47 @@ describe('TasksAPI.run (streaming mode)', () => {
         expect(result.status).toBe(TaskStatusCompleted);
         expect(onPartialUpdate).toHaveBeenCalledWith(expect.objectContaining({ id: 'task-1', status: TaskStatusCompleted }), ['status']);
     });
+    it('should preserve session_id across partial stream updates that omit it', async () => {
+        setupStreamMocks([
+            `${JSON.stringify({
+                data: { status: TaskStatusRunning, id: 'task-1' },
+                fields: ['status'],
+            })}\n`,
+            `${JSON.stringify({
+                data: { status: TaskStatusCompleted, id: 'task-1', output: { ok: true } },
+                fields: ['status', 'output'],
+            })}\n`,
+        ], makeTask({ session_id: 'sess-persist' }));
+        const onPartialUpdate = jest.fn();
+        const result = await api().run({ app: 'test-app', input: {} }, {}, { wait: true, onPartialUpdate });
+        expect(result.session_id).toBe('sess-persist');
+        expect(onPartialUpdate).toHaveBeenCalledWith(expect.objectContaining({ session_id: 'sess-persist', status: TaskStatusRunning }), ['status']);
+        expect(onPartialUpdate).toHaveBeenLastCalledWith(expect.objectContaining({
+            session_id: 'sess-persist',
+            status: TaskStatusCompleted,
+            output: { ok: true },
+        }), ['status', 'output']);
+    });
+});
+describe('TasksAPI.run (HTTP contract)', () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+    const api = () => new TasksAPI(new HttpClient({ apiKey: 'test-key' }));
+    it('should POST /apps/run with merged params and processedInput', async () => {
+        const task = makeTask();
+        mockJsonResponse(task);
+        const result = await api().run({ app: 'image-gen', version_id: 'ver-2', input: {} }, { prompt: 'sunset', width: 512 }, { wait: false });
+        expect(result).toEqual(task);
+        const [url, init] = mockFetch.mock.calls[0];
+        expect(url).toContain('/apps/run');
+        expect(init.method).toBe('POST');
+        expect(JSON.parse(init.body)).toEqual({
+            app: 'image-gen',
+            version_id: 'ver-2',
+            input: { prompt: 'sunset', width: 512 },
+        });
+    });
 });
 describe('TasksAPI.create', () => {
     beforeEach(() => {

package/dist/api/teams.test.js

@@ -76,4 +76,64 @@ describe('TeamsAPI', () => {
         expect(url).toContain('/teams/team-1/invites');
         expect(JSON.parse(init.body)).toEqual(payload);
     });
+    it('should GET /teams/{id} for get()', async () => {
+        const team = { id: 'team-1', name: 'Acme' };
+        mockJsonResponse(team);
+        const result = await api().get('team-1');
+        expect(result).toEqual(team);
+        const [url, init] = mockFetch.mock.calls[0];
+        expect(url).toContain('/teams/team-1');
+        expect(init.method).toBe('GET');
+    });
+    it('should POST /teams/{id} for update()', async () => {
+        const team = { id: 'team-1', name: 'Acme Updated' };
+        mockJsonResponse(team);
+        const result = await api().update('team-1', { name: 'Acme Updated' });
+        expect(result).toEqual(team);
+        const [url, init] = mockFetch.mock.calls[0];
+        expect(url).toContain('/teams/team-1');
+        expect(JSON.parse(init.body)).toEqual({ name: 'Acme Updated' });
+    });
+    it('should DELETE /teams/{id} for delete()', async () => {
+        mockJsonResponse(null);
+        await api().delete('team-1');
+        const [url, init] = mockFetch.mock.calls[0];
+        expect(url).toContain('/teams/team-1');
+        expect(init.method).toBe('DELETE');
+    });
+    it('should GET /teams/{id}/members for getMembers()', async () => {
+        const members = [{ user_id: 'user-1', role: 'owner' }];
+        mockJsonResponse(members);
+        const result = await api().getMembers('team-1');
+        expect(result).toEqual(members);
+        const [url, init] = mockFetch.mock.calls[0];
+        expect(url).toContain('/teams/team-1/members');
+        expect(init.method).toBe('GET');
+    });
+    it('should POST /teams/{id}/members for addMember()', async () => {
+        const payload = { user_id: 'user-4', role: 'member' };
+        const member = { ...payload };
+        mockJsonResponse(member);
+        const result = await api().addMember('team-1', payload);
+        expect(result).toEqual(member);
+        const [url, init] = mockFetch.mock.calls[0];
+        expect(url).toContain('/teams/team-1/members');
+        expect(JSON.parse(init.body)).toEqual(payload);
+    });
+    it('should GET /teams/{id}/invites for listInvites()', async () => {
+        const invites = [{ id: 'inv-1', email: 'dev@example.com' }];
+        mockJsonResponse(invites);
+        const result = await api().listInvites('team-1');
+        expect(result).toEqual(invites);
+        const [url, init] = mockFetch.mock.calls[0];
+        expect(url).toContain('/teams/team-1/invites');
+        expect(init.method).toBe('GET');
+    });
+    it('should DELETE /teams/{id}/invites/{inviteId} for revokeInvite()', async () => {
+        mockJsonResponse(null);
+        await api().revokeInvite('team-1', 'inv-9');
+        const [url, init] = mockFetch.mock.calls[0];
+        expect(url).toContain('/teams/team-1/invites/inv-9');
+        expect(init.method).toBe('DELETE');
+    });
 });

package/dist/client.test.js

@@ -1,5 +1,7 @@
-import { Inference, inference } from './index';
+import { Inference, inference, createClient } from './index';
 import { RequirementsNotMetException } from './http/errors';
+import { HttpClient } from './http/client';
+import { ChatStatusBusy, ChatStatusIdle } from './types';
 // Mock fetch globally
 const mockFetch = jest.fn();
 global.fetch = mockFetch;
@@ -138,6 +140,45 @@ describe('Inference', () => {
                 expect(exception.errors[0].action?.scopes).toEqual(['calendar.readonly', 'calendar.events']);
             }
         });
+        it('should process Blob inputs via processInput before calling /apps/run', async () => {
+            const fileRecord = {
+                id: 'file-blob',
+                uri: 'inf://files/blob',
+                upload_url: 'https://upload.example.com/put',
+                content_type: 'image/png',
+            };
+            const mockTask = {
+                id: 'task-456',
+                status: 9,
+                created_at: new Date().toISOString(),
+                updated_at: new Date().toISOString(),
+                input: {},
+                output: { result: 'done' },
+            };
+            mockFetch
+                .mockResolvedValueOnce({
+                ok: true,
+                status: 200,
+                text: () => Promise.resolve(JSON.stringify([fileRecord])),
+                json: () => Promise.resolve([fileRecord]),
+            })
+                .mockResolvedValueOnce({ ok: true, status: 200 })
+                .mockResolvedValueOnce({
+                ok: true,
+                status: 200,
+                text: () => Promise.resolve(JSON.stringify(mockTask)),
+                json: () => Promise.resolve(mockTask),
+            });
+            const client = new Inference({ apiKey: 'test-api-key' });
+            const blob = new Blob(['png-bytes'], { type: 'image/png' });
+            const result = await client.run({ app: 'test-app', input: { image: blob } }, { wait: false });
+            expect(result.id).toBe('task-456');
+            expect(mockFetch).toHaveBeenCalledTimes(3);
+            const runCall = mockFetch.mock.calls.find((call) => String(call[0]).includes('/apps/run'));
+            expect(runCall).toBeDefined();
+            const runBody = JSON.parse(runCall[1].body);
+            expect(runBody.input.image).toBe('inf://files/blob');
+        });
     });
     describe('cancel', () => {
         it('should make a POST request to cancel endpoint', async () => {
@@ -153,6 +194,76 @@ describe('Inference', () => {
             expect(mockFetch).toHaveBeenCalledWith(expect.stringContaining('/tasks/task-123/cancel'), expect.objectContaining({ method: 'POST' }));
         });
     });
+    describe('legacy task helpers', () => {
+        it('should delegate getTask() to tasks.get', async () => {
+            const mockTask = { id: 'task-legacy', status: 9 };
+            mockFetch.mockResolvedValueOnce({
+                ok: true,
+                status: 200,
+                text: () => Promise.resolve(JSON.stringify(mockTask)),
+                json: () => Promise.resolve(mockTask),
+            });
+            const client = new Inference({ apiKey: 'test-api-key' });
+            const result = await client.getTask('task-legacy');
+            expect(result.id).toBe('task-legacy');
+            expect(mockFetch).toHaveBeenCalledWith(expect.stringContaining('/tasks/task-legacy'), expect.objectContaining({ method: 'GET' }));
+        });
+        it('should delegate streamTask() to tasks.stream', async () => {
+            const client = new Inference({ apiKey: 'test-api-key' });
+            const createEventSource = jest
+                .spyOn(HttpClient.prototype, 'createEventSource')
+                .mockResolvedValue(null);
+            await client.streamTask('task-stream');
+            expect(createEventSource).toHaveBeenCalledWith('/tasks/task-stream/stream');
+            createEventSource.mockRestore();
+        });
+    });
+    describe('agent()', () => {
+        it('should return an Agent whose sendMessage hits POST /agents/run', async () => {
+            mockFetch
+                .mockResolvedValueOnce({
+                ok: true,
+                status: 200,
+                text: () => Promise.resolve(JSON.stringify({
+                    user_message: { id: 'user-1', chat_id: 'chat-1', role: 'user', content: 'hi' },
+                    assistant_message: { id: 'asst-1', chat_id: 'chat-1', role: 'assistant', content: 'hello' },
+                })),
+            })
+                .mockResolvedValueOnce({
+                ok: true,
+                status: 200,
+                text: () => Promise.resolve(JSON.stringify({ status: ChatStatusBusy })),
+            })
+                .mockResolvedValueOnce({
+                ok: true,
+                status: 200,
+                text: () => Promise.resolve(JSON.stringify({ id: 'chat-1', status: ChatStatusBusy, chat_messages: [] })),
+            })
+                .mockResolvedValueOnce({
+                ok: true,
+                status: 200,
+                text: () => Promise.resolve(JSON.stringify({ status: ChatStatusIdle })),
+            })
+                .mockResolvedValueOnce({
+                ok: true,
+                status: 200,
+                text: () => Promise.resolve(JSON.stringify({ id: 'chat-1', status: ChatStatusIdle, chat_messages: [] })),
+            });
+            const client = new Inference({ apiKey: 'test-api-key', stream: false, pollIntervalMs: 20 });
+            const agentInstance = client.agent('my-agent');
+            await agentInstance.sendMessage('hi', { stream: false });
+            const runCall = mockFetch.mock.calls.find(([url]) => String(url).includes('/agents/run'));
+            expect(runCall).toBeDefined();
+            const body = JSON.parse(runCall[1].body);
+            expect(body.agent).toBe('my-agent');
+        });
+    });
+    describe('createClient', () => {
+        it('should create an Inference instance with extended HttpClient config', () => {
+            const client = createClient({ apiKey: 'extended-key', baseUrl: 'https://api.example.com' });
+            expect(client).toBeInstanceOf(Inference);
+        });
+    });
     describe('lowercase factory', () => {
         it('should export lowercase inference factory', () => {
             expect(typeof inference).toBe('function');

package/dist/http/poll.test.js

@@ -82,4 +82,65 @@ describe('PollManager', () => {
         await Promise.resolve();
         expect(onData.mock.calls.length).toBe(callsBefore);
     });
+    it('should not run overlapping polls when pollFunction is still in flight', async () => {
+        let resolvePoll = () => { };
+        const pollFunction = jest.fn().mockImplementation(() => new Promise((resolve) => {
+            resolvePoll = resolve;
+        }));
+        const manager = new PollManager({
+            pollFunction,
+            intervalMs: 100,
+        });
+        manager.start();
+        await Promise.resolve();
+        expect(pollFunction).toHaveBeenCalledTimes(1);
+        jest.advanceTimersByTime(100);
+        await Promise.resolve();
+        expect(pollFunction).toHaveBeenCalledTimes(1);
+        resolvePoll({ status: 'ok' });
+        await Promise.resolve();
+        jest.advanceTimersByTime(100);
+        await Promise.resolve();
+        expect(pollFunction).toHaveBeenCalledTimes(2);
+        manager.stop();
+    });
+    it('should ignore start() when polling is already active', async () => {
+        const onStart = jest.fn();
+        const pollFunction = jest.fn().mockResolvedValue({});
+        const manager = new PollManager({ pollFunction, onStart });
+        manager.start();
+        manager.start();
+        expect(onStart).toHaveBeenCalledTimes(1);
+        manager.stop();
+    });
+    it('should reset consecutive error count after a successful poll', async () => {
+        const onError = jest.fn();
+        const onStop = jest.fn();
+        const pollFunction = jest
+            .fn()
+            .mockRejectedValueOnce(new Error('fail 1'))
+            .mockResolvedValueOnce({ status: 'ok' })
+            .mockRejectedValueOnce(new Error('fail 2'))
+            .mockRejectedValueOnce(new Error('fail 3'));
+        const manager = new PollManager({
+            pollFunction,
+            intervalMs: 100,
+            maxRetries: 2,
+            onError,
+            onStop,
+        });
+        manager.start();
+        await Promise.resolve();
+        jest.advanceTimersByTime(100);
+        await Promise.resolve();
+        expect(onStop).not.toHaveBeenCalled();
+        expect(onError).toHaveBeenCalledTimes(1);
+        jest.advanceTimersByTime(100);
+        await Promise.resolve();
+        jest.advanceTimersByTime(100);
+        await Promise.resolve();
+        expect(onStop).toHaveBeenCalled();
+        expect(onError).toHaveBeenCalledTimes(3);
+        manager.stop();
+    });
 });

package/dist/http/streamable.test.js

@@ -152,6 +152,18 @@ describe('streamable', () => {
             }
         }).rejects.toThrow('HTTP 401: Unauthorized');
     });
+    it('should throw when the response has no body', async () => {
+        global.fetch = jest.fn().mockResolvedValue({
+            ok: true,
+            status: 200,
+            body: null,
+        });
+        await expect(async () => {
+            for await (const _ of streamable('http://test.com/stream')) {
+                // consume
+            }
+        }).rejects.toThrow('No response body');
+    });
     // Edge cases for chunking/buffering
     describe('chunking edge cases', () => {
         it('should handle message split across many chunks', async () => {
@@ -379,6 +391,68 @@ describe('StreamableManager', () => {
         await manager.start();
         expect(events).toEqual(['start', 'data', 'end']);
     });
+    it('should dispatch typed events to addEventListener subscribers', async () => {
+        global.fetch = mockFetch([
+            '{"event":"chats","data":{"id":"chat-1","status":"busy"}}\n',
+            '{"event":"chat_messages","data":{"id":"msg-1","content":"hi"}}\n',
+        ]);
+        const onChat = jest.fn();
+        const onMessage = jest.fn();
+        const manager = new StreamableManager({
+            url: 'http://test.com/stream',
+            onData: jest.fn(),
+        });
+        manager.addEventListener('chats', onChat);
+        manager.addEventListener('chat_messages', onMessage);
+        await manager.start();
+        expect(onChat).toHaveBeenCalledWith({ id: 'chat-1', status: 'busy' });
+        expect(onMessage).toHaveBeenCalledWith({ id: 'msg-1', content: 'hi' });
+    });
+    it('should stop dispatching to an unsubscribed listener', async () => {
+        global.fetch = mockFetch([
+            '{"event":"chats","data":{"id":"chat-1"}}\n',
+        ]);
+        const removedListener = jest.fn();
+        const activeListener = jest.fn();
+        const manager = new StreamableManager({
+            url: 'http://test.com/stream',
+        });
+        const unsubscribe = manager.addEventListener('chats', removedListener);
+        manager.addEventListener('chats', activeListener);
+        unsubscribe();
+        await manager.start();
+        expect(removedListener).not.toHaveBeenCalled();
+        expect(activeListener).toHaveBeenCalledWith({ id: 'chat-1' });
+    });
+    it('should ignore start() when a stream is already running', async () => {
+        let readCount = 0;
+        const mockReader = {
+            read: jest.fn().mockImplementation(async () => {
+                readCount++;
+                if (readCount > 3) {
+                    return { done: true, value: undefined };
+                }
+                await new Promise((resolve) => setTimeout(resolve, 20));
+                return { done: false, value: new TextEncoder().encode('{"id":1}\n') };
+            }),
+            releaseLock: jest.fn(),
+        };
+        global.fetch = jest.fn().mockResolvedValue({
+            ok: true,
+            body: { getReader: () => mockReader },
+        });
+        const onStart = jest.fn();
+        const manager = new StreamableManager({
+            url: 'http://test.com/stream',
+            onStart,
+            onData: () => { },
+        });
+        const firstStart = manager.start();
+        await manager.start();
+        await firstStart;
+        expect(onStart).toHaveBeenCalledTimes(1);
+        expect(global.fetch).toHaveBeenCalledTimes(1);
+    });
     it('should handle stop()', async () => {
         let readCount = 0;
         const mockReader = {
@@ -407,4 +481,30 @@ describe('StreamableManager', () => {
         // Should have stopped before reading all 10
         expect(readCount).toBeLessThan(10);
     });
+    it('should call onError when the stream request fails', async () => {
+        global.fetch = jest.fn().mockResolvedValue({
+            ok: false,
+            status: 503,
+            text: async () => 'Service unavailable',
+        });
+        const onError = jest.fn();
+        const manager = new StreamableManager({
+            url: 'http://test.com/stream',
+            onError,
+        });
+        await manager.start();
+        expect(onError).toHaveBeenCalledWith(expect.objectContaining({ message: 'HTTP 503: Service unavailable' }));
+    });
+    it('should route partial updates to onData when onPartialData is not provided', async () => {
+        global.fetch = mockFetch([
+            '{"data":{"id":1,"status":"busy"},"fields":["status"]}\n',
+        ]);
+        const onData = jest.fn();
+        const manager = new StreamableManager({
+            url: 'http://test.com/stream',
+            onData,
+        });
+        await manager.start();
+        expect(onData).toHaveBeenCalledWith({ id: 1, status: 'busy' });
+    });
 });

package/dist/proxy/hono.test.d.ts

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

package/dist/proxy/hono.test.js

@@ -0,0 +1,90 @@
+import { INF_TARGET_HEADER } from './index';
+import { createHandler } from './hono';
+function createMockContext(overrides = {}) {
+    const headers = new Headers(overrides.headers ?? {});
+    const url = overrides.url ?? 'http://localhost/api/inference/proxy';
+    return {
+        req: {
+            method: overrides.method ?? 'POST',
+            url,
+            raw: { headers },
+            header: (name) => headers.get(name) ?? undefined,
+            text: () => Promise.resolve(overrides.body ?? '{"ok":true}'),
+        },
+    };
+}
+describe('hono createHandler', () => {
+    const originalFetch = global.fetch;
+    beforeEach(() => {
+        jest.clearAllMocks();
+        process.env.INFERENCE_API_KEY = 'hono-test-key';
+    });
+    afterEach(() => {
+        global.fetch = originalFetch;
+    });
+    it('should return 400 when target URL is missing', async () => {
+        const handler = createHandler();
+        const response = await handler(createMockContext());
+        expect(response.status).toBe(400);
+        expect(await response.json()).toEqual({
+            error: `Missing ${INF_TARGET_HEADER} header or __inf_target query param`,
+        });
+    });
+    it('should proxy JSON responses', async () => {
+        global.fetch = jest.fn().mockResolvedValue(new Response(JSON.stringify({ ok: true }), {
+            status: 200,
+            headers: { 'content-type': 'application/json' },
+        }));
+        const handler = createHandler();
+        const target = 'https://api.inference.sh/v1/run';
+        const response = await handler(createMockContext({
+            headers: { [INF_TARGET_HEADER]: target },
+        }));
+        expect(response.status).toBe(200);
+        expect(await response.json()).toEqual({ ok: true });
+        expect(global.fetch).toHaveBeenCalledWith(target, expect.objectContaining({
+            headers: expect.objectContaining({
+                authorization: 'Bearer hono-test-key',
+            }),
+        }));
+    });
+    it('should passthrough SSE streaming responses', async () => {
+        const encoder = new TextEncoder();
+        const stream = new ReadableStream({
+            start(controller) {
+                controller.enqueue(encoder.encode('data: {"x":1}\n\n'));
+                controller.close();
+            },
+        });
+        global.fetch = jest.fn().mockResolvedValue(new Response(stream, {
+            status: 200,
+            headers: { 'content-type': 'text/event-stream' },
+        }));
+        const handler = createHandler();
+        const target = 'https://api.inference.sh/v1/stream';
+        const response = await handler(createMockContext({
+            headers: { [INF_TARGET_HEADER]: target },
+        }));
+        expect(response.status).toBe(200);
+        expect(response.headers.get('content-type')).toContain('text/event-stream');
+        expect(await response.text()).toContain('data:');
+    });
+    it('should resolve API key via resolveApiKey option', async () => {
+        global.fetch = jest.fn().mockResolvedValue(new Response(JSON.stringify({ ok: true }), {
+            status: 200,
+            headers: { 'content-type': 'application/json' },
+        }));
+        const handler = createHandler({
+            resolveApiKey: async () => 'custom-hono-key',
+        });
+        const target = 'https://api.inference.sh/v1/run';
+        await handler(createMockContext({
+            headers: { [INF_TARGET_HEADER]: target },
+        }));
+        expect(global.fetch).toHaveBeenCalledWith(target, expect.objectContaining({
+            headers: expect.objectContaining({
+                authorization: 'Bearer custom-hono-key',
+            }),
+        }));
+    });
+});

package/dist/proxy/index.test.js

@@ -106,6 +106,23 @@ describe('processProxyRequest', () => {
             }),
         }));
     });
+    it('should prefer client Authorization header over env API key', async () => {
+        const target = 'https://api.inference.sh/v1/tasks/1';
+        await processProxyRequest(createTestAdapter({
+            header: (name) => {
+                if (name === INF_TARGET_HEADER)
+                    return target;
+                if (name === 'authorization')
+                    return 'Bearer client-session-token';
+                return undefined;
+            },
+        }));
+        expect(global.fetch).toHaveBeenCalledWith(target, expect.objectContaining({
+            headers: expect.objectContaining({
+                authorization: 'Bearer client-session-token',
+            }),
+        }));
+    });
     it('should use query param fallback when header is missing (SSE clients)', async () => {
         const target = 'https://api.inference.sh/v1/stream';
         const encoded = encodeURIComponent(target);

package/dist/proxy/nextjs.test.d.ts

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