@purista/harness 1.0.0 → 1.1.0

package/dist/memory/sandbox/index.d.ts

@@ -0,0 +1,17 @@
+import type { MemoryAdapter } from '../../ports/memory.js';
+/**
+ * Creates the built-in memory adapter backed by the current session sandbox.
+ *
+ * It is intentionally simple and local: session memory is stored below
+ * `/memory/session/`, run memory below `/memory/runs/<runId>/`.
+ *
+ * @example
+ * ```ts
+ * const harness = defineHarness()
+ *   .memory(sandboxMemory())
+ *   .models({ fast: model })
+ *   .agents(({ agent }) => ({ assistant: agent({ model: 'fast', instructions: 'Help.' }) }))
+ *   .build()
+ * ```
+ */
+export declare function sandboxMemory(): MemoryAdapter;

package/dist/memory/sandbox/index.js

@@ -0,0 +1,122 @@
+import { StateError } from '../../errors/index.js';
+/**
+ * Creates the built-in memory adapter backed by the current session sandbox.
+ *
+ * It is intentionally simple and local: session memory is stored below
+ * `/memory/session/`, run memory below `/memory/runs/<runId>/`.
+ *
+ * @example
+ * ```ts
+ * const harness = defineHarness()
+ *   .memory(sandboxMemory())
+ *   .models({ fast: model })
+ *   .agents(({ agent }) => ({ assistant: agent({ model: 'fast', instructions: 'Help.' }) }))
+ *   .build()
+ * ```
+ */
+export function sandboxMemory() {
+    return new SandboxMemoryAdapter();
+}
+class SandboxMemoryAdapter {
+    info = {
+        id: 'sandbox_memory',
+        packageName: '@purista/harness',
+        capabilities: ['memory.kv', 'memory.list', 'memory.delete', 'memory.run', 'memory.session']
+    };
+    capabilities = this.info.capabilities;
+    configureHarnessContext(_context) {
+        // The sandbox adapter receives runtime context through each `open(...)` call.
+    }
+    async open(scope, ctx) {
+        const sandbox = ctx.sandbox;
+        if (!sandbox) {
+            throw new StateError('sandboxMemory requires an active sandbox session.', {
+                op: 'memory.get',
+                adapter: 'memory',
+                memory_provider: this.info.id,
+                reason: 'missing_sandbox'
+            });
+        }
+        const root = scopeRoot(scope);
+        const metaRoot = scopeMetaRoot(scope);
+        return {
+            get: async (key, op) => {
+                op.signal.throwIfAborted();
+                const path = `${root}/${key}.json`;
+                if (!(await sandbox.exists(path)))
+                    return undefined;
+                return JSON.parse(await sandbox.readText(path));
+            },
+            set: async (key, value, op) => {
+                op.signal.throwIfAborted();
+                const existing = await readMetadata(sandbox, metaRoot, key);
+                const now = new Date().toISOString();
+                await sandbox.write(`${root}/${key}.json`, JSON.stringify(value));
+                await sandbox.write(`${metaRoot}/${key}.json`, JSON.stringify({
+                    createdAt: existing?.createdAt ?? now,
+                    updatedAt: now,
+                    ...(op.opts?.tags ? { tags: op.opts.tags } : existing?.tags ? { tags: existing.tags } : {}),
+                    ...(op.opts?.metadata ? { metadata: op.opts.metadata } : existing?.metadata ? { metadata: existing.metadata } : {})
+                }));
+            },
+            delete: async (key, op) => {
+                op.signal.throwIfAborted();
+                await sandbox.remove(`${root}/${key}.json`).catch(() => undefined);
+                await sandbox.remove(`${metaRoot}/${key}.json`).catch(() => undefined);
+            },
+            list: async (op) => {
+                op.signal.throwIfAborted();
+                const entries = await sandbox.list(root).catch(() => []);
+                const opts = op.opts ?? {};
+                const keys = entries
+                    .filter((entry) => entry.kind === 'file' && entry.name.endsWith('.json'))
+                    .map((entry) => entry.name.slice(0, -5))
+                    .filter((key) => !opts.prefix || key.startsWith(opts.prefix))
+                    .filter((key) => !opts.cursor || key > opts.cursor)
+                    .sort()
+                    .slice(0, opts.limit);
+                const out = [];
+                for (const key of keys) {
+                    const metadata = await readMetadata(sandbox, metaRoot, key);
+                    out.push({ key, ...(metadata ?? {}) });
+                }
+                return out;
+            }
+        };
+    }
+}
+function scopeRoot(scope) {
+    if (scope.kind === 'session')
+        return '/memory/session';
+    if (scope.kind === 'run' && scope.runId)
+        return `/memory/runs/${scope.runId}`;
+    throw new StateError('Unsupported sandbox memory scope.', {
+        op: 'memory.get',
+        adapter: 'memory',
+        memory_provider: 'sandbox_memory',
+        reason: `unsupported_scope:${scope.kind}`
+    });
+}
+function scopeMetaRoot(scope) {
+    if (scope.kind === 'session')
+        return '/memory/.meta/session';
+    if (scope.kind === 'run' && scope.runId)
+        return `/memory/.meta/runs/${scope.runId}`;
+    throw new StateError('Unsupported sandbox memory scope.', {
+        op: 'memory.list',
+        adapter: 'memory',
+        memory_provider: 'sandbox_memory',
+        reason: `unsupported_scope:${scope.kind}`
+    });
+}
+async function readMetadata(sandbox, metaRoot, key) {
+    const path = `${metaRoot}/${key}.json`;
+    if (!(await sandbox.exists(path).catch(() => false)))
+        return undefined;
+    try {
+        return JSON.parse(await sandbox.readText(path));
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/models/registry.js

@@ -131,10 +131,13 @@ function withModelStreamSpan(options, aliasKey, alias, method, ctx, fn) {
             span.setAttributes({
                 [ATTR_GEN_AI_USAGE_INPUT_TOKENS]: lastUsage.inputTokens,
                 [ATTR_GEN_AI_USAGE_OUTPUT_TOKENS]: lastUsage.outputTokens,
-                'gen_ai.usage.total_tokens': lastUsage.totalTokens
+                'gen_ai.usage.total_tokens': lastUsage.totalTokens,
+                'llm.token_count.prompt': lastUsage.inputTokens,
+                'llm.token_count.completion': lastUsage.outputTokens,
+                'llm.token_count.total': lastUsage.totalTokens
             });
-            options.telemetry?.recordCounter('gen_ai.client.token.usage', lastUsage.inputTokens, { ...attrs, [ATTR_GEN_AI_TOKEN_TYPE]: GEN_AI_TOKEN_TYPE_VALUE_INPUT });
-            options.telemetry?.recordCounter('gen_ai.client.token.usage', lastUsage.outputTokens, { ...attrs, [ATTR_GEN_AI_TOKEN_TYPE]: GEN_AI_TOKEN_TYPE_VALUE_OUTPUT });
+            options.telemetry?.recordHistogram('gen_ai.client.token.usage', lastUsage.inputTokens, { ...attrs, [ATTR_GEN_AI_TOKEN_TYPE]: GEN_AI_TOKEN_TYPE_VALUE_INPUT });
+            options.telemetry?.recordHistogram('gen_ai.client.token.usage', lastUsage.outputTokens, { ...attrs, [ATTR_GEN_AI_TOKEN_TYPE]: GEN_AI_TOKEN_TYPE_VALUE_OUTPUT });
         }
         if (lastFinishReason)
             span.setAttribute(ATTR_GEN_AI_RESPONSE_FINISH_REASONS, [lastFinishReason]);
@@ -188,10 +191,13 @@ async function withModelSpan(options, aliasKey, alias, method, ctx, fn) {
             span.setAttributes({
                 [ATTR_GEN_AI_USAGE_INPUT_TOKENS]: usage.inputTokens,
                 [ATTR_GEN_AI_USAGE_OUTPUT_TOKENS]: usage.outputTokens,
-                'gen_ai.usage.total_tokens': usage.totalTokens
+                'gen_ai.usage.total_tokens': usage.totalTokens,
+                'llm.token_count.prompt': usage.inputTokens,
+                'llm.token_count.completion': usage.outputTokens,
+                'llm.token_count.total': usage.totalTokens
             });
-            options.telemetry?.recordCounter('gen_ai.client.token.usage', usage.inputTokens, { ...attrs, [ATTR_GEN_AI_TOKEN_TYPE]: GEN_AI_TOKEN_TYPE_VALUE_INPUT });
-            options.telemetry?.recordCounter('gen_ai.client.token.usage', usage.outputTokens, { ...attrs, [ATTR_GEN_AI_TOKEN_TYPE]: GEN_AI_TOKEN_TYPE_VALUE_OUTPUT });
+            options.telemetry?.recordHistogram('gen_ai.client.token.usage', usage.inputTokens, { ...attrs, [ATTR_GEN_AI_TOKEN_TYPE]: GEN_AI_TOKEN_TYPE_VALUE_INPUT });
+            options.telemetry?.recordHistogram('gen_ai.client.token.usage', usage.outputTokens, { ...attrs, [ATTR_GEN_AI_TOKEN_TYPE]: GEN_AI_TOKEN_TYPE_VALUE_OUTPUT });
         }
         if (finishReason)
             span.setAttribute(ATTR_GEN_AI_RESPONSE_FINISH_REASONS, [finishReason]);
@@ -208,11 +214,30 @@ function modelSpanAttrs(options, aliasKey, alias, method, ctx) {
         'harness.agent.id': ctx?.agentId,
         'harness.model.alias': aliasKey,
         'harness.model.method': method,
+        'gen_ai.operation.name': genAiOperationName(method),
+        'openinference.span.kind': openInferenceSpanKind(method),
         [ATTR_GEN_AI_SYSTEM]: alias.provider.genAiSystem,
+        'gen_ai.provider.name': alias.provider.genAiSystem,
         [ATTR_GEN_AI_REQUEST_MODEL]: alias.model,
-        'model.provider': alias.provider.id
+        'model.provider': alias.provider.id,
+        'llm.provider': alias.provider.genAiSystem,
+        'llm.model_name': alias.model
     };
 }
+function genAiOperationName(method) {
+    if (method === 'embeddings')
+        return 'embeddings';
+    if (method === 'rerank')
+        return undefined;
+    return 'chat';
+}
+function openInferenceSpanKind(method) {
+    if (method === 'embeddings')
+        return 'EMBEDDING';
+    if (method === 'rerank')
+        return 'RERANKER';
+    return 'LLM';
+}
 /**
  * Validates alias capabilities for the requested operation.
  *

package/dist/ports/capabilities.d.ts

@@ -26,14 +26,36 @@ export type AdapterCapability =
 /** Runtime can resume from committed checkpoints. */
  | 'runtime.resume_from_checkpoint'
 /** Adapter can record feedback. */
- | 'feedback.record';
+ | 'feedback.record'
+/** Memory adapter supports key/value reads and writes. */
+ | 'memory.kv'
+/** Memory adapter supports key listing. */
+ | 'memory.list'
+/** Memory adapter supports key deletion. */
+ | 'memory.delete'
+/** Memory adapter supports text search over stored memory. */
+ | 'memory.search'
+/** Memory adapter supports entry expiration. */
+ | 'memory.ttl'
+/** Memory adapter supports run-scoped memory. */
+ | 'memory.run'
+/** Memory adapter supports session-scoped memory. */
+ | 'memory.session'
+/** Memory adapter supports agent-scoped memory. */
+ | 'memory.agent'
+/** Memory adapter supports user-scoped memory. */
+ | 'memory.user'
+/** Memory adapter supports tenant-scoped memory. */
+ | 'memory.tenant'
+/** Memory survives adapter close/reopen for the same logical scope. */
+ | 'memory.persistent';
 /** Data-only descriptor implemented by adapters that expose capability metadata. */
 export interface AdapterCapabilities {
     readonly capabilities: readonly AdapterCapability[];
 }
 /** Adapter descriptor surfaced through `harness.inspect()`. */
 export interface AdapterInspection {
-    readonly kind: 'state' | 'sandbox' | 'runtime' | 'feedback' | 'model';
+    readonly kind: 'state' | 'sandbox' | 'runtime' | 'feedback' | 'model' | 'memory';
     readonly id: string;
     readonly capabilities: readonly AdapterCapability[];
     readonly metadata?: Record<string, unknown>;

package/dist/ports/harness-context.d.ts

@@ -1,10 +1,13 @@
 import type { Logger } from '../logger/index.js';
-import type { TelemetryShim } from '../telemetry/index.js';
+import type { Metrics, TelemetryShim } from '../telemetry/index.js';
+import type { ContentCaptureMode } from '../harness/defineHarness.js';
 /** Harness-level context inherited by adapters registered with the harness. */
 export interface HarnessAdapterContext {
     harnessName: string;
     logger: Logger;
     telemetry: TelemetryShim;
+    metrics: Metrics;
+    contentCaptureMode: ContentCaptureMode;
     defaults: {
         agentMaxIterations: number;
         runTimeoutMs: number;

package/dist/ports/index.d.ts

@@ -4,3 +4,4 @@ export * from './state.js';
 export * from './harness-context.js';
 export * from './capabilities.js';
 export * from './feedback.js';
+export * from './memory.js';

package/dist/ports/index.js

@@ -4,3 +4,4 @@ export * from './state.js';
 export * from './harness-context.js';
 export * from './capabilities.js';
 export * from './feedback.js';
+export * from './memory.js';

package/dist/ports/memory/facade.d.ts

@@ -0,0 +1,5 @@
+import type { CreateMemoryFacadeOptions, MemoryFacade, MemoryScope, SessionMemory } from './types.js';
+/** Creates scoped memory helpers for a concrete session/run context. */
+export declare function createMemoryFacade(opts: CreateMemoryFacadeOptions): MemoryFacade;
+/** Creates a key/value memory facade bound to one normalized scope. */
+export declare function createSessionMemory(opts: CreateMemoryFacadeOptions, scope: MemoryScope): SessionMemory;

package/dist/ports/memory/facade.js

@@ -0,0 +1,123 @@
+import { ModelCapabilityError, ValidationError } from '../../errors/index.js';
+import { createMetrics } from '../../telemetry/index.js';
+import { attachContent, baseAttrs, errorType, hashKey, normalizeMemoryError, resultAttributes, shouldCaptureContent } from './telemetry.js';
+import { assertCapability, normalizeListOptions, normalizeSearchQuery, validateOperationInput } from './validation.js';
+/** Creates scoped memory helpers for a concrete session/run context. */
+export function createMemoryFacade(opts) {
+    const base = (scope) => createSessionMemory(opts, normalizeScope(opts, scope));
+    return {
+        session: base({ kind: 'session', sessionId: opts.sessionId }),
+        run: base({ kind: 'run', sessionId: opts.sessionId, runId: requireRunId(opts) }),
+        ...(opts.agentId ? { agent: base(definedScope({ kind: 'agent', sessionId: opts.sessionId, runId: opts.runId, agentId: opts.agentId, workflowId: opts.workflowId })) } : {}),
+        user(userId) {
+            return base(definedScope({ kind: 'user', sessionId: opts.sessionId, runId: opts.runId, agentId: opts.agentId, workflowId: opts.workflowId, userId: userId ?? metadataString(opts.metadata, 'userId') }));
+        },
+        tenant(tenantId) {
+            return base(definedScope({ kind: 'tenant', sessionId: opts.sessionId, runId: opts.runId, agentId: opts.agentId, workflowId: opts.workflowId, tenantId: tenantId ?? metadataString(opts.metadata, 'tenantId') }));
+        },
+        scope(scope) {
+            return base(scope);
+        }
+    };
+}
+/** Creates a key/value memory facade bound to one normalized scope. */
+export function createSessionMemory(opts, scope) {
+    const normalized = normalizeScope(opts, scope);
+    return {
+        read: (key) => runMemoryOperation(opts, normalized, 'get', key, undefined, async (store, ctx) => store.get(key, ctx)),
+        write: (key, value, writeOpts) => runMemoryOperation(opts, normalized, 'set', key, { value, ...(writeOpts ? { writeOpts } : {}) }, async (store, ctx) => store.set(key, value, { ...ctx, ...(writeOpts ? { opts: writeOpts } : {}) })),
+        delete: (key) => runMemoryOperation(opts, normalized, 'delete', key, undefined, async (store, ctx) => store.delete(key, ctx)),
+        list: async (listOpts) => {
+            const entries = await runMemoryOperation(opts, normalized, 'list', undefined, listOpts ? { listOpts } : undefined, async (store, ctx) => store.list({ ...ctx, opts: normalizeListOptions(listOpts) }));
+            return entries.map((entry) => entry.key).sort();
+        },
+        search: (query) => runMemoryOperation(opts, normalized, 'search', undefined, { query }, async (store, ctx) => {
+            assertCapability(opts.adapter, 'memory.search', 'search');
+            if (!store.search) {
+                throw new ModelCapabilityError('Memory search is not available for this adapter.', { alias: opts.adapter.info.id, method: 'memory.search', reason: 'method_missing' });
+            }
+            return store.search(normalizeSearchQuery(query), ctx);
+        })
+    };
+}
+async function runMemoryOperation(opts, scope, operation, key, content, fn) {
+    validateOperationInput(opts.adapter, scope, operation, key, content);
+    const metrics = createMetrics(opts.telemetry, baseAttrs(opts, scope, operation));
+    const started = Date.now();
+    let durationAttrs = {};
+    const attrs = {
+        ...baseAttrs(opts, scope, operation),
+        ...(key ? { 'harness.memory.key_hash': hashKey(key) } : {}),
+        'harness.memory.content_captured': shouldCaptureContent(opts.contentCaptureMode)
+    };
+    const context = {
+        logger: opts.logger,
+        telemetry: opts.telemetry,
+        metrics,
+        contentCaptureMode: opts.contentCaptureMode,
+        signal: opts.signal,
+        ...(opts.sandbox ? { sandbox: opts.sandbox } : {})
+    };
+    const execute = async (span) => {
+        if (shouldCaptureContent(opts.contentCaptureMode))
+            attachContent(span, opts.contentCaptureMode, operation, key, content);
+        try {
+            opts.signal.throwIfAborted();
+            const store = await opts.adapter.open(scope, context);
+            const result = await fn(store, { ...context, scope, operation });
+            const resultAttrs = resultAttributes(operation, result);
+            durationAttrs = resultAttrs;
+            span.setAttributes(resultAttrs);
+            metrics.counter('harness.memory.operations', 1, resultAttrs);
+            if (operation === 'search' && Array.isArray(result)) {
+                metrics.histogram('harness.memory.search.results', result.length);
+            }
+            return result;
+        }
+        catch (error) {
+            const normalized = normalizeMemoryError(opts.adapter, operation, error);
+            const errorAttrs = { 'error.type': errorType(normalized) };
+            durationAttrs = errorAttrs;
+            metrics.counter('harness.memory.operations', 1, errorAttrs);
+            throw normalized;
+        }
+        finally {
+            metrics.histogram('harness.memory.operation.duration', (Date.now() - started) / 1000, durationAttrs);
+        }
+    };
+    return opts.telemetry.span(`harness.memory.${operation}`, attrs, execute);
+}
+function normalizeScope(opts, scope) {
+    return {
+        sessionId: opts.sessionId,
+        ...(opts.runId ? { runId: opts.runId } : {}),
+        ...(opts.workflowId ? { workflowId: opts.workflowId } : {}),
+        ...(opts.agentId ? { agentId: opts.agentId } : {}),
+        ...scope
+    };
+}
+function definedScope(scope) {
+    const out = { kind: scope.kind };
+    if (scope.sessionId !== undefined)
+        out.sessionId = scope.sessionId;
+    if (scope.runId !== undefined)
+        out.runId = scope.runId;
+    if (scope.agentId !== undefined)
+        out.agentId = scope.agentId;
+    if (scope.workflowId !== undefined)
+        out.workflowId = scope.workflowId;
+    if (scope.userId !== undefined)
+        out.userId = scope.userId;
+    if (scope.tenantId !== undefined)
+        out.tenantId = scope.tenantId;
+    return out;
+}
+function requireRunId(opts) {
+    if (opts.runId)
+        return opts.runId;
+    throw new ValidationError('Run memory is only available inside a run.', { where: 'memory_scope', issues: { reason: 'missing_scope_identifier', field: 'runId', scope: 'run' } });
+}
+function metadataString(metadata, key) {
+    const value = metadata?.[key];
+    return typeof value === 'string' && value.length > 0 ? value : undefined;
+}

package/dist/ports/memory/telemetry.d.ts

@@ -0,0 +1,16 @@
+import type { Span } from '@opentelemetry/api';
+import type { JsonValue } from '../../models/json.js';
+import type { SpanAttrs } from '../../telemetry/index.js';
+import type { CreateMemoryFacadeOptions, MemoryOperation, MemoryScope, MemorySearchQuery, MemoryWriteOptions } from './types.js';
+export declare const CONTENT_ATTR_LIMIT = 8192;
+export declare function baseAttrs(opts: CreateMemoryFacadeOptions, scope: MemoryScope, operation: MemoryOperation): SpanAttrs;
+export declare function resultAttributes(operation: MemoryOperation, result: unknown): SpanAttrs;
+export declare function hashKey(key: string): string;
+export declare function shouldCaptureContent(mode: CreateMemoryFacadeOptions['contentCaptureMode']): boolean;
+export declare function attachContent(span: Span, mode: CreateMemoryFacadeOptions['contentCaptureMode'], operation: MemoryOperation, key: string | undefined, content: {
+    value?: JsonValue;
+    writeOpts?: MemoryWriteOptions;
+    query?: MemorySearchQuery;
+} | undefined): void;
+export declare function normalizeMemoryError(adapter: CreateMemoryFacadeOptions['adapter'], operation: MemoryOperation, error: unknown): unknown;
+export declare function errorType(error: unknown): string;

package/dist/ports/memory/telemetry.js

@@ -0,0 +1,77 @@
+import { createHash } from 'node:crypto';
+import { OperationCancelledError, StateError } from '../../errors/index.js';
+import { scopeCapability } from './validation.js';
+export const CONTENT_ATTR_LIMIT = 8192;
+export function baseAttrs(opts, scope, operation) {
+    return {
+        'harness.name': opts.harnessName,
+        'harness.memory.provider': opts.adapter.info.id,
+        'harness.memory.operation': operation,
+        'harness.memory.scope': scope.kind,
+        'harness.memory.capability': operation === 'search' ? 'memory.search' : scopeCapability[scope.kind],
+        'harness.session.id': scope.sessionId,
+        'harness.run.id': scope.runId,
+        'harness.agent.id': scope.agentId,
+        'harness.workflow.id': scope.workflowId
+    };
+}
+export function resultAttributes(operation, result) {
+    if (operation === 'get')
+        return { 'harness.memory.hit': result !== undefined };
+    if (Array.isArray(result) && (operation === 'list' || operation === 'search'))
+        return { 'harness.memory.result_count': result.length };
+    return {};
+}
+export function hashKey(key) {
+    return createHash('sha256').update(key).digest('hex');
+}
+export function shouldCaptureContent(mode) {
+    return mode !== 'NO_CONTENT';
+}
+export function attachContent(span, mode, operation, key, content) {
+    const attrs = {
+        ...(key ? { 'harness.memory.key': key } : {}),
+        ...(content?.value !== undefined ? { 'harness.memory.value': limitedJson(content.value) } : {}),
+        ...(content?.query ? { 'harness.memory.query': content.query.text } : {})
+    };
+    if (mode === 'SPAN_ONLY' || mode === 'SPAN_AND_EVENT') {
+        span.setAttributes(attrs);
+    }
+    if (mode === 'EVENT_ONLY' || mode === 'SPAN_AND_EVENT') {
+        span.addEvent('harness.memory.content', cleanAttrs({ ...attrs, 'harness.memory.operation': operation }));
+    }
+}
+export function normalizeMemoryError(adapter, operation, error) {
+    if (error instanceof OperationCancelledError)
+        return error;
+    if (isAbortError(error))
+        return new OperationCancelledError('Memory operation was cancelled.', { scope: 'memory' }, error);
+    if (isHarnessError(error))
+        return error;
+    return new StateError('Memory adapter operation failed.', { op: `memory.${operation}`, adapter: 'memory', memory_provider: adapter.info.id }, error);
+}
+export function errorType(error) {
+    return isHarnessError(error) ? error.code : error instanceof Error ? error.name : 'Error';
+}
+function limitedJson(value) {
+    try {
+        return JSON.stringify(value).slice(0, CONTENT_ATTR_LIMIT);
+    }
+    catch {
+        return undefined;
+    }
+}
+function isAbortError(error) {
+    return error instanceof Error && error.name === 'AbortError';
+}
+function isHarnessError(error) {
+    return Boolean(error && typeof error === 'object' && 'code' in error && 'category' in error);
+}
+function cleanAttrs(attrs) {
+    const out = {};
+    for (const [key, value] of Object.entries(attrs)) {
+        if (value !== undefined)
+            out[key] = value;
+    }
+    return out;
+}