@ganju/utils 0.0.8 → 0.0.10

package/dist/schema.d.ts

@@ -740,18 +740,6 @@ export declare const Schema: {
         organizationId: z.ZodUUID;
     }, z.core.$strip>;
     ARTIFACT_CREATE_RESOURCE_VIEW: z.ZodObject<{
-        content: z.ZodOptional<z.ZodString>;
-        type: z.ZodDefault<z.ZodEnum<{
-            static: "static";
-            template: "template";
-        }>>;
-        description: z.ZodOptional<z.ZodString>;
-        title: z.ZodString;
-        uri: z.ZodString;
-        crawlConfig: z.ZodOptional<z.ZodObject<{
-            maxPages: z.ZodDefault<z.ZodNumber>;
-            maxDepth: z.ZodDefault<z.ZodNumber>;
-        }, z.core.$strip>>;
         mimeType: z.ZodEnum<{
             "text/plain": "text/plain";
             "text/csv": "text/csv";
@@ -792,6 +780,19 @@ export declare const Schema: {
             "application/x-perl": "application/x-perl";
             "application/octet-stream": "application/octet-stream";
         }>;
+        fileName: z.ZodOptional<z.ZodString>;
+        content: z.ZodOptional<z.ZodString>;
+        type: z.ZodDefault<z.ZodEnum<{
+            static: "static";
+            template: "template";
+        }>>;
+        description: z.ZodOptional<z.ZodString>;
+        title: z.ZodString;
+        uri: z.ZodString;
+        crawlConfig: z.ZodOptional<z.ZodObject<{
+            maxPages: z.ZodDefault<z.ZodNumber>;
+            maxDepth: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strip>>;
         size: z.ZodOptional<z.ZodNumber>;
         sourceType: z.ZodDefault<z.ZodEnum<{
             FILE: "FILE";
@@ -802,7 +803,6 @@ export declare const Schema: {
         }>>;
         encoding: z.ZodOptional<z.ZodString>;
         fileKey: z.ZodOptional<z.ZodString>;
-        fileName: z.ZodOptional<z.ZodString>;
         annotations: z.ZodOptional<z.ZodObject<{
             audience: z.ZodOptional<z.ZodArray<z.ZodEnum<{
                 user: "user";
@@ -1001,14 +1001,6 @@ export declare const Schema: {
         organizationId: z.ZodUUID;
     }, z.core.$strip>;
     ARTIFACT_UPDATE_RESOURCE_VIEW: z.ZodObject<{
-        content: z.ZodOptional<z.ZodString>;
-        type: z.ZodDefault<z.ZodEnum<{
-            static: "static";
-            template: "template";
-        }>>;
-        description: z.ZodOptional<z.ZodString>;
-        title: z.ZodString;
-        uri: z.ZodString;
         mimeType: z.ZodEnum<{
             "text/plain": "text/plain";
             "text/csv": "text/csv";
@@ -1049,6 +1041,15 @@ export declare const Schema: {
             "application/x-perl": "application/x-perl";
             "application/octet-stream": "application/octet-stream";
         }>;
+        fileName: z.ZodOptional<z.ZodString>;
+        content: z.ZodOptional<z.ZodString>;
+        type: z.ZodDefault<z.ZodEnum<{
+            static: "static";
+            template: "template";
+        }>>;
+        description: z.ZodOptional<z.ZodString>;
+        title: z.ZodString;
+        uri: z.ZodString;
         size: z.ZodOptional<z.ZodNumber>;
         sourceType: z.ZodDefault<z.ZodEnum<{
             FILE: "FILE";
@@ -1059,7 +1060,6 @@ export declare const Schema: {
         }>>;
         encoding: z.ZodOptional<z.ZodString>;
         fileKey: z.ZodOptional<z.ZodString>;
-        fileName: z.ZodOptional<z.ZodString>;
         annotations: z.ZodOptional<z.ZodObject<{
             audience: z.ZodOptional<z.ZodArray<z.ZodEnum<{
                 user: "user";
@@ -1215,8 +1215,8 @@ export declare const Schema: {
             "openai-compatible": "openai-compatible";
         }>;
         apiKey: z.ZodString;
-        model: z.ZodString;
         baseUrl: z.ZodUnion<[z.ZodOptional<z.ZodURL>, z.ZodLiteral<"">]>;
+        model: z.ZodString;
         systemPrompt: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>;
     ORGANIZATION_UPDATE_LLM: z.ZodObject<{
@@ -1246,8 +1246,8 @@ export declare const Schema: {
             "openai-compatible": "openai-compatible";
         }>>;
         apiKey: z.ZodOptional<z.ZodString>;
-        model: z.ZodOptional<z.ZodString>;
         baseUrl: z.ZodNullable<z.ZodUnion<[z.ZodOptional<z.ZodURL>, z.ZodLiteral<"">]>>;
+        model: z.ZodOptional<z.ZodString>;
         systemPrompt: z.ZodNullable<z.ZodOptional<z.ZodString>>;
     }, z.core.$strip>;
     ORGANIZATION_REMOVE_LLM: z.ZodObject<{
@@ -1366,6 +1366,23 @@ export declare const Schema: {
         userId: z.ZodUUID;
         organizationId: z.ZodUUID;
     }, z.core.$strip>;
+    ARTIFACT_UPDATE_RESOURCE_SYNC_INTERVAL: z.ZodObject<{
+        resourceId: z.ZodUUID;
+        syncInterval: z.ZodEnum<{
+            off: "off";
+            daily: "daily";
+            weekly: "weekly";
+        }>;
+        projectId: z.ZodUUID;
+        userId: z.ZodUUID;
+        organizationId: z.ZodUUID;
+    }, z.core.$strip>;
+    ARTIFACT_SYNC_RESOURCE: z.ZodObject<{
+        resourceId: z.ZodUUID;
+        projectId: z.ZodUUID;
+        userId: z.ZodUUID;
+        organizationId: z.ZodUUID;
+    }, z.core.$strip>;
     HTTP_ENDPOINT_CONFIG: z.ZodPipe<z.ZodObject<{
         name: z.ZodString;
         title: z.ZodOptional<z.ZodString>;

package/dist/schema.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../src/schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AA6tBxB,QAAA,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0FrB,CAAC;AAyDN,QAAA,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;iBAmCpB,CAAC;AAWH,QAAA,MAAM,kBAAkB;;;;;;;;;;iBA+CtB,CAAC;AAiCH,QAAA,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAapB,CAAC;AAYH,QAAA,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAgCxB,CAAC;AA4LH,QAAA,MAAM,kCAAkC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA4DpC,CAAC;AA4BL,QAAA,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yBAkDzB,CAAC;AAwGH,eAAO,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA0GlB,CAAC;AAGF,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAG1E,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAIlE,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAMtE,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAGtE,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAMtE,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AAIvE,MAAM,MAAM,wBAAwB,GAAG,CAAC,CAAC,KAAK,CAC5C,OAAO,kCAAkC,CAC1C,CAAC;AAKF,MAAM,WAAW,sBAAsB;IACrC,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,WAAW,EAAE,OAAO,CAAC;CACtB;AAKD,MAAM,WAAW,0BAA0B;IACzC,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAKD,MAAM,WAAW,wBAAwB;IACvC,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,SAAS,CAAC,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,WAAW,CAAC,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,EAAE,OAAO,CAAA;KAAE,EAAE,CAAC;CAC1E;AAMD,MAAM,WAAW,iBAAiB;IAChC,YAAY,EAAE,MAAM,CAAC;IACrB,UAAU,CAAC,EAAE;QAAE,IAAI,CAAC,EAAE,MAAM,CAAC;QAAC,OAAO,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;IACjD,KAAK,EAAE,sBAAsB,EAAE,CAAC;IAChC,SAAS,CAAC,EAAE,0BAA0B,EAAE,CAAC;IACzC,OAAO,CAAC,EAAE,wBAAwB,EAAE,CAAC;CACtC"}
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../src/schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAixBxB,QAAA,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0FrB,CAAC;AAyDN,QAAA,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;iBAmCpB,CAAC;AAWH,QAAA,MAAM,kBAAkB;;;;;;;;;;iBA+CtB,CAAC;AAiCH,QAAA,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAapB,CAAC;AAYH,QAAA,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAgCxB,CAAC;AA4LH,QAAA,MAAM,kCAAkC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA4DpC,CAAC;AA4BL,QAAA,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yBAkDzB,CAAC;AAuHH,eAAO,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4GlB,CAAC;AAGF,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAG1E,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAIlE,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAMtE,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAGtE,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAMtE,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AAIvE,MAAM,MAAM,wBAAwB,GAAG,CAAC,CAAC,KAAK,CAC5C,OAAO,kCAAkC,CAC1C,CAAC;AAKF,MAAM,WAAW,sBAAsB;IACrC,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,WAAW,EAAE,OAAO,CAAC;CACtB;AAKD,MAAM,WAAW,0BAA0B;IACzC,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAKD,MAAM,WAAW,wBAAwB;IACvC,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,SAAS,CAAC,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,WAAW,CAAC,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,EAAE,OAAO,CAAA;KAAE,EAAE,CAAC;CAC1E;AAMD,MAAM,WAAW,iBAAiB;IAChC,YAAY,EAAE,MAAM,CAAC;IACrB,UAAU,CAAC,EAAE;QAAE,IAAI,CAAC,EAAE,MAAM,CAAC;QAAC,OAAO,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;IACjD,KAAK,EAAE,sBAAsB,EAAE,CAAC;IAChC,SAAS,CAAC,EAAE,0BAA0B,EAAE,CAAC;IACzC,OAAO,CAAC,EAAE,wBAAwB,EAAE,CAAC;CACtC"}

package/dist/schema.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Schema = void 0;
 const zod_1 = require("zod");
 const constants_1 = require("./constants");
+const llmBaseUrl_1 = require("./llmBaseUrl");
 const slug_1 = require("./slug");
 const reservedToolName_1 = require("./reservedToolName");
 const slugifyTitle_1 = require("./slugifyTitle");
@@ -491,29 +492,52 @@ const ORGANIZATION_LIST_LLM = zod_1.z.object({
     userId: zod_1.z.uuid(),
     organizationId: zod_1.z.uuid()
 });
-const ORGANIZATION_CREATE_LLM = zod_1.z.object({
+// The two rules live in `llmBaseUrl.ts`, because the update controller applies
+// them again to the merged row — the only place both halves are visible. Here
+// they are just the field validator and the cross-field check.
+const LLM_BASE_URL = zod_1.z
+    .url()
+    .max(500)
+    .refine(llmBaseUrl_1.isAllowedLlmBaseUrl, constants_1.constants.LLM_BASE_URL_INVALID_MESSAGE);
+const BASE_URL_REQUIRED = {
+    message: constants_1.constants.LLM_BASE_URL_REQUIRED_MESSAGE,
+    path: ['baseUrl']
+};
+const hasBaseUrlWhenRequired = (provider, baseUrl) => !(0, llmBaseUrl_1.requiresLlmBaseUrl)(provider) || !!baseUrl;
+// The base-URL rule is a cross-field check, and zod cannot `.omit()` from a
+// schema that already carries one. So the shape stays a plain object — the
+// `_VIEW` variants below derive from it — and the refinement is applied last,
+// to each schema in turn, which also keeps the two in step.
+const ORGANIZATION_CREATE_LLM_SHAPE = zod_1.z.object({
     name: zod_1.z.string().min(1).max(200),
     provider: zod_1.z.enum(constants_1.constants.LLM_PROVIDERS),
     model: zod_1.z.string().min(1).max(200),
-    baseUrl: zod_1.z.url().optional().or(zod_1.z.literal('')),
+    baseUrl: LLM_BASE_URL.optional().or(zod_1.z.literal('')),
     apiKey: zod_1.z.string().min(1).max(500),
     systemPrompt: zod_1.z.string().max(10000).optional(),
     config: zod_1.z.record(zod_1.z.string(), zod_1.z.any()).optional(),
     userId: zod_1.z.uuid(),
     organizationId: zod_1.z.uuid()
 });
-const ORGANIZATION_UPDATE_LLM = zod_1.z.object({
+const ORGANIZATION_CREATE_LLM = ORGANIZATION_CREATE_LLM_SHAPE.refine(v => hasBaseUrlWhenRequired(v.provider, v.baseUrl), BASE_URL_REQUIRED);
+// An update is a partial: an omitted field keeps its stored value, so the
+// base-URL rule can only be checked here when the caller sends the provider and
+// the base URL together. The controller re-checks it against the merged row,
+// which is the only place both halves are known.
+const ORGANIZATION_UPDATE_LLM_SHAPE = zod_1.z.object({
     llmId: zod_1.z.uuid(),
     name: zod_1.z.string().min(1).max(200).optional(),
     provider: zod_1.z.enum(constants_1.constants.LLM_PROVIDERS).optional(),
     model: zod_1.z.string().min(1).max(200).optional(),
-    baseUrl: zod_1.z.url().optional().or(zod_1.z.literal('')).nullable(),
+    baseUrl: LLM_BASE_URL.optional().or(zod_1.z.literal('')).nullable(),
     apiKey: zod_1.z.string().min(1).max(500).optional(),
     systemPrompt: zod_1.z.string().max(10000).optional().nullable(),
     config: zod_1.z.record(zod_1.z.string(), zod_1.z.any()).optional().nullable(),
     userId: zod_1.z.uuid(),
     organizationId: zod_1.z.uuid()
 });
+const refineUpdateBaseUrl = (schema) => schema.refine(v => v.baseUrl === undefined || hasBaseUrlWhenRequired(v.provider, v.baseUrl), BASE_URL_REQUIRED);
+const ORGANIZATION_UPDATE_LLM = refineUpdateBaseUrl(ORGANIZATION_UPDATE_LLM_SHAPE);
 const ORGANIZATION_REMOVE_LLM = zod_1.z.object({
     llmId: zod_1.z.uuid(),
     userId: zod_1.z.uuid(),
@@ -561,15 +585,15 @@ const ACCESS_TOKEN_CREATE_VIEW = ACCESS_TOKEN_CREATE.omit({
     organizationId: true,
     projectId: true
 });
-const ORGANIZATION_CREATE_LLM_VIEW = ORGANIZATION_CREATE_LLM.omit({
+const ORGANIZATION_CREATE_LLM_VIEW = ORGANIZATION_CREATE_LLM_SHAPE.omit({
     userId: true,
     organizationId: true
-});
-const ORGANIZATION_UPDATE_LLM_VIEW = ORGANIZATION_UPDATE_LLM.omit({
+}).refine(v => hasBaseUrlWhenRequired(v.provider, v.baseUrl), BASE_URL_REQUIRED);
+const ORGANIZATION_UPDATE_LLM_VIEW = refineUpdateBaseUrl(ORGANIZATION_UPDATE_LLM_SHAPE.omit({
     llmId: true,
     userId: true,
     organizationId: true
-});
+}));
 // `channel.config` is an open bag, so this stays loose — it only pins down the
 // keys we actually read, and passes everything else through untouched.
 // `debounceMs` is how long a burst from one participant is buffered before the
@@ -1239,6 +1263,19 @@ const ARTIFACT_UPDATE_RESOURCE_SHOW_SOURCE = zod_1.z.object({
     userId: zod_1.z.uuid(),
     organizationId: zod_1.z.uuid()
 });
+const ARTIFACT_UPDATE_RESOURCE_SYNC_INTERVAL = zod_1.z.object({
+    resourceId: zod_1.z.uuid(),
+    syncInterval: zod_1.z.enum(constants_1.constants.RESOURCE_SYNC_INTERVALS),
+    projectId: zod_1.z.uuid(),
+    userId: zod_1.z.uuid(),
+    organizationId: zod_1.z.uuid()
+});
+const ARTIFACT_SYNC_RESOURCE = zod_1.z.object({
+    resourceId: zod_1.z.uuid(),
+    projectId: zod_1.z.uuid(),
+    userId: zod_1.z.uuid(),
+    organizationId: zod_1.z.uuid()
+});
 const ARTIFACT_GET = zod_1.z.object({
     projectId: zod_1.z.uuid(),
     userId: zod_1.z.uuid(),
@@ -1401,6 +1438,8 @@ exports.Schema = {
     CHANNEL_LIST_CONVERSATIONS,
     CHANNEL_LIST_MESSAGES,
     ARTIFACT_UPDATE_RESOURCE_SHOW_SOURCE,
+    ARTIFACT_UPDATE_RESOURCE_SYNC_INTERVAL,
+    ARTIFACT_SYNC_RESOURCE,
     HTTP_ENDPOINT_CONFIG,
     HTTP_ENDPOINT_CONFIG_WRITE,
     MCP_PROXY_CONFIG,

package/dist/syncableResource.d.ts

@@ -0,0 +1,9 @@
+export interface SyncableResource {
+    sourceType?: string | null;
+    parentResourceId?: string | null;
+    metadata?: unknown;
+}
+export type ResourceSyncProvider = 'website' | 'google-drive' | 'one-drive';
+export declare const resourceSyncProvider: (resource: SyncableResource) => ResourceSyncProvider | null;
+export declare const isSyncableResource: (resource: SyncableResource) => boolean;
+//# sourceMappingURL=syncableResource.d.ts.map

package/dist/syncableResource.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"syncableResource.d.ts","sourceRoot":"","sources":["../src/syncableResource.ts"],"names":[],"mappings":"AAaA,MAAM,WAAW,gBAAgB;IAC/B,UAAU,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B,gBAAgB,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACjC,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AAED,MAAM,MAAM,oBAAoB,GAAG,SAAS,GAAG,cAAc,GAAG,WAAW,CAAC;AAE5E,eAAO,MAAM,oBAAoB,GAC/B,UAAU,gBAAgB,KACzB,oBAAoB,GAAG,IAqBzB,CAAC;AAEF,eAAO,MAAM,kBAAkB,GAAI,UAAU,gBAAgB,KAAG,OACvB,CAAC"}

package/dist/syncableResource.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isSyncableResource = exports.resourceSyncProvider = void 0;
+const constants_1 = require("./constants");
+const resourceSyncProvider = (resource) => {
+    if (resource.parentResourceId)
+        return null;
+    switch (resource.sourceType) {
+        case constants_1.constants.RESOURCE_SOURCE_TYPE_WEBSITE:
+            return 'website';
+        case constants_1.constants.RESOURCE_SOURCE_TYPE_GOOGLE_DRIVE_FOLDER:
+            return 'google-drive';
+        case constants_1.constants.RESOURCE_SOURCE_TYPE_ONE_DRIVE_FOLDER:
+            return 'one-drive';
+        case constants_1.constants.RESOURCE_SOURCE_TYPE_FILE: {
+            const meta = resource.metadata && typeof resource.metadata === 'object'
+                ? resource.metadata
+                : null;
+            if (typeof meta?.driveFileId === 'string')
+                return 'google-drive';
+            if (typeof meta?.oneDriveItemId === 'string')
+                return 'one-drive';
+            return null;
+        }
+        default:
+            return null;
+    }
+};
+exports.resourceSyncProvider = resourceSyncProvider;
+const isSyncableResource = (resource) => (0, exports.resourceSyncProvider)(resource) !== null;
+exports.isSyncableResource = isSyncableResource;

package/dist/toolCatalog.d.ts

@@ -350,7 +350,7 @@ export declare const TOOL_CATALOG: readonly [{
     }, {
         readonly key: "search-resources";
         readonly title: "Search Resources";
-        readonly description: "Find the resources most relevant to a question using semantic search.";
+        readonly description: "Find the resources most relevant to a question, by meaning and by exact keywords.";
         readonly requiredScopes: null;
     }, {
         readonly key: "send-resource";

package/dist/toolCatalog.js

@@ -431,7 +431,7 @@ exports.TOOL_CATALOG = [
             {
                 key: 'search-resources',
                 title: 'Search Resources',
-                description: 'Find the resources most relevant to a question using semantic search.',
+                description: 'Find the resources most relevant to a question, by meaning and by exact keywords.',
                 requiredScopes: null
             },
             {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ganju/utils",
-  "version": "0.0.8",
+  "version": "0.0.10",
   "description": "Shared constants, schemas and helpers for Ganju",
   "license": "Apache-2.0",
   "author": "MontoyaAndres <andresmontoyafcb@gmail.com>",

package/src/channelDebounce.ts

@@ -12,8 +12,41 @@ export interface BufferedChannelMessage {
   text: string;
   externalMessageId: string | null;
   receivedAt: number;
+  // Answer without waiting for the burst to settle: an explicit command, or a
+  // message on a channel with buffering turned off. It still goes through the
+  // buffer — that is what runs the turn under a caller patient enough for a
+  // long answer — it just flushes at once, taking any pending text with it.
+  immediate?: boolean;
+  // The prompt this message invoked, when it was a slash command.
+  command?: BufferedChannelCommand | null;
+  // Where this message must be answered, when that isn't the envelope's
+  // `delivery` — a Discord interaction waiting on its deferred response. Kept
+  // on the message because the envelope is replaced by every newer push, and a
+  // plain message typed a moment later must not orphan the interaction.
+  reply?: Record<string, unknown> | null;
 }
 
+// A resolved slash-command prompt, carried with the message that invoked it so
+// the flush can run it exactly as the webhook would have.
+export interface BufferedChannelCommand {
+  promptId: string;
+  artifactPromptId: string | null;
+  promptTitle: string;
+  args: Record<string, string>;
+}
+
+// The prompt a batch runs: the newest command in it, since that is the one the
+// participant asked for last. Null for a batch of plain text.
+export const batchCommand = (
+  messages: BufferedChannelMessage[]
+): BufferedChannelCommand | null => {
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const command = messages[i].command;
+    if (command) return command;
+  }
+  return null;
+};
+
 // Everything the flush needs to run the turn and deliver the reply, minus the
 // message texts themselves. The newest push wins: a display name or thread id
 // can change mid-burst, and the freshest is the one to answer against.
@@ -35,6 +68,9 @@ export interface ChannelBufferEnvelope {
 export interface ChannelBufferFlush {
   envelope: ChannelBufferEnvelope;
   messages: BufferedChannelMessage[];
+  // Stable across every hand-off of the same batch, so the worker can tell a
+  // retry of a turn it already answered from a new one.
+  batchId: string;
 }
 
 // Read the channel's debounce window off its `config`, clamped to the supported

package/src/chunking.ts

@@ -1,4 +1,5 @@
 import { constants } from './constants';
+import { decodeEntities } from './sanitize';
 
 import type {
   ExtractedDocument,
@@ -50,24 +51,140 @@ export const splitRecursive = (
   return chunks;
 };
 
-export const chunkText = (
+// Each piece keeps its `raw` text — the slice of the input it covers, without
+// the overlap borrowed from the piece before — so a caller can walk the input
+// in order without reading any of it twice.
+const chunkPieces = (
   text: string,
   options?: { targetChars?: number; overlapChars?: number }
-): string[] => {
+): Array<{ raw: string; content: string }> => {
   const target = options?.targetChars ?? constants.CHUNK_TARGET_CHARS;
   const overlap = options?.overlapChars ?? constants.CHUNK_OVERLAP_CHARS;
 
   const trimmed = text.trim();
   if (!trimmed) return [];
-  if (trimmed.length <= target) return [trimmed];
+  if (trimmed.length <= target) return [{ raw: trimmed, content: trimmed }];
 
   const rawChunks = splitRecursive(trimmed, target);
-  const withOverlap: string[] = [];
+  const pieces: Array<{ raw: string; content: string }> = [];
   for (let i = 0; i < rawChunks.length; i++) {
     const prev = i > 0 ? rawChunks[i - 1].slice(-overlap) : '';
-    withOverlap.push((prev ? prev + '\n' : '') + rawChunks[i]);
+    pieces.push({
+      raw: rawChunks[i],
+      content: (prev ? prev + '\n' : '') + rawChunks[i]
+    });
+  }
+  return pieces.filter(p => p.content.trim().length > 0);
+};
+
+export const chunkText = (
+  text: string,
+  options?: { targetChars?: number; overlapChars?: number }
+): string[] => chunkPieces(text, options).map(p => p.content);
+
+export type HeadingSyntax = 'markdown' | 'html';
+
+interface HeadingEvent {
+  offset: number;
+  level: number;
+  text: string;
+}
+
+const MARKDOWN_HEADING = /^ {0,3}(#{1,6})[ \t]+(.+?)(?:[ \t]+#+)?[ \t]*$/;
+const MARKDOWN_FENCE = /^ {0,3}(```|~~~)/;
+const HTML_HEADING = /<h([1-6])\b[^>]*>([\s\S]*?)<\/h\1\s*>/gi;
+const MAX_HEADING_CHARS = 120;
+
+const MARKDOWN_FILE_NAME = /\.(md|markdown|mdx)$/i;
+
+/**
+ * Which heading syntax a document is written in, or null when it has none we
+ * can trust. Plain text is left out on purpose: a line that happens to start
+ * with "# " there is as likely a comment or a list as a title.
+ */
+export const headingSyntaxFor = (input: {
+  mimeType?: string | null;
+  fileName?: string | null;
+  isWebPage?: boolean;
+}): HeadingSyntax | null => {
+  // Crawled pages are flattened to text with their headings written back as
+  // Markdown lines, whatever the page's own content type was.
+  if (input.isWebPage) return 'markdown';
+  if (input.mimeType === constants.MIMETYPE_TEXT_MARKDOWN) return 'markdown';
+  if (input.mimeType === constants.MIMETYPE_TEXT_HTML) return 'html';
+  if (input.fileName && MARKDOWN_FILE_NAME.test(input.fileName)) {
+    return 'markdown';
+  }
+  return null;
+};
+
+const cleanHeading = (text: string): string =>
+  text.replace(/\s+/g, ' ').trim().slice(0, MAX_HEADING_CHARS);
+
+const scanMarkdownHeadings = (
+  text: string,
+  state: { inFence: boolean }
+): HeadingEvent[] => {
+  const events: HeadingEvent[] = [];
+  let offset = 0;
+  for (const line of text.split('\n')) {
+    // A `#` inside a fenced block is a shell comment or a preprocessor line,
+    // not a title — and a fence can open in one chunk and close in the next.
+    if (MARKDOWN_FENCE.test(line)) {
+      state.inFence = !state.inFence;
+    } else if (!state.inFence) {
+      const match = MARKDOWN_HEADING.exec(line);
+      const heading = match ? cleanHeading(match[2]) : '';
+      if (match && heading) {
+        events.push({ offset, level: match[1].length, text: heading });
+      }
+    }
+    offset += line.length + 1;
   }
-  return withOverlap.filter(c => c.trim().length > 0);
+  return events;
+};
+
+const scanHtmlHeadings = (text: string): HeadingEvent[] =>
+  [...text.matchAll(HTML_HEADING)]
+    .map(match => ({
+      offset: match.index ?? 0,
+      level: Number(match[1]),
+      text: cleanHeading(decodeEntities(match[2].replace(/<[^>]*>/g, ' ')))
+    }))
+    .filter(event => event.text);
+
+/**
+ * Follows the heading hierarchy across a document's chunks, fed in order.
+ * Returns, for each chunk, the path of headings it sits under — the section a
+ * reader would be pointed to. A chunk that opens with a heading belongs to that
+ * heading; one that starts mid-section belongs to the section it continues,
+ * even when a later heading begins inside it.
+ */
+const createHeadingTracker = (syntax: HeadingSyntax) => {
+  let stack: Array<{ level: number; text: string }> = [];
+  const fence = { inFence: false };
+  const apply = (event: HeadingEvent) => {
+    stack = stack.filter(h => h.level < event.level);
+    stack.push({ level: event.level, text: event.text });
+  };
+
+  return (raw: string): string[] => {
+    const events =
+      syntax === 'markdown'
+        ? scanMarkdownHeadings(raw, fence)
+        : scanHtmlHeadings(raw);
+    const [first, ...rest] = events;
+    // Before a document's first heading there is no section to continue — only
+    // the metadata header, or the markup around an HTML body — so a chunk that
+    // holds the first heading belongs to it wherever in the chunk it falls.
+    const opensWithHeading =
+      first !== undefined &&
+      (stack.length === 0 || raw.slice(0, first.offset).trim() === '');
+    if (opensWithHeading) apply(first);
+    const path = stack.map(h => h.text);
+    for (const event of opensWithHeading ? rest : events) apply(event);
+    return path;
+  };
 };
 
 export const buildHeader = (input: {
@@ -87,9 +204,14 @@ export const buildHeader = (input: {
     .filter(Boolean)
     .join('\n');
 
-export interface ChunkMetadata extends ExtractedDocumentMetadata {
-  chunkIndexInPage: number;
-  chunksInPage: number;
+// Loose on purpose: a chunk of inline text has no extracted document behind it,
+// so only `headingPath` can be known about it.
+export interface ChunkMetadata extends Partial<ExtractedDocumentMetadata> {
+  chunkIndexInPage?: number;
+  chunksInPage?: number;
+  // The headings this chunk sits under, outermost first. Present only for
+  // Markdown and HTML, and only when the chunk is under at least one heading.
+  headingPath?: string[];
 }
 
 export interface PreparedChunk {
@@ -97,28 +219,43 @@ export interface PreparedChunk {
   metadata: ChunkMetadata | null;
 }
 
+const CONTROL_CHARS = /[\x00-\x08\x0B\x0C\x0E-\x1F]/g;
+
 export const prepareChunks = (
   header: string,
   documents: ExtractedDocument[] | null,
   fallbackContent: string | null,
-  options?: { targetChars?: number; overlapChars?: number }
+  options?: {
+    targetChars?: number;
+    overlapChars?: number;
+    // The resource's own type and file name, which decide the heading syntax
+    // for inline content and for documents that don't carry their own.
+    mimeType?: string | null;
+    fileName?: string | null;
+  }
 ): PreparedChunk[] => {
   if (documents && documents.length > 0) {
     const out: PreparedChunk[] = [];
     documents.forEach((doc, docIndex) => {
-      const body = (doc.pageContent || '')
-        .replace(/[\x00-\x08\x0B\x0C\x0E-\x1F]/g, '')
-        .trim();
+      const body = (doc.pageContent || '').replace(CONTROL_CHARS, '').trim();
       if (!body) return;
       const text = docIndex === 0 && header ? `${header}\n\n${body}` : body;
-      const pieces = chunkText(text, options);
+      const syntax = headingSyntaxFor({
+        mimeType: doc.metadata?.source?.mimeType ?? options?.mimeType,
+        fileName: doc.metadata?.source?.fileName ?? options?.fileName,
+        isWebPage: !!doc.metadata?.web
+      });
+      const headingPathOf = syntax ? createHeadingTracker(syntax) : null;
+      const pieces = chunkPieces(text, options);
       pieces.forEach((piece, pieceIndex) => {
+        const headingPath = headingPathOf?.(piece.raw) ?? [];
         out.push({
-          content: piece,
+          content: piece.content,
           metadata: {
             ...doc.metadata,
             chunkIndexInPage: pieceIndex,
-            chunksInPage: pieces.length
+            chunksInPage: pieces.length,
+            ...(headingPath.length > 0 ? { headingPath } : {})
           }
         });
       });
@@ -126,12 +263,18 @@ export const prepareChunks = (
     return out;
   }
 
-  const body = (fallbackContent || '')
-    .replace(/[\x00-\x08\x0B\x0C\x0E-\x1F]/g, '')
-    .trim();
+  const body = (fallbackContent || '').replace(CONTROL_CHARS, '').trim();
   const fullText = [header, body].filter(Boolean).join('\n\n');
-  return chunkText(fullText, options).map(content => ({
-    content,
-    metadata: null
-  }));
+  const syntax = headingSyntaxFor({
+    mimeType: options?.mimeType,
+    fileName: options?.fileName
+  });
+  const headingPathOf = syntax ? createHeadingTracker(syntax) : null;
+  return chunkPieces(fullText, options).map(piece => {
+    const headingPath = headingPathOf?.(piece.raw) ?? [];
+    return {
+      content: piece.content,
+      metadata: headingPath.length > 0 ? { headingPath } : null
+    };
+  });
 };