@xemahq/agent-session-runtime 0.11.1 → 0.11.2

package/src/lib/launch-identity/thread-reuse-key.ts

@@ -1,93 +0,0 @@
-import {
-  canonicalContractJson,
-  hashCanonicalContract,
-  type ResourceBindingRef,
-  requireEnumValue,
-  requireExactObject,
-  requireNonEmptyString,
-  requireResourceBindingRefs,
-  requireSha256,
-} from './canonical-contract';
-
-export enum ThreadReusePolicy {
-  ExplicitlyShareable = 'explicitly-shareable',
-}
-
-export interface ThreadReuseKey {
-  readonly schemaVersion: 1;
-  readonly reusePolicy: ThreadReusePolicy.ExplicitlyShareable;
-  readonly organizationId: string;
-  readonly projectId: string;
-  readonly userId: string;
-  readonly runtimeTemplateHash: string;
-  readonly conversationRef: string;
-  readonly workspaceRef: string;
-  readonly domainRefs: readonly ResourceBindingRef[];
-}
-
-const REQUIRED_KEYS = [
-  'schemaVersion',
-  'reusePolicy',
-  'organizationId',
-  'projectId',
-  'userId',
-  'runtimeTemplateHash',
-  'conversationRef',
-  'workspaceRef',
-  'domainRefs',
-] as const;
-
-/**
- * Canonical identity for the deliberately narrower same-user conversation and
- * filesystem reuse decision. A RuntimeTemplateKey match alone never permits
- * Thread reuse.
- */
-export function createThreadReuseKey(input: unknown): ThreadReuseKey {
-  const object = requireExactObject(input, 'ThreadReuseKey', REQUIRED_KEYS);
-
-  if (object.schemaVersion !== 1) {
-    throw new TypeError('ThreadReuseKey.schemaVersion must be 1.');
-  }
-
-  return Object.freeze({
-    schemaVersion: 1,
-    reusePolicy: requireEnumValue(
-      object.reusePolicy,
-      'ThreadReuseKey.reusePolicy',
-      [ThreadReusePolicy.ExplicitlyShareable],
-    ),
-    organizationId: requireNonEmptyString(
-      object.organizationId,
-      'ThreadReuseKey.organizationId',
-    ),
-    projectId: requireNonEmptyString(
-      object.projectId,
-      'ThreadReuseKey.projectId',
-    ),
-    userId: requireNonEmptyString(object.userId, 'ThreadReuseKey.userId'),
-    runtimeTemplateHash: requireSha256(
-      object.runtimeTemplateHash,
-      'ThreadReuseKey.runtimeTemplateHash',
-    ),
-    conversationRef: requireNonEmptyString(
-      object.conversationRef,
-      'ThreadReuseKey.conversationRef',
-    ),
-    workspaceRef: requireNonEmptyString(
-      object.workspaceRef,
-      'ThreadReuseKey.workspaceRef',
-    ),
-    domainRefs: requireResourceBindingRefs(
-      object.domainRefs,
-      'ThreadReuseKey.domainRefs',
-    ),
-  });
-}
-
-export function serializeThreadReuseKey(input: ThreadReuseKey): string {
-  return canonicalContractJson(createThreadReuseKey(input));
-}
-
-export function hashThreadReuseKey(input: ThreadReuseKey): string {
-  return hashCanonicalContract(createThreadReuseKey(input));
-}

package/src/lib/lifecycle-state.ts

@@ -1,30 +0,0 @@
-// ═══════════════════════════════════════════════════════════════════════════
-// ── Agent-session lifecycle state machine — re-export of the kernel SSOT ──
-//
-// This file is a thin re-export surface. The closed `SessionLifecycleState` /
-// `SessionOwnerKind` value sets, the transition FSM (`canTransition`), and the
-// `isTerminal` / `isPausable` / `isResumable` predicates are the canonical
-// Layer-0 contract owned by `@xemahq/kernel-contracts/agent-session`. The former
-// hand-maintained copy that lived here was collapsed into that single source of
-// truth; this module is retained ONLY so the package's public surface
-// (re-exported from `src/index.ts`) is unchanged.
-//
-// Prisma cannot import a TS value, so the agent-session-api schema re-declares
-// the same members and CI guards parity
-// (`tooling/boundaries/check-session-enum-parity.mjs`).
-// ═══════════════════════════════════════════════════════════════════════════
-
-export {
-  SessionLifecycleState,
-  SessionOwnerKind,
-  canTransition,
-  isTerminal,
-  isPausable,
-  isResumable,
-  SessionLifecycleStateSchema,
-  SessionOwnerKindSchema,
-} from '@xemahq/kernel-contracts/agent-session';
-export type {
-  SessionLifecycleStateValue,
-  SessionOwnerKindValue,
-} from '@xemahq/kernel-contracts/agent-session';

package/src/lib/skill-bundle-template-resolver.ts

@@ -1,147 +0,0 @@
-// ═══════════════════════════════════════════════════════════════════════════
-// ── Skill-bundle-backed TemplateResolver ──
-//
-// Seed-file templates used to
-// live in `workspace-manifests-api` (the `workspace_manifest_templates` table)
-// and were fetched by name. They are now SKILL-BUNDLE RESOURCES served by
-// `skill-registry-api` (`GET /skills/bundle`): a biome that ships templates
-// packages them inside a skill bundle under `assets/templates/<name>.hbs`.
-//
-// This factory builds a `TemplateResolver` that:
-//   1. Walks the resolved composition's skill set.
-//   2. Fetches each skill bundle through the injected `fetchBundle` function.
-//   3. Locates the requested template by mapping the bare template name
-//      (`demo-seeded-canvas-index.html`) to the resource relPath
-//      (`assets/templates/demo-seeded-canvas-index.html.hbs`).
-//   4. Compiles the raw template via the injected `compileTemplate` function
-//      and renders it with the seed-file `vars`.
-//
-// Both the bundle-fetch and the Handlebars compile are INJECTED so this
-// Kernel package stays free of an HTTP client and a templating dependency —
-// `agent-session-api` (and, after Step 4, `workflow-runtime-worker`) supply
-// the concrete implementations and share this one resolution algorithm.
-// ═══════════════════════════════════════════════════════════════════════════
-
-import type { TemplateResolver } from './types';
-
-/** The `assets/templates/` directory prefix every template resource sits under. */
-const TEMPLATE_RESOURCE_PREFIX = 'assets/templates/';
-/** The file extension a Handlebars template resource carries inside the bundle. */
-const TEMPLATE_RESOURCE_SUFFIX = '.hbs';
-
-/**
- * One resource inside a skill bundle. Mirrors `SkillBundleResourceDto` from
- * the skill-registry-api client without importing it (Kernel stays
- * client-dep-free).
- */
-export interface SkillBundleResource {
-  /** Forward-slash path relative to the skill directory. */
-  readonly relPath: string;
-  /** File bytes, base64-encoded. */
-  readonly content: string;
-}
-
-/**
- * The slice of a skill bundle this resolver needs. Mirrors
- * `SkillBundleResponseDto` (subset).
- */
-export interface SkillBundle {
-  readonly slug: string;
-  readonly resources: readonly SkillBundleResource[];
-}
-
-/**
- * Fetches one skill bundle by slug. Implemented by the consumer with its
- * `skill-registry-api` Orval client. Must reject (not return null) on a
- * missing bundle — a template referencing a skill that does not resolve is
- * a fail-fast condition.
- */
-export type SkillBundleFetcher = (slug: string) => Promise<SkillBundle>;
-
-/**
- * Compiles a raw template string and renders it with `vars`. Injected so
- * the Kernel package does not depend on a concrete templating library.
- */
-export type TemplateCompiler = (
-  source: string,
-  vars: Readonly<Record<string, unknown>>,
-) => string;
-
-/** Raised when a referenced seed-file template cannot be resolved. */
-export class SkillBundleTemplateNotFoundError extends Error {
-  constructor(
-    public readonly templateName: string,
-    public readonly skillSlugs: readonly string[],
-  ) {
-    super(
-      `Seed-file template "${templateName}" was not found as ` +
-        `"${TEMPLATE_RESOURCE_PREFIX}${templateName}${TEMPLATE_RESOURCE_SUFFIX}" ` +
-        `in any of the composition's skill bundles ` +
-        `[${skillSlugs.join(', ') || '<none>'}]. The biome that owns the ` +
-        `template must ship it inside a skill bundle the composition references.`,
-    );
-    this.name = 'SkillBundleTemplateNotFoundError';
-  }
-}
-
-/**
- * Map a bare seed-file template name to its skill-bundle resource relPath.
- * `demo-seeded-canvas-index.html` → `assets/templates/demo-seeded-canvas-index.html.hbs`.
- */
-export function templateResourceRelPath(templateName: string): string {
-  return `${TEMPLATE_RESOURCE_PREFIX}${templateName}${TEMPLATE_RESOURCE_SUFFIX}`;
-}
-
-/**
- * Build a `TemplateResolver` backed by the resolved composition's skill
- * bundles.
- *
- * `skillSlugs` is the set of skill slugs attached to the resolved
- * composition (root node + descendants). Bundles are fetched lazily and
- * memoised for the lifetime of the returned resolver, so a session whose
- * manifest references three templates from one skill fetches that bundle
- * exactly once.
- *
- * Fail-fast: a `fetchBundle` rejection propagates; a template name that
- * matches no resource in any bundle throws `SkillBundleTemplateNotFoundError`.
- */
-export function buildSkillBundleTemplateResolver(params: {
-  readonly skillSlugs: readonly string[];
-  readonly fetchBundle: SkillBundleFetcher;
-  readonly compileTemplate: TemplateCompiler;
-}): TemplateResolver {
-  const { skillSlugs, fetchBundle, compileTemplate } = params;
-  // De-duplicate so the same skill referenced at multiple nodes is fetched once.
-  const uniqueSlugs = [...new Set(skillSlugs)];
-  const bundleCache = new Map<string, Promise<SkillBundle>>();
-
-  const loadBundle = (slug: string): Promise<SkillBundle> => {
-    const cached = bundleCache.get(slug);
-    if (cached) {
-      return cached;
-    }
-    const pending = fetchBundle(slug);
-    bundleCache.set(slug, pending);
-    return pending;
-  };
-
-  return {
-    async resolve(
-      name: string,
-      vars: Readonly<Record<string, unknown>>,
-    ): Promise<string> {
-      const relPath = templateResourceRelPath(name);
-      for (const slug of uniqueSlugs) {
-        const bundle = await loadBundle(slug);
-        const resource = bundle.resources.find((r) => r.relPath === relPath);
-        if (resource) {
-          const source = Buffer.from(resource.content, 'base64').toString(
-            'utf8',
-          );
-          return compileTemplate(source, vars);
-        }
-      }
-      throw new SkillBundleTemplateNotFoundError(name, uniqueSlugs);
-    },
-  };
-}