reploid 0.0.0-stage → 0.1.0

package/shared/config/doppler-execution-contracts.js

@@ -0,0 +1,32 @@
+import configuration from './doppler-execution-contracts.json' with { type: 'json' };
+
+if (configuration?.schema !== 'reploid.doppler-execution-contracts/v1'
+  || !configuration.formats || Array.isArray(configuration.formats)
+  || !configuration.apis || Array.isArray(configuration.apis)
+  || !Object.keys(configuration.formats).length) throw new Error('Invalid Doppler execution contract configuration');
+
+const contracts = Object.freeze(Object.fromEntries(Object.entries(configuration.formats).map(([schema, format]) => {
+  const api = configuration.apis[format.api];
+  if (!api || typeof format.releaseHistory !== 'boolean'
+    || ['openMethod', 'sessionSchema', 'sessionIdentity', 'receiptIdentity', 'requestSchema', 'eventSchema',
+      'receiptSchema', 'sequenceReceiptSchema', 'adapterSchema'].some(field => typeof api[field] !== 'string' || !api[field])
+    || !Array.isArray(api.identityFields) || api.identityFields.length !== 5
+    || api.identityFields.some(field => typeof field !== 'string' || !field)) throw new Error('Invalid Doppler execution contract configuration');
+  return [schema, Object.freeze({ ...api, schema, releaseHistory: format.releaseHistory,
+    identityFields: Object.freeze([...api.identityFields]) })];
+})));
+
+export function resolveDopplerExecutionContract(schema) {
+  if (!Object.hasOwn(contracts, schema)) throw new Error('Unsupported executable model schema');
+  return contracts[schema];
+}
+
+export function resolveDopplerOperationContract(bindingSchema, requestSchema) {
+  const contract = resolveDopplerExecutionContract(bindingSchema);
+  if (requestSchema === contract.requestSchema) return contract;
+  const format = configuration.incrementalFormats?.[requestSchema];
+  if (!format || format.openMethod !== contract.openMethod || format.incremental !== true) {
+    throw new Error('Unsupported operation request format for this executable model');
+  }
+  return Object.freeze({ ...contract, ...format, requestSchema });
+}

package/shared/config/doppler-execution-contracts.json

@@ -0,0 +1,43 @@
+{
+  "schema": "reploid.doppler-execution-contracts/v1",
+  "incrementalFormats": {
+    "doppler.capsule-operation-request/v2": {
+      "openMethod": "openCapsule",
+      "eventSchema": "doppler.capsule-operation-event/v2",
+      "receiptSchema": "doppler.capsule-operation-receipt/v2",
+      "incremental": true
+    }
+  },
+  "formats": {
+    "doppler.pack/v2": { "api": "pack", "releaseHistory": false },
+    "doppler.pack/v3": { "api": "pack", "releaseHistory": true },
+    "doppler.capsule/v2": { "api": "capsule", "releaseHistory": false },
+    "doppler.capsule/v3": { "api": "capsule", "releaseHistory": true }
+  },
+  "apis": {
+    "pack": {
+      "openMethod": "openPack",
+      "sessionSchema": "doppler.pack-session/v1",
+      "sessionIdentity": "packIdentity",
+      "receiptIdentity": "pack",
+      "identityFields": ["schema", "packId", "semanticRoot", "envelopeDigest", "artifactClosureDigest"],
+      "requestSchema": "doppler.pack-operation-request/v1",
+      "eventSchema": "doppler.pack-operation-event/v1",
+      "receiptSchema": "doppler.pack-operation-receipt/v1",
+      "sequenceReceiptSchema": "doppler.pack-execution-receipt/v1",
+      "adapterSchema": "doppler.pack-adapter/v1"
+    },
+    "capsule": {
+      "openMethod": "openCapsule",
+      "sessionSchema": "doppler.capsule-session/v1",
+      "sessionIdentity": "capsuleIdentity",
+      "receiptIdentity": "capsule",
+      "identityFields": ["schema", "capsuleId", "semanticRoot", "envelopeDigest", "artifactClosureDigest"],
+      "requestSchema": "doppler.capsule-operation-request/v1",
+      "eventSchema": "doppler.capsule-operation-event/v1",
+      "receiptSchema": "doppler.capsule-operation-receipt/v1",
+      "sequenceReceiptSchema": "doppler.capsule-execution-receipt/v1",
+      "adapterSchema": "doppler.capsule-adapter/v1"
+    }
+  }
+}

package/shared/config/doppler-generation-contract.js

@@ -0,0 +1,223 @@
+// Generated by scripts/sync-doppler-generation-contract.js from installed doppler-gpu/generation-contract.
+// src/config/generation-contract.json
+var generation_contract_default = {
+  schema: "doppler.generation-contract/v1",
+  input: {
+    prompt: { type: "string", nonempty: true },
+    promptTokens: { type: "array", items: "integer", minimum: 0, maximum: 4294967294, nonempty: true }
+  },
+  inputExactlyOne: ["prompt", "promptTokens"],
+  options: {
+    maxTokens: { type: "integer", minimum: 1, required: true },
+    maxSeqLen: { type: "integer", minimum: 1, required: true },
+    temperature: { type: "number", minimum: 0, required: true, runtimeSampling: true },
+    topP: { type: "number", exclusiveMinimum: 0, maximum: 1, required: true, runtimeSampling: true },
+    topK: { type: "integer", minimum: 0, required: true, runtimeSampling: true },
+    repetitionPenalty: { type: "number", exclusiveMinimum: 0, required: true, runtimeSampling: true },
+    repetitionPenaltyWindow: { type: "integer", minimum: 0, maximum: 4294967295, required: true, runtimeSampling: true },
+    presencePenalty: { type: "number", minimum: 0, default: 0, runtimeSampling: true },
+    useChatTemplate: { type: "boolean", required: true },
+    seed: { type: "number", minimum: 0, requiredWhenPositive: "temperature" },
+    suppressTokenIds: { type: "array", items: "integer", minimum: 0, maximum: 4294967294, default: [], runtimeSampling: true },
+    stopSequences: { type: "array", items: "string", nonemptyItems: true, default: [] }
+  },
+  penaltyOrder: ["repetitionPenalty", "presencePenalty"],
+  filterOrder: ["topK", "topP"],
+  zeroWindow: "all-context-tokens",
+  completionSchema: "doppler.generation-completion/v1",
+  stoppingReasons: ["max-tokens", "eos-token", "stop-token", "stop-sequence"],
+  errors: {
+    invalidRequest: "DOPPLER_GENERATION_INVALID_REQUEST",
+    aborted: "DOPPLER_GENERATION_ABORTED",
+    deadline: "DOPPLER_GENERATION_DEADLINE"
+  },
+  canonical: {
+    metadataLimits: {
+      maxBytes: 65536,
+      maxDepth: 16,
+      maxNodes: 8192
+    },
+    maxProposalTokens: 4,
+    policy: {
+      schema: {
+        type: "string",
+        enum: [
+          "doppler.generation-policy/v3"
+        ]
+      },
+      sampler: {
+        type: "string",
+        enum: [
+          "philox4x32-10/cpu-categorical-v1"
+        ]
+      },
+      seedHex64: {
+        type: "string",
+        pattern: "^[a-f0-9]{16}$"
+      },
+      selectionArithmeticId: {
+        type: "hash"
+      },
+      temperature: {
+        type: "number",
+        minimum: 0
+      },
+      topK: {
+        type: "integer",
+        minimum: 0
+      },
+      topP: {
+        type: "number",
+        exclusiveMinimum: 0,
+        maximum: 1
+      },
+      repetitionPenalty: {
+        type: "number",
+        exclusiveMinimum: 0
+      },
+      repetitionPenaltyWindow: {
+        type: "integer",
+        minimum: 0
+      },
+      presencePenalty: {
+        type: "number",
+        minimum: 0
+      },
+      presencePenaltyWindow: {
+        type: "integer",
+        minimum: 0
+      },
+      suppressTokenIds: {
+        type: "tokens"
+      },
+      padTokenId: {
+        type: "token",
+        nullable: true
+      },
+      eosTokenIds: {
+        type: "tokens"
+      },
+      stopTokenIds: {
+        type: "tokens"
+      },
+      toolTokenIds: {
+        type: "tokens"
+      },
+      stopSequences: {
+        type: "array",
+        items: "string",
+        maxItems: 16,
+        maxItemLength: 256,
+        nonemptyItems: true
+      },
+      toolBoundaryPolicy: {
+        type: "string",
+        enum: [
+          "stop",
+          "reject"
+        ]
+      },
+      maxGeneratedTokens: {
+        type: "integer",
+        minimum: 0
+      },
+      materializedInputCapacity: {
+        type: "integer",
+        minimum: 0
+      },
+      totalAcceptedTokenLimit: {
+        type: "integer",
+        minimum: 0
+      },
+      maxRawOutputUtf16: {
+        type: "integer",
+        minimum: 0
+      },
+      maxVisibleOutputUtf16: {
+        type: "integer",
+        minimum: 0
+      },
+      decoderContract: {
+        type: "hash"
+      }
+    },
+    stopReasons: [
+      "eos-token",
+      "stop-token",
+      "tool-boundary",
+      "stop-sequence",
+      "max-tokens",
+      "context-limit"
+    ]
+  }
+};
+
+// src/config/generation-contract.js
+function freezeGeneration(value) {
+  if (!value || typeof value !== "object" || Object.isFrozen(value)) return value;
+  for (const child of Object.values(value)) freezeGeneration(child);
+  return Object.freeze(value);
+}
+var GENERATION_CONTRACT = freezeGeneration(generation_contract_default);
+var GenerationError = class extends Error {
+  constructor(kind, message, options = {}) {
+    super(message, options);
+    this.name = "GenerationError";
+    this.code = GENERATION_CONTRACT.errors[kind];
+    if (!this.code) throw new Error("Unknown generation error kind.");
+  }
+};
+function requireValue(ok, message) {
+  if (!ok) throw new GenerationError("invalidRequest", message);
+}
+function validateGenerationField(name, value, rule = GENERATION_CONTRACT.options[name]) {
+  requireValue(rule, `Unknown generation field: ${name}.`);
+  if (rule.type === "array") {
+    requireValue(Array.isArray(value) && (!rule.nonempty || value.length > 0), `Invalid ${name}: array required.`);
+    for (const item of value) validateGenerationField(name, item, {
+      type: rule.items,
+      minimum: rule.minimum,
+      maximum: rule.maximum,
+      nonempty: rule.nonemptyItems
+    });
+    return;
+  }
+  const matches = rule.type === "integer" ? Number.isSafeInteger(value) : rule.type === "number" ? Number.isFinite(value) : typeof value === rule.type;
+  requireValue(matches, `Invalid ${name}: ${rule.type} required.`);
+  requireValue(!rule.nonempty || value.trim().length > 0, `Invalid ${name}: non-empty text required.`);
+  requireValue((rule.minimum === void 0 || value >= rule.minimum) && (rule.exclusiveMinimum === void 0 || value > rule.exclusiveMinimum) && (rule.maximum === void 0 || value <= rule.maximum), `Invalid ${name}: outside its supported range.`);
+}
+function validateGenerationInput(input) {
+  requireValue(input && typeof input === "object" && !Array.isArray(input), "Generation input must be an object.");
+  requireValue(Object.keys(input).every((key) => Object.hasOwn(GENERATION_CONTRACT.input, key)), "Unknown generation input field.");
+  requireValue(
+    GENERATION_CONTRACT.inputExactlyOne.filter((key) => Object.hasOwn(input, key)).length === 1,
+    "generate requires exactly one prompt or promptTokens input."
+  );
+  for (const [key, value] of Object.entries(input)) validateGenerationField(key, value, GENERATION_CONTRACT.input[key]);
+}
+function resolveGenerationOptions(options) {
+  requireValue(options && typeof options === "object" && !Array.isArray(options), "Generation options must be an object.");
+  requireValue(Object.keys(options).every((key) => Object.hasOwn(GENERATION_CONTRACT.options, key)), "Unknown generation option field.");
+  const resolved = {};
+  for (const [key, rule] of Object.entries(GENERATION_CONTRACT.options)) {
+    const value = options[key] === void 0 ? rule.default : options[key];
+    if (value === void 0) {
+      requireValue(
+        !rule.required && !(rule.requiredWhenPositive && options[rule.requiredWhenPositive] > 0),
+        `Capsule generation requires explicit ${key}.`
+      );
+      continue;
+    }
+    validateGenerationField(key, value, rule);
+    resolved[key] = structuredClone(value);
+  }
+  return freezeGeneration(resolved);
+}
+export {
+  GENERATION_CONTRACT,
+  GenerationError,
+  resolveGenerationOptions,
+  validateGenerationField,
+  validateGenerationInput
+};

package/shared/config/doppler-local-models.js

@@ -0,0 +1,79 @@
+/**
+ * @fileoverview Reploid local Doppler model contract.
+ */
+import chatModels from './chat-models.json' with { type: 'json' };
+import dopplerPackage from './doppler-package.json' with { type: 'json' };
+
+export const DOPPLER_PACKAGE_NAME = dopplerPackage.name;
+export const DOPPLER_PACKAGE_VERSION = dopplerPackage.version;
+// Browser generation and partitions consume the same integrity-pinned package.
+export const DOPPLER_BROWSER_RUNTIME_VERSION = dopplerPackage.version;
+export const DOPPLER_PACKAGE_SPEC = dopplerPackage.spec;
+export const DOPPLER_PACKAGE_TARBALL_URL = dopplerPackage.resolved;
+export const DOPPLER_PACKAGE_INTEGRITY = dopplerPackage.integrity;
+export const DOPPLER_BROWSER_RELEASE_REF =
+  `${DOPPLER_PACKAGE_NAME}@${DOPPLER_BROWSER_RUNTIME_VERSION}`;
+const DOPPLER_BROWSER_RELEASE_BASE_URL =
+  `/vendor/doppler/${DOPPLER_BROWSER_RUNTIME_VERSION}`;
+export const DOPPLER_MODULE_URL = `${DOPPLER_BROWSER_RELEASE_BASE_URL}/src/index.js`;
+export const DOPPLER_TRAINING_URL = `${DOPPLER_BROWSER_RELEASE_BASE_URL}/src/training-browser.js`;
+export const DOPPLER_PARTITIONS_MODULE_URL = `/vendor/doppler/${dopplerPackage.version}/src/partitions.js`;
+export const DOPPLER_KERNEL_BASE_URL = `${DOPPLER_BROWSER_RELEASE_BASE_URL}/src/gpu/kernels`;
+export const DOPPLER_TOOLING_URL = `${DOPPLER_BROWSER_RELEASE_BASE_URL}/src/tooling-exports.browser.js`;
+export const DOPPLER_STORAGE_TOOLING_URL =
+  `${DOPPLER_BROWSER_RELEASE_BASE_URL}/src/tooling-exports/storage.js`;
+
+export function resolveDopplerBrowserAssets({ pageUrl, explicitBase, storedBase } = {}) {
+  const origin = new URL(pageUrl);
+  const normalize = value => value ? new URL(String(value).replace(/\/+$/, '') + '/', origin).href.replace(/\/$/, '') : null;
+  const explicit = normalize(explicitBase);
+  let saved = null;
+  if (!explicit) {
+    try {
+      saved = normalize(storedBase);
+      if (saved && !['http:', 'https:'].includes(new URL(saved).protocol)) saved = null;
+    } catch { /* Ignore an unusable saved override, not an explicit developer selection. */ }
+  }
+  const obsolete = saved === normalize('/doppler')
+    || saved === 'https://cdn.jsdelivr.net/npm/doppler-gpu@0.6.2';
+  const baseUrl = explicit || (!obsolete && saved) || normalize(DOPPLER_BROWSER_RELEASE_BASE_URL);
+  if (!['http:', 'https:'].includes(new URL(baseUrl).protocol)) throw new Error('Doppler assets require an HTTP(S) base');
+  return { baseUrl, moduleUrl: `${baseUrl}/src/index.js`, kernelBaseUrl: `${baseUrl}/src/gpu/kernels`,
+    storageModuleUrl: `${baseUrl}/src/tooling-exports/storage.js` };
+}
+
+export const DEFAULT_DOPPLER_MODEL_ID = 'qwen-3-5-2b-q4k-ehaf16';
+
+export const LOCAL_DOPPLER_MODELS = Object.freeze(chatModels.map(model => Object.freeze({
+  ...model, adapters: Object.freeze(model.adapters),
+  packageName: DOPPLER_PACKAGE_NAME, packageVersion: DOPPLER_BROWSER_RUNTIME_VERSION
+})));
+
+export function getLocalDopplerModel(modelId) {
+  const id = String(modelId || '').trim();
+  if (!id) return null;
+  return LOCAL_DOPPLER_MODELS.find((model) => model.id === id) || null;
+}
+
+export function getDefaultLocalDopplerModel() {
+  return getLocalDopplerModel(DEFAULT_DOPPLER_MODEL_ID) || LOCAL_DOPPLER_MODELS[0] || null;
+}
+
+export function buildLocalDopplerModelConfig(modelId) {
+  const model = getLocalDopplerModel(modelId);
+  if (!model) return null;
+  return {
+    id: model.id,
+    name: model.name,
+    identity: model.identity,
+    provider: model.provider,
+    hostType: 'browser-local',
+    packageName: model.packageName,
+    packageVersion: model.packageVersion
+  };
+}
+
+export function buildDefaultLocalDopplerModelConfig() {
+  const model = getDefaultLocalDopplerModel();
+  return model ? buildLocalDopplerModelConfig(model.id) : null;
+}

package/shared/config/doppler-package.json

@@ -0,0 +1,7 @@
+{
+  "name": "doppler-gpu",
+  "version": "0.7.1",
+  "spec": "0.7.1",
+  "resolved": "https://registry.npmjs.org/doppler-gpu/-/doppler-gpu-0.7.1.tgz",
+  "integrity": "sha512-nsg0sPBzUaG1tSI3+GoPtV6PIf4iV9gFtHSI77H1WPMPyNWbJ3OyQde5URb8NlRP0asR7B39y/y1nAk2fqi28Q=="
+}