@wirecat/cli-core 0.398.0 → 0.400.0

package/dist/entities/conversation-results.js

@@ -0,0 +1,94 @@
+import * as v from "valibot";
+import { conversation } from "./conversation.js";
+import { chatEmbedding, conversationBuild, conversationPreparation } from "./conversation-preparation.js";
+import { count, id, reference, text, time } from "./fields.js";
+import { message } from "./message.js";
+/** JSON returns the conversation with its messages; JSONL streams the messages themselves. */
+export const conversationDetails = v.union([
+    v.strictObject({ ...conversation.entries, messages: v.array(message) }),
+    message,
+]);
+export const conversationBatchStatus = v.strictObject({
+    chat: id,
+    messages: count,
+    characters: count,
+    batches: count,
+    tokens_estimate: count,
+});
+const batchMessage = v.strictObject({
+    id,
+    at: time,
+    sender: v.strictObject({ id: v.nullable(id), name: v.nullable(text) }),
+    text,
+    reply_to: v.optional(id),
+    thread: v.optional(id),
+    mentions: v.optional(v.array(id)),
+    answer: v.boolean(),
+    candidates: v.optional(v.array(v.strictObject({ parent: v.nullable(id), source: text, kind: text, confidence: v.number() }))),
+});
+export const conversationBatch = v.union([
+    v.strictObject({ batch: v.null() }),
+    v.strictObject({
+        batch: id,
+        chat: id,
+        messages: v.array(batchMessage),
+        remaining: v.strictObject({ messages: count, characters: count }),
+    }),
+]);
+const analyzedConversation = v.strictObject({
+    chat: id,
+    model: text,
+    batches: count,
+    stored: count,
+    tokens: count,
+    reserved_tokens: count,
+    max_tokens: count,
+    stopped: v.picklist(["complete", "budget"]),
+    remaining: conversationBatchStatus,
+    built: v.optional(conversationBuild),
+});
+export const conversationBuildResult = v.union([conversationBuild, conversationPreparation, analyzedConversation]);
+export const conversationEmbedding = v.union([chatEmbedding, conversationPreparation]);
+export const conversationChange = v.union([
+    v.strictObject({ chat: id, stored: count }),
+    v.strictObject({ chat: id, cleared: count }),
+]);
+export const conversationReadiness = v.strictObject({
+    chat: id,
+    model: text,
+    state: v.picklist(["ready", "stale", "partial", "words-only", "not-built"]),
+    graph: v.nullable(v.strictObject({ built_at: time, rules_version: v.nullable(count), outdated_rules: v.boolean() })),
+    pending: v.strictObject({ new: count, edited: count, deleted: count }),
+    vectors: v.strictObject({ chunks: count, current: count, stale: count, missing: count }),
+});
+export const conversationEmbeddingStatus = v.strictObject({
+    chat: id,
+    model: text,
+    chunks: count,
+    embedded: count,
+    left: count,
+    estimate_seconds: v.nullable(v.number()),
+    tokens_at_most: count,
+    price_at_most: v.optional(v.strictObject({ usd: v.number(), read: text })),
+});
+const summary = v.strictObject({
+    id,
+    chat_id: id,
+    first_message_id: id,
+    first_at: time,
+    last_at: time,
+    message_count: count,
+    senders: count,
+    built_at: time,
+    algorithm_version: count,
+});
+export const conversationHit = v.strictObject({
+    source: v.optional(v.strictObject({ provider: text, account: id })),
+    locator: v.optional(reference),
+    summary,
+    chunk: v.strictObject({ first_message_id: id, last_message_id: id }),
+    score: v.nullable(v.number()),
+    matched_in: v.optional(v.literal("context")),
+    by: v.array(v.picklist(["meaning", "words"])),
+    stale: v.boolean(),
+});

package/dist/entities/document-link.d.ts

@@ -0,0 +1,13 @@
+import * as v from "valibot";
+export declare const documentLink: v.StrictObjectSchema<{
+    readonly ref: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>;
+    readonly url: v.StringSchema<undefined>;
+    readonly document_id: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>, undefined>;
+    readonly title: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+    readonly in_store: v.BooleanSchema<undefined>;
+    readonly sent_at: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoTimestampAction<string, "an ISO 8601 time in UTC">, v.EndsWithAction<string, "Z", "an ISO 8601 time in UTC, ending in `Z`">]>;
+    readonly sender: v.StrictObjectSchema<{
+        readonly id: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>, undefined>;
+        readonly name: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+    }, undefined>;
+}, undefined>;

package/dist/entities/document-link.js

@@ -0,0 +1,11 @@
+import * as v from "valibot";
+import { id, reference, text, time } from "./fields.js";
+export const documentLink = v.strictObject({
+    ref: reference,
+    url: text,
+    document_id: v.nullable(id),
+    title: v.nullable(text),
+    in_store: v.boolean(),
+    sent_at: time,
+    sender: v.strictObject({ id: v.nullable(id), name: v.nullable(text) }),
+});

package/dist/entities/extraction-report.d.ts

@@ -0,0 +1,95 @@
+import * as v from "valibot";
+export declare const extractionItem: v.StrictObjectSchema<{
+    readonly ref: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>;
+    readonly attachment: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+    readonly kind: v.StringSchema<undefined>;
+    readonly name: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+    readonly status: v.PicklistSchema<["extracted", "needs-agent", "unreadable", "engine-missing", "too-large", "missing"], undefined>;
+    readonly extractor: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+    readonly chars: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>;
+    readonly local_path: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+    readonly pages: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>;
+    readonly ocr_pages: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>;
+    readonly error: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+    readonly issue: v.OptionalSchema<v.ObjectWithRestSchema<{
+        readonly code: v.StringSchema<undefined>;
+        readonly message: v.StringSchema<undefined>;
+        readonly retryable: v.BooleanSchema<undefined>;
+        readonly retry_after_ms: v.OptionalSchema<v.NumberSchema<undefined>, undefined>;
+    }, v.UnknownSchema, undefined>, undefined>;
+}, undefined>;
+export declare const extractionSummary: v.StrictObjectSchema<{
+    readonly extracted: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+    readonly failed: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+    readonly needs_agent: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+    readonly complete: v.BooleanSchema<undefined>;
+    readonly batch: v.OptionalSchema<v.StrictObjectSchema<{
+        readonly attempted: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+        readonly succeeded: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+        readonly failed: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+        readonly error_rate: v.NumberSchema<undefined>;
+        readonly failures: v.ArraySchema<v.StrictObjectSchema<{
+            readonly id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
+            readonly stage: v.StringSchema<undefined>;
+            readonly error: v.ObjectWithRestSchema<{
+                readonly code: v.StringSchema<undefined>;
+                readonly message: v.StringSchema<undefined>;
+                readonly retryable: v.BooleanSchema<undefined>;
+                readonly retry_after_ms: v.OptionalSchema<v.NumberSchema<undefined>, undefined>;
+            }, v.UnknownSchema, undefined>;
+            readonly attachment: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>;
+        }, undefined>, undefined>;
+        readonly stop_reason: v.OptionalSchema<v.PicklistSchema<["rate_limited", "authentication", "error_rate", "cancelled"], undefined>, undefined>;
+        readonly max_error_percent: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+    }, undefined>, undefined>;
+}, undefined>;
+export declare const extractionReport: v.StrictObjectSchema<{
+    readonly extracted: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+    readonly failed: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+    readonly needs_agent: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+    readonly complete: v.BooleanSchema<undefined>;
+    readonly batch: v.OptionalSchema<v.StrictObjectSchema<{
+        readonly attempted: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+        readonly succeeded: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+        readonly failed: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+        readonly error_rate: v.NumberSchema<undefined>;
+        readonly failures: v.ArraySchema<v.StrictObjectSchema<{
+            readonly id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
+            readonly stage: v.StringSchema<undefined>;
+            readonly error: v.ObjectWithRestSchema<{
+                readonly code: v.StringSchema<undefined>;
+                readonly message: v.StringSchema<undefined>;
+                readonly retryable: v.BooleanSchema<undefined>;
+                readonly retry_after_ms: v.OptionalSchema<v.NumberSchema<undefined>, undefined>;
+            }, v.UnknownSchema, undefined>;
+            readonly attachment: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>;
+        }, undefined>, undefined>;
+        readonly stop_reason: v.OptionalSchema<v.PicklistSchema<["rate_limited", "authentication", "error_rate", "cancelled"], undefined>, undefined>;
+        readonly max_error_percent: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+    }, undefined>, undefined>;
+    readonly items: v.ArraySchema<v.StrictObjectSchema<{
+        readonly ref: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>;
+        readonly attachment: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+        readonly kind: v.StringSchema<undefined>;
+        readonly name: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+        readonly status: v.PicklistSchema<["extracted", "needs-agent", "unreadable", "engine-missing", "too-large", "missing"], undefined>;
+        readonly extractor: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+        readonly chars: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>;
+        readonly local_path: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+        readonly pages: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>;
+        readonly ocr_pages: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>;
+        readonly error: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+        readonly issue: v.OptionalSchema<v.ObjectWithRestSchema<{
+            readonly code: v.StringSchema<undefined>;
+            readonly message: v.StringSchema<undefined>;
+            readonly retryable: v.BooleanSchema<undefined>;
+            readonly retry_after_ms: v.OptionalSchema<v.NumberSchema<undefined>, undefined>;
+        }, v.UnknownSchema, undefined>, undefined>;
+    }, undefined>, undefined>;
+    readonly unchanged: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+    readonly not_downloaded: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+    readonly unsupported: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+    /** Reader package names, such as unpdf or @napi-rs/canvas. */
+    readonly engines_missing: v.ArraySchema<v.StringSchema<undefined>, undefined>;
+    readonly cursor: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+}, undefined>;

package/dist/entities/extraction-report.js

@@ -0,0 +1,34 @@
+import * as v from "valibot";
+import { actionableError, batchResult } from "./batch-result.js";
+import { count, reference, text } from "./fields.js";
+export const extractionItem = v.strictObject({
+    ref: reference,
+    attachment: count,
+    kind: text,
+    name: v.nullable(text),
+    status: v.picklist(["extracted", "needs-agent", "unreadable", "engine-missing", "too-large", "missing"]),
+    extractor: v.optional(text),
+    chars: v.optional(count),
+    local_path: v.optional(text),
+    pages: v.optional(count),
+    ocr_pages: v.optional(count),
+    error: v.optional(text),
+    issue: v.optional(actionableError),
+});
+export const extractionSummary = v.strictObject({
+    extracted: count,
+    failed: count,
+    needs_agent: count,
+    complete: v.boolean(),
+    batch: v.optional(batchResult),
+});
+export const extractionReport = v.strictObject({
+    ...extractionSummary.entries,
+    items: v.array(extractionItem),
+    unchanged: count,
+    not_downloaded: count,
+    unsupported: count,
+    /** Reader package names, such as unpdf or @napi-rs/canvas. */
+    engines_missing: v.array(text),
+    cursor: v.optional(text),
+});

package/dist/entities/image-embedding.d.ts

@@ -0,0 +1,9 @@
+import * as v from "valibot";
+/** The bounded image batch's progress; failed and unreadable pictures remain distinct. */
+export declare const imageEmbedding: v.StrictObjectSchema<{
+    readonly model: v.StringSchema<undefined>;
+    readonly embedded: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+    readonly skipped: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+    readonly failed: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+    readonly more: v.BooleanSchema<undefined>;
+}, undefined>;

package/dist/entities/image-embedding.js

@@ -0,0 +1,10 @@
+import * as v from "valibot";
+import { count, text } from "./fields.js";
+/** The bounded image batch's progress; failed and unreadable pictures remain distinct. */
+export const imageEmbedding = v.strictObject({
+    model: text,
+    embedded: count,
+    skipped: count,
+    failed: count,
+    more: v.boolean(),
+});