@botlearn-course/daemon 0.0.13 → 0.0.15

package/dist/runtime-skills.js

@@ -0,0 +1,401 @@
+const SHA256_PATTERN = /^sha256:[0-9a-f]{64}$/;
+const UUID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+const LOGICAL_ID_PATTERN = /^[a-z0-9]+(?:[.-][a-z0-9]+)*$/;
+const STRICT_SEMVER_PATTERN = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-(?:0|[1-9]\d*|\d*[A-Za-z-][0-9A-Za-z-]*)(?:\.(?:0|[1-9]\d*|\d*[A-Za-z-][0-9A-Za-z-]*))*)?$/;
+const RFC3339_PATTERN = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{1,9})?(?:Z|[+-]\d{2}:\d{2})$/;
+const CAPABILITY_PATTERN = /^[a-z0-9]+(?:[._-][a-z0-9]+)*$/;
+const MAX_SKILLS = 32;
+const MAX_CATALOG_DESCRIPTION_CODE_POINTS = 500;
+const MAX_PROVIDER_RESPONSE_BYTES = 512 * 1024;
+const MAX_LOADED_CONTENT_BYTES = 256 * 1024;
+const MAX_BINDING_LIFETIME_MS = 24 * 60 * 60 * 1000;
+export const COURSE_SKILLS_BINDING_SCHEMA = "course-skills-binding/0.1";
+export const COURSE_SKILLS_PROTOCOL = "course-skills/0.1";
+export const COURSE_SKILLS_CALL_SCHEMA = "course-skills-call/0.1";
+export class RuntimeSkillProviderError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+        this.name = "RuntimeSkillProviderError";
+    }
+}
+export function parseRuntimeSkillProviderBinding(raw, now = Date.now(), options = {}) {
+    const record = skillProviderBindingRecord(raw);
+    validateBindingProtocol(record);
+    const endpoint = providerEndpoint(record.endpoint, options.allowInsecureLoopbackForTests === true);
+    const bearerToken = requiredString(record.bearerToken, "bearerToken", 16, 4096);
+    const expiresAt = requiredString(record.expiresAt, "expiresAt", 20, 64);
+    const expiresAtMs = Date.parse(expiresAt);
+    if (!RFC3339_PATTERN.test(expiresAt) ||
+        !Number.isFinite(expiresAtMs)
+        || expiresAtMs <= now
+        || expiresAtMs > now + MAX_BINDING_LIFETIME_MS) {
+        throw new RuntimeSkillProviderError("skill_provider_binding_expired", "Skill Provider binding expiry is invalid");
+    }
+    const effectiveSkillGrants = parseEffectiveSkillGrants(record.effectiveSkillGrants);
+    return {
+        schemaVersion: COURSE_SKILLS_BINDING_SCHEMA,
+        protocol: COURSE_SKILLS_PROTOCOL,
+        endpoint,
+        bearerToken,
+        expiresAt: new Date(expiresAtMs).toISOString(),
+        effectiveSkillGrants,
+    };
+}
+/**
+ * Parse only the stable grant identity of a replayed binding.
+ *
+ * Credential values remain the first accepted activation snapshot, so replay validation
+ * deliberately checks their shape but not their endpoint/expiry semantics.
+ */
+export function parseRuntimeSkillProviderGrantSet(raw) {
+    const record = skillProviderBindingRecord(raw);
+    validateBindingProtocol(record);
+    requiredString(record.endpoint, "endpoint", 10, 2048);
+    requiredString(record.bearerToken, "bearerToken", 16, 4096);
+    requiredString(record.expiresAt, "expiresAt", 20, 64);
+    return parseEffectiveSkillGrants(record.effectiveSkillGrants);
+}
+export async function prepareRuntimeSkillProvider(rawBinding, options = {}) {
+    const now = options.now ?? Date.now;
+    const binding = parseRuntimeSkillProviderBinding(rawBinding, now(), {
+        allowInsecureLoopbackForTests: options.allowInsecureLoopbackForTests,
+    });
+    const provider = new HttpRuntimeSkillProvider(binding, {
+        fetchFn: options.fetchFn,
+        now,
+    });
+    const catalog = await provider.listEligibleSkills();
+    return { binding, provider, catalog };
+}
+export class HttpRuntimeSkillProvider {
+    binding;
+    fetchFn;
+    now;
+    grantsByRef;
+    constructor(binding, options = {}) {
+        this.binding = binding;
+        this.fetchFn = options.fetchFn ?? fetch;
+        this.now = options.now ?? Date.now;
+        this.grantsByRef = new Map(binding.effectiveSkillGrants.map((grant) => [grant.ref, grant]));
+    }
+    async listEligibleSkills() {
+        const envelope = await this.call("list", {});
+        const data = resultData(envelope, "skill_catalog_listed");
+        if (!Array.isArray(data.skills)) {
+            throw providerResponseError("Skill Provider catalog is invalid");
+        }
+        const catalog = data.skills.map(parseCatalogEntry);
+        if (catalog.length !== this.binding.effectiveSkillGrants.length) {
+            throw new RuntimeSkillProviderError("skill_provider_catalog_mismatch", "Skill Provider catalog does not match the activation grants");
+        }
+        for (let index = 0; index < catalog.length; index += 1) {
+            const expected = this.binding.effectiveSkillGrants[index];
+            const actual = catalog[index];
+            if (actual.assetVersionId !== expected.assetVersionId
+                || actual.ref !== expected.ref
+                || actual.digest !== expected.digest) {
+                throw new RuntimeSkillProviderError("skill_provider_catalog_mismatch", "Skill Provider catalog does not match the activation grants");
+            }
+        }
+        return catalog;
+    }
+    async loadSkill(ref) {
+        const grant = this.requireEligible(ref);
+        const envelope = await this.call("load", { ref });
+        const data = resultData(envelope, "skill_loaded");
+        return parseLoadedSkill(data, grant);
+    }
+    async loadReference(ref, referencePath) {
+        const grant = this.requireEligible(ref);
+        const safePath = safeReferencePath(referencePath);
+        const envelope = await this.call("load_reference", { ref, path: safePath });
+        const data = resultData(envelope, "skill_reference_loaded");
+        const loaded = parseLoadedSkill(data, grant);
+        if (data.path !== safePath) {
+            throw providerResponseError("Skill Provider reference path does not match the request");
+        }
+        return { ...loaded, path: safePath };
+    }
+    requireEligible(ref) {
+        const grant = this.grantsByRef.get(ref);
+        if (!grant) {
+            throw new RuntimeSkillProviderError("skill_not_eligible", "Skill is not eligible for the current activation");
+        }
+        return grant;
+    }
+    async call(operation, input) {
+        if (Date.parse(this.binding.expiresAt) <= this.now()) {
+            throw new RuntimeSkillProviderError("agent_run_activation_expired", "Skill Provider binding has expired");
+        }
+        let response;
+        try {
+            response = await this.fetchFn(this.binding.endpoint, {
+                method: "POST",
+                headers: {
+                    authorization: `Bearer ${this.binding.bearerToken}`,
+                    "content-type": "application/json",
+                },
+                body: JSON.stringify({
+                    schemaVersion: COURSE_SKILLS_CALL_SCHEMA,
+                    operation,
+                    ...input,
+                }),
+                signal: AbortSignal.timeout(10_000),
+                redirect: "error",
+            });
+        }
+        catch {
+            throw new RuntimeSkillProviderError("skill_provider_unavailable", "Skill Provider request failed");
+        }
+        const envelope = await readBoundedJson(response);
+        if (!response.ok) {
+            const code = safeErrorCode(envelope.code) ?? "skill_provider_unavailable";
+            throw new RuntimeSkillProviderError(code, "Skill Provider rejected the request");
+        }
+        return envelope;
+    }
+}
+export function safeReferencePath(value) {
+    if (typeof value !== "string"
+        || value.length < 1
+        || Buffer.byteLength(value, "utf8") > 240
+        || value.includes("\\")
+        || value.includes("\0")
+        || value.startsWith("/")
+        || value.split("/").some((part) => part === "" || part === "." || part === "..")) {
+        throw new RuntimeSkillProviderError("skill_reference_invalid", "Skill reference path is invalid");
+    }
+    return value;
+}
+function parseGrant(raw) {
+    const record = exactRecord(raw, ["assetVersionId", "ref", "digest"], "Skill grant");
+    const assetVersionId = requiredString(record.assetVersionId, "assetVersionId", 36, 36);
+    const ref = requiredString(record.ref, "ref", 5, 240);
+    const digest = requiredString(record.digest, "digest", 71, 71);
+    const separator = ref.lastIndexOf("@");
+    const logicalId = separator > 0 ? ref.slice(0, separator) : "";
+    const version = separator > 0 ? ref.slice(separator + 1) : "";
+    if (!UUID_PATTERN.test(assetVersionId)
+        || !LOGICAL_ID_PATTERN.test(logicalId)
+        || !STRICT_SEMVER_PATTERN.test(version)
+        || !SHA256_PATTERN.test(digest)) {
+        throw new RuntimeSkillProviderError("skill_provider_binding_invalid", "Skill grant identity is invalid");
+    }
+    return { assetVersionId, ref, digest };
+}
+function parseCatalogEntry(raw) {
+    try {
+        return parseCatalogEntryValue(raw);
+    }
+    catch (error) {
+        if (error instanceof RuntimeSkillProviderError
+            && error.code === "skill_provider_invalid_response") {
+            throw error;
+        }
+        throw providerResponseError("Skill Provider catalog entry is invalid");
+    }
+}
+function parseCatalogEntryValue(raw) {
+    const record = exactRecord(raw, [
+        "assetVersionId",
+        "ref",
+        "digest",
+        "name",
+        "description",
+        "version",
+        "requiredCapabilities",
+    ], "Skill catalog entry");
+    const grant = parseGrant({
+        assetVersionId: record.assetVersionId,
+        ref: record.ref,
+        digest: record.digest,
+    });
+    const name = requiredString(record.name, "name", 1, 160);
+    const description = requiredString(record.description, "description", 1, 2000);
+    const version = requiredString(record.version, "version", 5, 64);
+    if (Array.from(description).length > MAX_CATALOG_DESCRIPTION_CODE_POINTS) {
+        throw providerResponseError("Skill catalog description is too long");
+    }
+    if (!Array.isArray(record.requiredCapabilities) || record.requiredCapabilities.length > 32) {
+        throw providerResponseError("Skill catalog capabilities are invalid");
+    }
+    const requiredCapabilities = record.requiredCapabilities.map((value) => {
+        if (typeof value !== "string" || !CAPABILITY_PATTERN.test(value)) {
+            throw providerResponseError("Skill catalog capability is invalid");
+        }
+        return value;
+    });
+    if (new Set(requiredCapabilities).size !== requiredCapabilities.length
+        || !isUtf8Sorted(requiredCapabilities)) {
+        throw providerResponseError("Skill catalog capabilities must be unique and sorted");
+    }
+    const refVersion = grant.ref.slice(grant.ref.lastIndexOf("@") + 1);
+    if (version !== refVersion) {
+        throw providerResponseError("Skill catalog version does not match ref");
+    }
+    return { ...grant, name, description, version, requiredCapabilities };
+}
+function parseLoadedSkill(data, grant) {
+    try {
+        const ref = requiredString(data.ref, "ref", 5, 240);
+        const digest = requiredString(data.digest, "digest", 71, 71);
+        const content = requiredString(data.content, "content", 1, MAX_LOADED_CONTENT_BYTES);
+        const bytes = data.bytes;
+        const truncated = data.truncated;
+        const actualBytes = Buffer.byteLength(content, "utf8");
+        if (ref !== grant.ref
+            || digest !== grant.digest
+            || !Number.isInteger(bytes)
+            || bytes !== actualBytes
+            || actualBytes > MAX_LOADED_CONTENT_BYTES
+            || typeof truncated !== "boolean") {
+            throw providerResponseError("Skill Provider content response is invalid");
+        }
+        return { ref, digest, content, bytes: actualBytes, truncated };
+    }
+    catch (error) {
+        if (error instanceof RuntimeSkillProviderError
+            && error.code === "skill_provider_invalid_response") {
+            throw error;
+        }
+        throw providerResponseError("Skill Provider content response is invalid");
+    }
+}
+function providerEndpoint(value, allowInsecureLoopback) {
+    const raw = requiredString(value, "endpoint", 10, 2048);
+    let parsed;
+    try {
+        parsed = new URL(raw);
+    }
+    catch {
+        throw new RuntimeSkillProviderError("skill_provider_binding_invalid", "Skill Provider endpoint is invalid");
+    }
+    if (parsed.username || parsed.password || parsed.hash) {
+        throw new RuntimeSkillProviderError("skill_provider_binding_invalid", "Skill Provider endpoint cannot contain credentials or a fragment");
+    }
+    const loopback = parsed.hostname === "127.0.0.1"
+        || parsed.hostname === "::1"
+        || parsed.hostname === "[::1]"
+        || parsed.hostname === "localhost";
+    if (parsed.protocol !== "https:"
+        && !(allowInsecureLoopback && parsed.protocol === "http:" && loopback)) {
+        throw new RuntimeSkillProviderError("skill_provider_binding_invalid", "Skill Provider endpoint must use HTTPS");
+    }
+    return parsed.toString();
+}
+function skillProviderBindingRecord(raw) {
+    return exactRecord(raw, [
+        "schemaVersion",
+        "protocol",
+        "endpoint",
+        "bearerToken",
+        "expiresAt",
+        "effectiveSkillGrants",
+    ], "Skill Provider binding");
+}
+function validateBindingProtocol(record) {
+    if (record.schemaVersion !== COURSE_SKILLS_BINDING_SCHEMA) {
+        throw new RuntimeSkillProviderError("skill_provider_binding_invalid", "Skill Provider binding schemaVersion is unsupported");
+    }
+    if (record.protocol !== COURSE_SKILLS_PROTOCOL) {
+        throw new RuntimeSkillProviderError("skill_provider_binding_invalid", "Skill Provider protocol is unsupported");
+    }
+}
+function parseEffectiveSkillGrants(raw) {
+    if (!Array.isArray(raw)) {
+        throw new RuntimeSkillProviderError("skill_provider_binding_invalid", "Skill Provider grants must be an array");
+    }
+    if (raw.length < 1 || raw.length > MAX_SKILLS) {
+        throw new RuntimeSkillProviderError("skill_provider_binding_invalid", `Skill Provider grants must contain 1 to ${MAX_SKILLS} entries`);
+    }
+    const grants = raw.map(parseGrant);
+    const refs = grants.map((grant) => grant.ref);
+    if (new Set(refs).size !== refs.length) {
+        throw new RuntimeSkillProviderError("skill_provider_binding_invalid", "Skill Provider grants contain duplicate refs");
+    }
+    if (!isUtf8Sorted(refs)) {
+        throw new RuntimeSkillProviderError("skill_provider_binding_invalid", "Skill Provider grants must be sorted by ref UTF-8 bytes");
+    }
+    return grants;
+}
+async function readBoundedJson(response) {
+    const declared = Number(response.headers.get("content-length") ?? 0);
+    if (Number.isFinite(declared) && declared > MAX_PROVIDER_RESPONSE_BYTES) {
+        throw providerResponseError("Skill Provider response is too large");
+    }
+    if (!response.body)
+        throw providerResponseError("Skill Provider response has no body");
+    const reader = response.body.getReader();
+    const chunks = [];
+    let size = 0;
+    while (true) {
+        const { value, done } = await reader.read();
+        if (done)
+            break;
+        if (!value)
+            continue;
+        size += value.byteLength;
+        if (size > MAX_PROVIDER_RESPONSE_BYTES) {
+            await reader.cancel().catch(() => undefined);
+            throw providerResponseError("Skill Provider response is too large");
+        }
+        chunks.push(value);
+    }
+    const bytes = Buffer.concat(chunks.map((chunk) => Buffer.from(chunk)));
+    try {
+        const parsed = JSON.parse(bytes.toString("utf8"));
+        if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+            throw new Error("response is not an object");
+        }
+        return parsed;
+    }
+    catch {
+        throw providerResponseError("Skill Provider response is not valid JSON");
+    }
+}
+function resultData(envelope, expectedCode) {
+    if (envelope.schemaVersion !== "tool-result/0.1"
+        || envelope.ok !== true
+        || envelope.code !== expectedCode
+        || !envelope.data
+        || typeof envelope.data !== "object"
+        || Array.isArray(envelope.data)) {
+        const code = safeErrorCode(envelope.code);
+        if (envelope.ok === false && code) {
+            throw new RuntimeSkillProviderError(code, "Skill Provider returned an error");
+        }
+        throw providerResponseError("Skill Provider result envelope is invalid");
+    }
+    return envelope.data;
+}
+function exactRecord(raw, allowedKeys, label) {
+    if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+        throw new RuntimeSkillProviderError("skill_provider_binding_invalid", `${label} must be an object`);
+    }
+    const record = raw;
+    const allowed = new Set(allowedKeys);
+    if (Object.keys(record).some((key) => !allowed.has(key))) {
+        throw new RuntimeSkillProviderError("skill_provider_binding_invalid", `${label} contains unsupported fields`);
+    }
+    return record;
+}
+function requiredString(value, field, minLength, maxLength) {
+    if (typeof value !== "string" || value.length < minLength || value.length > maxLength) {
+        throw new RuntimeSkillProviderError("skill_provider_binding_invalid", `Skill Provider ${field} is invalid`);
+    }
+    return value;
+}
+function isUtf8Sorted(values) {
+    return values.every((value, index) => index === 0
+        || Buffer.compare(Buffer.from(values[index - 1], "utf8"), Buffer.from(value, "utf8")) <= 0);
+}
+function safeErrorCode(value) {
+    return typeof value === "string" && /^[a-z][a-z0-9_]{2,79}$/.test(value)
+        ? value
+        : null;
+}
+function providerResponseError(message) {
+    return new RuntimeSkillProviderError("skill_provider_invalid_response", message);
+}

package/dist/runtimes/deepseek-tui.d.ts

@@ -50,8 +50,9 @@ export declare class DeepseekTuiAdapter implements EngineAdapter {
     private clearCompactionRequired;
     private managedActivationId;
     private createThread;
-    private patchThreadSystemContext;
+    private patchThreadSettings;
     private compactThread;
+    private runtimeSystemContext;
     private startTurnAndReadEvents;
     private interruptTurn;
     private readEvents;