@agentims/sdk 0.0.0-stage → 0.3.1

package/dist/internal/protocol/registry.js

@@ -0,0 +1,72 @@
+import { readFileSync } from "node:fs";
+import { ProtocolError } from "../../api/errors.js";
+import { parseJSON } from "./codec.js";
+import { isRecord } from "./schema.js";
+// Local generated metadata is loaded losslessly, including exact u64 schema bounds.
+function loadRegistry() {
+    const value = parseJSON(readFileSync(new URL("./operations.json", import.meta.url), "utf8"));
+    if (!isRecord(value) || value.version !== 1 || !isRecord(value.operations)) {
+        throw new ProtocolError("Unsupported generated operation registry");
+    }
+    for (const operation of Object.values(value.operations)) {
+        if (!isRecord(operation) || typeof operation.method !== "string"
+            || typeof operation.path !== "string" || !Array.isArray(operation.parameters)
+            || typeof operation.status !== "number" || typeof operation.binary !== "boolean"
+            || !(operation.request === null || isRecord(operation.request))
+            || !(operation.response === null || isRecord(operation.response))) {
+            throw new ProtocolError("Invalid generated operation metadata");
+        }
+        if (!["GET", "POST", "PUT"].includes(operation.method)
+            || !/^\/v[12]\//.test(operation.path) || !Number.isSafeInteger(operation.status)
+            || operation.status < 200 || operation.status >= 300) {
+            throw new ProtocolError("Unsupported generated operation semantics");
+        }
+        for (const parameter of operation.parameters) {
+            if (!isRecord(parameter) || typeof parameter.name !== "string"
+                || !["path", "query"].includes(String(parameter.in))
+                || typeof parameter.required !== "boolean" || !isRecord(parameter.schema)) {
+                throw new ProtocolError("Invalid generated parameter metadata");
+            }
+            checkSchema(parameter.schema);
+        }
+        if (operation.request !== null)
+            checkSchema(operation.request);
+        if (operation.response !== null)
+            checkSchema(operation.response);
+    }
+    // Trusted generated data has been checked above; network data is checked per call.
+    return value.operations;
+}
+function checkSchema(schema) {
+    const annotations = ["$id", "$schema", "title", "description", "default", "examples", "writeOnly", "contentEncoding"];
+    const assertions = ["type", "const", "enum", "anyOf", "properties", "required", "additionalProperties",
+        "items", "minItems", "maxItems", "uniqueItems", "minLength", "maxLength", "pattern", "minimum", "maximum", "format"];
+    for (const [key, value] of Object.entries(schema)) {
+        if (!annotations.includes(key) && !assertions.includes(key) && !key.startsWith("x-")) {
+            throw new ProtocolError("Unsupported generated schema assertion");
+        }
+        if (key === "format" && value !== "uri" && value !== "binary") {
+            throw new ProtocolError("Unsupported generated schema format");
+        }
+        if (key === "properties" && isRecord(value)) {
+            for (const child of Object.values(value))
+                if (isRecord(child))
+                    checkSchema(child);
+        }
+        else if (key === "anyOf" && Array.isArray(value)) {
+            for (const child of value)
+                if (isRecord(child))
+                    checkSchema(child);
+        }
+        else if (["items", "additionalProperties"].includes(key) && isRecord(value)) {
+            checkSchema(value);
+        }
+    }
+}
+const operations = loadRegistry();
+export function operationFor(id) {
+    const operation = operations[id];
+    if (!operation)
+        throw new ProtocolError("Unknown local API operation");
+    return operation;
+}

package/dist/internal/protocol/schema.d.ts

@@ -0,0 +1,23 @@
+export interface Schema {
+    readonly type?: string | readonly string[];
+    readonly const?: unknown;
+    readonly enum?: readonly unknown[];
+    readonly anyOf?: readonly Schema[];
+    readonly properties?: Readonly<Record<string, Schema>>;
+    readonly required?: readonly string[];
+    readonly additionalProperties?: boolean | Schema;
+    readonly items?: Schema;
+    readonly minItems?: number;
+    readonly maxItems?: number;
+    readonly uniqueItems?: boolean;
+    readonly minLength?: number;
+    readonly maxLength?: number;
+    readonly pattern?: string;
+    readonly minimum?: number | bigint;
+    readonly maximum?: number | bigint;
+    readonly format?: string;
+    readonly "x-max-body-bytes"?: number | bigint;
+}
+export declare function isRecord(value: unknown): value is Record<string, unknown>;
+/** Implements the assertions actually used by the canonical expanded schemas. */
+export declare function schemaIssue(value: unknown, schema: Schema, path?: string): string | null;

package/dist/internal/protocol/schema.js

@@ -0,0 +1,105 @@
+import { stringifyJSON } from "./codec.js";
+export function isRecord(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+/** Implements the assertions actually used by the canonical expanded schemas. */
+export function schemaIssue(value, schema, path = "$") {
+    if (schema.anyOf && !schema.anyOf.some((part) => schemaIssue(value, part) === null)) {
+        return `${path}: does not match any allowed schema`;
+    }
+    if ("const" in schema && value !== schema.const)
+        return `${path}: invalid constant`;
+    if (schema.enum && !schema.enum.includes(value))
+        return `${path}: invalid enum value`;
+    const types = typeof schema.type === "string" ? [schema.type] : schema.type;
+    if (types && !types.some((type) => matchesType(value, type))) {
+        return `${path}: invalid type`;
+    }
+    if (typeof value === "number" || typeof value === "bigint") {
+        if (typeof value === "number" && !Number.isSafeInteger(value)) {
+            return `${path}: use bigint for integers outside the safe Number range`;
+        }
+        if (schema.minimum !== undefined && value < schema.minimum)
+            return `${path}: below minimum`;
+        if (schema.maximum !== undefined && value > schema.maximum)
+            return `${path}: above maximum`;
+    }
+    if (typeof value === "string") {
+        for (const character of value) {
+            const point = character.codePointAt(0);
+            if (point !== undefined && point >= 0xd800 && point <= 0xdfff)
+                return `${path}: invalid Unicode scalar`;
+        }
+        const length = [...value].length;
+        if (schema.minLength !== undefined && length < schema.minLength)
+            return `${path}: too short`;
+        if (schema.maxLength !== undefined && length > schema.maxLength)
+            return `${path}: too long`;
+        if (schema.pattern && !new RegExp(schema.pattern, "u").test(value))
+            return `${path}: invalid pattern`;
+        if (schema.format === "uri") {
+            // WHATWG URL normalizes whitespace/non-ASCII and accepts malformed escapes.
+            // Canonical URI values must already use URI characters and valid %HH tokens.
+            if (!/^[A-Za-z0-9._~:/?#\[\]@!$&'()*+,;=%-]+$/.test(value)
+                || /%(?![0-9A-Fa-f]{2})/.test(value))
+                return `${path}: invalid URI`;
+            try {
+                new URL(value);
+            }
+            catch {
+                return `${path}: invalid URI`;
+            }
+        }
+    }
+    if (Array.isArray(value)) {
+        if (schema.minItems !== undefined && value.length < schema.minItems)
+            return `${path}: too few items`;
+        if (schema.maxItems !== undefined && value.length > schema.maxItems)
+            return `${path}: too many items`;
+        if (schema.uniqueItems && new Set(value.map(stringifyJSON)).size !== value.length) {
+            return `${path}: duplicate items`;
+        }
+        if (schema.items) {
+            for (const [index, item] of value.entries()) {
+                const issue = schemaIssue(item, schema.items, `${path}[${index}]`);
+                if (issue)
+                    return issue;
+            }
+        }
+    }
+    if (isRecord(value)) {
+        for (const name of schema.required ?? []) {
+            if (!Object.hasOwn(value, name))
+                return `${path}.${name}: required`;
+        }
+        for (const [name, field] of Object.entries(value)) {
+            const child = schema.properties && Object.hasOwn(schema.properties, name) ? schema.properties[name] : undefined;
+            if (child) {
+                const issue = schemaIssue(field, child, `${path}.${name}`);
+                if (issue)
+                    return issue;
+            }
+            else if (schema.additionalProperties === false) {
+                return `${path}: unknown property`;
+            }
+            else if (isRecord(schema.additionalProperties)) {
+                const issue = schemaIssue(field, schema.additionalProperties, `${path}.${name}`);
+                if (issue)
+                    return issue;
+            }
+        }
+    }
+    return null;
+}
+function matchesType(value, type) {
+    if (type === "null")
+        return value === null;
+    if (type === "object")
+        return isRecord(value);
+    if (type === "array")
+        return Array.isArray(value);
+    if (type === "integer") {
+        return typeof value === "bigint" || (typeof value === "number" && Number.isSafeInteger(value));
+    }
+    return typeof value === type;
+}

package/dist/internal/transport/client.d.ts

@@ -0,0 +1,8 @@
+import type { ClientOptions } from "../../api/options.js";
+import type { CallOptions } from "./request.js";
+export declare class Transport {
+    #private;
+    constructor(options: ClientOptions);
+    call<T>(id: string, options?: CallOptions): Promise<T>;
+    close(): Promise<void>;
+}

package/dist/internal/transport/client.js

@@ -0,0 +1,102 @@
+import { AgentIMError, ClientClosedError, RequestCancelledError, RequestTimeoutError, TransportError, ValidationError, } from "../../api/errors.js";
+import { operationFor } from "../protocol/registry.js";
+import { requestBody, requestURL } from "./request.js";
+import { readResponse } from "./response.js";
+export class Transport {
+    #origin;
+    #token;
+    #timeoutMs;
+    #maxResponseBytes;
+    #pending = new Map();
+    #closed = false;
+    constructor(options) {
+        let url;
+        try {
+            url = new URL(options.baseUrl);
+        }
+        catch {
+            throw new ValidationError("Invalid local daemon URL");
+        }
+        if (url.protocol !== "http:" || !["127.0.0.1", "[::1]"].includes(url.hostname)
+            || url.username || url.password || url.pathname !== "/" || url.search || url.hash) {
+            throw new ValidationError("Daemon URL must be a loopback HTTP origin");
+        }
+        if (typeof options.apiToken !== "string" || !options.apiToken
+            || /[^\x21-\x7e]/.test(options.apiToken)) {
+            throw new ValidationError("A local daemon bearer token is required");
+        }
+        this.#origin = url.origin;
+        this.#token = options.apiToken;
+        this.#timeoutMs = positiveInteger(options.timeoutMs ?? 45_000, "timeoutMs");
+        this.#maxResponseBytes = positiveInteger(options.maxResponseBytes ?? 64 * 1024 * 1024, "maxResponseBytes");
+    }
+    call(id, options = {}) {
+        if (this.#closed)
+            return Promise.reject(new ClientClosedError("SDK client is closed"));
+        let operation;
+        let url;
+        let body;
+        let timeoutMs;
+        try {
+            operation = operationFor(id);
+            url = requestURL(this.#origin, operation, options);
+            body = requestBody(operation, options.body);
+            timeoutMs = positiveInteger(options.timeoutMs ?? this.#timeoutMs, "timeoutMs");
+        }
+        catch (error) {
+            return Promise.reject(error);
+        }
+        const controller = new AbortController();
+        const cancel = () => controller.abort(new RequestCancelledError("SDK request cancelled"));
+        if (options.signal?.aborted)
+            cancel();
+        else
+            options.signal?.addEventListener("abort", cancel, { once: true });
+        const timer = setTimeout(() => {
+            controller.abort(new RequestTimeoutError("SDK request timed out; write outcome may be unknown"));
+        }, timeoutMs);
+        const run = async () => {
+            try {
+                const headers = { Authorization: `Bearer ${this.#token}` };
+                if (body !== undefined)
+                    headers["Content-Type"] = "application/json";
+                const response = await fetch(url, {
+                    method: operation.method, headers, redirect: "error", signal: controller.signal,
+                    ...(body === undefined ? {} : { body }),
+                });
+                return await readResponse(response, operation, this.#maxResponseBytes, this.#token);
+            }
+            catch (error) {
+                if (controller.signal.aborted) {
+                    const reason = controller.signal.reason;
+                    if (reason instanceof AgentIMError)
+                        throw reason;
+                    throw new RequestCancelledError("SDK request cancelled");
+                }
+                if (error instanceof AgentIMError)
+                    throw error;
+                throw new TransportError("Local daemon connection failed; write outcome may be unknown");
+            }
+        };
+        const pending = run().finally(() => {
+            clearTimeout(timer);
+            options.signal?.removeEventListener("abort", cancel);
+            this.#pending.delete(pending);
+        });
+        this.#pending.set(pending, controller);
+        return pending;
+    }
+    async close() {
+        this.#closed = true;
+        for (const controller of this.#pending.values()) {
+            controller.abort(new ClientClosedError("SDK client closed; write outcome may be unknown"));
+        }
+        await Promise.allSettled(this.#pending.keys());
+    }
+}
+function positiveInteger(value, name) {
+    if (!Number.isSafeInteger(value) || value < 1 || value > 2_147_483_647) {
+        throw new ValidationError(`${name} must be a positive bounded integer`);
+    }
+    return value;
+}

package/dist/internal/transport/error-diagnostics.d.ts

@@ -0,0 +1,3 @@
+import type { ErrorDiagnostics } from "../../api/errors.js";
+/** Accept new diagnostics only on the versioned public registration operation. */
+export declare function errorDiagnostics(value: Record<string, unknown>, enabled: boolean, token: string): ErrorDiagnostics;

package/dist/internal/transport/error-diagnostics.js

@@ -0,0 +1,50 @@
+import { ProtocolError } from "../../api/errors.js";
+/** Accept new diagnostics only on the versioned public registration operation. */
+export function errorDiagnostics(value, enabled, token) {
+    const keys = ["code", "message", ...(enabled ? ["request_id", "retry_after_ms", "server_code", "next_action", "edge_request_id", "stage", "transport", "upstream_status", "safe_to_retry", "attempt_id", "device_created"] : [])];
+    if (Object.keys(value).some((key) => !keys.includes(key)))
+        throw new ProtocolError("Invalid error envelope");
+    const requestId = value.request_id;
+    const retryAfterMs = value.retry_after_ms;
+    const serverCode = value.server_code;
+    const nextAction = value.next_action;
+    const edgeRequestId = value.edge_request_id;
+    if (edgeRequestId !== undefined && (typeof edgeRequestId !== "string" || !/^[A-Za-z0-9_-]{1,80}$/.test(edgeRequestId)))
+        throw new ProtocolError("Invalid edge correlation");
+    if (requestId !== undefined && (typeof requestId !== "string" || !/^[a-f0-9]{32}$/.test(requestId)))
+        throw new ProtocolError("Invalid request correlation");
+    if (retryAfterMs !== undefined && (typeof retryAfterMs !== "number" || !Number.isSafeInteger(retryAfterMs) || retryAfterMs < 0 || retryAfterMs > 86_400_000))
+        throw new ProtocolError("Invalid retry time");
+    if (serverCode !== undefined && (typeof serverCode !== "string" || !/^[A-Z0-9_]{1,64}$/.test(serverCode)))
+        throw new ProtocolError("Invalid server error code");
+    if (nextAction !== undefined && (typeof nextAction !== "string" || !/^[a-z_]{1,64}$/.test(nextAction)))
+        throw new ProtocolError("Invalid next action");
+    const more = {};
+    const strings = [["stage", "stage", ["matrix_login", "account_exchange", "restore_session", "persist_session"]],
+        ["transport", "transport", ["http", "connect", "timeout", "non_json", "sdk", "unknown"]],
+        ["device_created", "deviceCreated", ["yes", "no", "unknown"]]];
+    for (const [wire, field, allowed] of strings) {
+        const item = value[wire];
+        if (item !== undefined && (typeof item !== "string" || !allowed.includes(item)))
+            throw new ProtocolError("Invalid login diagnostic");
+        if (typeof item === "string")
+            Object.assign(more, { [field]: item });
+    }
+    if (value.upstream_status !== undefined && (typeof value.upstream_status !== "number" || !Number.isInteger(value.upstream_status) || value.upstream_status < 100 || value.upstream_status > 599))
+        throw new ProtocolError("Invalid upstream status");
+    if (value.safe_to_retry !== undefined && typeof value.safe_to_retry !== "boolean")
+        throw new ProtocolError("Invalid retry classification");
+    if (value.attempt_id !== undefined && (typeof value.attempt_id !== "string" || !/^[A-Za-z0-9_-]{43}$/.test(value.attempt_id)))
+        throw new ProtocolError("Invalid login attempt");
+    return {
+        ...more,
+        ...(typeof value.upstream_status === "number" ? { upstreamStatus: value.upstream_status } : {}),
+        ...(typeof value.safe_to_retry === "boolean" ? { safeToRetry: value.safe_to_retry } : {}),
+        ...(typeof value.attempt_id === "string" && !value.attempt_id.includes(token) ? { attemptId: value.attempt_id } : {}),
+        ...(typeof edgeRequestId === "string" && !edgeRequestId.includes(token) ? { edgeRequestId } : {}),
+        ...(typeof requestId === "string" && !requestId.includes(token) ? { requestId } : {}),
+        ...(typeof retryAfterMs === "number" ? { retryAfterMs } : {}),
+        ...(typeof serverCode === "string" && !serverCode.includes(token) ? { serverCode } : {}),
+        ...(typeof nextAction === "string" && !nextAction.includes(token) ? { nextAction } : {}),
+    };
+}

package/dist/internal/transport/request.d.ts

@@ -0,0 +1,9 @@
+import type { RequestOptions } from "../../api/options.js";
+import type { Operation } from "../protocol/registry.js";
+export interface CallOptions extends RequestOptions {
+    readonly path?: Readonly<Record<string, unknown>>;
+    readonly query?: object;
+    readonly body?: unknown;
+}
+export declare function requestURL(origin: string, operation: Operation, options: CallOptions): URL;
+export declare function requestBody(operation: Operation, body: unknown): string | undefined;

package/dist/internal/transport/request.js

@@ -0,0 +1,55 @@
+import { ValidationError } from "../../api/errors.js";
+import { stringifyJSON } from "../protocol/codec.js";
+import { snapshotInput } from "../protocol/input.js";
+import { isRecord, schemaIssue } from "../protocol/schema.js";
+export function requestURL(origin, operation, options) {
+    let path = operation.path;
+    const query = snapshotInput(options.query === undefined ? {} : options.query);
+    const pathValues = snapshotInput(options.path ?? {});
+    for (const [location, values] of [["path", pathValues], ["query", query]]) {
+        if (!isRecord(values)) {
+            throw new ValidationError(`Invalid ${location} parameters`);
+        }
+        const entries = Object.entries(values);
+        const expected = operation.parameters.filter((parameter) => parameter.in === location);
+        if (entries.some(([name]) => !expected.some((parameter) => parameter.name === name))) {
+            throw new ValidationError(`Unknown ${location} parameter`);
+        }
+        for (const parameter of expected) {
+            const value = values[parameter.name];
+            if (value === undefined && !Object.hasOwn(values, parameter.name) && !parameter.required)
+                continue;
+            const issue = schemaIssue(value, parameter.schema);
+            if (issue)
+                throw new ValidationError(`Invalid ${location} parameter ${parameter.name}: ${issue}`);
+            if (location === "path") {
+                path = path.replace(`{${parameter.name}}`, encodeURIComponent(String(value)));
+            }
+        }
+    }
+    if (/[{}]/.test(path))
+        throw new ValidationError("Missing path parameter");
+    const url = new URL(path, origin);
+    if (!isRecord(query))
+        throw new ValidationError("Invalid query parameters");
+    for (const [key, value] of Object.entries(query))
+        url.searchParams.set(key, String(value));
+    return url;
+}
+export function requestBody(operation, body) {
+    if (operation.request === null) {
+        if (body !== undefined)
+            throw new ValidationError("Operation has no request body");
+        return undefined;
+    }
+    const snapshot = snapshotInput(body);
+    const issue = schemaIssue(snapshot, operation.request);
+    if (issue)
+        throw new ValidationError(`Invalid request body: ${issue}`);
+    const encoded = stringifyJSON(snapshot);
+    const limit = Math.min(8 * 1024 * 1024, Number(operation.request["x-max-body-bytes"] ?? Infinity));
+    if (new TextEncoder().encode(encoded).byteLength > limit) {
+        throw new ValidationError("Request body exceeds the local API byte limit");
+    }
+    return encoded;
+}

package/dist/internal/transport/response.d.ts

@@ -0,0 +1,2 @@
+import type { Operation } from "../protocol/registry.js";
+export declare function readResponse<T>(response: Response, operation: Operation, limit: number, token: string): Promise<T>;

package/dist/internal/transport/response.js

@@ -0,0 +1,85 @@
+import { AuthenticationError, OperationError, ProtocolError, ResponseTooLargeError } from "../../api/errors.js";
+import { parseJSON } from "../protocol/codec.js";
+import { isRecord, schemaIssue } from "../protocol/schema.js";
+import { errorDiagnostics } from "./error-diagnostics.js";
+async function readBounded(response, limit) {
+    const length = response.headers.get("content-length");
+    if (length !== null && (!/^\d+$/.test(length) || BigInt(length) > BigInt(limit))) {
+        await response.body?.cancel();
+        throw new ResponseTooLargeError("Response exceeds the configured byte budget");
+    }
+    if (!response.body)
+        return new Uint8Array();
+    const reader = response.body.getReader();
+    const chunks = [];
+    let total = 0;
+    try {
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            total += value.byteLength;
+            if (total > limit) {
+                await reader.cancel();
+                throw new ResponseTooLargeError("Response exceeds the configured byte budget");
+            }
+            chunks.push(value);
+        }
+    }
+    finally {
+        reader.releaseLock();
+    }
+    const result = new Uint8Array(total);
+    let offset = 0;
+    for (const chunk of chunks) {
+        result.set(chunk, offset);
+        offset += chunk.length;
+    }
+    return result;
+}
+export async function readResponse(response, operation, limit, token) {
+    const bytes = await readBounded(response, limit);
+    const contentType = response.headers.get("content-type")?.split(";", 1)[0]?.trim().toLowerCase();
+    if (response.status === operation.status && operation.binary) {
+        if (contentType !== "application/octet-stream")
+            throw new ProtocolError("Expected attachment bytes");
+        return bytes;
+    }
+    if (contentType !== "application/json")
+        throw new ProtocolError("Expected a JSON response");
+    let text;
+    try {
+        text = new TextDecoder("utf-8", { fatal: true }).decode(bytes);
+    }
+    catch {
+        throw new ProtocolError("Invalid UTF-8 response");
+    }
+    const value = parseJSON(text);
+    if (response.status !== operation.status) {
+        if (response.status >= 200 && response.status < 300) {
+            throw new ProtocolError("Unexpected success status");
+        }
+        if (!isRecord(value) || Object.keys(value).length !== 1 || !isRecord(value.error)
+            || typeof value.error.code !== "string"
+            || value.error.code.length < 1 || value.error.code.length > 64
+            || typeof value.error.message !== "string" || [...value.error.message].length > 512) {
+            throw new ProtocolError("Invalid error envelope");
+        }
+        const code = /^[A-Za-z0-9._:-]+$/.test(value.error.code) && !value.error.code.includes(token)
+            ? value.error.code : "remote_error";
+        const bodyDiagnostics = errorDiagnostics(value.error, operation.path.startsWith("/v2/identity/"), token);
+        const requestId = response.headers.get("x-agentim-request-id");
+        const diagnostics = !bodyDiagnostics.requestId && requestId && !requestId.includes(token) && /^[a-f0-9]{32}$/.test(requestId)
+            ? { ...bodyDiagnostics, requestId } : bodyDiagnostics;
+        // A daemon may reflect input in its message; retain only bounded status/code.
+        const ErrorClass = response.status === 401 ? AuthenticationError : OperationError;
+        throw new ErrorClass(response.status, code, `Local API rejected request (HTTP ${response.status})`, diagnostics);
+    }
+    if (operation.response === null)
+        throw new ProtocolError("Missing response schema");
+    const issue = schemaIssue(value, operation.response);
+    if (issue)
+        throw new ProtocolError(`Response does not match the local API contract: ${issue}`);
+    // Narrow only after checking the canonical operation response at the boundary.
+    return value;
+}

package/package.json

@@ -1,6 +1,36 @@
 {
   "name": "@agentims/sdk",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.3.1",
+  "description": "Typed Node.js client for the AgentIM local daemon API",
+  "type": "module",
+  "license": "UNLICENSED",
+  "engines": {
+    "node": ">=24.22.2 <25"
+  },
+  "packageManager": "pnpm@10.32.1",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "node scripts/compiler.mjs build",
+    "typecheck": "node scripts/compiler.mjs typecheck",
+    "format:check": "node scripts/source-check.mjs format",
+    "lint": "node scripts/source-check.mjs lint",
+    "test": "node scripts/run-tests.mjs",
+    "test:consumer": "node tests/consumer/package-check.mjs",
+    "pack:check": "node tests/consumer/package-check.mjs"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "homepage": "https://agentims.shipkitx.com/downloads/agent/"
+}