@hypit/hypit 0.1.4 → 0.1.5

package/packages/provider-kie/package.json

@@ -1,43 +0,0 @@
-{
-  "name": "@hypit/provider-kie",
-  "version": "0.0.0-dev",
-  "license": "SEE LICENSE IN LICENSE",
-  "private": true,
-  "type": "module",
-  "exports": {
-    ".": "./src/index.ts"
-  },
-  "hypit": {
-    "activation": "./src/activation.ts"
-  },
-  "dependencies": {
-    "@hypit/artifact": "workspace:*",
-    "@hypit/background-removal": "workspace:*",
-    "@hypit/endpoint-kit": "workspace:*",
-    "@hypit/generation": "workspace:*",
-    "@hypit/protocol": "workspace:*",
-    "@hypit/runtime": "workspace:*",
-    "@hypit/runtime-kit": "workspace:*"
-  },
-  "devDependencies": {
-    "@hypit/resource-store-fs": "workspace:*",
-    "@hypit/component-kit": "workspace:*",
-    "@hypit/core": "workspace:*",
-    "@hypit/credential-store-env": "workspace:*",
-    "@hypit/driver-node": "workspace:*",
-    "@hypit/elaborator": "workspace:*",
-    "@hypit/gpt-image": "workspace:*",
-    "@hypit/grok-imagine": "workspace:*",
-    "@hypit/runtime-local": "workspace:*",
-    "@hypit/media": "workspace:*",
-    "@hypit/minimax-h3": "workspace:*",
-    "@hypit/model-kit": "workspace:*",
-    "@hypit/nano-banana": "workspace:*",
-    "@hypit/narrative": "workspace:*",
-    "@hypit/seedance": "workspace:*",
-    "@hypit/seedream": "workspace:*",
-    "@hypit/store-sqlite": "workspace:*",
-    "@hypit/text": "workspace:*",
-    "@hypit/validation": "workspace:*"
-  }
-}

package/packages/provider-kie/src/activation.ts

@@ -1,71 +0,0 @@
-import {
-  createRuntimeEndpointAdapterFacet,
-  runtimeConfigCredentialRef,
-  runtimeConfigActionLimits,
-  runtimeConfigExact,
-  runtimeConfigObject,
-  runtimeConfigPositiveInteger,
-  runtimeConfigString,
-} from "@hypit/runtime-kit";
-
-import { createKieProvider } from "./provider.js";
-
-const kieRuntimeAdapter = createRuntimeEndpointAdapterFacet({
-  use: "@hypit/provider-kie",
-  activate(context) {
-    if (context.pool === undefined) throw new Error("KIE Provider Pool is required");
-    const config = runtimeConfigObject(context.config, "KIE");
-    runtimeConfigExact(config, [
-      "apiBaseUrl", "uploadBaseUrl", "apiKey", "defaultConcurrency", "pollIntervalMs",
-      "capabilityConcurrency", "actionLimits", "requestTimeoutMs", "maxOperationMs", "maxArtifactBytes",
-    ], "KIE");
-    const apiBaseUrl = runtimeConfigString(config.apiBaseUrl, "KIE apiBaseUrl");
-    const uploadBaseUrl = runtimeConfigString(config.uploadBaseUrl, "KIE uploadBaseUrl");
-    for (const [value, subject] of [[apiBaseUrl, "KIE apiBaseUrl"], [uploadBaseUrl, "KIE uploadBaseUrl"]] as const) {
-      if (value === undefined) continue;
-      const url = new URL(value);
-      if (url.protocol !== "https:" && url.hostname !== "localhost") {
-        throw new Error(`${subject} must use HTTPS or localhost`);
-      }
-    }
-    const apiKey = runtimeConfigCredentialRef(config.apiKey, "KIE apiKey");
-    if (apiKey === undefined) throw new Error("KIE apiKey CredentialRef is required");
-    const defaultConcurrency = runtimeConfigPositiveInteger(config.defaultConcurrency, "KIE defaultConcurrency");
-    const capabilityConcurrency = config.capabilityConcurrency === undefined
-      ? undefined
-      : Object.fromEntries(Object.entries(runtimeConfigObject(config.capabilityConcurrency, "KIE capabilityConcurrency"))
-        .map(([capability, value]) => {
-          const concurrency = runtimeConfigPositiveInteger(value, `KIE capabilityConcurrency.${capability}`);
-          if (concurrency === undefined) throw new Error(`KIE capabilityConcurrency.${capability} is required`);
-          return [capability, concurrency];
-        }));
-    const pollIntervalMs = runtimeConfigPositiveInteger(config.pollIntervalMs, "KIE pollIntervalMs");
-    const actionLimits = runtimeConfigActionLimits(config.actionLimits);
-    const requestTimeoutMs = runtimeConfigPositiveInteger(config.requestTimeoutMs, "KIE requestTimeoutMs");
-    const maxOperationMs = runtimeConfigPositiveInteger(config.maxOperationMs, "KIE maxOperationMs");
-    const maxArtifactBytes = runtimeConfigPositiveInteger(config.maxArtifactBytes, "KIE maxArtifactBytes");
-    return {
-      endpoint: createKieProvider({
-        instance: context.instance,
-        pool: context.pool,
-        ...(apiBaseUrl === undefined ? {} : { apiBaseUrl }),
-        ...(uploadBaseUrl === undefined ? {} : { uploadBaseUrl }),
-        apiKey,
-        ...(defaultConcurrency === undefined ? {} : { defaultConcurrency }),
-        ...(capabilityConcurrency === undefined ? {} : { capabilityConcurrency }),
-        ...(pollIntervalMs === undefined ? {} : { pollIntervalMs }),
-        ...(actionLimits === undefined ? {} : { actionLimits }),
-        ...(requestTimeoutMs === undefined ? {} : { requestTimeoutMs }),
-        ...(maxOperationMs === undefined ? {} : { maxOperationMs }),
-        ...(maxArtifactBytes === undefined ? {} : { maxArtifactBytes }),
-      }),
-    };
-  },
-});
-
-export const hypitPackage = {
-  format: "hypit.node-package@1" as const,
-  hostFacets: [kieRuntimeAdapter],
-};
-
-export default hypitPackage;

package/packages/provider-kie/src/index.ts

@@ -1,10 +0,0 @@
-export {
-  kieMappingForCapability,
-  kieModelCatalog,
-  verifyKieModelCatalog,
-} from "./mapping.js";
-export {
-  createKieProvider,
-  kieProviderModuleRef,
-} from "./provider.js";
-export type { CreateKieProviderOptions } from "./provider.js";

package/packages/provider-kie/src/mapping.ts

@@ -1,182 +0,0 @@
-import type { CapabilityRef, ModuleRef } from "@hypit/protocol";
-import type { GenerationWireMapping } from "@hypit/generation";
-
-/**
- * How KIE names each model's declared input ports.
- *
- * This file contains data only. It references Capabilities by module and model
- * name, so this Provider package imports no model package: a model owns what it
- * accepts, and KIE owns what it calls that on its wire. Splitting one model
- * across several KIE endpoints is a KIE fact and lives in `routes`.
- */
-
-/** Model packages this KIE release is written against. A version bump is a mapping review. */
-const SEEDANCE: ModuleRef = { name: "@hypit/seedance", version: "1" };
-const MINIMAX: ModuleRef = { name: "@hypit/minimax-h3", version: "1" };
-const GROK: ModuleRef = { name: "@hypit/grok-imagine", version: "1" };
-const GPT_IMAGE: ModuleRef = { name: "@hypit/gpt-image", version: "1" };
-const NANO_BANANA: ModuleRef = { name: "@hypit/nano-banana", version: "1" };
-const SEEDREAM: ModuleRef = { name: "@hypit/seedream", version: "1" };
-
-/** KIE keeps each reference modality in its own array, as its schema documents. */
-const referenceFields = {
-  referenceImage: { as: "urlArray", field: "reference_image_urls" },
-  referenceVideo: { as: "urlArray", field: "reference_video_urls" },
-  referenceAudio: { as: "urlArray", field: "reference_audio_urls" },
-} as const;
-
-function seedanceMapping(model: string, kieModel: string): GenerationWireMapping {
-  return {
-    capability: { module: SEEDANCE, name: model },
-    result: "video",
-    routes: [{ model: kieModel }],
-    fields: {
-      prompt: { as: "value", field: "prompt" },
-      ...referenceFields,
-      firstFrame: { as: "url", field: "first_frame_url" },
-      lastFrame: { as: "url", field: "last_frame_url" },
-      resolution: { as: "value", field: "resolution" },
-      aspectRatio: { as: "value", field: "aspect_ratio" },
-      duration: { as: "value", field: "duration" },
-      generateAudio: { as: "value", field: "generate_audio" },
-      webSearch: { as: "value", field: "web_search" },
-    },
-  };
-}
-
-const minimaxMapping: GenerationWireMapping = {
-  capability: { module: MINIMAX, name: "minimax-h3" },
-  result: "video",
-  routes: [
-    { model: "minimax-h3/image-to-video", whenPresent: ["lastFrame"] },
-    { model: "minimax-h3/image-to-video", whenPresent: ["firstFrame"] },
-    { model: "minimax-h3/reference-to-video", whenPresent: ["referenceImage"] },
-    { model: "minimax-h3/reference-to-video", whenPresent: ["referenceVideo"] },
-    { model: "minimax-h3/text-to-video" },
-  ],
-  fields: {
-    prompt: { as: "value", field: "prompt" },
-    duration: { as: "value", field: "duration" },
-    resolution: { as: "value", field: "resolution" },
-    aspectRatio: { as: "value", field: "aspect_ratio" },
-    ...referenceFields,
-    firstFrame: { as: "url", field: "first_frame_url" },
-    lastFrame: { as: "url", field: "last_frame_url" },
-  },
-};
-
-const grokVideoMapping: GenerationWireMapping = {
-  capability: { module: GROK, name: "grok-imagine-video" },
-  result: "video",
-  routes: [
-    { model: "grok-imagine/image-to-video", whenPresent: ["images"] },
-    { model: "grok-imagine/text-to-video" },
-  ],
-  fields: {
-    prompt: { as: "value", field: "prompt" },
-    aspectRatio: { as: "value", field: "aspect_ratio" },
-    resolution: { as: "value", field: "resolution" },
-    duration: { as: "string", field: "duration" },
-    images: { as: "urlArray", field: "image_urls" },
-  },
-  constants: { mode: "normal" },
-};
-
-const grokPreviewMapping: GenerationWireMapping = {
-  capability: { module: GROK, name: "grok-imagine-video-1.5-preview" },
-  result: "video",
-  routes: [{ model: "grok-imagine-video-1-5-preview" }],
-  fields: {
-    prompt: { as: "value", field: "prompt" },
-    aspectRatio: { as: "value", field: "aspect_ratio" },
-    resolution: { as: "value", field: "resolution" },
-    duration: { as: "value", field: "duration" },
-    images: { as: "urlArray", field: "image_urls" },
-  },
-};
-
-const gptImageMapping: GenerationWireMapping = {
-  capability: { module: GPT_IMAGE, name: "gpt-image-2" },
-  result: "image",
-  routes: [
-    { model: "gpt-image-2-image-to-image", whenPresent: ["images"] },
-    { model: "gpt-image-2-text-to-image" },
-  ],
-  fields: {
-    prompt: { as: "value", field: "prompt" },
-    aspectRatio: { as: "value", field: "aspect_ratio" },
-    resolution: { as: "value", field: "resolution" },
-    background: { as: "value", field: "background" },
-    images: { as: "urlArray", field: "input_urls" },
-  },
-};
-
-function nanoBananaMapping(model: string): GenerationWireMapping {
-  return {
-    capability: { module: NANO_BANANA, name: model },
-    result: "image",
-    routes: [{ model }],
-    fields: {
-      prompt: { as: "value", field: "prompt" },
-      /** KIE expects the key even with no input image. */
-      images: { as: "urlArray", field: "image_input", whenAbsent: [] },
-      aspectRatio: { as: "value", field: "aspect_ratio" },
-      resolution: { as: "value", field: "resolution" },
-      outputFormat: { as: "value", field: "output_format" },
-    },
-  };
-}
-
-const seedreamMapping: GenerationWireMapping = {
-  capability: { module: SEEDREAM, name: "seedream-5-lite" },
-  result: "image",
-  routes: [
-    { model: "seedream/5-lite-image-to-image", whenPresent: ["images"] },
-    { model: "seedream/5-lite-text-to-image" },
-  ],
-  fields: {
-    prompt: { as: "value", field: "prompt" },
-    aspectRatio: { as: "value", field: "aspect_ratio" },
-    quality: { as: "value", field: "quality" },
-    outputFormat: { as: "value", field: "output_format" },
-    nsfwCheck: { as: "value", field: "nsfw_checker" },
-    images: { as: "urlArray", field: "image_urls" },
-  },
-};
-
-export const kieModelCatalog: readonly GenerationWireMapping[] = [
-  seedanceMapping("seedance-2", "bytedance/seedance-2"),
-  seedanceMapping("seedance-2-fast", "bytedance/seedance-2-fast"),
-  seedanceMapping("seedance-2-mini", "bytedance/seedance-2-mini"),
-  {
-    ...seedanceMapping("seedance-2.5", "bytedance/seedance-2-5"),
-    // These are KIE output-envelope choices, not Seedance model inputs.
-    constants: { return_last_frame: false, output_format: "mp4" },
-  },
-  minimaxMapping,
-  grokVideoMapping,
-  grokPreviewMapping,
-  gptImageMapping,
-  nanoBananaMapping("nano-banana-2"),
-  nanoBananaMapping("nano-banana-pro"),
-  seedreamMapping,
-];
-
-function capabilityKey(ref: CapabilityRef): string {
-  return `${ref.module.name}@${ref.module.version}#${ref.name}`;
-}
-
-const catalogByCapability = new Map(kieModelCatalog.map((item) => [capabilityKey(item.capability), item]));
-
-export function kieMappingForCapability(capability: CapabilityRef): GenerationWireMapping | undefined {
-  return catalogByCapability.get(capabilityKey(capability));
-}
-
-export function verifyKieModelCatalog(): void {
-  if (catalogByCapability.size !== kieModelCatalog.length) {
-    throw new Error("KIE model catalog repeats a capability");
-  }
-  kieModelCatalog.forEach((item) => {
-    if (item.capability.name.trim().length === 0) throw new Error("KIE model catalog contains an empty model");
-  });
-}