@treeseed/sdk 0.13.0-rc.54 → 0.13.0-rc.56

package/dist/security/encrypted-envelope.d.ts

@@ -0,0 +1,177 @@
+import { z } from 'zod';
+export declare const encryptedEnvelopeAadSchema: z.ZodObject<{
+    purpose: z.ZodString;
+    teamId: z.ZodOptional<z.ZodString>;
+    resourceType: z.ZodString;
+    resourceId: z.ZodString;
+    topicId: z.ZodOptional<z.ZodString>;
+    sendId: z.ZodOptional<z.ZodString>;
+    invocationId: z.ZodOptional<z.ZodString>;
+    assignmentId: z.ZodOptional<z.ZodString>;
+    sequence: z.ZodOptional<z.ZodNumber>;
+    eventType: z.ZodOptional<z.ZodString>;
+    schemaVersion: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    purpose: string;
+    resourceType: string;
+    resourceId: string;
+    schemaVersion: string;
+    teamId?: string | undefined;
+    topicId?: string | undefined;
+    sendId?: string | undefined;
+    invocationId?: string | undefined;
+    assignmentId?: string | undefined;
+    sequence?: number | undefined;
+    eventType?: string | undefined;
+}, {
+    purpose: string;
+    resourceType: string;
+    resourceId: string;
+    schemaVersion: string;
+    teamId?: string | undefined;
+    topicId?: string | undefined;
+    sendId?: string | undefined;
+    invocationId?: string | undefined;
+    assignmentId?: string | undefined;
+    sequence?: number | undefined;
+    eventType?: string | undefined;
+}>;
+export declare const encryptedEnvelopeSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"treeseed.encrypted-envelope/v1">;
+    algorithm: z.ZodLiteral<"aes-256-gcm">;
+    keyProvider: z.ZodString;
+    keyId: z.ZodString;
+    keyVersion: z.ZodNumber;
+    wrappedDek: z.ZodObject<{
+        nonce: z.ZodString;
+        authenticationTag: z.ZodString;
+        ciphertext: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        nonce: string;
+        authenticationTag: string;
+        ciphertext: string;
+    }, {
+        nonce: string;
+        authenticationTag: string;
+        ciphertext: string;
+    }>;
+    payload: z.ZodObject<{
+        nonce: z.ZodString;
+        authenticationTag: z.ZodString;
+        ciphertext: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        nonce: string;
+        authenticationTag: string;
+        ciphertext: string;
+    }, {
+        nonce: string;
+        authenticationTag: string;
+        ciphertext: string;
+    }>;
+    aad: z.ZodObject<{
+        purpose: z.ZodString;
+        teamId: z.ZodOptional<z.ZodString>;
+        resourceType: z.ZodString;
+        resourceId: z.ZodString;
+        topicId: z.ZodOptional<z.ZodString>;
+        sendId: z.ZodOptional<z.ZodString>;
+        invocationId: z.ZodOptional<z.ZodString>;
+        assignmentId: z.ZodOptional<z.ZodString>;
+        sequence: z.ZodOptional<z.ZodNumber>;
+        eventType: z.ZodOptional<z.ZodString>;
+        schemaVersion: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        purpose: string;
+        resourceType: string;
+        resourceId: string;
+        schemaVersion: string;
+        teamId?: string | undefined;
+        topicId?: string | undefined;
+        sendId?: string | undefined;
+        invocationId?: string | undefined;
+        assignmentId?: string | undefined;
+        sequence?: number | undefined;
+        eventType?: string | undefined;
+    }, {
+        purpose: string;
+        resourceType: string;
+        resourceId: string;
+        schemaVersion: string;
+        teamId?: string | undefined;
+        topicId?: string | undefined;
+        sendId?: string | undefined;
+        invocationId?: string | undefined;
+        assignmentId?: string | undefined;
+        sequence?: number | undefined;
+        eventType?: string | undefined;
+    }>;
+    aadDigest: z.ZodString;
+    ciphertextDigest: z.ZodString;
+    createdAt: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    schemaVersion: "treeseed.encrypted-envelope/v1";
+    algorithm: "aes-256-gcm";
+    keyProvider: string;
+    keyId: string;
+    keyVersion: number;
+    wrappedDek: {
+        nonce: string;
+        authenticationTag: string;
+        ciphertext: string;
+    };
+    payload: {
+        nonce: string;
+        authenticationTag: string;
+        ciphertext: string;
+    };
+    aad: {
+        purpose: string;
+        resourceType: string;
+        resourceId: string;
+        schemaVersion: string;
+        teamId?: string | undefined;
+        topicId?: string | undefined;
+        sendId?: string | undefined;
+        invocationId?: string | undefined;
+        assignmentId?: string | undefined;
+        sequence?: number | undefined;
+        eventType?: string | undefined;
+    };
+    aadDigest: string;
+    ciphertextDigest: string;
+    createdAt: string;
+}, {
+    schemaVersion: "treeseed.encrypted-envelope/v1";
+    algorithm: "aes-256-gcm";
+    keyProvider: string;
+    keyId: string;
+    keyVersion: number;
+    wrappedDek: {
+        nonce: string;
+        authenticationTag: string;
+        ciphertext: string;
+    };
+    payload: {
+        nonce: string;
+        authenticationTag: string;
+        ciphertext: string;
+    };
+    aad: {
+        purpose: string;
+        resourceType: string;
+        resourceId: string;
+        schemaVersion: string;
+        teamId?: string | undefined;
+        topicId?: string | undefined;
+        sendId?: string | undefined;
+        invocationId?: string | undefined;
+        assignmentId?: string | undefined;
+        sequence?: number | undefined;
+        eventType?: string | undefined;
+    };
+    aadDigest: string;
+    ciphertextDigest: string;
+    createdAt: string;
+}>;
+export type EncryptedEnvelopeAad = z.infer<typeof encryptedEnvelopeAadSchema>;
+export type EncryptedEnvelope = z.infer<typeof encryptedEnvelopeSchema>;

package/dist/security/encrypted-envelope.js

@@ -0,0 +1,34 @@
+import { z } from "zod";
+const base64Url = z.string().min(1).regex(/^[A-Za-z0-9_-]+$/u);
+const digest = z.string().regex(/^sha256:[a-f0-9]{64}$/u);
+const identifier = z.string().regex(/^[a-z][a-z0-9._-]{0,127}$/u);
+const encryptedEnvelopeAadSchema = z.object({
+  purpose: identifier,
+  teamId: z.string().min(1).max(256).optional(),
+  resourceType: identifier,
+  resourceId: z.string().min(1).max(512),
+  topicId: z.string().min(1).max(256).optional(),
+  sendId: z.string().min(1).max(256).optional(),
+  invocationId: z.string().min(1).max(256).optional(),
+  assignmentId: z.string().min(1).max(256).optional(),
+  sequence: z.number().int().nonnegative().optional(),
+  eventType: z.string().min(1).max(256).optional(),
+  schemaVersion: z.string().min(1).max(128)
+}).strict();
+const encryptedEnvelopeSchema = z.object({
+  schemaVersion: z.literal("treeseed.encrypted-envelope/v1"),
+  algorithm: z.literal("aes-256-gcm"),
+  keyProvider: identifier,
+  keyId: identifier,
+  keyVersion: z.number().int().positive(),
+  wrappedDek: z.object({ nonce: base64Url, authenticationTag: base64Url, ciphertext: base64Url }).strict(),
+  payload: z.object({ nonce: base64Url, authenticationTag: base64Url, ciphertext: base64Url }).strict(),
+  aad: encryptedEnvelopeAadSchema,
+  aadDigest: digest,
+  ciphertextDigest: digest,
+  createdAt: z.string().datetime()
+}).strict();
+export {
+  encryptedEnvelopeAadSchema,
+  encryptedEnvelopeSchema
+};

package/dist/security/envelope-codec.d.ts

@@ -0,0 +1,38 @@
+import { type EncryptedEnvelope, type EncryptedEnvelopeAad } from './encrypted-envelope.js';
+export interface EnvelopeKeyProvider {
+    readonly id: string;
+    active(): {
+        id: string;
+        version: number;
+        key: Uint8Array;
+    };
+    resolve(id: string, version: number): Uint8Array | undefined;
+}
+export declare class EncryptedEnvelopeCodec {
+    private readonly keys;
+    constructor(keys: EnvelopeKeyProvider);
+    encrypt(plaintext: Uint8Array | string, aad: EncryptedEnvelopeAad): EncryptedEnvelope;
+    decrypt(input: EncryptedEnvelope): Buffer;
+    authenticate(input: EncryptedEnvelope): boolean;
+    rewrap(input: EncryptedEnvelope): EncryptedEnvelope;
+}
+export declare class StaticEnvelopeKeyProvider implements EnvelopeKeyProvider {
+    private readonly activeKey;
+    private readonly historical;
+    readonly id: string;
+    constructor(id: string, activeKey: {
+        id: string;
+        version: number;
+        key: Uint8Array;
+    }, historical?: Array<{
+        id: string;
+        version: number;
+        key: Uint8Array;
+    }>);
+    active(): {
+        id: string;
+        version: number;
+        key: Uint8Array;
+    };
+    resolve(id: string, version: number): Uint8Array<ArrayBufferLike> | undefined;
+}

package/dist/security/envelope-codec.js

@@ -0,0 +1,96 @@
+import { createCipheriv, createDecipheriv, createHash, randomBytes } from "node:crypto";
+import { encryptedEnvelopeSchema } from "./encrypted-envelope.js";
+function canonical(value) {
+  if (Array.isArray(value)) return `[${value.map(canonical).join(",")}]`;
+  if (value && typeof value === "object") return `{${Object.entries(value).filter(([, item]) => item !== void 0).sort(([left], [right]) => left.localeCompare(right)).map(([key, item]) => `${JSON.stringify(key)}:${canonical(item)}`).join(",")}}`;
+  return JSON.stringify(value);
+}
+const digest = (value) => `sha256:${createHash("sha256").update(value).digest("hex")}`;
+const encode = (value) => Buffer.from(value).toString("base64url");
+const decode = (value) => {
+  const decoded = Buffer.from(value, "base64url");
+  if (decoded.toString("base64url") !== value) throw new Error("Encrypted envelope contains a non-canonical base64url value.");
+  return decoded;
+};
+function seal(key, plaintext, aad) {
+  if (key.byteLength !== 32) throw new Error("Envelope keys must contain exactly 32 bytes.");
+  const nonce = randomBytes(12);
+  const cipher = createCipheriv("aes-256-gcm", key, nonce);
+  cipher.setAAD(Buffer.from(aad));
+  const ciphertext = Buffer.concat([cipher.update(plaintext), cipher.final()]);
+  return { nonce: encode(nonce), authenticationTag: encode(cipher.getAuthTag()), ciphertext: encode(ciphertext) };
+}
+function open(key, value, aad) {
+  const decipher = createDecipheriv("aes-256-gcm", key, decode(value.nonce));
+  decipher.setAAD(Buffer.from(aad));
+  decipher.setAuthTag(decode(value.authenticationTag));
+  return Buffer.concat([decipher.update(decode(value.ciphertext)), decipher.final()]);
+}
+class EncryptedEnvelopeCodec {
+  constructor(keys) {
+    this.keys = keys;
+  }
+  keys;
+  encrypt(plaintext, aad) {
+    const active = this.keys.active();
+    const aadValue = canonical(aad);
+    const dek = randomBytes(32);
+    const payload = seal(dek, typeof plaintext === "string" ? Buffer.from(plaintext) : plaintext, aadValue);
+    const wrappedDek = seal(active.key, dek, `${aadValue}:dek`);
+    return encryptedEnvelopeSchema.parse({
+      schemaVersion: "treeseed.encrypted-envelope/v1",
+      algorithm: "aes-256-gcm",
+      keyProvider: this.keys.id,
+      keyId: active.id,
+      keyVersion: active.version,
+      wrappedDek,
+      payload,
+      aad,
+      aadDigest: digest(aadValue),
+      ciphertextDigest: digest(decode(payload.ciphertext)),
+      createdAt: (/* @__PURE__ */ new Date()).toISOString()
+    });
+  }
+  decrypt(input) {
+    const envelope = encryptedEnvelopeSchema.parse(input);
+    const aad = canonical(envelope.aad);
+    if (digest(aad) !== envelope.aadDigest || digest(decode(envelope.payload.ciphertext)) !== envelope.ciphertextDigest) throw new Error("Encrypted envelope digest verification failed.");
+    const key = this.keys.resolve(envelope.keyId, envelope.keyVersion);
+    if (!key) throw new Error(`Encrypted envelope key ${envelope.keyId}:${envelope.keyVersion} is unavailable.`);
+    const dek = open(key, envelope.wrappedDek, `${aad}:dek`);
+    return open(dek, envelope.payload, aad);
+  }
+  authenticate(input) {
+    this.decrypt(input);
+    return true;
+  }
+  rewrap(input) {
+    const envelope = encryptedEnvelopeSchema.parse(input);
+    const prior = this.keys.resolve(envelope.keyId, envelope.keyVersion);
+    if (!prior) throw new Error(`Encrypted envelope key ${envelope.keyId}:${envelope.keyVersion} is unavailable.`);
+    const aad = canonical(envelope.aad);
+    const dek = open(prior, envelope.wrappedDek, `${aad}:dek`);
+    const active = this.keys.active();
+    return encryptedEnvelopeSchema.parse({ ...envelope, keyProvider: this.keys.id, keyId: active.id, keyVersion: active.version, wrappedDek: seal(active.key, dek, `${aad}:dek`) });
+  }
+}
+class StaticEnvelopeKeyProvider {
+  constructor(id, activeKey, historical = []) {
+    this.activeKey = activeKey;
+    this.historical = historical;
+    this.id = id;
+  }
+  activeKey;
+  historical;
+  id;
+  active() {
+    return this.activeKey;
+  }
+  resolve(id, version) {
+    return [this.activeKey, ...this.historical].find((entry) => entry.id === id && entry.version === version)?.key;
+  }
+}
+export {
+  EncryptedEnvelopeCodec,
+  StaticEnvelopeKeyProvider
+};

package/dist/security/index.d.ts

@@ -0,0 +1,2 @@
+export * from './encrypted-envelope.js';
+export * from './envelope-codec.js';

package/dist/security/index.js

@@ -0,0 +1,2 @@
+export * from "./encrypted-envelope.js";
+export * from "./envelope-codec.js";

package/dist/types/agents/agent-activity-profile.d.ts

@@ -4,6 +4,18 @@ export interface AgentContentRevisionRef {
     id: string;
     revision: number;
 }
+export interface AgentCapabilityConfigurationValue {
+    value: unknown;
+    requirement: 'required' | 'preferred';
+}
+export interface AgentCapabilityRequirement {
+    capabilityId: string;
+    versionRange: string;
+    requirement: 'required' | 'preferred';
+    alternativeGroup?: string | null;
+    requiredFeatures?: string[];
+    configuration?: Record<string, AgentCapabilityConfigurationValue>;
+}
 export interface AgentActivityProfile {
     activityType?: AgentActivityType;
     enabled: boolean;
@@ -15,6 +27,7 @@ export interface AgentActivityProfile {
     contextQueryRefs?: AgentContentRevisionRef[];
     contextQuerySetRefs?: AgentContentRevisionRef[];
     instructionTemplateRefs?: AgentContentRevisionRef[];
+    capabilityRequirements?: AgentCapabilityRequirement[];
     artifactTriggers?: Array<{
         event: string;
         artifactKind: string;
@@ -27,15 +40,6 @@ export interface AgentActivityProfile {
         requiredArtifactKinds?: string[];
         blockOnOpenQuestions?: boolean;
     };
-    providerOverrides?: {
-        requiredCapabilities?: string[];
-        disallowedProviderIds?: string[];
-        promptRef?: string;
-        instructionTemplateRefs?: AgentContentRevisionRef[];
-        maxRuntimeSeconds?: number;
-        maxTotalTokens?: number;
-        maxCostAmount?: number;
-    };
     tools: AgentToolPolicy;
     signals?: AgentSignalPolicy;
     outputs: AgentOutputContract;
@@ -48,7 +52,7 @@ export interface AgentChatProfileConfiguration {
     foundation: 'discussion-v1';
     responseStyle?: string;
     promptTask?: string;
-    requiredCapabilities?: string[];
+    capabilityRequirements?: AgentCapabilityRequirement[];
     maxRuntimeSeconds?: number;
     maxTotalTokens?: number;
     warningTokens?: number;
@@ -81,8 +85,6 @@ export interface AgentDefinition {
     chatProfile?: AgentChatProfileConfiguration;
 }
 export interface AgentExecutionConfig {
-    provider?: string;
-    model?: string;
     approvalPolicy?: 'never' | 'on_request' | 'always' | string;
     sandboxMode?: 'read_only' | 'workspace_write' | string;
     reasoningEffort?: 'low' | 'medium' | 'high' | string;
@@ -99,30 +101,10 @@ export interface AgentExecutionConfig {
     leaseSeconds: number;
     retryLimit: number;
     branchPrefix: string;
-    providerProfile?: AgentProviderProfile;
 }
 export type AgentProviderFallbackPolicy = 'allow_substitution' | 'require_same_model_class' | 'fail_if_unavailable' | 'ask_for_approval';
-export interface AgentExecutionProviderPreference {
-    providerId?: string;
-    provider?: string;
-    model?: string;
-    modelClass?: string;
-    weight: number;
-    reason?: string;
-}
-export interface AgentProviderFallback {
-    providerId?: string;
-    provider?: string;
-    model?: string;
-    modelClass?: string;
-    maxQualityPenalty?: number;
-}
 export interface AgentProviderProfile {
-    requiredCapabilities: string[];
-    preferredExecutionProviders: AgentExecutionProviderPreference[];
-    acceptableFallbacks: AgentProviderFallback[];
-    disallowedProviders?: string[];
-    disallowedRegions?: string[];
+    capabilityRequirements: AgentCapabilityRequirement[];
     fallbackPolicy: AgentProviderFallbackPolicy;
 }
 export interface ExecutionResourceNeed {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@treeseed/sdk",
-  "version": "0.13.0-rc.54",
+  "version": "0.13.0-rc.56",
   "description": "Portable TreeSeed contracts, standards, and typed remote control-plane clients.",
   "license": "Apache-2.0",
   "repository": {
@@ -62,6 +62,10 @@
     "vitest": "^4.1.2"
   },
   "exports": {
+    "./security": {
+      "types": "./dist/security/index.d.ts",
+      "default": "./dist/security/index.js"
+    },
     "./development": {
       "types": "./dist/development/index.d.ts",
       "default": "./dist/development/index.js"