@demicodes/core 0.10.3 → 0.12.0

package/dist/index.d.mts

@@ -11,6 +11,14 @@ type ImageSource = {
   type: 'url';
   url: string;
 };
+type VideoSource = {
+  type: 'binary';
+  data: Uint8Array;
+  mediaType: string;
+} | {
+  type: 'url';
+  url: string;
+};
 interface DocumentSource {
   data: Uint8Array;
   mediaType: string;
@@ -22,6 +30,9 @@ type UserContentBlock = {
 } | {
   type: 'image';
   source: ImageSource;
+} | {
+  type: 'video';
+  source: VideoSource;
 } | {
   type: 'document';
   source: DocumentSource;
@@ -33,12 +44,19 @@ interface Base64ImageSource {
   mediaType: string;
   data: string;
 }
+interface Base64VideoSource {
+  mediaType: string;
+  data: string;
+}
 type ToolResultContentBlock = {
   type: 'text';
   text: string;
 } | {
   type: 'image';
   source: Base64ImageSource;
+} | {
+  type: 'video';
+  source: Base64VideoSource;
 };
 interface TokenUsage {
   inputTokens: number;
@@ -48,7 +66,10 @@ interface TokenUsage {
 }
 /** A `TokenUsage` with every counter at zero. */
 declare function zeroUsage(): TokenUsage;
-type FileExtension = 'png' | 'jpg' | 'jpeg' | 'gif' | 'webp' | 'pdf';
+type ImageFileExtension = 'png' | 'jpg' | 'jpeg' | 'gif' | 'webp';
+type VideoFileExtension = 'mp4' | 'mov' | 'webm' | 'm4v';
+type FileExtension = ImageFileExtension | VideoFileExtension | 'pdf';
+declare const VIDEO_FILE_EXTENSIONS: readonly VideoFileExtension[];
 type ThinkingEffort = string;
 type ThinkingSummary = 'auto' | 'concise' | 'detailed' | 'off' | 'on';
 type ThinkingCapability = {
@@ -90,6 +111,21 @@ interface Model {
   thinking: ThinkingCapability[];
   acceptedExtensions: FileExtension[];
 }
+declare function modelAcceptsVideo(model: Model): boolean;
+type ModelMediaKind = 'image' | 'video';
+interface ModelMediaType {
+  mediaType: string;
+  kind: ModelMediaKind;
+  extension: ImageFileExtension | VideoFileExtension;
+}
+declare function modelMediaTypeFor(mediaType: string): ModelMediaType | null;
+/** Whether this model accepts the given media type natively (per its catalog extensions). */
+declare function modelAcceptsMediaType(model: Model, mediaType: string): boolean;
+/**
+ * Detect a model-media type from a byte stream's magic numbers. Returns null
+ * for anything outside the closed set — callers must not guess further.
+ */
+declare function sniffModelMediaType(bytes: Uint8Array): ModelMediaType | null;
 interface ModelSelection {
   providerId: string;
   model: Model;
@@ -97,6 +133,14 @@ interface ModelSelection {
   serviceTierId?: string | null;
 }
 type ToolCallStatus = 'executing' | 'completed' | 'error';
+interface ProviderErrorDiagnostics {
+  source: 'http' | 'stream' | 'transport' | 'unknown';
+  clientRequestId?: string;
+  providerRequestId?: string;
+  providerResponseId?: string;
+  providerCode?: string;
+  httpStatus?: number;
+}
 type Block = {
   type: 'user';
   id: string;
@@ -150,7 +194,13 @@ type Block = {
   status: ToolCallStatus;
   streamingOutput: ToolResultContentBlock[];
   output: ToolResultContentBlock[];
-  metadata: unknown | null;
+  /**
+   * Bounded UI-facing enhancement data, typed by the tool's owning layer.
+   * Never replayed to the model. Must not embed unbounded payloads (full
+   * command output, file bodies, raw or base64 bytes) — anything unbounded
+   * lives in a command artifact or blob and is referenced by id.
+   */
+  view: unknown | null;
 } | {
   type: 'response';
   id: string;
@@ -164,6 +214,7 @@ type Block = {
   model: ModelSelection;
   message: string;
   code: string | null;
+  diagnostics?: ProviderErrorDiagnostics;
 } | {
   type: 'abort';
   id: string;
@@ -200,10 +251,5 @@ interface QueuedMessage {
 interface Transcript {
   blocks: Block[];
 }
-interface AgentSessionCoreState {
-  transcript: Transcript;
-  phase: SessionPhase;
-  queue: QueuedMessage[];
-}
 //#endregion
-export { AgentSessionCoreState, Base64ImageSource, Block, BlockMeta, DocumentSource, FileExtension, ImageSource, Model, ModelSelection, QueuedMessage, SessionPhase, ThinkingCapability, ThinkingConfig, ThinkingEffort, ThinkingSummary, TokenUsage, ToolCallStatus, ToolResultContentBlock, Transcript, UserContentBlock, zeroUsage };
+export { Base64ImageSource, Base64VideoSource, Block, BlockMeta, DocumentSource, FileExtension, ImageFileExtension, ImageSource, Model, ModelMediaKind, ModelMediaType, ModelSelection, ProviderErrorDiagnostics, QueuedMessage, SessionPhase, ThinkingCapability, ThinkingConfig, ThinkingEffort, ThinkingSummary, TokenUsage, ToolCallStatus, ToolResultContentBlock, Transcript, UserContentBlock, VIDEO_FILE_EXTENSIONS, VideoFileExtension, VideoSource, modelAcceptsMediaType, modelAcceptsVideo, modelMediaTypeFor, sniffModelMediaType, zeroUsage };

package/dist/index.mjs

@@ -8,5 +8,91 @@ function zeroUsage() {
 		cacheWriteTokens: 0
 	};
 }
+const VIDEO_FILE_EXTENSIONS = [
+	"mp4",
+	"mov",
+	"webm",
+	"m4v"
+];
+function modelAcceptsVideo(model) {
+	return VIDEO_FILE_EXTENSIONS.some((extension) => model.acceptedExtensions.includes(extension));
+}
+const MODEL_MEDIA_TYPES = [
+	{
+		mediaType: "image/png",
+		kind: "image",
+		extension: "png"
+	},
+	{
+		mediaType: "image/jpeg",
+		kind: "image",
+		extension: "jpeg"
+	},
+	{
+		mediaType: "image/gif",
+		kind: "image",
+		extension: "gif"
+	},
+	{
+		mediaType: "image/webp",
+		kind: "image",
+		extension: "webp"
+	},
+	{
+		mediaType: "video/mp4",
+		kind: "video",
+		extension: "mp4"
+	},
+	{
+		mediaType: "video/x-m4v",
+		kind: "video",
+		extension: "m4v"
+	},
+	{
+		mediaType: "video/quicktime",
+		kind: "video",
+		extension: "mov"
+	},
+	{
+		mediaType: "video/webm",
+		kind: "video",
+		extension: "webm"
+	}
+];
+function modelMediaTypeFor(mediaType) {
+	return MODEL_MEDIA_TYPES.find((entry) => entry.mediaType === mediaType) ?? null;
+}
+/** Whether this model accepts the given media type natively (per its catalog extensions). */
+function modelAcceptsMediaType(model, mediaType) {
+	const entry = modelMediaTypeFor(mediaType);
+	if (!entry) return false;
+	if (model.acceptedExtensions.includes(entry.extension)) return true;
+	return entry.extension === "jpeg" && model.acceptedExtensions.includes("jpg");
+}
+/**
+* Detect a model-media type from a byte stream's magic numbers. Returns null
+* for anything outside the closed set — callers must not guess further.
+*/
+function sniffModelMediaType(bytes) {
+	if (bytes.length < 12) return null;
+	const at = (index) => bytes[index] ?? 0;
+	const ascii = (start, length) => {
+		let out = "";
+		for (let i = start; i < start + length && i < bytes.length; i += 1) out += String.fromCharCode(at(i));
+		return out;
+	};
+	if (at(0) === 137 && ascii(1, 3) === "PNG") return modelMediaTypeFor("image/png");
+	if (at(0) === 255 && at(1) === 216 && at(2) === 255) return modelMediaTypeFor("image/jpeg");
+	if (ascii(0, 6) === "GIF87a" || ascii(0, 6) === "GIF89a") return modelMediaTypeFor("image/gif");
+	if (ascii(0, 4) === "RIFF" && ascii(8, 4) === "WEBP") return modelMediaTypeFor("image/webp");
+	if (at(0) === 26 && at(1) === 69 && at(2) === 223 && at(3) === 163) return modelMediaTypeFor("video/webm");
+	if (ascii(4, 4) === "ftyp") {
+		const brand = ascii(8, 4);
+		if (brand === "qt  ") return modelMediaTypeFor("video/quicktime");
+		if (brand.startsWith("M4V")) return modelMediaTypeFor("video/x-m4v");
+		return modelMediaTypeFor("video/mp4");
+	}
+	return null;
+}
 //#endregion
-export { zeroUsage };
+export { VIDEO_FILE_EXTENSIONS, modelAcceptsMediaType, modelAcceptsVideo, modelMediaTypeFor, sniffModelMediaType, zeroUsage };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@demicodes/core",
   "description": "Core data types and shared domain primitives for the Demi agent toolkit.",
-  "version": "0.10.3",
+  "version": "0.12.0",
   "private": false,
   "type": "module",
   "exports": {