@puku-ai/sdk 4.0.2 → 4.0.4

package/dist/vendor/core/streaming.cjs

@@ -0,0 +1,346 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Stream = void 0;
+exports._iterSSEMessages = _iterSSEMessages;
+const error_1 = require("./error");
+const shims_1 = require("../internal/shims");
+const line_1 = require("../internal/decoders/line");
+const shims_2 = require("../internal/shims");
+const errors_1 = require("../internal/errors");
+const values_1 = require("../internal/utils/values");
+const bytes_1 = require("../internal/utils/bytes");
+const log_1 = require("../internal/utils/log");
+const error_2 = require("./error");
+const request_signal_1 = require("../internal/request-signal");
+class Stream {
+    iterator;
+    controller;
+    #client;
+    constructor(iterator, controller, client) {
+        this.iterator = iterator;
+        this.controller = controller;
+        this.#client = client;
+    }
+    /**
+     * Iterate the raw Server-Sent Events from `response` — `{event, data, raw}`
+     * objects, before any JSON parsing or event-name filtering.
+     *
+     * This reads `response.body` directly (not a clone), so the response is
+     * consumed. Use this in middleware that fully replaces the stream body; for
+     * read-only observation of parsed events, use `ctx.parse()` instead.
+     */
+    static rawEvents(response, controller = new AbortController()) {
+        return _iterSSEMessages(response, controller);
+    }
+    static fromSSEResponse(response, controller, client) {
+        let consumed = false;
+        const logger = client ? (0, log_1.loggerFor)(client) : console;
+        async function* iterator() {
+            if (consumed) {
+                throw new error_1.PukuError('Cannot iterate over a consumed stream, use `.tee()` to split the stream.');
+            }
+            consumed = true;
+            let done = false;
+            try {
+                for await (const sse of _iterSSEMessages(response, controller)) {
+                    if (sse.event === 'completion') {
+                        try {
+                            yield JSON.parse(sse.data);
+                        }
+                        catch (e) {
+                            logger.error(`Could not parse message into JSON:`, sse.data);
+                            logger.error(`From chunk:`, sse.raw);
+                            throw e;
+                        }
+                    }
+                    if (sse.event === 'message_start' ||
+                        sse.event === 'message_delta' ||
+                        sse.event === 'message_stop' ||
+                        sse.event === 'content_block_start' ||
+                        sse.event === 'content_block_delta' ||
+                        sse.event === 'content_block_stop' ||
+                        sse.event === 'message' ||
+                        sse.event === 'user.message' ||
+                        sse.event === 'user.interrupt' ||
+                        sse.event === 'user.tool_confirmation' ||
+                        sse.event === 'user.custom_tool_result' ||
+                        sse.event === 'user.tool_result' ||
+                        sse.event === 'agent.message' ||
+                        sse.event === 'agent.thinking' ||
+                        sse.event === 'agent.tool_use' ||
+                        sse.event === 'agent.tool_result' ||
+                        sse.event === 'agent.mcp_tool_use' ||
+                        sse.event === 'agent.mcp_tool_result' ||
+                        sse.event === 'agent.custom_tool_use' ||
+                        sse.event === 'agent.thread_context_compacted' ||
+                        sse.event === 'session.status_running' ||
+                        sse.event === 'session.status_idle' ||
+                        sse.event === 'session.status_rescheduled' ||
+                        sse.event === 'session.status_terminated' ||
+                        sse.event === 'session.error' ||
+                        sse.event === 'session.deleted' ||
+                        sse.event === 'session.updated' ||
+                        sse.event === 'span.model_request_start' ||
+                        sse.event === 'span.model_request_end' ||
+                        sse.event === 'span.outcome_evaluation_start' ||
+                        sse.event === 'span.outcome_evaluation_ongoing' ||
+                        sse.event === 'span.outcome_evaluation_end' ||
+                        sse.event === 'user.define_outcome' ||
+                        sse.event === 'agent.thread_message_received' ||
+                        sse.event === 'agent.thread_message_sent' ||
+                        sse.event === 'agent.session_thread_message_received' ||
+                        sse.event === 'agent.session_thread_message_sent' ||
+                        sse.event === 'session.thread_created' ||
+                        sse.event === 'session.thread_status_created' ||
+                        sse.event === 'session.thread_status_running' ||
+                        sse.event === 'session.thread_status_idle' ||
+                        sse.event === 'session.thread_status_rescheduled' ||
+                        sse.event === 'session.thread_status_terminated' ||
+                        sse.event === 'event_start' ||
+                        sse.event === 'event_delta' ||
+                        sse.event === 'system.message') {
+                        try {
+                            yield JSON.parse(sse.data);
+                        }
+                        catch (e) {
+                            logger.error(`Could not parse message into JSON:`, sse.data);
+                            logger.error(`From chunk:`, sse.raw);
+                            throw e;
+                        }
+                    }
+                    if (sse.event === 'ping') {
+                        continue;
+                    }
+                    if (sse.event === 'error') {
+                        const body = (0, values_1.safeJSON)(sse.data) ?? sse.data;
+                        const type = body?.error?.type;
+                        throw new error_2.APIError(undefined, body, undefined, response.headers, type);
+                    }
+                }
+                done = true;
+            }
+            catch (e) {
+                // If the user calls `stream.controller.abort()`, we should exit without throwing.
+                if ((0, errors_1.isAbortError)(e))
+                    return;
+                throw e;
+            }
+            finally {
+                // If the user `break`s, abort the ongoing request.
+                if (!done)
+                    controller.abort();
+                (0, request_signal_1.releaseRequestSignal)(controller);
+            }
+        }
+        return new Stream(iterator, controller, client);
+    }
+    /**
+     * Generates a Stream from a newline-separated ReadableStream
+     * where each item is a JSON value.
+     */
+    static fromReadableStream(readableStream, controller, client) {
+        let consumed = false;
+        async function* iterLines() {
+            const lineDecoder = new line_1.LineDecoder();
+            const iter = (0, shims_2.ReadableStreamToAsyncIterable)(readableStream);
+            for await (const chunk of iter) {
+                for (const line of lineDecoder.decode(chunk)) {
+                    yield line;
+                }
+            }
+            for (const line of lineDecoder.flush()) {
+                yield line;
+            }
+        }
+        async function* iterator() {
+            if (consumed) {
+                throw new error_1.PukuError('Cannot iterate over a consumed stream, use `.tee()` to split the stream.');
+            }
+            consumed = true;
+            let done = false;
+            try {
+                for await (const line of iterLines()) {
+                    if (done)
+                        continue;
+                    if (line)
+                        yield JSON.parse(line);
+                }
+                done = true;
+            }
+            catch (e) {
+                // If the user calls `stream.controller.abort()`, we should exit without throwing.
+                if ((0, errors_1.isAbortError)(e))
+                    return;
+                throw e;
+            }
+            finally {
+                // If the user `break`s, abort the ongoing request.
+                if (!done)
+                    controller.abort();
+                (0, request_signal_1.releaseRequestSignal)(controller);
+            }
+        }
+        return new Stream(iterator, controller, client);
+    }
+    [Symbol.asyncIterator]() {
+        return this.iterator();
+    }
+    /**
+     * Splits the stream into two streams which can be
+     * independently read from at different speeds.
+     */
+    tee() {
+        const left = [];
+        const right = [];
+        const iterator = this.iterator();
+        const teeIterator = (queue) => {
+            return {
+                next: () => {
+                    if (queue.length === 0) {
+                        const result = iterator.next();
+                        left.push(result);
+                        right.push(result);
+                    }
+                    return queue.shift();
+                },
+            };
+        };
+        return [
+            new Stream(() => teeIterator(left), this.controller, this.#client),
+            new Stream(() => teeIterator(right), this.controller, this.#client),
+        ];
+    }
+    /**
+     * Converts this stream to a newline-separated ReadableStream of
+     * JSON stringified values in the stream
+     * which can be turned back into a Stream with `Stream.fromReadableStream()`.
+     */
+    toReadableStream() {
+        const self = this;
+        let iter;
+        return (0, shims_1.makeReadableStream)({
+            async start() {
+                iter = self[Symbol.asyncIterator]();
+            },
+            async pull(ctrl) {
+                try {
+                    const { value, done } = await iter.next();
+                    if (done)
+                        return ctrl.close();
+                    const bytes = (0, bytes_1.encodeUTF8)(JSON.stringify(value) + '\n');
+                    ctrl.enqueue(bytes);
+                }
+                catch (err) {
+                    ctrl.error(err);
+                }
+            },
+            async cancel() {
+                await iter.return?.();
+            },
+        });
+    }
+}
+exports.Stream = Stream;
+async function* _iterSSEMessages(response, controller) {
+    if (!response.body) {
+        controller.abort();
+        if (typeof globalThis.navigator !== 'undefined' &&
+            globalThis.navigator.product === 'ReactNative') {
+            throw new error_1.PukuError(`The default react-native fetch implementation does not support streaming. Please use expo/fetch: https://docs.expo.dev/versions/latest/sdk/expo/#expofetch-api`);
+        }
+        throw new error_1.PukuError(`Attempted to iterate over a response with no body`);
+    }
+    const sseDecoder = new SSEDecoder();
+    const lineDecoder = new line_1.LineDecoder();
+    const iter = (0, shims_2.ReadableStreamToAsyncIterable)(response.body);
+    for await (const sseChunk of iterSSEChunks(iter)) {
+        for (const line of lineDecoder.decode(sseChunk)) {
+            const sse = sseDecoder.decode(line);
+            if (sse)
+                yield sse;
+        }
+    }
+    for (const line of lineDecoder.flush()) {
+        const sse = sseDecoder.decode(line);
+        if (sse)
+            yield sse;
+    }
+}
+/**
+ * Given an async iterable iterator, iterates over it and yields full
+ * SSE chunks, i.e. yields when a double new-line is encountered.
+ */
+async function* iterSSEChunks(iterator) {
+    let data = new Uint8Array();
+    for await (const chunk of iterator) {
+        if (chunk == null) {
+            continue;
+        }
+        const binaryChunk = chunk instanceof ArrayBuffer ? new Uint8Array(chunk)
+            : typeof chunk === 'string' ? (0, bytes_1.encodeUTF8)(chunk)
+                : chunk;
+        let newData = new Uint8Array(data.length + binaryChunk.length);
+        newData.set(data);
+        newData.set(binaryChunk, data.length);
+        data = newData;
+        let patternIndex;
+        while ((patternIndex = (0, line_1.findDoubleNewlineIndex)(data)) !== -1) {
+            yield data.slice(0, patternIndex);
+            data = data.slice(patternIndex);
+        }
+    }
+    if (data.length > 0) {
+        yield data;
+    }
+}
+class SSEDecoder {
+    data;
+    event;
+    chunks;
+    constructor() {
+        this.event = null;
+        this.data = [];
+        this.chunks = [];
+    }
+    decode(line) {
+        if (line.endsWith('\r')) {
+            line = line.substring(0, line.length - 1);
+        }
+        if (!line) {
+            // empty line and we didn't previously encounter any messages
+            if (!this.event && !this.data.length)
+                return null;
+            const sse = {
+                event: this.event,
+                data: this.data.join('\n'),
+                raw: this.chunks,
+            };
+            this.event = null;
+            this.data = [];
+            this.chunks = [];
+            return sse;
+        }
+        this.chunks.push(line);
+        if (line.startsWith(':')) {
+            return null;
+        }
+        let [fieldname, _, value] = partition(line, ':');
+        if (value.startsWith(' ')) {
+            value = value.substring(1);
+        }
+        if (fieldname === 'event') {
+            this.event = value;
+        }
+        else if (fieldname === 'data') {
+            this.data.push(value);
+        }
+        return null;
+    }
+}
+function partition(str, delimiter) {
+    const index = str.indexOf(delimiter);
+    if (index !== -1) {
+        return [str.substring(0, index), delimiter, str.substring(index + delimiter.length)];
+    }
+    return [str, '', ''];
+}

package/dist/vendor/core/uploads.cjs

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toFile = void 0;
+var to_file_1 = require("../internal/to-file");
+Object.defineProperty(exports, "toFile", { enumerable: true, get: function () { return to_file_1.toFile; } });

package/dist/vendor/error.cjs

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/** @deprecated Import from ./core/error instead */
+__exportStar(require("./core/error"), exports);

package/dist/vendor/helpers/beta/environments.cjs

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_MAX_IDLE_MS = exports.MANAGED_AGENTS_BETA = exports.SessionToolRunner = exports.EnvironmentWorker = exports.WorkPoller = void 0;
+/**
+ * Self-hosted environment runner helpers.
+ *
+ * - {@link WorkPoller} (`client.beta.environments.work.poller`) — control-plane
+ *   only: claims work items and yields each one.
+ * - {@link SessionToolRunner} (`client.beta.sessions.events.toolRunner`) — the
+ *   sessions-side counterpart to `client.beta.messages.toolRunner`: dispatches
+ *   local tools against a session's `agent.tool_use` events.
+ * - {@link EnvironmentWorker} (`client.beta.environments.work.worker`) — the full
+ *   composition: poll → set up the workdir + skills → run a
+ *   {@link SessionToolRunner} while heartbeating the work-item lease →
+ *   force-stop on exit (unless the lease was lost to another holder) → loop.
+ *   Use `handleItem()` for the per-item flow when you already hold a claimed
+ *   work item — with no arguments it reads the `PUKU_*` env vars that
+ *   `ant worker poll --on-work` sets. The class is also exported here if you
+ *   prefer `new EnvironmentWorker({ client, ... })`.
+ *
+ * The tool implementations themselves (`betaAgentToolset` and the
+ * per-tool factories) live in their own Node-only module — import them directly
+ * from `@puku-ai/sdk/tools/agent-toolset/node`.
+ */
+var index_1 = require("../../lib/environments/index");
+Object.defineProperty(exports, "WorkPoller", { enumerable: true, get: function () { return index_1.WorkPoller; } });
+Object.defineProperty(exports, "EnvironmentWorker", { enumerable: true, get: function () { return index_1.EnvironmentWorker; } });
+Object.defineProperty(exports, "SessionToolRunner", { enumerable: true, get: function () { return index_1.SessionToolRunner; } });
+Object.defineProperty(exports, "MANAGED_AGENTS_BETA", { enumerable: true, get: function () { return index_1.MANAGED_AGENTS_BETA; } });
+Object.defineProperty(exports, "DEFAULT_MAX_IDLE_MS", { enumerable: true, get: function () { return index_1.DEFAULT_MAX_IDLE_MS; } });

package/dist/vendor/helpers/beta/json-schema.cjs

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.betaTool = betaTool;
+exports.betaJSONSchemaOutputFormat = betaJSONSchemaOutputFormat;
+const __1 = require("../..");
+const transform_json_schema_1 = require("../../lib/transform-json-schema");
+/**
+ * Creates a Tool with a provided JSON schema that can be passed
+ * to the `.toolRunner()` method. The schema is used to automatically validate
+ * the input arguments for the tool.
+ */
+function betaTool(options) {
+    if (options.inputSchema.type !== 'object') {
+        throw new Error(`JSON schema for tool "${options.name}" must be an object, but got ${options.inputSchema.type}`);
+    }
+    return {
+        type: 'custom',
+        name: options.name,
+        input_schema: options.inputSchema,
+        description: options.description,
+        run: options.run,
+        parse: (content) => content,
+        ...(options.close ? { close: options.close } : {}),
+    };
+}
+/**
+ * Creates a JSON schema output format object from the given JSON schema.
+ * If this is passed to the `.parse()` method then the response message will contain a
+ * `.parsed_output` property that is the result of parsing the content with the given JSON schema.
+ *
+ */
+function betaJSONSchemaOutputFormat(jsonSchema, options) {
+    if (jsonSchema.type !== 'object') {
+        throw new Error(`JSON schema for tool must be an object, but got ${jsonSchema.type}`);
+    }
+    const transform = options?.transform ?? true;
+    if (transform) {
+        // todo: doing this is arguably necessary, but it does change the schema the user passed in
+        // so I'm not sure how we should handle that
+        jsonSchema = (0, transform_json_schema_1.transformJSONSchema)(jsonSchema);
+    }
+    return {
+        type: 'json_schema',
+        schema: {
+            ...jsonSchema,
+        },
+        parse: (content) => {
+            try {
+                return JSON.parse(content);
+            }
+            catch (error) {
+                throw new __1.PukuError(`Failed to parse structured output: ${error}`);
+            }
+        },
+    };
+}