@open-agent-toolkit/cli 0.1.43 → 0.1.46

package/dist/providers/identity/family.d.ts

@@ -0,0 +1,13 @@
+export type ModelFamily = 'claude' | 'openai' | 'composer' | 'glm' | 'unknown';
+interface ClassifyModelFamilyInput {
+    value: string;
+    /**
+     * Structured model-provider identifier, when a harness exposes one. This is
+     * not the orchestration/runtime harness id; e.g. Cursor can run several model
+     * families and must be classified from the concrete model value.
+     */
+    providerId?: string;
+}
+export declare function classifyModelFamily(input: ClassifyModelFamilyInput): ModelFamily;
+export {};
+//# sourceMappingURL=family.d.ts.map

package/dist/providers/identity/family.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"family.d.ts","sourceRoot":"","sources":["../../../src/providers/identity/family.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,WAAW,GAAG,QAAQ,GAAG,QAAQ,GAAG,UAAU,GAAG,KAAK,GAAG,SAAS,CAAC;AAE/E,UAAU,wBAAwB;IAChC,KAAK,EAAE,MAAM,CAAC;IACd;;;;OAIG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAgCD,wBAAgB,mBAAmB,CACjC,KAAK,EAAE,wBAAwB,GAC9B,WAAW,CASb"}

package/dist/providers/identity/family.js

@@ -0,0 +1,32 @@
+const PROVIDER_ID_FAMILIES = [
+    [/^(anthropic|claude)$/i, 'claude'],
+    [/^(openai|codex)$/i, 'openai'],
+    [/^composer$/i, 'composer'],
+    [/^(glm|zai|zhipu)$/i, 'glm'],
+];
+const VALUE_FAMILIES = [
+    [/\b(claude|sonnet|opus|haiku|fable)\b/i, 'claude'],
+    [/\b(gpt|openai|codex|o[1-9])[-\w.]*\b/i, 'openai'],
+    [/\bcomposer\b/i, 'composer'],
+    [/\bglm\b/i, 'glm'],
+];
+function normalize(value) {
+    return typeof value === 'string' ? value.trim() : '';
+}
+function firstMatchingFamily(value, patterns) {
+    for (const [pattern, family] of patterns) {
+        if (pattern.test(value)) {
+            return family;
+        }
+    }
+    return undefined;
+}
+export function classifyModelFamily(input) {
+    const providerId = normalize(input?.providerId);
+    const providerFamily = firstMatchingFamily(providerId, PROVIDER_ID_FAMILIES);
+    if (providerFamily) {
+        return providerFamily;
+    }
+    const value = normalize(input?.value);
+    return firstMatchingFamily(value, VALUE_FAMILIES) ?? 'unknown';
+}

package/dist/providers/identity/provenance.d.ts

@@ -0,0 +1,21 @@
+export type IdentityProvenance = 'declared' | 'observed' | 'inferred' | 'unknown';
+export type IdentityConfidence = 'high' | 'medium' | 'low' | 'unknown';
+export interface IdentityRecord {
+    value: string;
+    provenance: IdentityProvenance;
+    /**
+     * True when the harness has been proven to reject invalid model selections
+     * instead of silently falling back to another model.
+     */
+    rejectOnInvalid?: boolean;
+}
+export interface ResolvedIdentity {
+    value: string;
+    provenance: IdentityProvenance;
+    confidence: IdentityConfidence;
+    mismatch: boolean;
+    diversityClaimable: boolean;
+    records: IdentityRecord[];
+}
+export declare function resolveIdentityConfidence(records: IdentityRecord[]): ResolvedIdentity;
+//# sourceMappingURL=provenance.d.ts.map

package/dist/providers/identity/provenance.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"provenance.d.ts","sourceRoot":"","sources":["../../../src/providers/identity/provenance.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,kBAAkB,GAC1B,UAAU,GACV,UAAU,GACV,UAAU,GACV,SAAS,CAAC;AAEd,MAAM,MAAM,kBAAkB,GAAG,MAAM,GAAG,QAAQ,GAAG,KAAK,GAAG,SAAS,CAAC;AAEvE,MAAM,WAAW,cAAc;IAC7B,KAAK,EAAE,MAAM,CAAC;IACd,UAAU,EAAE,kBAAkB,CAAC;IAC/B;;;OAGG;IACH,eAAe,CAAC,EAAE,OAAO,CAAC;CAC3B;AAED,MAAM,WAAW,gBAAgB;IAC/B,KAAK,EAAE,MAAM,CAAC;IACd,UAAU,EAAE,kBAAkB,CAAC;IAC/B,UAAU,EAAE,kBAAkB,CAAC;IAC/B,QAAQ,EAAE,OAAO,CAAC;IAClB,kBAAkB,EAAE,OAAO,CAAC;IAC5B,OAAO,EAAE,cAAc,EAAE,CAAC;CAC3B;AA+DD,wBAAgB,yBAAyB,CACvC,OAAO,EAAE,cAAc,EAAE,GACxB,gBAAgB,CAmClB"}

package/dist/providers/identity/provenance.js

@@ -0,0 +1,65 @@
+const PROVENANCE_PRIORITY = {
+    declared: 4,
+    observed: 3,
+    inferred: 2,
+    unknown: 1,
+};
+function normalizedValue(value) {
+    return typeof value === 'string' && value.trim().length > 0
+        ? value.trim()
+        : 'unknown';
+}
+function normalizeRecord(record) {
+    return {
+        ...record,
+        value: normalizedValue(record.value),
+    };
+}
+function strongestRecord(records, provenance) {
+    return records.find((record) => record.provenance === provenance && record.value !== 'unknown');
+}
+function strongestKnownRecord(records) {
+    return records
+        .filter((record) => record.value !== 'unknown')
+        .sort((left, right) => PROVENANCE_PRIORITY[right.provenance] -
+        PROVENANCE_PRIORITY[left.provenance])[0];
+}
+function resolved(record, confidence, mismatch, records) {
+    const value = record.value;
+    return {
+        value,
+        provenance: record.provenance,
+        confidence,
+        mismatch,
+        diversityClaimable: value !== 'unknown' &&
+            record.provenance !== 'unknown' &&
+            confidence !== 'unknown',
+        records,
+    };
+}
+export function resolveIdentityConfidence(records) {
+    const normalizedRecords = records.map(normalizeRecord);
+    const declared = strongestRecord(normalizedRecords, 'declared');
+    const observed = strongestRecord(normalizedRecords, 'observed');
+    if (declared && observed) {
+        if (declared.value === observed.value) {
+            return resolved(declared, 'high', false, normalizedRecords);
+        }
+        return resolved(observed, 'low', true, normalizedRecords);
+    }
+    if (declared) {
+        return resolved(declared, declared.rejectOnInvalid === true ? 'high' : 'medium', false, normalizedRecords);
+    }
+    if (observed) {
+        return resolved(observed, 'low', false, normalizedRecords);
+    }
+    const inferred = strongestRecord(normalizedRecords, 'inferred');
+    if (inferred) {
+        return resolved(inferred, 'low', false, normalizedRecords);
+    }
+    const fallback = strongestKnownRecord(normalizedRecords) ?? {
+        value: 'unknown',
+        provenance: 'unknown',
+    };
+    return resolved(fallback, 'unknown', false, normalizedRecords);
+}

package/dist/providers/identity/stamp.d.ts

@@ -0,0 +1,35 @@
+import type { IdentityProvenance } from './provenance.js';
+export type DispatchAction = 'implementation' | 'fix' | 'review';
+export type DispatchRole = 'implementer' | 'fix' | 'reviewer';
+export interface DispatchStampRecord {
+    scope: string;
+    action: DispatchAction;
+    role: DispatchRole;
+    producer: string;
+    provenance: IdentityProvenance;
+    modelAxis: string;
+    effortAxis: string;
+    dispatchPolicy: string;
+    dispatchCeiling: string;
+    target: string;
+}
+export interface DispatchStamp extends DispatchStampRecord {
+    line: string;
+    lineNumber: number;
+    legacy: boolean;
+}
+export interface ProducerIdentity {
+    scope: string;
+    action: DispatchAction;
+    role: DispatchRole;
+    producer: string;
+    provenance: IdentityProvenance;
+    target: string;
+}
+export interface ParseDispatchStampsOptions {
+    onWarning?: (warning: string) => void;
+}
+export declare function formatDispatchStamp(record: DispatchStampRecord): string;
+export declare function parseDispatchStamps(markdown: string, options?: ParseDispatchStampsOptions): DispatchStamp[];
+export declare function getProducerIdentitiesByScope(markdown: string, options?: ParseDispatchStampsOptions): Record<string, ProducerIdentity[]>;
+//# sourceMappingURL=stamp.d.ts.map

package/dist/providers/identity/stamp.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stamp.d.ts","sourceRoot":"","sources":["../../../src/providers/identity/stamp.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,cAAc,CAAC;AAEvD,MAAM,MAAM,cAAc,GAAG,gBAAgB,GAAG,KAAK,GAAG,QAAQ,CAAC;AACjE,MAAM,MAAM,YAAY,GAAG,aAAa,GAAG,KAAK,GAAG,UAAU,CAAC;AAE9D,MAAM,WAAW,mBAAmB;IAClC,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,cAAc,CAAC;IACvB,IAAI,EAAE,YAAY,CAAC;IACnB,QAAQ,EAAE,MAAM,CAAC;IACjB,UAAU,EAAE,kBAAkB,CAAC;IAC/B,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;IACnB,cAAc,EAAE,MAAM,CAAC;IACvB,eAAe,EAAE,MAAM,CAAC;IACxB,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,aAAc,SAAQ,mBAAmB;IACxD,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,OAAO,CAAC;CACjB;AAED,MAAM,WAAW,gBAAgB;IAC/B,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,cAAc,CAAC;IACvB,IAAI,EAAE,YAAY,CAAC;IACnB,QAAQ,EAAE,MAAM,CAAC;IACjB,UAAU,EAAE,kBAAkB,CAAC;IAC/B,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,0BAA0B;IACzC,SAAS,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;CACvC;AAyDD,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,mBAAmB,GAAG,MAAM,CAiBvE;AAqGD,wBAAgB,mBAAmB,CACjC,QAAQ,EAAE,MAAM,EAChB,OAAO,GAAE,0BAA+B,GACvC,aAAa,EAAE,CAqBjB;AAED,wBAAgB,4BAA4B,CAC1C,QAAQ,EAAE,MAAM,EAChB,OAAO,GAAE,0BAA+B,GACvC,MAAM,CAAC,MAAM,EAAE,gBAAgB,EAAE,CAAC,CAepC"}

package/dist/providers/identity/stamp.js

@@ -0,0 +1,171 @@
+const ACTIONS = new Set(['implementation', 'fix', 'review']);
+const ROLES = new Set(['implementer', 'fix', 'reviewer']);
+const PROVENANCES = new Set([
+    'declared',
+    'observed',
+    'inferred',
+    'unknown',
+]);
+const FIELD_ORDER = [
+    ['scope', 'scope'],
+    ['action', 'action'],
+    ['role', 'role'],
+    ['producer', 'producer'],
+    ['provenance', 'provenance'],
+    ['modelAxis', 'model_axis'],
+    ['effortAxis', 'effort_axis'],
+    ['dispatchPolicy', 'dispatch_policy'],
+    ['dispatchCeiling', 'dispatch_ceiling'],
+    ['target', 'target'],
+];
+function singleToken(value, fallback) {
+    const trimmed = value?.trim() ?? '';
+    return trimmed.length > 0 && /^\S+$/.test(trimmed) ? trimmed : fallback;
+}
+function normalizeAction(value) {
+    return ACTIONS.has(value)
+        ? value
+        : undefined;
+}
+function normalizeRole(value) {
+    return ROLES.has(value) ? value : undefined;
+}
+function normalizeProvenance(value) {
+    return PROVENANCES.has(value)
+        ? value
+        : 'unknown';
+}
+function inferRole(action) {
+    if (action === 'review') {
+        return 'reviewer';
+    }
+    if (action === 'fix') {
+        return 'fix';
+    }
+    return 'implementer';
+}
+export function formatDispatchStamp(record) {
+    const normalized = {
+        scope: singleToken(record.scope, 'unknown'),
+        action: record.action,
+        role: record.role,
+        producer: singleToken(record.producer, 'unknown'),
+        provenance: normalizeProvenance(record.provenance),
+        modelAxis: singleToken(record.modelAxis, 'unknown'),
+        effortAxis: singleToken(record.effortAxis, 'unknown'),
+        dispatchPolicy: singleToken(record.dispatchPolicy, 'unknown'),
+        dispatchCeiling: singleToken(record.dispatchCeiling, 'none'),
+        target: singleToken(record.target, 'unknown'),
+    };
+    return `Dispatch: ${FIELD_ORDER.map(([property, key]) => `${key}=${normalized[property]}`).join(' ')}`;
+}
+function tokenMap(tokens) {
+    const fields = new Map();
+    for (const token of tokens) {
+        const sanitized = token.replace(/,$/, '');
+        const match = sanitized.match(/^([a-z_]+)=(.+)$/);
+        const key = match?.[1];
+        const value = match?.[2];
+        if (key && value) {
+            fields.set(key, value);
+        }
+    }
+    return fields;
+}
+function dispatchPayload(line) {
+    const match = line.match(/\bDispatch:\s*(.+)$/);
+    return match?.[1]?.trim();
+}
+function warn(options, lineNumber, reason) {
+    options.onWarning?.(`Skipped malformed Dispatch line ${lineNumber}: ${reason}`);
+}
+function parseModernStamp(line, lineNumber, fields, options) {
+    const action = normalizeAction(fields.get('action'));
+    if (!action) {
+        warn(options, lineNumber, 'missing or invalid action');
+        return undefined;
+    }
+    const role = normalizeRole(fields.get('role'));
+    if (!role) {
+        warn(options, lineNumber, 'missing or invalid role');
+        return undefined;
+    }
+    const scope = singleToken(fields.get('scope'), '');
+    if (!scope) {
+        warn(options, lineNumber, 'missing scope');
+        return undefined;
+    }
+    return {
+        scope,
+        action,
+        role,
+        producer: singleToken(fields.get('producer'), 'unknown'),
+        provenance: normalizeProvenance(fields.get('provenance')),
+        modelAxis: singleToken(fields.get('model_axis'), 'unknown'),
+        effortAxis: singleToken(fields.get('effort_axis'), 'unknown'),
+        dispatchPolicy: singleToken(fields.get('dispatch_policy'), 'unknown'),
+        dispatchCeiling: singleToken(fields.get('dispatch_ceiling'), 'none'),
+        target: singleToken(fields.get('target'), 'unknown'),
+        line,
+        lineNumber,
+        legacy: false,
+    };
+}
+function parseLegacyStamp(line, lineNumber, tokens, fields, options) {
+    const scope = singleToken(tokens[0], '');
+    const action = normalizeAction(tokens[1]);
+    if (!scope || !action) {
+        warn(options, lineNumber, 'missing legacy scope/action');
+        return undefined;
+    }
+    return {
+        scope,
+        action,
+        role: inferRole(action),
+        producer: 'unknown',
+        provenance: 'unknown',
+        modelAxis: singleToken(fields.get('model_axis'), 'unknown'),
+        effortAxis: singleToken(fields.get('effort_axis'), 'unknown'),
+        dispatchPolicy: singleToken(fields.get('dispatch_policy'), 'unknown'),
+        dispatchCeiling: singleToken(fields.get('dispatch_ceiling'), 'none'),
+        target: singleToken(fields.get('target'), 'unknown'),
+        line,
+        lineNumber,
+        legacy: true,
+    };
+}
+export function parseDispatchStamps(markdown, options = {}) {
+    const stamps = [];
+    const lines = markdown.split(/\r?\n/);
+    lines.forEach((line, index) => {
+        const payload = dispatchPayload(line);
+        if (!payload) {
+            return;
+        }
+        const tokens = payload.split(/\s+/);
+        const fields = tokenMap(tokens);
+        const stamp = fields.has('scope')
+            ? parseModernStamp(line, index + 1, fields, options)
+            : parseLegacyStamp(line, index + 1, tokens, fields, options);
+        if (stamp) {
+            stamps.push(stamp);
+        }
+    });
+    return stamps;
+}
+export function getProducerIdentitiesByScope(markdown, options = {}) {
+    const grouped = {};
+    for (const stamp of parseDispatchStamps(markdown, options)) {
+        const identities = grouped[stamp.scope] ?? [];
+        identities.push({
+            scope: stamp.scope,
+            action: stamp.action,
+            role: stamp.role,
+            producer: stamp.producer,
+            provenance: stamp.provenance,
+            target: stamp.target,
+        });
+        grouped[stamp.scope] = identities;
+    }
+    return grouped;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@open-agent-toolkit/cli",
-  "version": "0.1.43",
+  "version": "0.1.46",
   "private": false,
   "description": "Open Agent Toolkit CLI",
   "homepage": "https://github.com/voxmedia/open-agent-toolkit/tree/main/packages/cli",
@@ -34,7 +34,7 @@
     "ora": "^9.0.0",
     "yaml": "2.8.2",
     "zod": "^3.25.76",
-    "@open-agent-toolkit/control-plane": "0.1.43"
+    "@open-agent-toolkit/control-plane": "0.1.46"
   },
   "devDependencies": {
     "@types/node": "^22.10.0",