@huggingface/inference 3.13.2 → 3.14.0

package/dist/esm/vendor/fetch-event-source/parse.js

@@ -0,0 +1,180 @@
+/**
+ This file is a part of fetch-event-source package (as of v2.0.1)
+ https://github.com/Azure/fetch-event-source/blob/v2.0.1/src/parse.ts
+
+ Full package can be used after it is made compatible with nodejs:
+ https://github.com/Azure/fetch-event-source/issues/20
+
+ Below is the fetch-event-source package license:
+
+ MIT License
+
+ Copyright (c) Microsoft Corporation.
+
+ Permission is hereby granted, free of charge, to any person obtaining a copy
+ of this software and associated documentation files (the "Software"), to deal
+ in the Software without restriction, including without limitation the rights
+ to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ copies of the Software, and to permit persons to whom the Software is
+ furnished to do so, subject to the following conditions:
+
+ The above copyright notice and this permission notice shall be included in all
+ copies or substantial portions of the Software.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ SOFTWARE
+
+ */
+/**
+ * Converts a ReadableStream into a callback pattern.
+ * @param stream The input ReadableStream.
+ * @param onChunk A function that will be called on each new byte chunk in the stream.
+ * @returns {Promise<void>} A promise that will be resolved when the stream closes.
+ */
+export async function getBytes(stream, onChunk) {
+    const reader = stream.getReader();
+    let result;
+    while (!(result = await reader.read()).done) {
+        onChunk(result.value);
+    }
+}
+/**
+ * Parses arbitary byte chunks into EventSource line buffers.
+ * Each line should be of the format "field: value" and ends with \r, \n, or \r\n.
+ * @param onLine A function that will be called on each new EventSource line.
+ * @returns A function that should be called for each incoming byte chunk.
+ */
+export function getLines(onLine) {
+    let buffer;
+    let position; // current read position
+    let fieldLength; // length of the `field` portion of the line
+    let discardTrailingNewline = false;
+    // return a function that can process each incoming byte chunk:
+    return function onChunk(arr) {
+        if (buffer === undefined) {
+            buffer = arr;
+            position = 0;
+            fieldLength = -1;
+        }
+        else {
+            // we're still parsing the old line. Append the new bytes into buffer:
+            buffer = concat(buffer, arr);
+        }
+        const bufLength = buffer.length;
+        let lineStart = 0; // index where the current line starts
+        while (position < bufLength) {
+            if (discardTrailingNewline) {
+                if (buffer[position] === 10 /* ControlChars.NewLine */) {
+                    lineStart = ++position; // skip to next char
+                }
+                discardTrailingNewline = false;
+            }
+            // start looking forward till the end of line:
+            let lineEnd = -1; // index of the \r or \n char
+            for (; position < bufLength && lineEnd === -1; ++position) {
+                switch (buffer[position]) {
+                    case 58 /* ControlChars.Colon */:
+                        if (fieldLength === -1) { // first colon in line
+                            fieldLength = position - lineStart;
+                        }
+                        break;
+                    case 13 /* ControlChars.CarriageReturn */:
+                        discardTrailingNewline = true;
+                    // eslint-disable-next-line no-fallthrough
+                    case 10 /* ControlChars.NewLine */:
+                        lineEnd = position;
+                        break;
+                }
+            }
+            if (lineEnd === -1) {
+                // We reached the end of the buffer but the line hasn't ended.
+                // Wait for the next arr and then continue parsing:
+                break;
+            }
+            // we've reached the line end, send it out:
+            onLine(buffer.subarray(lineStart, lineEnd), fieldLength);
+            lineStart = position; // we're now on the next line
+            fieldLength = -1;
+        }
+        if (lineStart === bufLength) {
+            buffer = undefined; // we've finished reading it
+        }
+        else if (lineStart !== 0) {
+            // Create a new view into buffer beginning at lineStart so we don't
+            // need to copy over the previous lines when we get the new arr:
+            buffer = buffer.subarray(lineStart);
+            position -= lineStart;
+        }
+    };
+}
+/**
+ * Parses line buffers into EventSourceMessages.
+ * @param onId A function that will be called on each `id` field.
+ * @param onRetry A function that will be called on each `retry` field.
+ * @param onMessage A function that will be called on each message.
+ * @returns A function that should be called for each incoming line buffer.
+ */
+export function getMessages(onId, onRetry, onMessage) {
+    let message = newMessage();
+    const decoder = new TextDecoder();
+    // return a function that can process each incoming line buffer:
+    return function onLine(line, fieldLength) {
+        if (line.length === 0) {
+            // empty line denotes end of message. Trigger the callback and start a new message:
+            onMessage?.(message);
+            message = newMessage();
+        }
+        else if (fieldLength > 0) { // exclude comments and lines with no values
+            // line is of format "<field>:<value>" or "<field>: <value>"
+            // https://html.spec.whatwg.org/multipage/server-sent-events.html#event-stream-interpretation
+            const field = decoder.decode(line.subarray(0, fieldLength));
+            const valueOffset = fieldLength + (line[fieldLength + 1] === 32 /* ControlChars.Space */ ? 2 : 1);
+            const value = decoder.decode(line.subarray(valueOffset));
+            switch (field) {
+                case 'data':
+                    // if this message already has data, append the new value to the old.
+                    // otherwise, just set to the new value:
+                    message.data = message.data
+                        ? message.data + '\n' + value
+                        : value; // otherwise, 
+                    break;
+                case 'event':
+                    message.event = value;
+                    break;
+                case 'id':
+                    onId(message.id = value);
+                    break;
+                case 'retry': {
+                    const retry = parseInt(value, 10);
+                    if (!isNaN(retry)) { // per spec, ignore non-integers
+                        onRetry(message.retry = retry);
+                    }
+                    break;
+                }
+            }
+        }
+    };
+}
+function concat(a, b) {
+    const res = new Uint8Array(a.length + b.length);
+    res.set(a);
+    res.set(b, a.length);
+    return res;
+}
+function newMessage() {
+    // data, event, and id must be initialized to empty strings:
+    // https://html.spec.whatwg.org/multipage/server-sent-events.html#event-stream-interpretation
+    // retry should be initialized to undefined so we return a consistent shape
+    // to the js engine all the time: https://mathiasbynens.be/notes/shapes-ics#takeaways
+    return {
+        data: '',
+        event: '',
+        id: '',
+        retry: undefined,
+    };
+}

package/dist/esm/vendor/fetch-event-source/parse.spec.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=parse.spec.d.ts.map

package/dist/esm/vendor/fetch-event-source/parse.spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse.spec.d.ts","sourceRoot":"","sources":["../../../../src/vendor/fetch-event-source/parse.spec.ts"],"names":[],"mappings":""}

package/dist/esm/vendor/fetch-event-source/parse.spec.js

@@ -0,0 +1,335 @@
+import { expect, it, describe } from "vitest";
+const fail = (msg) => { throw new Error(msg); };
+/**
+ This file is a part of fetch-event-source package (as of v2.0.1)
+ https://github.com/Azure/fetch-event-source/blob/v2.0.1/src/parse.spec.ts
+
+ Full package can be used after it is made compatible with nodejs:
+ https://github.com/Azure/fetch-event-source/issues/20
+
+ Below is the fetch-event-source package license:
+
+ MIT License
+
+ Copyright (c) Microsoft Corporation.
+
+ Permission is hereby granted, free of charge, to any person obtaining a copy
+ of this software and associated documentation files (the "Software"), to deal
+ in the Software without restriction, including without limitation the rights
+ to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ copies of the Software, and to permit persons to whom the Software is
+ furnished to do so, subject to the following conditions:
+
+ The above copyright notice and this permission notice shall be included in all
+ copies or substantial portions of the Software.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ SOFTWARE
+
+ */
+import * as parse from './parse.js';
+describe('parse', () => {
+    const encoder = new TextEncoder();
+    const decoder = new TextDecoder();
+    describe('getLines', () => {
+        it('single line', () => {
+            // arrange:
+            let lineNum = 0;
+            const next = parse.getLines((line, fieldLength) => {
+                ++lineNum;
+                expect(decoder.decode(line)).toEqual('id: abc');
+                expect(fieldLength).toEqual(2);
+            });
+            // act:
+            next(encoder.encode('id: abc\n'));
+            // assert:
+            expect(lineNum).toBe(1);
+        });
+        it('multiple lines', () => {
+            // arrange:
+            let lineNum = 0;
+            const next = parse.getLines((line, fieldLength) => {
+                ++lineNum;
+                expect(decoder.decode(line)).toEqual(lineNum === 1 ? 'id: abc' : 'data: def');
+                expect(fieldLength).toEqual(lineNum === 1 ? 2 : 4);
+            });
+            // act:
+            next(encoder.encode('id: abc\n'));
+            next(encoder.encode('data: def\n'));
+            // assert:
+            expect(lineNum).toBe(2);
+        });
+        it('single line split across multiple arrays', () => {
+            // arrange:
+            let lineNum = 0;
+            const next = parse.getLines((line, fieldLength) => {
+                ++lineNum;
+                expect(decoder.decode(line)).toEqual('id: abc');
+                expect(fieldLength).toEqual(2);
+            });
+            // act:
+            next(encoder.encode('id: a'));
+            next(encoder.encode('bc\n'));
+            // assert:
+            expect(lineNum).toBe(1);
+        });
+        it('multiple lines split across multiple arrays', () => {
+            // arrange:
+            let lineNum = 0;
+            const next = parse.getLines((line, fieldLength) => {
+                ++lineNum;
+                expect(decoder.decode(line)).toEqual(lineNum === 1 ? 'id: abc' : 'data: def');
+                expect(fieldLength).toEqual(lineNum === 1 ? 2 : 4);
+            });
+            // act:
+            next(encoder.encode('id: ab'));
+            next(encoder.encode('c\nda'));
+            next(encoder.encode('ta: def\n'));
+            // assert:
+            expect(lineNum).toBe(2);
+        });
+        it('new line', () => {
+            // arrange:
+            let lineNum = 0;
+            const next = parse.getLines((line, fieldLength) => {
+                ++lineNum;
+                expect(decoder.decode(line)).toEqual('');
+                expect(fieldLength).toEqual(-1);
+            });
+            // act:
+            next(encoder.encode('\n'));
+            // assert:
+            expect(lineNum).toBe(1);
+        });
+        it('comment line', () => {
+            // arrange:
+            let lineNum = 0;
+            const next = parse.getLines((line, fieldLength) => {
+                ++lineNum;
+                expect(decoder.decode(line)).toEqual(': this is a comment');
+                expect(fieldLength).toEqual(0);
+            });
+            // act:
+            next(encoder.encode(': this is a comment\n'));
+            // assert:
+            expect(lineNum).toBe(1);
+        });
+        it('line with no field', () => {
+            // arrange:
+            let lineNum = 0;
+            const next = parse.getLines((line, fieldLength) => {
+                ++lineNum;
+                expect(decoder.decode(line)).toEqual('this is an invalid line');
+                expect(fieldLength).toEqual(-1);
+            });
+            // act:
+            next(encoder.encode('this is an invalid line\n'));
+            // assert:
+            expect(lineNum).toBe(1);
+        });
+        it('line with multiple colons', () => {
+            // arrange:
+            let lineNum = 0;
+            const next = parse.getLines((line, fieldLength) => {
+                ++lineNum;
+                expect(decoder.decode(line)).toEqual('id: abc: def');
+                expect(fieldLength).toEqual(2);
+            });
+            // act:
+            next(encoder.encode('id: abc: def\n'));
+            // assert:
+            expect(lineNum).toBe(1);
+        });
+        it('single byte array with multiple lines separated by \\n', () => {
+            // arrange:
+            let lineNum = 0;
+            const next = parse.getLines((line, fieldLength) => {
+                ++lineNum;
+                expect(decoder.decode(line)).toEqual(lineNum === 1 ? 'id: abc' : 'data: def');
+                expect(fieldLength).toEqual(lineNum === 1 ? 2 : 4);
+            });
+            // act:
+            next(encoder.encode('id: abc\ndata: def\n'));
+            // assert:
+            expect(lineNum).toBe(2);
+        });
+        it('single byte array with multiple lines separated by \\r', () => {
+            // arrange:
+            let lineNum = 0;
+            const next = parse.getLines((line, fieldLength) => {
+                ++lineNum;
+                expect(decoder.decode(line)).toEqual(lineNum === 1 ? 'id: abc' : 'data: def');
+                expect(fieldLength).toEqual(lineNum === 1 ? 2 : 4);
+            });
+            // act:
+            next(encoder.encode('id: abc\rdata: def\r'));
+            // assert:
+            expect(lineNum).toBe(2);
+        });
+        it('single byte array with multiple lines separated by \\r\\n', () => {
+            // arrange:
+            let lineNum = 0;
+            const next = parse.getLines((line, fieldLength) => {
+                ++lineNum;
+                expect(decoder.decode(line)).toEqual(lineNum === 1 ? 'id: abc' : 'data: def');
+                expect(fieldLength).toEqual(lineNum === 1 ? 2 : 4);
+            });
+            // act:
+            next(encoder.encode('id: abc\r\ndata: def\r\n'));
+            // assert:
+            expect(lineNum).toBe(2);
+        });
+    });
+    describe('getMessages', () => {
+        it('happy path', () => {
+            // arrange:
+            let msgNum = 0;
+            const next = parse.getMessages(id => {
+                expect(id).toEqual('abc');
+            }, retry => {
+                expect(retry).toEqual(42);
+            }, msg => {
+                ++msgNum;
+                expect(msg).toEqual({
+                    retry: 42,
+                    id: 'abc',
+                    event: 'def',
+                    data: 'ghi'
+                });
+            });
+            // act:
+            next(encoder.encode('retry: 42'), 5);
+            next(encoder.encode('id: abc'), 2);
+            next(encoder.encode('event:def'), 5);
+            next(encoder.encode('data:ghi'), 4);
+            next(encoder.encode(''), -1);
+            // assert:
+            expect(msgNum).toBe(1);
+        });
+        it('skip unknown fields', () => {
+            let msgNum = 0;
+            const next = parse.getMessages(id => {
+                expect(id).toEqual('abc');
+            }, _retry => {
+                fail('retry should not be called');
+            }, msg => {
+                ++msgNum;
+                expect(msg).toEqual({
+                    id: 'abc',
+                    data: '',
+                    event: '',
+                    retry: undefined,
+                });
+            });
+            // act:
+            next(encoder.encode('id: abc'), 2);
+            next(encoder.encode('foo: null'), 3);
+            next(encoder.encode(''), -1);
+            // assert:
+            expect(msgNum).toBe(1);
+        });
+        it('ignore non-integer retry', () => {
+            let msgNum = 0;
+            const next = parse.getMessages(_id => {
+                fail('id should not be called');
+            }, _retry => {
+                fail('retry should not be called');
+            }, msg => {
+                ++msgNum;
+                expect(msg).toEqual({
+                    id: '',
+                    data: '',
+                    event: '',
+                    retry: undefined,
+                });
+            });
+            // act:
+            next(encoder.encode('retry: def'), 5);
+            next(encoder.encode(''), -1);
+            // assert:
+            expect(msgNum).toBe(1);
+        });
+        it('skip comment-only messages', () => {
+            // arrange:
+            let msgNum = 0;
+            const next = parse.getMessages(id => {
+                expect(id).toEqual('123');
+            }, _retry => {
+                fail('retry should not be called');
+            }, msg => {
+                ++msgNum;
+                expect(msg).toEqual({
+                    retry: undefined,
+                    id: '123',
+                    event: 'foo ',
+                    data: '',
+                });
+            });
+            // act:
+            next(encoder.encode('id:123'), 2);
+            next(encoder.encode(':'), 0);
+            next(encoder.encode(':    '), 0);
+            next(encoder.encode('event: foo '), 5);
+            next(encoder.encode(''), -1);
+            // assert:
+            expect(msgNum).toBe(1);
+        });
+        it('should append data split across multiple lines', () => {
+            // arrange:
+            let msgNum = 0;
+            const next = parse.getMessages(_id => {
+                fail('id should not be called');
+            }, _retry => {
+                fail('retry should not be called');
+            }, msg => {
+                ++msgNum;
+                expect(msg).toEqual({
+                    data: 'YHOO\n+2\n\n10',
+                    id: '',
+                    event: '',
+                    retry: undefined,
+                });
+            });
+            // act:
+            next(encoder.encode('data:YHOO'), 4);
+            next(encoder.encode('data: +2'), 4);
+            next(encoder.encode('data'), 4);
+            next(encoder.encode('data: 10'), 4);
+            next(encoder.encode(''), -1);
+            // assert:
+            expect(msgNum).toBe(1);
+        });
+        it('should reset id if sent multiple times', () => {
+            // arrange:
+            const expectedIds = ['foo', ''];
+            let idsIdx = 0;
+            let msgNum = 0;
+            const next = parse.getMessages(id => {
+                expect(id).toEqual(expectedIds[idsIdx]);
+                ++idsIdx;
+            }, _retry => {
+                fail('retry should not be called');
+            }, msg => {
+                ++msgNum;
+                expect(msg).toEqual({
+                    data: '',
+                    id: '',
+                    event: '',
+                    retry: undefined,
+                });
+            });
+            // act:
+            next(encoder.encode('id: foo'), 2);
+            next(encoder.encode('id'), 2);
+            next(encoder.encode(''), -1);
+            // assert:
+            expect(idsIdx).toBe(2);
+            expect(msgNum).toBe(1);
+        });
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@huggingface/inference",
-  "version": "3.13.2",
+  "version": "3.14.0",
   "license": "MIT",
   "author": "Hugging Face and Tim Mikeladze <tim.mikeladze@gmail.com>",
   "description": "Typescript client for the Hugging Face Inference Providers and Inference Endpoints",
@@ -29,26 +29,39 @@
     "!src/snippets/templates/**/*.jinja"
   ],
   "source": "src/index.ts",
-  "types": "./dist/src/index.d.ts",
-  "main": "./dist/index.cjs",
-  "module": "./dist/index.js",
-  "exports": {
-    "types": "./dist/src/index.d.ts",
-    "require": "./dist/index.cjs",
-    "import": "./dist/index.js"
+  "types": "./dist/commonjs/index.d.ts",
+  "main": "./dist/commonjs/index.js",
+  "module": "./dist/esm/index.js",
+  "tshy": {
+    "exports": {
+      "./package.json": "./package.json",
+      ".": "./src/index.ts"
+    }
   },
   "type": "module",
   "dependencies": {
-    "@huggingface/tasks": "^0.19.6",
+    "@huggingface/tasks": "^0.19.8",
     "@huggingface/jinja": "^0.5.0"
   },
   "devDependencies": {
     "@types/node": "18.13.0"
   },
   "resolutions": {},
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "import": {
+        "types": "./dist/esm/index.d.ts",
+        "default": "./dist/esm/index.js"
+      },
+      "require": {
+        "types": "./dist/commonjs/index.d.ts",
+        "default": "./dist/commonjs/index.js"
+      }
+    }
+  },
   "scripts": {
-    "build": "pnpm run export-templates && tsup src/index.ts --format cjs,esm --clean && tsc --emitDeclarationOnly --declaration",
-    "dts": "tsx scripts/generate-dts.ts && tsc --noEmit dist/index.d.ts",
+    "build": "pnpm run export-templates && pnpm run package-to-ts && tshy",
     "lint": "eslint --quiet --fix --ext .cjs,.ts .",
     "lint:check": "eslint --ext .cjs,.ts .",
     "format": "prettier --write .",
@@ -57,6 +70,7 @@
     "test:browser": "vitest run --browser.name=chrome --browser.headless --config vitest.config.mts",
     "check": "tsc",
     "dev": "pnpm run export-templates && tsup src/index.ts --format cjs,esm --watch",
-    "export-templates": "tsx scripts/export-templates.ts"
+    "export-templates": "tsx scripts/export-templates.ts",
+    "package-to-ts": "tsx scripts/package-json-to-ts.ts"
   }
 }

package/src/InferenceClient.ts

@@ -1,7 +1,7 @@
-import * as tasks from "./tasks";
-import type { Options } from "./types";
-import { omit } from "./utils/omit";
-import { typedEntries } from "./utils/typedEntries";
+import * as tasks from "./tasks/index.js";
+import type { Options } from "./types.js";
+import { omit } from "./utils/omit.js";
+import { typedEntries } from "./utils/typedEntries.js";
 
 /* eslint-disable @typescript-eslint/no-empty-interface */
 /* eslint-disable @typescript-eslint/no-unsafe-declaration-merging */

package/src/index.ts

@@ -1,7 +1,7 @@
-export { InferenceClient, InferenceClientEndpoint, HfInference } from "./InferenceClient";
-export { InferenceOutputError } from "./lib/InferenceOutputError";
-export * from "./types";
-export * from "./tasks";
+export { InferenceClient, InferenceClientEndpoint, HfInference } from "./InferenceClient.js";
+export { InferenceOutputError } from "./lib/InferenceOutputError.js";
+export * from "./types.js";
+export * from "./tasks/index.js";
 import * as snippets from "./snippets/index.js";
 
 export { snippets };

package/src/lib/getDefaultTask.ts

@@ -1,5 +1,5 @@
-import { HF_HUB_URL } from "../config";
-import { isUrl } from "./isUrl";
+import { HF_HUB_URL } from "../config.js";
+import { isUrl } from "./isUrl.js";
 
 /**
  * We want to make calls to the huggingface hub the least possible, eg if

package/src/lib/getInferenceProviderMapping.ts

@@ -1,9 +1,9 @@
 import type { WidgetType } from "@huggingface/tasks";
-import { HF_HUB_URL } from "../config";
-import { HARDCODED_MODEL_INFERENCE_MAPPING } from "../providers/consts";
-import { EQUIVALENT_SENTENCE_TRANSFORMERS_TASKS } from "../providers/hf-inference";
-import type { InferenceProvider, InferenceProviderOrPolicy, ModelId } from "../types";
-import { typedInclude } from "../utils/typedInclude";
+import { HF_HUB_URL } from "../config.js";
+import { HARDCODED_MODEL_INFERENCE_MAPPING } from "../providers/consts.js";
+import { EQUIVALENT_SENTENCE_TRANSFORMERS_TASKS } from "../providers/hf-inference.js";
+import type { InferenceProvider, InferenceProviderOrPolicy, ModelId } from "../types.js";
+import { typedInclude } from "../utils/typedInclude.js";
 
 export const inferenceProviderMappingCache = new Map<ModelId, InferenceProviderMapping>();