@agent-api/sdk 1.0.5 → 1.0.8

package/CHANGELOG.md

@@ -1,5 +1,26 @@
 # Changelog — @agent-api/sdk
 
+## 1.0.8
+
+### Changed
+
+- Expanded `reasoning.effort` types to match the Responses-compatible enum: `none`, `minimal`, `low`, `medium`, `high`, and `xhigh`.
+
+## 1.0.7
+
+### Added
+
+- Skill artifact archive APIs: `client.skills.exportArchive()` and `client.skills.importArchive()`.
+- Local directory sync helpers for platform skills: `client.skills.pushDirectory()` and `client.skills.pullDirectory()`.
+- Skill branch diff API and file-level `acceptDev()` strategies (`patch` or `mirror`).
+
+## 1.0.6
+
+### Changed
+
+- Replaced skill focus `max_manifest_bytes` with `max_manifest_chars`.
+- Local skill `SKILL.md` manifests are decoded as strict UTF-8 and truncated by characters.
+
 ## 1.0.5
 
 ### Added

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.0.5)
+**Published on npm:** [`@agent-api/sdk`](https://www.npmjs.com/package/@agent-api/sdk) (v1.0.8)
 
 ## Install
 
@@ -60,7 +60,7 @@ 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`, `acceptDev`, `discardDev`, `listFiles`, `readFile`, `writeFile`, `deleteFile` |
+| `client.skills` | `list`, `create`, `discover`, `focus`, `createDev`, `updateFile`, `retrieve`, `update`, `archive`, `delete`, `diff`, `acceptDev`, `discardDev`, `exportArchive`, `importArchive`, `pushDirectory`, `pullDirectory`, `listFiles`, `readFile`, `writeFile`, `deleteFile` |
 
 ## Durable Volumes
 
@@ -80,6 +80,8 @@ const response = await client.agent.create({
 
 ## 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";
 

package/dist/local-skills.d.ts

@@ -5,6 +5,7 @@ export interface LocalSkillDirectoryOptions {
     id?: string;
     name?: string;
     description?: string;
+    max_manifest_chars?: number;
     metadata?: Record<string, unknown>;
 }
 export declare function localSkillFromDirectory(rootDir: string, options?: LocalSkillDirectoryOptions): Promise<LocalSkillDescriptor>;

package/dist/local-skills.js

@@ -1,4 +1,6 @@
 import { functionCallOutputInput, pendingFunctionCalls } from "./local-functions.js";
+const DEFAULT_FOCUS_MANIFEST_CHARS = 16000;
+const DEFAULT_FOCUS_FILE_CHARS = 12000;
 export async function localSkillFromDirectory(rootDir, options = {}) {
     const fs = await import("node:fs/promises");
     const path = await import("node:path");
@@ -14,12 +16,17 @@ export async function localSkillFromDirectory(rootDir, options = {}) {
     }
     const digest = "sha256:" + hash.digest("hex");
     const base = path.basename(root);
+    const localSkillID = options.id ?? base;
+    const { manifest, manifestTruncated } = await readLocalManifest(fs, path, root, options.max_manifest_chars ?? DEFAULT_FOCUS_MANIFEST_CHARS);
     return {
-        local_skill_id: options.id ?? base,
+        local_skill_id: localSkillID,
+        skill_ref: skillRefForLocal(localSkillID, digest),
         name: options.name ?? base,
         description: options.description,
         root_hint: root,
         digest,
+        manifest,
+        manifest_truncated: manifestTruncated,
         metadata: options.metadata,
     };
 }
@@ -27,17 +34,18 @@ export function pendingLocalSkillCalls(response) {
     return pendingFunctionCalls(response).filter((call) => call.name === "skill_focus");
 }
 export async function runLocalSkillHandlers(response, localSkills) {
-    const byID = new Map(localSkills.map((skill) => [skill.local_skill_id, skill]));
+    const byRef = await localSkillsByRef(localSkills);
     const outputs = [];
     for (const call of pendingLocalSkillCalls(response)) {
         const args = call.arguments ? JSON.parse(call.arguments) : {};
-        const payload = await focusLocalSkills(args, byID);
+        const payload = await focusLocalSkills(args, byRef);
         outputs.push(functionCallOutputInput(call.call_id, payload));
     }
     return outputs;
 }
-async function focusLocalSkills(args, byID) {
-    const maxManifestBytes = Number(args.max_manifest_bytes || 16 * 1024);
+async function focusLocalSkills(args, byRef) {
+    const maxManifestChars = manifestCharLimit(args);
+    const maxFileChars = fileCharLimit(args);
     const items = Array.isArray(args.skills) ? args.skills : [];
     if (!Array.isArray(args.skills)) {
         return { data: [{ ok: false, error: { code: "invalid_skill_focus", message: "skills must be an array" } }] };
@@ -49,16 +57,16 @@ async function focusLocalSkills(args, byID) {
             continue;
         }
         const item = raw;
-        const localSkillID = String(item.local_skill_id || "").trim();
-        const result = { ok: false, local_skill_id: localSkillID, branch: "main" };
-        const descriptor = byID.get(localSkillID);
+        const skillRef = String(item.skill_ref || "").trim();
+        const result = { ok: false, skill_ref: skillRef, branch: "main" };
+        const descriptor = byRef.get(skillRef);
         if (!descriptor) {
-            result.error = { code: "local_skill_not_found", message: "local_skill_id was not registered with the SDK" };
+            result.error = { code: "skill_ref_not_found", message: "skill_ref was not registered with the SDK" };
             data.push(result);
             continue;
         }
         try {
-            result.skill = await focusedLocalSkill(descriptor, maxManifestBytes);
+            result.skill = await focusedLocalSkill(descriptor, maxManifestChars, pathsArg(item), maxFileChars, includeManifest(item));
             result.ok = true;
         }
         catch (error) {
@@ -68,9 +76,10 @@ async function focusLocalSkills(args, byID) {
     }
     return { data };
 }
-async function focusedLocalSkill(descriptor, maxManifestBytes) {
+async function focusedLocalSkill(descriptor, maxManifestChars, paths, maxFileChars, includeManifest) {
     const fs = await import("node:fs/promises");
     const path = await import("node:path");
+    const { TextDecoder } = await import("node:util");
     const root = path.resolve(descriptor.root_hint || ".");
     const stat = await fs.stat(root);
     if (!stat.isDirectory()) {
@@ -78,17 +87,20 @@ async function focusedLocalSkill(descriptor, maxManifestBytes) {
     }
     let manifest = "";
     let manifestTruncated = false;
-    try {
-        let manifestBytes = await fs.readFile(path.join(root, "SKILL.md"));
-        if (maxManifestBytes > 0 && manifestBytes.length > maxManifestBytes) {
-            manifestBytes = manifestBytes.subarray(0, maxManifestBytes);
-            manifestTruncated = true;
+    if (includeManifest) {
+        try {
+            const manifestBytes = await fs.readFile(path.join(root, "SKILL.md"));
+            manifest = new TextDecoder("utf-8", { fatal: true }).decode(manifestBytes);
+            const manifestChars = Array.from(manifest);
+            if (maxManifestChars > 0 && manifestChars.length > maxManifestChars) {
+                manifest = manifestChars.slice(0, maxManifestChars).join("");
+                manifestTruncated = true;
+            }
         }
-        manifest = manifestBytes.toString("utf8");
-    }
-    catch (error) {
-        if (error?.code !== "ENOENT") {
-            throw error;
+        catch (error) {
+            if (error?.code !== "ENOENT") {
+                throw error;
+            }
         }
     }
     const dirents = await fs.readdir(root, { withFileTypes: true });
@@ -106,20 +118,72 @@ async function focusedLocalSkill(descriptor, maxManifestBytes) {
         };
     }));
     return {
-        source_type: "SKILL_SOURCE_TYPE_LOCAL",
-        local_skill_id: descriptor.local_skill_id,
+        skill_ref: await descriptorSkillRef(descriptor),
         name: descriptor.name || "",
         description: descriptor.description || "",
         branch: "SKILL_BRANCH_MAIN",
         digest: descriptor.digest || "",
-        artifact_uri: "local://" + root.replace(/^\/+/, ""),
-        mount_hint: root,
         manifest,
         manifest_truncated: manifestTruncated,
         entries,
-        metadata: descriptor.metadata || {},
+        files: await Promise.all(paths.map((relPath) => focusedLocalFile(fs, path, root, relPath, maxFileChars))),
     };
 }
+function manifestCharLimit(args) {
+    const raw = args.max_manifest_chars ?? DEFAULT_FOCUS_MANIFEST_CHARS;
+    const value = Number(raw);
+    return Number.isFinite(value) ? value : DEFAULT_FOCUS_MANIFEST_CHARS;
+}
+function fileCharLimit(args) {
+    const raw = args.max_file_chars ?? DEFAULT_FOCUS_FILE_CHARS;
+    const value = Number(raw);
+    return Number.isFinite(value) ? value : DEFAULT_FOCUS_FILE_CHARS;
+}
+function pathsArg(item) {
+    if (!Array.isArray(item.paths)) {
+        return [];
+    }
+    return item.paths
+        .filter((value) => typeof value === "string")
+        .map((value) => value.trim())
+        .filter(Boolean);
+}
+function includeManifest(item) {
+    return typeof item.include_manifest === "boolean" ? item.include_manifest : true;
+}
+async function focusedLocalFile(fs, path, root, relPath, maxFileChars) {
+    const base = { path: relPath, branch: "SKILL_BRANCH_MAIN", content: "", truncated: false, size: 0 };
+    const { TextDecoder } = await import("node:util");
+    try {
+        const full = path.resolve(root, relPath);
+        const relative = path.relative(root, full);
+        if (relative.startsWith("..") || path.isAbsolute(relative)) {
+            return { ...base, error: { type: "skill_error", code: "invalid_skill_file_path", message: "path must stay inside the local skill root" } };
+        }
+        const stat = await fs.stat(full);
+        if (!stat.isFile()) {
+            return { ...base, error: { type: "skill_error", code: "skill_file_not_found", message: "skill file was not found" } };
+        }
+        const raw = await fs.readFile(full);
+        let content = new TextDecoder("utf-8", { fatal: true }).decode(raw);
+        let truncated = false;
+        const chars = Array.from(content);
+        if (maxFileChars > 0 && chars.length > maxFileChars) {
+            content = chars.slice(0, maxFileChars).join("");
+            truncated = true;
+        }
+        return { ...base, content, truncated, size: stat.size };
+    }
+    catch (error) {
+        if (error?.code === "ENOENT") {
+            return { ...base, error: { type: "skill_error", code: "skill_file_not_found", message: "skill file was not found" } };
+        }
+        if (error instanceof TypeError) {
+            return { ...base, error: { type: "skill_error", code: "invalid_skill_file_utf8", message: "skill file must be valid UTF-8" } };
+        }
+        return { ...base, error: { type: "skill_error", code: "skill_file_read_failed", message: error instanceof Error ? error.message : String(error) } };
+    }
+}
 async function walkFiles(fs, path, root, dir) {
     const entries = await fs.readdir(dir, { withFileTypes: true });
     const out = [];
@@ -138,3 +202,57 @@ async function walkFiles(fs, path, root, dir) {
     }
     return out;
 }
+async function localSkillsByRef(localSkills) {
+    const out = new Map();
+    for (const skill of localSkills) {
+        out.set(await descriptorSkillRef(skill), skill);
+    }
+    return out;
+}
+async function descriptorSkillRef(descriptor) {
+    const existing = String(descriptor.skill_ref || "").trim();
+    if (existing) {
+        return existing;
+    }
+    return skillRefForLocal(descriptor.local_skill_id || "", descriptor.digest || "");
+}
+function skillRefForLocal(localSkillID, digest) {
+    const slug = skillRefSlug(localSkillID) || "local-skill";
+    const digestPart = skillRefDigestPart(digest) || "unknown";
+    return `local::${slug}@${digestPart}::main`;
+}
+function skillRefSlug(raw) {
+    return raw
+        .trim()
+        .toLowerCase()
+        .replace(/::/g, "-")
+        .replace(/@/g, "-")
+        .replace(/[^a-z0-9_-]+/g, "-")
+        .replace(/^[-_]+|[-_]+$/g, "")
+        .slice(0, 64)
+        .replace(/^[-_]+|[-_]+$/g, "");
+}
+function skillRefDigestPart(raw) {
+    const digest = raw.trim().toLowerCase().split(":").pop() || "";
+    return digest.replace(/[^a-z0-9_-]+/g, "").slice(0, 16);
+}
+async function readLocalManifest(fs, path, root, maxManifestChars) {
+    const { TextDecoder } = await import("node:util");
+    try {
+        const raw = await fs.readFile(path.join(root, "SKILL.md"));
+        let manifest = new TextDecoder("utf-8", { fatal: true }).decode(raw);
+        let manifestTruncated = false;
+        const chars = Array.from(manifest);
+        if (maxManifestChars > 0 && chars.length > maxManifestChars) {
+            manifest = chars.slice(0, maxManifestChars).join("");
+            manifestTruncated = true;
+        }
+        return { manifest, manifestTruncated };
+    }
+    catch (error) {
+        if (error?.code === "ENOENT") {
+            return { manifest: "", manifestTruncated: false };
+        }
+        throw error;
+    }
+}

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, ListSkillFilesParams, ListSkillFilesResponse, ListSkillsParams, ListSkillsResponse, ListSkillSummariesResponse, Skill, SkillFile, SkillBranch, SkillFocusResponse, UpdateSkillFilePrimitiveParams, UpdateSkillFilePrimitiveResponse, UpdateSkillParams } from "../types/skills.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";
 export declare class SkillsResource {
     private readonly http;
     constructor(http: HTTPClient);
@@ -16,7 +16,9 @@ export declare class SkillsResource {
     delete(skillID: string, options?: RequestOptions): Promise<{
         deleted: boolean;
     }>;
-    acceptDev(skillID: string, options?: RequestOptions): Promise<Skill>;
+    acceptDev(skillID: string, params?: {
+        strategy?: SkillAcceptStrategy;
+    }, options?: RequestOptions): Promise<Skill>;
     discardDev(skillID: string, options?: RequestOptions): Promise<Skill>;
     listFiles(skillID: string, params?: ListSkillFilesParams, options?: RequestOptions): Promise<ListSkillFilesResponse>;
     readFile(skillID: string, path: string, params?: {
@@ -30,4 +32,9 @@ export declare class SkillsResource {
     deleteFile(skillID: string, path: string, params?: {
         branch?: SkillBranch;
     }, options?: RequestOptions): Promise<SkillFile>;
+    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

@@ -38,8 +38,8 @@ export class SkillsResource {
     delete(skillID, options) {
         return this.http.request("DELETE", `/v1/skills/${encodeURIComponent(skillID)}`, undefined, options);
     }
-    acceptDev(skillID, options) {
-        return this.http.request("POST", `/v1/skills/${encodeURIComponent(skillID)}/accept_dev`, {}, options);
+    acceptDev(skillID, params = {}, options) {
+        return this.http.request("POST", `/v1/skills/${encodeURIComponent(skillID)}/accept_dev${buildQuery({ strategy: params.strategy })}`, {}, options);
     }
     discardDev(skillID, options) {
         return this.http.request("POST", `/v1/skills/${encodeURIComponent(skillID)}/discard_dev`, {}, options);
@@ -66,6 +66,43 @@ export class SkillsResource {
     deleteFile(skillID, path, params = {}, options) {
         return this.http.request("DELETE", `/v1/skills/${encodeURIComponent(skillID)}/files/${skillPath(path)}${buildQuery({ branch: params.branch })}`, undefined, options);
     }
+    exportArchive(skillID, params = {}, options) {
+        const archivePath = normalizeArchivePath(params.path);
+        return this.http
+            .requestBinary("GET", `/v1/skills/${encodeURIComponent(skillID)}/export${buildQuery({
+            path: archivePath || undefined,
+            branch: params.branch,
+            fallback_to_main: params.fallback_to_main === false ? "false" : undefined,
+        })}`, options)
+            .then(({ body, headers }) => ({
+            path: archivePath,
+            content: body,
+            content_type: headers.get("Content-Type") ?? undefined,
+        }));
+    }
+    importArchive(skillID, archive, params = {}, options) {
+        return this.http.requestRaw("POST", `/v1/skills/${encodeURIComponent(skillID)}/import${buildQuery({
+            path: normalizeArchivePath(params.path) || undefined,
+            branch: params.branch,
+            replace: params.replace ? "true" : undefined,
+            strip_top_level_dir: params.strip_top_level_dir === false ? "false" : undefined,
+        })}`, archive, options);
+    }
+    diff(skillID, params = {}, options) {
+        return this.http.request("GET", `/v1/skills/${encodeURIComponent(skillID)}/diff${buildQuery({
+            path: normalizeArchivePath(params.path) || undefined,
+            max_file_chars: params.max_file_chars,
+            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
@@ -74,3 +111,151 @@ function skillPath(path) {
         .map((part) => encodeURIComponent(part))
         .join("/");
 }
+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;
+}

package/dist/types/input.d.ts

@@ -37,7 +37,7 @@ export interface FunctionCallOutputInput {
 export type InputItem = InputMessage | FunctionCallInput | FunctionCallOutputInput;
 export type Input = string | InputItem[];
 export interface ReasoningConfig {
-    effort?: "low" | "medium" | "high";
+    effort?: "none" | "minimal" | "low" | "medium" | "high" | "xhigh";
 }
 export interface ResponseFormat {
     type: "json_schema";

package/dist/types/skills.d.ts

@@ -1,15 +1,20 @@
 export type SkillSourceType = "SKILL_SOURCE_TYPE_PLATFORM" | "SKILL_SOURCE_TYPE_LOCAL" | "SKILL_SOURCE_TYPE_GENERATED" | string;
 export type SkillBranch = "main" | "dev" | string;
+export type SkillAcceptStrategy = "patch" | "mirror";
+export type SkillBranchDiffStatus = "added" | "modified" | "deleted" | "unchanged" | string;
 export interface SkillReference {
     skill_id: string;
     branch?: SkillBranch;
 }
 export interface LocalSkillDescriptor {
     local_skill_id: string;
+    skill_ref?: string;
     name?: string;
     description?: string;
     root_hint?: string;
     digest?: string;
+    manifest?: string;
+    manifest_truncated?: boolean;
     metadata?: Record<string, unknown>;
 }
 export interface Skill {
@@ -34,6 +39,7 @@ export interface Skill {
 export interface SkillSummary {
     object: "skill_summary";
     skill_id: string;
+    skill_ref?: string;
     name?: string;
     description?: string;
     source_type?: SkillSourceType;
@@ -49,10 +55,21 @@ export interface FocusedSkill extends Omit<SkillSummary, "object"> {
     manifest?: string;
     manifest_truncated?: boolean;
     entries?: SkillFileEntry[];
+    files?: SkillFocusedFile[];
+}
+export interface SkillFocusedFile {
+    path: string;
+    content?: string;
+    truncated?: boolean;
+    size?: number;
+    branch?: SkillBranch;
+    error?: SkillOperationError;
 }
 export interface SkillFocusItem {
     skill_id?: string;
     branch?: SkillBranch;
+    paths?: string[];
+    include_manifest?: boolean;
     local_skill?: LocalSkillDescriptor;
 }
 export interface SkillOperationError {
@@ -61,6 +78,7 @@ export interface SkillOperationError {
 }
 export interface SkillFocusResultItem {
     ok: boolean;
+    skill_ref?: string;
     skill_id?: string;
     local_skill_id?: string;
     branch?: SkillBranch;
@@ -102,7 +120,8 @@ export interface DiscoverSkillsParams {
 export interface FocusSkillParams {
     skills: SkillFocusItem[];
     fallback_to_main?: boolean;
-    max_manifest_bytes?: number;
+    max_manifest_chars?: number;
+    max_file_chars?: number;
 }
 export interface SkillFileMutation {
     path: string;
@@ -164,6 +183,69 @@ export interface SkillFile {
     truncated?: boolean;
     recursive?: boolean;
 }
+export interface SkillArchiveParams {
+    path?: string;
+    branch?: SkillBranch;
+    fallback_to_main?: boolean;
+}
+export interface SkillArchive {
+    path: string;
+    content: ArrayBuffer;
+    content_type?: string;
+}
+export interface ImportSkillArchiveParams {
+    path?: string;
+    branch?: SkillBranch;
+    replace?: boolean;
+    strip_top_level_dir?: boolean;
+}
+export interface SkillImportResponse {
+    object: "skill_import_result";
+    branch: SkillBranch;
+    file_count: number;
+    byte_count: number;
+    skill: Skill;
+}
+export interface SkillBranchDiffParams {
+    path?: string;
+    max_file_chars?: number;
+    include_unchanged?: boolean;
+}
+export interface SkillBranchDiffFile {
+    path: string;
+    status: SkillBranchDiffStatus;
+    base_size?: number;
+    compare_size?: number;
+    text?: boolean;
+    binary?: boolean;
+    too_large?: boolean;
+    truncated?: boolean;
+    diff?: string;
+}
+export interface SkillBranchDiff {
+    object: "skill_branch_diff";
+    skill_id: string;
+    base_branch: SkillBranch;
+    compare_branch: SkillBranch;
+    path?: string;
+    summary: {
+        added: number;
+        modified: number;
+        deleted: number;
+        unchanged: number;
+    };
+    files: SkillBranchDiffFile[];
+}
+export interface PushSkillDirectoryParams extends ImportSkillArchiveParams {
+}
+export interface PullSkillDirectoryParams extends SkillArchiveParams {
+    replace?: boolean;
+}
+export interface SkillDirectoryPullResult {
+    path: string;
+    file_count: number;
+    byte_count: number;
+}
 export interface CreateSkillParams {
     name?: string;
     description?: string;

package/dist/version.d.ts

@@ -1,2 +1,2 @@
-export declare const VERSION = "1.0.5";
-export declare const USER_AGENT = "@agent-api/sdk/1.0.5";
+export declare const VERSION = "1.0.8";
+export declare const USER_AGENT = "@agent-api/sdk/1.0.8";

package/dist/version.js

@@ -1,2 +1,2 @@
-export const VERSION = "1.0.5";
+export const VERSION = "1.0.8";
 export const USER_AGENT = `@agent-api/sdk/${VERSION}`;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agent-api/sdk",
-  "version": "1.0.5",
+  "version": "1.0.8",
   "description": "Production JavaScript SDK for the Managed Agent API",
   "license": "MIT",
   "repository": {