@ci-kit/ai 0.0.0-stage → 0.0.1

package/dist/cli.d.mts

@@ -0,0 +1 @@
+

package/dist/cli.d.ts

@@ -0,0 +1 @@
+

package/dist/cli.mjs

@@ -0,0 +1,87 @@
+#!/usr/bin/env node
+import { writeFileSync, readFileSync } from 'node:fs';
+import process from 'node:process';
+import { cac } from 'cac';
+import { text, image, AiError } from './index.mjs';
+import 'node:buffer';
+import '@ci-kit/http';
+
+const version = "0.0.1";
+const pkg = {
+	version: version};
+
+const cli = cac("ci-kit-ai");
+function readPrompt(prompt, promptFile, vars = {}) {
+  let content = prompt ?? "";
+  if (promptFile) {
+    content = readFileSync(promptFile, "utf8");
+  }
+  if (!content) {
+    throw new Error("Provide --prompt or --prompt-file");
+  }
+  return content.replace(/\{\{\s*(\w+)\s*\}\}/g, (_, name) => vars[name] ?? "");
+}
+function optionalNumber(value) {
+  return value === void 0 ? void 0 : Number(value);
+}
+function reportError(error) {
+  if (error instanceof AiError) {
+    process.stderr.write(`ci-kit-ai: ${error.describe()}
+`);
+  } else {
+    process.stderr.write(`ci-kit-ai: ${error instanceof Error ? error.message : String(error)}
+`);
+  }
+  process.exit(1);
+}
+cli.command("text", "Generate text with the configured provider").option("--prompt <text>", "Inline prompt").option("--prompt-file <path>", "Read prompt from file (supports {{var}})").option("--system <text>", "System message").option("--var <k=v>", "Template variable, repeatable").option("--max-tokens <n>", "Upper bound for generated tokens").option("--json", "Ask for a JSON object response").option("--temperature <n>", "Sampling temperature").option("--retries <n>", "Transport retries; use 0 for paid calls").option("--out <path>", "Write result to file").option("--timeout <ms>", "Request timeout in milliseconds").action(async (options) => {
+  const vars = {};
+  for (const [key, value] of Object.entries(options)) {
+    if (key.startsWith("var") && typeof value === "string") {
+      const [k, v = ""] = value.split("=");
+      vars[k] = v;
+    }
+  }
+  try {
+    const result = await text({
+      prompt: readPrompt(options.prompt, options.promptFile, vars),
+      system: options.system,
+      maxTokens: optionalNumber(options.maxTokens),
+      json: options.json === true,
+      temperature: optionalNumber(options.temperature),
+      retries: optionalNumber(options.retries),
+      timeoutMs: optionalNumber(options.timeout)
+    });
+    const usage = result.usage ? ` tokens ${result.usage.input}/${result.usage.output}` : "";
+    if (options.out) {
+      writeFileSync(options.out, `${result.value}
+`, "utf8");
+      process.stdout.write(`Wrote ${options.out} via ${result.provider} (${result.model})${usage}
+`);
+    } else {
+      process.stdout.write(`${result.value}
+`);
+    }
+  } catch (error) {
+    reportError(error);
+  }
+});
+cli.command("image", "Generate an image with the configured provider").option("--prompt <text>", "Image prompt").option("--prompt-file <path>", "Read prompt from file").option("--size <wxh>", "Image size; defaults to AI_IMAGE_SIZE or the provider default").option("--retries <n>", "Transport retries; use 0 for paid calls").option("--out <path>", "Output image path").option("--timeout <ms>", "Request timeout in milliseconds").action(async (options) => {
+  try {
+    const result = await image({
+      prompt: readPrompt(options.prompt, options.promptFile),
+      size: options.size,
+      retries: optionalNumber(options.retries),
+      timeoutMs: optionalNumber(options.timeout)
+    });
+    const out = options.out ?? "impression.png";
+    writeFileSync(out, result.value);
+    process.stdout.write(`Wrote ${out} (${result.value.length} bytes) via ${result.provider} (${result.model})
+`);
+  } catch (error) {
+    reportError(error);
+  }
+});
+cli.help();
+cli.version(pkg.version);
+cli.parse();

package/dist/index.d.mts

@@ -0,0 +1,126 @@
+/**
+ * Structured AI failures.
+ *
+ * Callers branch on `kind`, never on message text. The message stays short and
+ * never carries credentials, request bodies or provider payloads, because CI
+ * logs are usually readable by anyone with repository access.
+ */
+type AiErrorKind = 'auth'
+/** Rate limited or out of quota. */
+ | 'quota'
+/** Bad request: unknown model, unsupported parameter, incompatible payload. */
+ | 'request'
+/** Unreachable host, DNS failure, timeout. */
+ | 'network'
+/** Provider returned 5xx. */
+ | 'server'
+/** Request succeeded but the payload could not be used. */
+ | 'output'
+/** Local configuration problem, before any network call. */
+ | 'config';
+interface AiErrorInit {
+    kind: AiErrorKind;
+    message: string;
+    provider?: string;
+    model?: string;
+    status?: number;
+    /** Whether the same request may succeed later without changing anything. */
+    retryable?: boolean;
+    cause?: unknown;
+}
+declare class AiError extends Error {
+    readonly kind: AiErrorKind;
+    readonly provider?: string;
+    readonly model?: string;
+    readonly status?: number;
+    readonly retryable: boolean;
+    constructor(init: AiErrorInit);
+    /** One line for logs. Never includes the request body or the key. */
+    describe(): string;
+}
+declare function isAiError(error: unknown): error is AiError;
+/** Map an HTTP status to a kind and whether a plain retry can help. */
+declare function classifyStatus(status: number): {
+    kind: AiErrorKind;
+    retryable: boolean;
+};
+
+type TextProtocol = 'openai' | 'dashscope';
+type ImageProtocol = 'seedream' | 'dashscope' | 'openai';
+interface TextProvider {
+    /** Registry key, used by AI_TEXT_PROVIDER */
+    id: string;
+    /** Human readable vendor name */
+    label: string;
+    protocol: TextProtocol;
+    baseUrl: string;
+    model: string;
+    /** Environment variable holding the key; keys are never passed as flags */
+    apiKeyEnv: string;
+}
+interface ImageProvider {
+    id: string;
+    label: string;
+    protocol: ImageProtocol;
+    baseUrl: string;
+    model: string;
+    apiKeyEnv: string;
+    /** Provider specific default size, for example 1280x720 */
+    defaultSize?: string;
+    /** Size separator used by the API, defaults to x */
+    sizeSeparator?: string;
+}
+
+declare const imageProviders: Record<string, ImageProvider>;
+declare const defaultImageProvider: string;
+
+declare const textProviders: Record<string, TextProvider>;
+declare const defaultTextProvider: string;
+
+declare function resolveTextProvider(env?: NodeJS.ProcessEnv): TextProvider;
+declare function resolveImageProvider(env?: NodeJS.ProcessEnv): ImageProvider;
+
+interface TextOptions {
+    prompt: string;
+    system?: string;
+    /** Upper bound for the generated text. Providers that support it pass it through. */
+    maxTokens?: number;
+    /** Ask the provider for a JSON object. Unsupported providers throw instead of ignoring it. */
+    json?: boolean;
+    temperature?: number;
+    /**
+     * Transport retries. Defaults to the http package value.
+     * Pass 0 for paid or non-idempotent calls: the provider may already have
+     * completed the request, and retrying charges again.
+     */
+    retries?: number;
+    timeoutMs?: number;
+    env?: NodeJS.ProcessEnv;
+}
+interface ImageOptions {
+    prompt: string;
+    size?: string;
+    retries?: number;
+    timeoutMs?: number;
+    env?: NodeJS.ProcessEnv;
+}
+interface TokenUsage {
+    input: number;
+    output: number;
+}
+interface AiResult<T> {
+    value: T;
+    provider: string;
+    model: string;
+    /** Present when the provider reports token usage. */
+    usage?: TokenUsage;
+    /** Raw provider finish reason, for example `stop` or `length`. */
+    finishReason?: string;
+}
+declare function text(options: TextOptions): Promise<AiResult<string>>;
+declare function image(options: ImageOptions): Promise<AiResult<Uint8Array>>;
+type ImageFormat = 'png' | 'jpeg';
+declare function detectImageFormat(bytes: Uint8Array): ImageFormat | null;
+
+export { AiError, classifyStatus, defaultImageProvider, defaultTextProvider, detectImageFormat, image, imageProviders, isAiError, resolveImageProvider, resolveTextProvider, text, textProviders };
+export type { AiErrorInit, AiErrorKind, AiResult, ImageFormat, ImageOptions, ImageProtocol, ImageProvider, TextOptions, TextProtocol, TextProvider, TokenUsage };

package/dist/index.d.ts

@@ -0,0 +1,126 @@
+/**
+ * Structured AI failures.
+ *
+ * Callers branch on `kind`, never on message text. The message stays short and
+ * never carries credentials, request bodies or provider payloads, because CI
+ * logs are usually readable by anyone with repository access.
+ */
+type AiErrorKind = 'auth'
+/** Rate limited or out of quota. */
+ | 'quota'
+/** Bad request: unknown model, unsupported parameter, incompatible payload. */
+ | 'request'
+/** Unreachable host, DNS failure, timeout. */
+ | 'network'
+/** Provider returned 5xx. */
+ | 'server'
+/** Request succeeded but the payload could not be used. */
+ | 'output'
+/** Local configuration problem, before any network call. */
+ | 'config';
+interface AiErrorInit {
+    kind: AiErrorKind;
+    message: string;
+    provider?: string;
+    model?: string;
+    status?: number;
+    /** Whether the same request may succeed later without changing anything. */
+    retryable?: boolean;
+    cause?: unknown;
+}
+declare class AiError extends Error {
+    readonly kind: AiErrorKind;
+    readonly provider?: string;
+    readonly model?: string;
+    readonly status?: number;
+    readonly retryable: boolean;
+    constructor(init: AiErrorInit);
+    /** One line for logs. Never includes the request body or the key. */
+    describe(): string;
+}
+declare function isAiError(error: unknown): error is AiError;
+/** Map an HTTP status to a kind and whether a plain retry can help. */
+declare function classifyStatus(status: number): {
+    kind: AiErrorKind;
+    retryable: boolean;
+};
+
+type TextProtocol = 'openai' | 'dashscope';
+type ImageProtocol = 'seedream' | 'dashscope' | 'openai';
+interface TextProvider {
+    /** Registry key, used by AI_TEXT_PROVIDER */
+    id: string;
+    /** Human readable vendor name */
+    label: string;
+    protocol: TextProtocol;
+    baseUrl: string;
+    model: string;
+    /** Environment variable holding the key; keys are never passed as flags */
+    apiKeyEnv: string;
+}
+interface ImageProvider {
+    id: string;
+    label: string;
+    protocol: ImageProtocol;
+    baseUrl: string;
+    model: string;
+    apiKeyEnv: string;
+    /** Provider specific default size, for example 1280x720 */
+    defaultSize?: string;
+    /** Size separator used by the API, defaults to x */
+    sizeSeparator?: string;
+}
+
+declare const imageProviders: Record<string, ImageProvider>;
+declare const defaultImageProvider: string;
+
+declare const textProviders: Record<string, TextProvider>;
+declare const defaultTextProvider: string;
+
+declare function resolveTextProvider(env?: NodeJS.ProcessEnv): TextProvider;
+declare function resolveImageProvider(env?: NodeJS.ProcessEnv): ImageProvider;
+
+interface TextOptions {
+    prompt: string;
+    system?: string;
+    /** Upper bound for the generated text. Providers that support it pass it through. */
+    maxTokens?: number;
+    /** Ask the provider for a JSON object. Unsupported providers throw instead of ignoring it. */
+    json?: boolean;
+    temperature?: number;
+    /**
+     * Transport retries. Defaults to the http package value.
+     * Pass 0 for paid or non-idempotent calls: the provider may already have
+     * completed the request, and retrying charges again.
+     */
+    retries?: number;
+    timeoutMs?: number;
+    env?: NodeJS.ProcessEnv;
+}
+interface ImageOptions {
+    prompt: string;
+    size?: string;
+    retries?: number;
+    timeoutMs?: number;
+    env?: NodeJS.ProcessEnv;
+}
+interface TokenUsage {
+    input: number;
+    output: number;
+}
+interface AiResult<T> {
+    value: T;
+    provider: string;
+    model: string;
+    /** Present when the provider reports token usage. */
+    usage?: TokenUsage;
+    /** Raw provider finish reason, for example `stop` or `length`. */
+    finishReason?: string;
+}
+declare function text(options: TextOptions): Promise<AiResult<string>>;
+declare function image(options: ImageOptions): Promise<AiResult<Uint8Array>>;
+type ImageFormat = 'png' | 'jpeg';
+declare function detectImageFormat(bytes: Uint8Array): ImageFormat | null;
+
+export { AiError, classifyStatus, defaultImageProvider, defaultTextProvider, detectImageFormat, image, imageProviders, isAiError, resolveImageProvider, resolveTextProvider, text, textProviders };
+export type { AiErrorInit, AiErrorKind, AiResult, ImageFormat, ImageOptions, ImageProtocol, ImageProvider, TextOptions, TextProtocol, TextProvider, TokenUsage };

package/dist/index.mjs

@@ -0,0 +1,360 @@
+import { Buffer } from 'node:buffer';
+import process from 'node:process';
+import { requestJson, HttpError, request } from '@ci-kit/http';
+
+class AiError extends Error {
+  kind;
+  provider;
+  model;
+  status;
+  retryable;
+  constructor(init) {
+    super(init.message, { cause: init.cause });
+    this.name = "AiError";
+    this.kind = init.kind;
+    this.provider = init.provider;
+    this.model = init.model;
+    this.status = init.status;
+    this.retryable = init.retryable ?? false;
+  }
+  /** One line for logs. Never includes the request body or the key. */
+  describe() {
+    const parts = [this.kind];
+    if (this.provider) {
+      parts.push(this.provider);
+    }
+    if (this.model) {
+      parts.push(this.model);
+    }
+    if (this.status !== void 0) {
+      parts.push(`HTTP ${this.status}`);
+    }
+    return `${parts.join(" / ")}: ${this.message}`;
+  }
+}
+function isAiError(error) {
+  return error instanceof AiError;
+}
+function classifyStatus(status) {
+  if (status === 401 || status === 403) {
+    return { kind: "auth", retryable: false };
+  }
+  if (status === 429) {
+    return { kind: "quota", retryable: true };
+  }
+  if (status === 408) {
+    return { kind: "network", retryable: true };
+  }
+  if (status >= 500) {
+    return { kind: "server", retryable: true };
+  }
+  return { kind: "request", retryable: false };
+}
+
+const dashscopeImage = {
+  id: "dashscope-image",
+  label: "Alibaba DashScope (image)",
+  protocol: "dashscope",
+  baseUrl: "https://dashscope.aliyuncs.com/api/v1",
+  model: "qwen-image-3.0",
+  apiKeyEnv: "AI_IMAGE_API_KEY",
+  defaultSize: "1280x720",
+  sizeSeparator: "*"
+};
+
+const seedreamImage = {
+  id: "seedream",
+  label: "Volcengine Ark Seedream",
+  protocol: "seedream",
+  baseUrl: "https://ark.cn-beijing.volces.com/api/v3",
+  model: "doubao-seedream-5-0-flash-260915",
+  apiKeyEnv: "AI_IMAGE_API_KEY",
+  defaultSize: "1280x720"
+};
+
+const imageProviders = {
+  [seedreamImage.id]: seedreamImage,
+  [dashscopeImage.id]: dashscopeImage
+};
+const defaultImageProvider = seedreamImage.id;
+
+const dashscopeText = {
+  id: "dashscope",
+  label: "Alibaba DashScope (compatible mode)",
+  protocol: "openai",
+  baseUrl: "https://dashscope.aliyuncs.com/compatible-mode/v1",
+  model: "ZHIPU/GLM-5.3-Flash",
+  apiKeyEnv: "AI_API_KEY"
+};
+
+const openaiText = {
+  id: "openai",
+  label: "OpenAI (chat completions)",
+  protocol: "openai",
+  baseUrl: "https://api.openai.com/v1",
+  model: "gpt-4.1-mini",
+  apiKeyEnv: "AI_API_KEY"
+};
+
+const textProviders = {
+  [dashscopeText.id]: dashscopeText,
+  [openaiText.id]: openaiText
+};
+const defaultTextProvider = dashscopeText.id;
+
+function resolveTextProvider(env = process.env) {
+  const id = env.AI_TEXT_PROVIDER || defaultTextProvider;
+  const provider = textProviders[id];
+  if (!provider) {
+    throw new Error(`Unknown AI_TEXT_PROVIDER: ${id}. Available: ${Object.keys(textProviders).join(", ")}`);
+  }
+  return provider;
+}
+function resolveImageProvider(env = process.env) {
+  const id = env.AI_IMAGE_PROVIDER || defaultImageProvider;
+  const provider = imageProviders[id];
+  if (!provider) {
+    throw new Error(`Unknown AI_IMAGE_PROVIDER: ${id}. Available: ${Object.keys(imageProviders).join(", ")}`);
+  }
+  return provider;
+}
+
+const PNG_MAGIC = [137, 80, 78, 71];
+const JPEG_MAGIC = [255, 216, 255];
+function apiKeyOf(env, keyEnv, provider) {
+  const key = env[keyEnv]?.trim();
+  if (!key) {
+    throw new AiError({
+      kind: "config",
+      provider,
+      message: `Missing ${keyEnv}; set it in the environment or .env store`
+    });
+  }
+  return key;
+}
+function trimSlash(baseUrl) {
+  return baseUrl.replace(/\/+$/, "");
+}
+function wrapError(error, provider, context) {
+  if (error instanceof AiError) {
+    return error;
+  }
+  if (error instanceof HttpError) {
+    const { kind, retryable } = classifyStatus(error.status);
+    return new AiError({
+      kind,
+      provider: provider.id,
+      model: provider.model,
+      status: error.status,
+      retryable,
+      // The body is deliberately dropped: it can echo the prompt or request.
+      message: `${context} rejected by the provider`,
+      cause: error
+    });
+  }
+  if (error instanceof Error) {
+    const timedOut = error.name === "TimeoutError" || error.name === "AbortError";
+    return new AiError({
+      kind: "network",
+      provider: provider.id,
+      model: provider.model,
+      // A timeout after the provider accepted the request must not be retried
+      // blindly, so it is reported as non-retryable by default.
+      retryable: !timedOut,
+      message: timedOut ? `${context} timed out` : `${context} request failed: ${error.message}`,
+      cause: error
+    });
+  }
+  return new AiError({
+    kind: "network",
+    provider: provider.id,
+    model: provider.model,
+    message: `${context} failed`,
+    cause: error
+  });
+}
+function supportsJsonMode(provider) {
+  return provider.protocol === "openai" || provider.protocol === "dashscope";
+}
+async function text(options) {
+  const env = options.env ?? process.env;
+  const provider = resolveTextProvider(env);
+  if (options.json && !supportsJsonMode(provider)) {
+    throw new AiError({
+      kind: "config",
+      provider: provider.id,
+      model: provider.model,
+      message: `Provider ${provider.id} does not support JSON output; remove json: true or change provider`
+    });
+  }
+  const key = apiKeyOf(env, provider.apiKeyEnv, provider.id);
+  const messages = [
+    ...options.system ? [
+      { role: "system", content: options.system }
+    ] : [],
+    { role: "user", content: options.prompt }
+  ];
+  const body = {
+    model: env.AI_TEXT_MODEL || provider.model,
+    messages,
+    stream: false
+  };
+  if (options.maxTokens !== void 0) {
+    body.max_tokens = options.maxTokens;
+  }
+  if (options.temperature !== void 0) {
+    body.temperature = options.temperature;
+  }
+  if (options.json) {
+    body.response_format = { type: "json_object" };
+  }
+  let data;
+  try {
+    data = await requestJson(`${trimSlash(provider.baseUrl)}/chat/completions`, {
+      method: "POST",
+      headers: { "authorization": `Bearer ${key}`, "content-type": "application/json" },
+      body: JSON.stringify(body)
+    }, { timeoutMs: options.timeoutMs, retries: options.retries });
+  } catch (error) {
+    throw wrapError(error, provider, "text");
+  }
+  const choice = data.choices?.[0];
+  const value = choice?.message?.content?.trim();
+  if (!value) {
+    throw new AiError({
+      kind: "output",
+      provider: provider.id,
+      model: provider.model,
+      message: "Empty text response from provider"
+    });
+  }
+  const finishReason = choice?.finish_reason;
+  if (finishReason && finishReason !== "stop") {
+    throw new AiError({
+      kind: "output",
+      provider: provider.id,
+      model: provider.model,
+      retryable: finishReason === "length",
+      message: `Text generation ended with finish_reason=${finishReason}; the content is incomplete`
+    });
+  }
+  return {
+    value,
+    provider: provider.id,
+    model: String(body.model),
+    usage: data.usage ? { input: Number(data.usage.prompt_tokens) || 0, output: Number(data.usage.completion_tokens) || 0 } : void 0,
+    finishReason
+  };
+}
+async function image(options) {
+  const env = options.env ?? process.env;
+  const provider = resolveImageProvider(env);
+  const key = apiKeyOf(env, provider.apiKeyEnv, provider.id);
+  const rawSize = options.size ?? env.AI_IMAGE_SIZE ?? provider.defaultSize ?? "1280x720";
+  const size = normalizeSize(rawSize, provider);
+  const body = provider.protocol === "seedream" ? {
+    model: env.AI_IMAGE_MODEL || provider.model,
+    prompt: options.prompt,
+    size,
+    response_format: "b64_json"
+  } : {
+    model: env.AI_IMAGE_MODEL || provider.model,
+    prompt: options.prompt,
+    size,
+    n: 1
+  };
+  let data;
+  try {
+    data = await requestJson(`${trimSlash(provider.baseUrl)}/images/generations`, {
+      method: "POST",
+      headers: { "authorization": `Bearer ${key}`, "content-type": "application/json" },
+      body: JSON.stringify(body)
+    }, { timeoutMs: options.timeoutMs, retries: options.retries });
+  } catch (error) {
+    throw wrapError(error, provider, "image");
+  }
+  const items = data.data;
+  if (!Array.isArray(items) || items.length !== 1) {
+    throw new AiError({
+      kind: "output",
+      provider: provider.id,
+      model: provider.model,
+      message: `Expected exactly 1 image, received ${Array.isArray(items) ? items.length : "none"}`
+    });
+  }
+  const item = items[0];
+  if (item.error) {
+    throw new AiError({
+      kind: "output",
+      provider: provider.id,
+      model: provider.model,
+      // Only the code is surfaced; provider messages may echo the prompt.
+      message: `Image item failed${item.error.code ? ` with code ${item.error.code}` : ""}`
+    });
+  }
+  const value = await readImagePayload(item, provider, options.timeoutMs, options.retries);
+  const format = detectImageFormat(value);
+  if (!format) {
+    throw new AiError({
+      kind: "output",
+      provider: provider.id,
+      model: provider.model,
+      message: "Image payload is neither PNG nor JPEG"
+    });
+  }
+  return {
+    value,
+    provider: provider.id,
+    model: String(body.model)
+  };
+}
+function normalizeSize(size, provider) {
+  const [width, height] = size.toLowerCase().split("x");
+  if (!width || !height || !Number.isFinite(Number(width)) || !Number.isFinite(Number(height))) {
+    throw new AiError({
+      kind: "config",
+      provider: provider.id,
+      model: provider.model,
+      message: `Invalid size: ${size}. Expected WxH, for example 1280x720`
+    });
+  }
+  return `${width}${provider.sizeSeparator ?? "x"}${height}`;
+}
+async function readImagePayload(item, provider, timeoutMs, retries) {
+  if (item.b64_json) {
+    return new Uint8Array(Buffer.from(item.b64_json, "base64"));
+  }
+  if (item.url) {
+    if (!/^https:\/\//i.test(item.url)) {
+      throw new AiError({
+        kind: "output",
+        provider: provider.id,
+        model: provider.model,
+        message: "Image URL must be HTTPS"
+      });
+    }
+    try {
+      const response = await request(item.url, {}, { timeoutMs, retries });
+      return new Uint8Array(await response.arrayBuffer());
+    } catch (error) {
+      throw wrapError(error, provider, "image download");
+    }
+  }
+  throw new AiError({
+    kind: "output",
+    provider: provider.id,
+    model: provider.model,
+    message: "Empty image response from provider"
+  });
+}
+function detectImageFormat(bytes) {
+  if (bytes.length >= 4 && PNG_MAGIC.every((byte, index) => bytes[index] === byte)) {
+    return "png";
+  }
+  if (bytes.length >= 3 && JPEG_MAGIC.every((byte, index) => bytes[index] === byte)) {
+    return "jpeg";
+  }
+  return null;
+}
+
+export { AiError, classifyStatus, defaultImageProvider, defaultTextProvider, detectImageFormat, image, imageProviders, isAiError, resolveImageProvider, resolveTextProvider, text, textProviders };

package/package.json

@@ -1,6 +1,43 @@
 {
   "name": "@ci-kit/ai",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "type": "module",
+  "version": "0.0.1",
+  "description": "Multi-provider AI client for text and image generation",
+  "author": "imba97",
+  "license": "MIT",
+  "homepage": "https://github.com/cikit-js/ci-kit#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/cikit-js/ci-kit.git"
+  },
+  "bugs": {
+    "url": "https://github.com/cikit-js/ci-kit/issues"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.mts",
+      "import": "./dist/index.mjs"
+    }
+  },
+  "main": "./dist/index.mjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.mts",
+  "bin": {
+    "ci-kit-ai": "dist/cli.mjs"
+  },
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "@ci-kit/http": "0.0.1",
+    "cac": "^7.1.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "unbuild",
+    "typecheck": "tsc --noEmit",
+    "stub": "unbuild --stub"
+  }
 }

package/README.md

@@ -1,3 +0,0 @@
-# Temporary Holding Version
-
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.