@agent-api/sdk 1.1.2 → 1.1.4

package/README.md

@@ -2,7 +2,7 @@
 
 Production JavaScript/TypeScript SDK for the Managed Agent API.
 
-**Published on npm:** [`@agent-api/sdk`](https://www.npmjs.com/package/@agent-api/sdk) (v1.1.2)
+**Published on npm:** [`@agent-api/sdk`](https://www.npmjs.com/package/@agent-api/sdk) (v1.1.4)
 
 ## Install
 
@@ -40,6 +40,13 @@ The default base URL is `https://api.agentsway.dev` when neither option nor env
 
 ## Package layout
 
+Public package entrypoints:
+
+- `@agent-api/sdk`: browser-safe REST client, public types, auth, responses, models, presets, tools, volumes, and skills HTTP APIs.
+- `@agent-api/sdk/browser`: explicit alias of the browser-safe REST client entry.
+- `@agent-api/sdk/local`: Node-only local runtime, workspace, context, and local workspace tool support.
+- `@agent-api/sdk/node`: Node aggregate entry for local helpers such as `localSkillFromDirectory()` plus `NodeAgentAPI`.
+
 ```
 src/
   client.ts           # AgentAPI entrypoint
@@ -60,9 +67,11 @@ src/
 | `client.presets` | `list` |
 | `client.tools` | `list` |
 | `client.volumes` | `list`, `create`, `retrieve`, `update`, `delete`, `listEntries`, `searchEntries`, `readFile`, `writeFile`, `deletePath`, `reconcileUsage`, `createDirectory`, `downloadArchive`, `summarize`, `readLines`, `patchLines`, `grep` |
-| `client.skills` | `list`, `create`, `discover`, `focus`, `createDev`, `updateFile`, `retrieve`, `update`, `archive`, `delete`, `diff`, `acceptDev`, `discardDev`, `exportArchive`, `importArchive`, `pushDirectory`, `pullDirectory`, `listFiles`, `readFile`, `writeFile`, `deleteFile` |
+| `client.skills` | `list`, `create`, `discover`, `focus`, `createDev`, `updateFile`, `retrieve`, `update`, `archive`, `delete`, `diff`, `acceptDev`, `discardDev`, `exportArchive`, `importArchive`, `listFiles`, `readFile`, `writeFile`, `deleteFile` |
 | `client.auth` | `startDeviceAuth`, `pollDeviceAuth`, `waitForDeviceAuth` |
 
+`NodeAgentAPI` from `@agent-api/sdk/node` extends `client.skills` with Node-only `pushDirectory` and `pullDirectory`.
+
 ## Browser Device Login
 
 CLI and desktop apps can use browser login without handling user passwords or static API keys.
@@ -97,12 +106,37 @@ const response = await client.agent.create({
 });
 ```
 
+## Preset tools and local/client tools
+
+`tools` is the concrete model-visible tool list. Tool names must be unique because model tool calls select tools by name. When you send `preset` and `tools` together, the explicit `tools` array replaces the preset's default tools. Hybrid apps that add local function tools should resolve the preset defaults first, merge in their local tools, then pass the merged array. The SDK rejects duplicate tool names before submitting requests.
+
+```typescript
+import { resolvePresetTools } from "@agent-api/sdk";
+import { createLocalWorkspaceToolRegistry, LocalWorkspace } from "@agent-api/sdk/local";
+
+const workspace = new LocalWorkspace("/path/to/project", { trusted: true });
+const registry = createLocalWorkspaceToolRegistry(workspace);
+
+const { tools } = await resolvePresetTools(client, {
+  preset: "pro-search",
+  tools: registry.definitions(),
+});
+
+const response = await client.agent.create({
+  preset: "pro-search",
+  input: "Research the topic and update local notes.",
+  tools,
+});
+```
+
+For long-running apps, cache `client.presets.list()` and `client.tools.list()` and refresh them periodically. Use `resolvePresetToolsFromCatalog()` with cached catalogs when you want deterministic request construction without fetching on every turn.
+
 ## Skills
 
 `localSkillFromDirectory()` reads `SKILL.md` into the descriptor for initial local-skill auto-focus; later focused reads still use the local skill tool bridge.
 
 ```typescript
-import { localSkillFromDirectory } from "@agent-api/sdk";
+import { localSkillFromDirectory } from "@agent-api/sdk/node";
 
 const skill = await client.skills.create({ name: "research-helper" });
 await client.skills.writeFile(skill.skill_id, "SKILL.md", "# Research helper\n");

package/dist/client.d.ts

@@ -1,3 +1,4 @@
+import { HTTPClient } from "./internal/http.js";
 import { AuthResource } from "./resources/auth.js";
 import { ModelsResource } from "./resources/models.js";
 import { PresetsResource } from "./resources/presets.js";
@@ -25,8 +26,9 @@ export declare class AgentAPI {
     readonly volumes: VolumesResource;
     readonly skills: SkillsResource;
     readonly auth: AuthResource;
-    private readonly http;
+    protected readonly http: HTTPClient;
     constructor(options?: ClientOptions);
+    protected createSkillsResource(): SkillsResource;
     startDeviceAuth: (...args: Parameters<AuthResource["startDeviceAuth"]>) => Promise<import("./index.js").DeviceAuthStart>;
     pollDeviceAuth: (...args: Parameters<AuthResource["pollDeviceAuth"]>) => Promise<import("./index.js").DeviceAuthPollResult>;
     waitForDeviceAuth: (...args: Parameters<AuthResource["waitForDeviceAuth"]>) => Promise<import("./index.js").ApprovedDeviceAuth>;

package/dist/client.js

@@ -54,9 +54,12 @@ export class AgentAPI {
         this.presets = new PresetsResource(this.http);
         this.tools = new ToolsResource(this.http);
         this.volumes = new VolumesResource(this.http);
-        this.skills = new SkillsResource(this.http);
+        this.skills = this.createSkillsResource();
         this.auth = new AuthResource(this.http);
     }
+    createSkillsResource() {
+        return new SkillsResource(this.http);
+    }
     startDeviceAuth = (...args) => this.auth.startDeviceAuth(...args);
     pollDeviceAuth = (...args) => this.auth.pollDeviceAuth(...args);
     waitForDeviceAuth = (...args) => this.auth.waitForDeviceAuth(...args);

package/dist/index.d.ts

@@ -5,8 +5,6 @@ export { APIError, APIConnectionError, APIStatusError, AuthenticationError, BadR
 export * from "./types/index.js";
 export { functionCallOutputInput, pendingFunctionCalls, runLocalFunctionHandlers, } from "./local-functions.js";
 export type { LocalFunctionHandler, LocalFunctionHandlers } from "./local-functions.js";
-export { LocalWorkspaceDriver, createLocalWorkspaceToolRegistry, localWorkspaceToolDefinition, localWorkspaceToolInstructions, } from "./local/tools.js";
-export type { LocalWorkspaceAction, LocalWorkspaceAccessMode, LocalWorkspaceToolRegistry, LocalWorkspaceToolRegistryOptions, } from "./local/tools.js";
-export { localSkillFromDirectory, pendingLocalSkillCalls, runLocalSkillHandlers } from "./local-skills.js";
-export type { LocalSkillDirectoryOptions } from "./local-skills.js";
+export { mergeTools, publicToolToRequestTool, resolvePresetTools, resolvePresetToolsFromCatalog, } from "./preset-tools.js";
+export type { PresetToolCatalogClient, ResolvePresetToolsOptions, ResolvePresetToolsResult, UnknownPresetToolBehavior, } from "./preset-tools.js";
 export { AuthResource, DeviceAuthFlowError } from "./resources/auth.js";

package/dist/index.js

@@ -3,6 +3,5 @@ export { Page, collectPage } from "./pagination.js";
 export { APIError, APIConnectionError, APIStatusError, AuthenticationError, BadRequestError, InternalServerError, NotFoundError, PermissionDeniedError, RateLimitError, isRetryableStatus, parseResponseError, } from "./errors.js";
 export * from "./types/index.js";
 export { functionCallOutputInput, pendingFunctionCalls, runLocalFunctionHandlers, } from "./local-functions.js";
-export { LocalWorkspaceDriver, createLocalWorkspaceToolRegistry, localWorkspaceToolDefinition, localWorkspaceToolInstructions, } from "./local/tools.js";
-export { localSkillFromDirectory, pendingLocalSkillCalls, runLocalSkillHandlers } from "./local-skills.js";
+export { mergeTools, publicToolToRequestTool, resolvePresetTools, resolvePresetToolsFromCatalog, } from "./preset-tools.js";
 export { AuthResource, DeviceAuthFlowError } from "./resources/auth.js";

package/dist/node-client.d.ts

@@ -0,0 +1,6 @@
+import { AgentAPI } from "./client.js";
+import { NodeSkillsResource } from "./resources/skills-node.js";
+export declare class NodeAgentAPI extends AgentAPI {
+    readonly skills: NodeSkillsResource;
+    protected createSkillsResource(): NodeSkillsResource;
+}

package/dist/node-client.js

@@ -0,0 +1,7 @@
+import { AgentAPI } from "./client.js";
+import { NodeSkillsResource } from "./resources/skills-node.js";
+export class NodeAgentAPI extends AgentAPI {
+    createSkillsResource() {
+        return new NodeSkillsResource(this.http);
+    }
+}

package/dist/node.d.ts

@@ -0,0 +1,8 @@
+export * from "./index.js";
+export { NodeAgentAPI } from "./node-client.js";
+export { NodeSkillsResource } from "./resources/skills-node.js";
+export { LocalWorkspaceDriver, createLocalWorkspaceToolRegistry, localWorkspaceToolDefinition, localWorkspaceToolInstructions, } from "./local/tools.js";
+export type { LocalWorkspaceAction, LocalWorkspaceAccessMode, LocalWorkspaceToolRegistry, LocalWorkspaceToolRegistryOptions, } from "./local/tools.js";
+export { localSkillFromDirectory, pendingLocalSkillCalls, runLocalSkillHandlers } from "./local-skills.js";
+export type { LocalSkillDirectoryOptions } from "./local-skills.js";
+export * from "./local/index.js";

package/dist/node.js

@@ -0,0 +1,6 @@
+export * from "./index.js";
+export { NodeAgentAPI } from "./node-client.js";
+export { NodeSkillsResource } from "./resources/skills-node.js";
+export { LocalWorkspaceDriver, createLocalWorkspaceToolRegistry, localWorkspaceToolDefinition, localWorkspaceToolInstructions, } from "./local/tools.js";
+export { localSkillFromDirectory, pendingLocalSkillCalls, runLocalSkillHandlers } from "./local-skills.js";
+export * from "./local/index.js";

package/dist/preset-tools.d.ts

@@ -0,0 +1,53 @@
+import type { ListPresetsResponse, Preset } from "./types/catalog.js";
+import type { ListToolsResponse, PublicTool, Tool } from "./types/tools.js";
+export interface PresetToolCatalogClient {
+    presets: {
+        list(): Promise<ListPresetsResponse>;
+    };
+    tools: {
+        list(): Promise<ListToolsResponse>;
+    };
+}
+export type UnknownPresetToolBehavior = "stub" | "omit" | "error";
+export interface ResolvePresetToolsOptions {
+    /**
+     * Preset id whose policy.allowed_tools should be resolved.
+     */
+    preset: string;
+    /**
+     * Additional caller/client tools to append after the preset tools.
+     */
+    tools?: readonly Tool[];
+    /**
+     * Optional pre-fetched preset catalog. Use this when your app caches discovery
+     * responses and wants deterministic request construction.
+     */
+    presets?: readonly Preset[];
+    /**
+     * Optional pre-fetched tool catalog.
+     */
+    toolCatalog?: readonly PublicTool[];
+    /**
+     * Behavior when a preset allows a tool that is not present in the supplied
+     * or fetched tool catalog. "stub" keeps a name-only tool definition so the
+     * backend can still enrich it by name.
+     */
+    unknownPresetTool?: UnknownPresetToolBehavior;
+}
+export interface ResolvePresetToolsResult {
+    preset: Preset;
+    tools: Tool[];
+    missingToolNames: string[];
+}
+/**
+ * Resolve a preset's allowed tool names into concrete request tools and append
+ * caller-provided tools. This is a convenience for hybrid apps that need to add
+ * local/client tools while preserving the preset's default server tools.
+ *
+ * The Agent API request surface remains OpenAI-compatible: the returned array
+ * is intended for the normal CreateResponseRequest.tools field.
+ */
+export declare function resolvePresetTools(client: PresetToolCatalogClient, options: ResolvePresetToolsOptions): Promise<ResolvePresetToolsResult>;
+export declare function resolvePresetToolsFromCatalog(options: ResolvePresetToolsOptions): ResolvePresetToolsResult;
+export declare function mergeTools(...groups: Array<readonly Tool[]>): Tool[];
+export declare function publicToolToRequestTool(tool: PublicTool): Tool;

package/dist/preset-tools.js

@@ -0,0 +1,85 @@
+import { validateUniqueToolNames } from "./tool-validation.js";
+/**
+ * Resolve a preset's allowed tool names into concrete request tools and append
+ * caller-provided tools. This is a convenience for hybrid apps that need to add
+ * local/client tools while preserving the preset's default server tools.
+ *
+ * The Agent API request surface remains OpenAI-compatible: the returned array
+ * is intended for the normal CreateResponseRequest.tools field.
+ */
+export async function resolvePresetTools(client, options) {
+    const presets = options.presets ?? (await client.presets.list()).data;
+    const toolCatalog = options.toolCatalog ?? (await client.tools.list()).data;
+    return resolvePresetToolsFromCatalog({ ...options, presets, toolCatalog });
+}
+export function resolvePresetToolsFromCatalog(options) {
+    const presetId = options.preset.trim();
+    if (!presetId) {
+        throw new Error("preset is required");
+    }
+    const preset = options.presets?.find((row) => row.preset === presetId);
+    if (!preset) {
+        throw new Error(`preset not found: ${presetId}`);
+    }
+    const catalogByName = new Map();
+    for (const tool of options.toolCatalog ?? []) {
+        const name = tool.name?.trim();
+        if (name)
+            catalogByName.set(name, tool);
+    }
+    const missingToolNames = [];
+    const presetTools = [];
+    const unknownPresetTool = options.unknownPresetTool ?? "stub";
+    for (const name of preset.policy?.allowed_tools ?? []) {
+        const trimmed = name.trim();
+        if (!trimmed)
+            continue;
+        const catalogTool = catalogByName.get(trimmed);
+        if (catalogTool) {
+            presetTools.push(publicToolToRequestTool(catalogTool));
+            continue;
+        }
+        missingToolNames.push(trimmed);
+        if (unknownPresetTool === "error") {
+            throw new Error(`preset tool not found in catalog: ${trimmed}`);
+        }
+        if (unknownPresetTool === "stub") {
+            presetTools.push({ name: trimmed });
+        }
+    }
+    return {
+        preset,
+        tools: mergeTools(presetTools, options.tools ?? []),
+        missingToolNames,
+    };
+}
+export function mergeTools(...groups) {
+    const out = [];
+    for (const group of groups) {
+        for (const tool of group) {
+            const name = tool.name?.trim();
+            if (!name) {
+                throw new Error("tools[].name is required");
+            }
+            out.push({ ...tool, name });
+        }
+    }
+    validateUniqueToolNames(out);
+    return out;
+}
+export function publicToolToRequestTool(tool) {
+    const out = { name: tool.name };
+    if (tool.type)
+        out.type = tool.type;
+    if (tool.description)
+        out.description = tool.description;
+    if (tool.parameters)
+        out.parameters = tool.parameters;
+    if (tool.max_tokens != null)
+        out.max_tokens = tool.max_tokens;
+    if (tool.max_tokens_per_page != null)
+        out.max_tokens_per_page = tool.max_tokens_per_page;
+    if (tool.version)
+        out.version = tool.version;
+    return out;
+}

package/dist/resources/responses.js

@@ -1,6 +1,7 @@
 import { addOutputText } from "../internal/output-text.js";
 import { buildQuery } from "../internal/query.js";
 import { collectPage } from "../pagination.js";
+import { validateUniqueToolNames } from "../tool-validation.js";
 export class ResponsesResource {
     http;
     path;
@@ -9,6 +10,7 @@ export class ResponsesResource {
         this.path = path;
     }
     create(params, options) {
+        validateUniqueToolNames(params.tools);
         if (params.stream) {
             return this.http.stream(this.path, params, options);
         }

package/dist/resources/skills-node.d.ts

@@ -0,0 +1,7 @@
+import { SkillsResource } from "./skills.js";
+import type { RequestOptions } from "../types/common.js";
+import type { PullSkillDirectoryParams, PushSkillDirectoryParams, SkillDirectoryPullResult, SkillImportResponse } from "../types/skills.js";
+export declare class NodeSkillsResource extends SkillsResource {
+    pushDirectory(skillID: string, rootDir: string, params?: PushSkillDirectoryParams, options?: RequestOptions): Promise<SkillImportResponse>;
+    pullDirectory(skillID: string, targetDir: string, params?: PullSkillDirectoryParams, options?: RequestOptions): Promise<SkillDirectoryPullResult>;
+}

package/dist/resources/skills-node.js

@@ -0,0 +1,156 @@
+import { SkillsResource } from "./skills.js";
+export class NodeSkillsResource extends SkillsResource {
+    async pushDirectory(skillID, rootDir, params = {}, options) {
+        const archive = await zipDirectory(rootDir);
+        return this.importArchive(skillID, archive, params, options);
+    }
+    async pullDirectory(skillID, targetDir, params = {}, options) {
+        const archive = await this.exportArchive(skillID, params, options);
+        return extractStoredZipToDirectory(archive.content, targetDir, { replace: params.replace === true });
+    }
+}
+async function zipDirectory(rootDir) {
+    const fs = await import("node:fs/promises");
+    const path = await import("node:path");
+    const root = path.resolve(rootDir);
+    const files = await walkArchiveFiles(fs, path, root, root);
+    const entries = [];
+    for (const rel of files.sort()) {
+        const content = await fs.readFile(path.join(root, rel));
+        entries.push({ path: rel, data: new Uint8Array(content.buffer, content.byteOffset, content.byteLength) });
+    }
+    return createStoredZip(entries);
+}
+async function walkArchiveFiles(fs, path, root, dir) {
+    const entries = await fs.readdir(dir, { withFileTypes: true });
+    const out = [];
+    for (const entry of entries) {
+        if (entry.name === ".git" || entry.name === "__pycache__" || entry.name === "node_modules") {
+            continue;
+        }
+        const full = path.join(dir, entry.name);
+        if (entry.isDirectory()) {
+            out.push(...await walkArchiveFiles(fs, path, root, full));
+        }
+        else if (entry.isFile()) {
+            out.push(path.relative(root, full).split(path.sep).join("/"));
+        }
+    }
+    return out;
+}
+async function extractStoredZipToDirectory(archive, targetDir, opts) {
+    const fs = await import("node:fs/promises");
+    const path = await import("node:path");
+    const root = path.resolve(targetDir);
+    if (opts.replace) {
+        await fs.rm(root, { recursive: true, force: true });
+    }
+    await fs.mkdir(root, { recursive: true });
+    let fileCount = 0;
+    let byteCount = 0;
+    for (const entry of parseStoredZip(archive)) {
+        const dest = path.resolve(root, entry.path);
+        const rel = path.relative(root, dest);
+        if (rel.startsWith("..") || path.isAbsolute(rel)) {
+            throw new Error(`archive entry escapes target directory: ${entry.path}`);
+        }
+        await fs.mkdir(path.dirname(dest), { recursive: true });
+        await fs.writeFile(dest, entry.data);
+        fileCount += 1;
+        byteCount += entry.data.byteLength;
+    }
+    return { path: root, file_count: fileCount, byte_count: byteCount };
+}
+function createStoredZip(entries) {
+    const encoder = new TextEncoder();
+    const localParts = [];
+    const centralParts = [];
+    let offset = 0;
+    for (const entry of entries) {
+        const name = encoder.encode(entry.path);
+        const crc = crc32(entry.data);
+        const local = new Uint8Array(30 + name.length);
+        const lv = new DataView(local.buffer);
+        lv.setUint32(0, 0x04034b50, true);
+        lv.setUint16(4, 20, true);
+        lv.setUint16(8, 0, true);
+        lv.setUint32(14, crc, true);
+        lv.setUint32(18, entry.data.byteLength, true);
+        lv.setUint32(22, entry.data.byteLength, true);
+        lv.setUint16(26, name.length, true);
+        local.set(name, 30);
+        localParts.push(local, entry.data);
+        const central = new Uint8Array(46 + name.length);
+        const cv = new DataView(central.buffer);
+        cv.setUint32(0, 0x02014b50, true);
+        cv.setUint16(4, 20, true);
+        cv.setUint16(6, 20, true);
+        cv.setUint32(16, crc, true);
+        cv.setUint32(20, entry.data.byteLength, true);
+        cv.setUint32(24, entry.data.byteLength, true);
+        cv.setUint16(28, name.length, true);
+        cv.setUint32(42, offset, true);
+        central.set(name, 46);
+        centralParts.push(central);
+        offset += local.byteLength + entry.data.byteLength;
+    }
+    const centralOffset = offset;
+    const centralSize = centralParts.reduce((sum, part) => sum + part.byteLength, 0);
+    const end = new Uint8Array(22);
+    const ev = new DataView(end.buffer);
+    ev.setUint32(0, 0x06054b50, true);
+    ev.setUint16(8, entries.length, true);
+    ev.setUint16(10, entries.length, true);
+    ev.setUint32(12, centralSize, true);
+    ev.setUint32(16, centralOffset, true);
+    const zip = concatUint8([...localParts, ...centralParts, end]);
+    return zip.buffer.slice(zip.byteOffset, zip.byteOffset + zip.byteLength);
+}
+function parseStoredZip(archive) {
+    const data = new Uint8Array(archive);
+    const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+    const entries = [];
+    let pos = 0;
+    const decoder = new TextDecoder();
+    while (pos + 4 <= data.byteLength && view.getUint32(pos, true) === 0x04034b50) {
+        const method = view.getUint16(pos + 8, true);
+        if (method !== 0) {
+            throw new Error("Only stored ZIP entries are supported by pullDirectory");
+        }
+        const compressedSize = view.getUint32(pos + 18, true);
+        const fileNameLength = view.getUint16(pos + 26, true);
+        const extraLength = view.getUint16(pos + 28, true);
+        const nameStart = pos + 30;
+        const contentStart = nameStart + fileNameLength + extraLength;
+        const contentEnd = contentStart + compressedSize;
+        if (contentEnd > data.byteLength) {
+            throw new Error("Invalid ZIP archive");
+        }
+        const name = decoder.decode(data.slice(nameStart, nameStart + fileNameLength)).replace(/\\/g, "/");
+        if (name && !name.endsWith("/") && !name.startsWith("__MACOSX/") && !name.split("/").includes("..")) {
+            entries.push({ path: name.replace(/^\/+/, ""), data: data.slice(contentStart, contentEnd) });
+        }
+        pos = contentEnd;
+    }
+    return entries;
+}
+function concatUint8(parts) {
+    const total = parts.reduce((sum, part) => sum + part.byteLength, 0);
+    const out = new Uint8Array(total);
+    let offset = 0;
+    for (const part of parts) {
+        out.set(part, offset);
+        offset += part.byteLength;
+    }
+    return out;
+}
+function crc32(data) {
+    let crc = 0xffffffff;
+    for (const byte of data) {
+        crc ^= byte;
+        for (let i = 0; i < 8; i += 1) {
+            crc = (crc >>> 1) ^ (0xedb88320 & -(crc & 1));
+        }
+    }
+    return (crc ^ 0xffffffff) >>> 0;
+}

package/dist/resources/skills.d.ts

@@ -1,6 +1,6 @@
 import type { HTTPClient } from "../internal/http.js";
 import type { RequestOptions } from "../types/common.js";
-import type { CreateSkillParams, CreateSkillDevParams, CreateSkillDevResponse, DiscoverSkillsParams, FocusSkillParams, ImportSkillArchiveParams, ListSkillFilesParams, ListSkillFilesResponse, ListSkillsParams, ListSkillsResponse, ListSkillSummariesResponse, PullSkillDirectoryParams, PushSkillDirectoryParams, Skill, SkillAcceptStrategy, SkillArchive, SkillArchiveParams, SkillBranchDiff, SkillBranchDiffParams, SkillDirectoryPullResult, SkillFile, SkillBranch, SkillFocusResponse, SkillImportResponse, UpdateSkillFilePrimitiveParams, UpdateSkillFilePrimitiveResponse, UpdateSkillParams } from "../types/skills.js";
+import type { CreateSkillParams, CreateSkillDevParams, CreateSkillDevResponse, DiscoverSkillsParams, FocusSkillParams, ImportSkillArchiveParams, ListSkillFilesParams, ListSkillFilesResponse, ListSkillsParams, ListSkillsResponse, ListSkillSummariesResponse, Skill, SkillAcceptStrategy, SkillArchive, SkillArchiveParams, SkillBranchDiff, SkillBranchDiffParams, SkillFile, SkillBranch, SkillFocusResponse, SkillImportResponse, UpdateSkillFilePrimitiveParams, UpdateSkillFilePrimitiveResponse, UpdateSkillParams } from "../types/skills.js";
 export declare class SkillsResource {
     private readonly http;
     constructor(http: HTTPClient);
@@ -35,6 +35,4 @@ export declare class SkillsResource {
     exportArchive(skillID: string, params?: SkillArchiveParams, options?: RequestOptions): Promise<SkillArchive>;
     importArchive(skillID: string, archive: ArrayBuffer | Blob, params?: ImportSkillArchiveParams, options?: RequestOptions): Promise<SkillImportResponse>;
     diff(skillID: string, params?: SkillBranchDiffParams, options?: RequestOptions): Promise<SkillBranchDiff>;
-    pushDirectory(skillID: string, rootDir: string, params?: PushSkillDirectoryParams, options?: RequestOptions): Promise<SkillImportResponse>;
-    pullDirectory(skillID: string, targetDir: string, params?: PullSkillDirectoryParams, options?: RequestOptions): Promise<SkillDirectoryPullResult>;
 }

package/dist/resources/skills.js

@@ -95,14 +95,6 @@ export class SkillsResource {
             include_unchanged: params.include_unchanged ? "true" : undefined,
         })}`, undefined, options);
     }
-    async pushDirectory(skillID, rootDir, params = {}, options) {
-        const archive = await zipDirectory(rootDir);
-        return this.importArchive(skillID, archive, params, options);
-    }
-    async pullDirectory(skillID, targetDir, params = {}, options) {
-        const archive = await this.exportArchive(skillID, params, options);
-        return extractStoredZipToDirectory(archive.content, targetDir, { replace: params.replace === true });
-    }
 }
 function skillPath(path) {
     return path
@@ -114,148 +106,3 @@ function skillPath(path) {
 function normalizeArchivePath(path) {
     return (path ?? "").trim().replace(/^\/+|\/+$/g, "");
 }
-async function zipDirectory(rootDir) {
-    const fs = await import("node:fs/promises");
-    const path = await import("node:path");
-    const root = path.resolve(rootDir);
-    const files = await walkArchiveFiles(fs, path, root, root);
-    const entries = [];
-    for (const rel of files.sort()) {
-        const content = await fs.readFile(path.join(root, rel));
-        entries.push({ path: rel, data: new Uint8Array(content.buffer, content.byteOffset, content.byteLength) });
-    }
-    return createStoredZip(entries);
-}
-async function walkArchiveFiles(fs, path, root, dir) {
-    const entries = await fs.readdir(dir, { withFileTypes: true });
-    const out = [];
-    for (const entry of entries) {
-        if (entry.name === ".git" || entry.name === "__pycache__" || entry.name === "node_modules") {
-            continue;
-        }
-        const full = path.join(dir, entry.name);
-        if (entry.isDirectory()) {
-            out.push(...await walkArchiveFiles(fs, path, root, full));
-        }
-        else if (entry.isFile()) {
-            out.push(path.relative(root, full).split(path.sep).join("/"));
-        }
-    }
-    return out;
-}
-async function extractStoredZipToDirectory(archive, targetDir, opts) {
-    const fs = await import("node:fs/promises");
-    const path = await import("node:path");
-    const root = path.resolve(targetDir);
-    if (opts.replace) {
-        await fs.rm(root, { recursive: true, force: true });
-    }
-    await fs.mkdir(root, { recursive: true });
-    let fileCount = 0;
-    let byteCount = 0;
-    for (const entry of parseStoredZip(archive)) {
-        const dest = path.resolve(root, entry.path);
-        const rel = path.relative(root, dest);
-        if (rel.startsWith("..") || path.isAbsolute(rel)) {
-            throw new Error(`archive entry escapes target directory: ${entry.path}`);
-        }
-        await fs.mkdir(path.dirname(dest), { recursive: true });
-        await fs.writeFile(dest, entry.data);
-        fileCount += 1;
-        byteCount += entry.data.byteLength;
-    }
-    return { path: root, file_count: fileCount, byte_count: byteCount };
-}
-function createStoredZip(entries) {
-    const encoder = new TextEncoder();
-    const localParts = [];
-    const centralParts = [];
-    let offset = 0;
-    for (const entry of entries) {
-        const name = encoder.encode(entry.path);
-        const crc = crc32(entry.data);
-        const local = new Uint8Array(30 + name.length);
-        const lv = new DataView(local.buffer);
-        lv.setUint32(0, 0x04034b50, true);
-        lv.setUint16(4, 20, true);
-        lv.setUint16(8, 0, true);
-        lv.setUint32(14, crc, true);
-        lv.setUint32(18, entry.data.byteLength, true);
-        lv.setUint32(22, entry.data.byteLength, true);
-        lv.setUint16(26, name.length, true);
-        local.set(name, 30);
-        localParts.push(local, entry.data);
-        const central = new Uint8Array(46 + name.length);
-        const cv = new DataView(central.buffer);
-        cv.setUint32(0, 0x02014b50, true);
-        cv.setUint16(4, 20, true);
-        cv.setUint16(6, 20, true);
-        cv.setUint32(16, crc, true);
-        cv.setUint32(20, entry.data.byteLength, true);
-        cv.setUint32(24, entry.data.byteLength, true);
-        cv.setUint16(28, name.length, true);
-        cv.setUint32(42, offset, true);
-        central.set(name, 46);
-        centralParts.push(central);
-        offset += local.byteLength + entry.data.byteLength;
-    }
-    const centralOffset = offset;
-    const centralSize = centralParts.reduce((sum, part) => sum + part.byteLength, 0);
-    const end = new Uint8Array(22);
-    const ev = new DataView(end.buffer);
-    ev.setUint32(0, 0x06054b50, true);
-    ev.setUint16(8, entries.length, true);
-    ev.setUint16(10, entries.length, true);
-    ev.setUint32(12, centralSize, true);
-    ev.setUint32(16, centralOffset, true);
-    const zip = concatUint8([...localParts, ...centralParts, end]);
-    return zip.buffer.slice(zip.byteOffset, zip.byteOffset + zip.byteLength);
-}
-function parseStoredZip(archive) {
-    const data = new Uint8Array(archive);
-    const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
-    const entries = [];
-    let pos = 0;
-    const decoder = new TextDecoder();
-    while (pos + 4 <= data.byteLength && view.getUint32(pos, true) === 0x04034b50) {
-        const method = view.getUint16(pos + 8, true);
-        if (method !== 0) {
-            throw new Error("Only stored ZIP entries are supported by pullDirectory");
-        }
-        const compressedSize = view.getUint32(pos + 18, true);
-        const fileNameLength = view.getUint16(pos + 26, true);
-        const extraLength = view.getUint16(pos + 28, true);
-        const nameStart = pos + 30;
-        const contentStart = nameStart + fileNameLength + extraLength;
-        const contentEnd = contentStart + compressedSize;
-        if (contentEnd > data.byteLength) {
-            throw new Error("Invalid ZIP archive");
-        }
-        const name = decoder.decode(data.slice(nameStart, nameStart + fileNameLength)).replace(/\\/g, "/");
-        if (name && !name.endsWith("/") && !name.startsWith("__MACOSX/") && !name.split("/").includes("..")) {
-            entries.push({ path: name.replace(/^\/+/, ""), data: data.slice(contentStart, contentEnd) });
-        }
-        pos = contentEnd;
-    }
-    return entries;
-}
-function concatUint8(parts) {
-    const total = parts.reduce((sum, part) => sum + part.byteLength, 0);
-    const out = new Uint8Array(total);
-    let offset = 0;
-    for (const part of parts) {
-        out.set(part, offset);
-        offset += part.byteLength;
-    }
-    return out;
-}
-function crc32(data) {
-    let crc = 0xffffffff;
-    for (const byte of data) {
-        crc ^= byte;
-        for (let i = 0; i < 8; i += 1) {
-            crc = (crc >>> 1) ^ (0xedb88320 & -(crc & 1));
-        }
-    }
-    return (crc ^ 0xffffffff) >>> 0;
-}