@getpaseo/protocol 0.1.84

package/dist/agent-types.js

@@ -0,0 +1,22 @@
+export function normalizeAgentModelDefinition(model) {
+    const defaultThinkingOptionId = model.defaultThinkingOptionId ?? model.thinkingOptions?.find((option) => option.isDefault)?.id;
+    if (!defaultThinkingOptionId || defaultThinkingOptionId === model.defaultThinkingOptionId) {
+        return model;
+    }
+    return { ...model, defaultThinkingOptionId };
+}
+export const TOOL_CALL_ICON_NAMES = [
+    "wrench",
+    "square_terminal",
+    "eye",
+    "pencil",
+    "search",
+    "bot",
+    "sparkles",
+    "brain",
+    "mic_vocal",
+];
+export function getAgentStreamEventTurnId(event) {
+    return "turnId" in event ? event.turnId : undefined;
+}
+//# sourceMappingURL=agent-types.js.map

package/dist/binary-frames/file-transfer.d.ts

@@ -0,0 +1,56 @@
+import { z } from "zod";
+export declare const FileTransferOpcode: {
+    readonly FileBegin: 16;
+    readonly FileChunk: 17;
+    readonly FileEnd: 18;
+};
+export type FileTransferOpcode = (typeof FileTransferOpcode)[keyof typeof FileTransferOpcode];
+export declare const FileBeginMetadataSchema: z.ZodObject<{
+    mime: z.ZodString;
+    size: z.ZodNumber;
+    encoding: z.ZodEnum<["utf-8", "binary"]>;
+    modifiedAt: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    size: number;
+    modifiedAt: string;
+    encoding: "binary" | "utf-8";
+    mime: string;
+}, {
+    size: number;
+    modifiedAt: string;
+    encoding: "binary" | "utf-8";
+    mime: string;
+}>;
+export interface FileBegin {
+    opcode: typeof FileTransferOpcode.FileBegin;
+    requestId: string;
+    metadata: z.infer<typeof FileBeginMetadataSchema>;
+    payload: Uint8Array;
+}
+export interface FileChunk {
+    opcode: typeof FileTransferOpcode.FileChunk;
+    requestId: string;
+    payload: Uint8Array;
+}
+export interface FileEnd {
+    opcode: typeof FileTransferOpcode.FileEnd;
+    requestId: string;
+    payload: Uint8Array;
+}
+export type FileTransferFrame = FileBegin | FileChunk | FileEnd;
+type FileTransferFrameInput = {
+    opcode: typeof FileTransferOpcode.FileBegin;
+    requestId: string;
+    metadata: z.infer<typeof FileBeginMetadataSchema>;
+} | {
+    opcode: typeof FileTransferOpcode.FileChunk;
+    requestId: string;
+    payload?: Uint8Array | ArrayBuffer | string;
+} | {
+    opcode: typeof FileTransferOpcode.FileEnd;
+    requestId: string;
+};
+export declare function encodeFileTransferFrame(input: FileTransferFrameInput): Uint8Array;
+export declare function decodeFileTransferFrame(bytes: Uint8Array): FileTransferFrame | null;
+export {};
+//# sourceMappingURL=file-transfer.d.ts.map

package/dist/binary-frames/file-transfer.js

@@ -0,0 +1,108 @@
+import { z } from "zod";
+import { asUint8Array } from "./terminal.js";
+export const FileTransferOpcode = {
+    FileBegin: 0x10,
+    FileChunk: 0x11,
+    FileEnd: 0x12,
+};
+export const FileBeginMetadataSchema = z
+    .object({
+    mime: z.string().min(1),
+    size: z.number().int().nonnegative(),
+    encoding: z.enum(["utf-8", "binary"]),
+    modifiedAt: z.string(),
+})
+    .strict();
+export function encodeFileTransferFrame(input) {
+    const requestId = encodeRequestId(input.requestId);
+    if (input.opcode === FileTransferOpcode.FileBegin) {
+        const metadata = encodeJsonPayload(input.metadata);
+        if (metadata.byteLength > 0xffff) {
+            throw new RangeError("FileBegin metadata is too long");
+        }
+        const bytes = new Uint8Array(4 + requestId.byteLength + metadata.byteLength);
+        const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+        bytes[0] = input.opcode;
+        bytes[1] = requestId.byteLength;
+        bytes.set(requestId, 2);
+        view.setUint16(2 + requestId.byteLength, metadata.byteLength);
+        bytes.set(metadata, 4 + requestId.byteLength);
+        return bytes;
+    }
+    const payload = input.opcode === FileTransferOpcode.FileChunk
+        ? (asUint8Array(input.payload ?? new Uint8Array()) ?? new Uint8Array())
+        : new Uint8Array();
+    const bytes = new Uint8Array(2 + requestId.byteLength + payload.byteLength);
+    bytes[0] = input.opcode;
+    bytes[1] = requestId.byteLength;
+    bytes.set(requestId, 2);
+    bytes.set(payload, 2 + requestId.byteLength);
+    return bytes;
+}
+export function decodeFileTransferFrame(bytes) {
+    if (bytes.byteLength < 2) {
+        return null;
+    }
+    const opcode = bytes[0];
+    if (!isFileTransferOpcode(opcode)) {
+        return null;
+    }
+    const requestIdLength = bytes[1];
+    if (requestIdLength === 0 || requestIdLength > bytes.byteLength - 2) {
+        return null;
+    }
+    const requestId = decodeRequestId(bytes.subarray(2, 2 + requestIdLength));
+    const body = bytes.subarray(2 + requestIdLength);
+    if (opcode === FileTransferOpcode.FileBegin) {
+        if (body.byteLength < 2) {
+            return null;
+        }
+        const view = new DataView(body.buffer, body.byteOffset, body.byteLength);
+        const metadataLength = view.getUint16(0);
+        if (metadataLength !== body.byteLength - 2) {
+            return null;
+        }
+        const metadataBytes = body.subarray(2);
+        const result = FileBeginMetadataSchema.safeParse(decodeJsonPayload(metadataBytes));
+        return result.success
+            ? { opcode, requestId, metadata: result.data, payload: new Uint8Array() }
+            : null;
+    }
+    if (opcode === FileTransferOpcode.FileChunk) {
+        return { opcode, requestId, payload: body };
+    }
+    if (body.byteLength !== 0) {
+        return null;
+    }
+    return { opcode, requestId, payload: new Uint8Array() };
+}
+function isFileTransferOpcode(value) {
+    return (value === FileTransferOpcode.FileBegin ||
+        value === FileTransferOpcode.FileChunk ||
+        value === FileTransferOpcode.FileEnd);
+}
+function encodeJsonPayload(value) {
+    return new TextEncoder().encode(JSON.stringify(value));
+}
+function encodeRequestId(requestId) {
+    const bytes = new TextEncoder().encode(requestId);
+    if (bytes.byteLength === 0) {
+        throw new RangeError("File transfer requestId is required");
+    }
+    if (bytes.byteLength > 0xff) {
+        throw new RangeError("File transfer requestId is too long");
+    }
+    return bytes;
+}
+function decodeRequestId(bytes) {
+    return new TextDecoder().decode(bytes);
+}
+function decodeJsonPayload(bytes) {
+    try {
+        return JSON.parse(new TextDecoder().decode(bytes));
+    }
+    catch {
+        return null;
+    }
+}
+//# sourceMappingURL=file-transfer.js.map

package/dist/binary-frames/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./file-transfer.js";
+export * from "./terminal.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/binary-frames/index.js

@@ -0,0 +1,3 @@
+export * from "./file-transfer.js";
+export * from "./terminal.js";
+//# sourceMappingURL=index.js.map

package/dist/binary-frames/terminal.d.ts

@@ -0,0 +1,37 @@
+import { z } from "zod";
+import { TerminalStateSchema } from "../messages.js";
+export declare const TerminalStreamResizeSchema: z.ZodObject<{
+    rows: z.ZodNumber;
+    cols: z.ZodNumber;
+}, "strict", z.ZodTypeAny, {
+    rows: number;
+    cols: number;
+}, {
+    rows: number;
+    cols: number;
+}>;
+export declare const TerminalStreamOpcode: {
+    readonly Output: 1;
+    readonly Input: 2;
+    readonly Resize: 3;
+    readonly Snapshot: 4;
+    readonly Restore: 5;
+};
+export type TerminalStreamOpcode = (typeof TerminalStreamOpcode)[keyof typeof TerminalStreamOpcode];
+export interface TerminalStreamFrame {
+    opcode: TerminalStreamOpcode;
+    slot: number;
+    payload: Uint8Array;
+}
+export declare function asUint8Array(data: unknown): Uint8Array | null;
+export declare function encodeTerminalStreamFrame(input: {
+    opcode: TerminalStreamOpcode;
+    slot: number;
+    payload?: Uint8Array | ArrayBuffer | string;
+}): Uint8Array;
+export declare function decodeTerminalStreamFrame(bytes: Uint8Array): TerminalStreamFrame | null;
+export declare function encodeTerminalSnapshotPayload(state: z.infer<typeof TerminalStateSchema>): Uint8Array;
+export declare function decodeTerminalSnapshotPayload(bytes: Uint8Array): z.infer<typeof TerminalStateSchema> | null;
+export declare function encodeTerminalResizePayload(input: z.infer<typeof TerminalStreamResizeSchema>): Uint8Array;
+export declare function decodeTerminalResizePayload(bytes: Uint8Array): z.infer<typeof TerminalStreamResizeSchema> | null;
+//# sourceMappingURL=terminal.d.ts.map

package/dist/binary-frames/terminal.js

@@ -0,0 +1,101 @@
+import { z } from "zod";
+import { TerminalStateSchema } from "../messages.js";
+export const TerminalStreamResizeSchema = z
+    .object({
+    rows: z.number().int().positive(),
+    cols: z.number().int().positive(),
+})
+    .strict();
+export const TerminalStreamOpcode = {
+    Output: 0x01,
+    Input: 0x02,
+    Resize: 0x03,
+    Snapshot: 0x04,
+    Restore: 0x05,
+};
+export function asUint8Array(data) {
+    if (typeof data === "string") {
+        if (typeof TextEncoder !== "undefined") {
+            return new TextEncoder().encode(data);
+        }
+        if (typeof Buffer !== "undefined") {
+            return new Uint8Array(Buffer.from(data, "utf8"));
+        }
+        const out = new Uint8Array(data.length);
+        for (let index = 0; index < data.length; index += 1) {
+            out[index] = data.charCodeAt(index) & 0xff;
+        }
+        return out;
+    }
+    if (data instanceof Uint8Array) {
+        return data;
+    }
+    if (typeof ArrayBuffer !== "undefined" && data instanceof ArrayBuffer) {
+        return new Uint8Array(data);
+    }
+    if (ArrayBuffer.isView(data)) {
+        return new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
+    }
+    if (typeof Buffer !== "undefined" && Buffer.isBuffer(data)) {
+        return new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
+    }
+    return null;
+}
+function isTerminalStreamOpcode(value) {
+    return (value === TerminalStreamOpcode.Output ||
+        value === TerminalStreamOpcode.Input ||
+        value === TerminalStreamOpcode.Resize ||
+        value === TerminalStreamOpcode.Snapshot ||
+        value === TerminalStreamOpcode.Restore);
+}
+export function encodeTerminalStreamFrame(input) {
+    const payload = asUint8Array(input.payload ?? new Uint8Array(0)) ?? new Uint8Array(0);
+    const bytes = new Uint8Array(2 + payload.byteLength);
+    bytes[0] = input.opcode;
+    bytes[1] = input.slot & 0xff;
+    bytes.set(payload, 2);
+    return bytes;
+}
+export function decodeTerminalStreamFrame(bytes) {
+    if (bytes.byteLength < 2) {
+        return null;
+    }
+    const opcode = bytes[0];
+    if (!isTerminalStreamOpcode(opcode)) {
+        return null;
+    }
+    return {
+        opcode,
+        slot: bytes[1],
+        payload: bytes.subarray(2),
+    };
+}
+export function encodeTerminalSnapshotPayload(state) {
+    return encodeJsonPayload(state);
+}
+export function decodeTerminalSnapshotPayload(bytes) {
+    const parsed = decodeJsonPayload(bytes);
+    const result = TerminalStateSchema.safeParse(parsed);
+    return result.success ? result.data : null;
+}
+export function encodeTerminalResizePayload(input) {
+    return encodeJsonPayload(input);
+}
+export function decodeTerminalResizePayload(bytes) {
+    const parsed = decodeJsonPayload(bytes);
+    const result = TerminalStreamResizeSchema.safeParse(parsed);
+    return result.success ? result.data : null;
+}
+function encodeJsonPayload(value) {
+    return new TextEncoder().encode(JSON.stringify(value));
+}
+function decodeJsonPayload(bytes) {
+    try {
+        const text = new TextDecoder().decode(bytes);
+        return JSON.parse(text);
+    }
+    catch {
+        return null;
+    }
+}
+//# sourceMappingURL=terminal.js.map