@inferencesh/sdk 0.6.12 → 0.6.13

package/dist/api/knowledge.test.js

@@ -50,6 +50,55 @@ describe('KnowledgeAPI', () => {
         expect(url).toContain('/knowledge/know-1/transfer');
         expect(JSON.parse(init.body)).toEqual({ team_id: 'team-5' });
     });
+    it('should GET /knowledge/{id} for get()', async () => {
+        const entry = { id: 'know-1', name: 'docs' };
+        mockJsonResponse(entry);
+        const result = await api().get('know-1');
+        expect(result).toEqual(entry);
+        const [url, init] = mockFetch.mock.calls[0];
+        expect(url).toContain('/knowledge/know-1');
+        expect(init.method).toBe('GET');
+    });
+    it('should POST /knowledge/{id} for update()', async () => {
+        const entry = { id: 'know-1', name: 'updated' };
+        mockJsonResponse(entry);
+        const result = await api().update('know-1', { name: 'updated' });
+        expect(result).toEqual(entry);
+        const [, init] = mockFetch.mock.calls[0];
+        expect(JSON.parse(init.body)).toEqual({ name: 'updated' });
+    });
+    it('should DELETE /knowledge/{id} for delete()', async () => {
+        mockJsonResponse(null);
+        await api().delete('know-1');
+        const [url, init] = mockFetch.mock.calls[0];
+        expect(url).toContain('/knowledge/know-1');
+        expect(init.method).toBe('DELETE');
+    });
+    it('should POST /knowledge/{id}/versions/list for listVersions()', async () => {
+        const page = { items: [{ id: 'ver-1' }], next_cursor: null };
+        mockJsonResponse(page);
+        const result = await api().listVersions('know-1', { limit: 10 });
+        expect(result).toEqual(page);
+        const [url, init] = mockFetch.mock.calls[0];
+        expect(url).toContain('/knowledge/know-1/versions/list');
+        expect(JSON.parse(init.body)).toEqual({ limit: 10 });
+    });
+    it('should GET /knowledge/{id}/versions/{versionId} for getVersion()', async () => {
+        const version = { id: 'ver-1', knowledge_id: 'know-1' };
+        mockJsonResponse(version);
+        const result = await api().getVersion('know-1', 'ver-1');
+        expect(result).toEqual(version);
+        const [url, init] = mockFetch.mock.calls[0];
+        expect(url).toContain('/knowledge/know-1/versions/ver-1');
+        expect(init.method).toBe('GET');
+    });
+    it('should POST visibility for updateVisibility()', async () => {
+        const entry = { id: 'know-1', visibility: 'team' };
+        mockJsonResponse(entry);
+        await api().updateVisibility('know-1', 'team');
+        const [, init] = mockFetch.mock.calls[0];
+        expect(JSON.parse(init.body)).toEqual({ visibility: 'team' });
+    });
 });
 describe('SkillsAPI', () => {
     beforeEach(() => {
@@ -91,4 +140,99 @@ describe('SkillsAPI', () => {
         expect(url).toContain('/store/skills/list');
         expect(init.method).toBe('POST');
     });
+    it('should GET /skills/resolve with ref only when skill is omitted', async () => {
+        const resolved = { ref: 'acme/skill@v1' };
+        mockJsonResponse(resolved);
+        const result = await api().resolve('acme/skill@v1');
+        expect(result).toEqual(resolved);
+        const [url] = mockFetch.mock.calls[0];
+        expect(url).toContain('/skills/resolve');
+        expect(url).toContain('ref=acme');
+        expect(url).not.toContain('skill=');
+    });
+    it('should GET /skills/{namespace}/{name}/content for getContent()', async () => {
+        mockJsonResponse({ body: '# Skill instructions' });
+        const result = await api().getContent('acme', 'research');
+        expect(result).toEqual({ body: '# Skill instructions' });
+        const [url, init] = mockFetch.mock.calls[0];
+        expect(url).toContain('/skills/acme/research/content');
+        expect(init.method).toBe('GET');
+    });
+    it('should POST team_id for transferOwnership()', async () => {
+        const skill = { id: 'skill-1' };
+        mockJsonResponse(skill);
+        await api().transferOwnership('skill-1', 'team-8');
+        const [url, init] = mockFetch.mock.calls[0];
+        expect(url).toContain('/skills/skill-1/transfer');
+        expect(JSON.parse(init.body)).toEqual({ team_id: 'team-8' });
+    });
+    it('should POST /skills/list for list()', async () => {
+        const page = { items: [{ id: 'skill-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('/skills/list');
+        expect(init.method).toBe('POST');
+    });
+    it('should GET /skills/{id} for get()', async () => {
+        const skill = { id: 'skill-1', name: 'research' };
+        mockJsonResponse(skill);
+        const result = await api().get('skill-1');
+        expect(result).toEqual(skill);
+        const [url, init] = mockFetch.mock.calls[0];
+        expect(url).toContain('/skills/skill-1');
+        expect(init.method).toBe('GET');
+    });
+    it('should POST /skills for create()', async () => {
+        const payload = { namespace: 'acme', name: 'research' };
+        const skill = { id: 'skill-new', ...payload };
+        mockJsonResponse(skill);
+        const result = await api().create(payload);
+        expect(result).toEqual(skill);
+        const [url, init] = mockFetch.mock.calls[0];
+        expect(url).toContain('/skills');
+        expect(init.method).toBe('POST');
+        expect(JSON.parse(init.body)).toEqual(payload);
+    });
+    it('should POST /skills/{id} for update()', async () => {
+        const skill = { id: 'skill-1', name: 'updated' };
+        mockJsonResponse(skill);
+        const result = await api().update('skill-1', { name: 'updated' });
+        expect(result).toEqual(skill);
+        const [, init] = mockFetch.mock.calls[0];
+        expect(JSON.parse(init.body)).toEqual({ name: 'updated' });
+    });
+    it('should DELETE /skills/{id} for delete()', async () => {
+        mockJsonResponse(null);
+        await api().delete('skill-1');
+        const [url, init] = mockFetch.mock.calls[0];
+        expect(url).toContain('/skills/skill-1');
+        expect(init.method).toBe('DELETE');
+    });
+    it('should POST /skills/{id}/versions/list for listVersions()', async () => {
+        const page = { items: [{ id: 'ver-1' }], next_cursor: null };
+        mockJsonResponse(page);
+        const result = await api().listVersions('skill-1', { limit: 5 });
+        expect(result).toEqual(page);
+        const [url, init] = mockFetch.mock.calls[0];
+        expect(url).toContain('/skills/skill-1/versions/list');
+        expect(JSON.parse(init.body)).toEqual({ limit: 5 });
+    });
+    it('should GET /skills/{id}/versions/{versionId} for getVersion()', async () => {
+        const version = { id: 'ver-1', skill_id: 'skill-1' };
+        mockJsonResponse(version);
+        const result = await api().getVersion('skill-1', 'ver-1');
+        expect(result).toEqual(version);
+        const [url, init] = mockFetch.mock.calls[0];
+        expect(url).toContain('/skills/skill-1/versions/ver-1');
+        expect(init.method).toBe('GET');
+    });
+    it('should POST visibility for updateVisibility()', async () => {
+        const skill = { id: 'skill-1', visibility: 'team' };
+        mockJsonResponse(skill);
+        await api().updateVisibility('skill-1', 'team');
+        const [, init] = mockFetch.mock.calls[0];
+        expect(JSON.parse(init.body)).toEqual({ visibility: 'team' });
+    });
 });

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/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({
@@ -201,6 +218,26 @@ describe('TasksAPI.run (streaming mode)', () => {
         expect(onPartialUpdate).toHaveBeenCalledWith(expect.objectContaining({ id: 'task-1', status: TaskStatusCompleted }), ['status']);
     });
 });
+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(() => {
         jest.clearAllMocks();

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/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/nextjs.test.d.ts

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