@crewai-ts/core 0.1.13 → 0.2.0

package/dist/feature-hooks.cjs

@@ -0,0 +1,149 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/feature-hooks.ts
+var feature_hooks_exports = {};
+__export(feature_hooks_exports, {
+  applyA2AAgentWrapper: () => applyA2AAgentWrapper,
+  applyA2AServerMethodsInjector: () => applyA2AServerMethodsInjector,
+  bindRegisteredMemoryView: () => bindRegisteredMemoryView,
+  createRegisteredKnowledge: () => createRegisteredKnowledge,
+  createRegisteredMemory: () => createRegisteredMemory,
+  createRegisteredMemoryTools: () => createRegisteredMemoryTools,
+  extractKnowledgeContext: () => extractKnowledgeContext,
+  extractRegisteredPDFText: () => extractRegisteredPDFText,
+  getLiteAgentA2AKickoffHandler: () => getLiteAgentA2AKickoffHandler,
+  isRegisteredKnowledge: () => isRegisteredKnowledge,
+  isRegisteredMemory: () => isRegisteredMemory,
+  isRegisteredMemoryScope: () => isRegisteredMemoryScope,
+  registerA2AAgentWrapper: () => registerA2AAgentWrapper,
+  registerA2AServerMethodsInjector: () => registerA2AServerMethodsInjector,
+  registerLiteAgentA2AKickoffHandler: () => registerLiteAgentA2AKickoffHandler,
+  registerRagFeatureHooks: () => registerRagFeatureHooks
+});
+module.exports = __toCommonJS(feature_hooks_exports);
+var a2aServerMethodsInjector = null;
+var a2aAgentWrapper = null;
+var liteAgentA2AKickoffHandler = null;
+var ragFeatureHooks = {};
+function registerA2AServerMethodsInjector(injector) {
+  a2aServerMethodsInjector = injector;
+}
+function applyA2AServerMethodsInjector(agent) {
+  return a2aServerMethodsInjector?.(agent) ?? agent;
+}
+function registerA2AAgentWrapper(wrapper) {
+  a2aAgentWrapper = wrapper;
+}
+function applyA2AAgentWrapper(agent) {
+  return a2aAgentWrapper?.(agent) ?? agent;
+}
+function registerLiteAgentA2AKickoffHandler(handler) {
+  liteAgentA2AKickoffHandler = handler;
+}
+function getLiteAgentA2AKickoffHandler() {
+  return liteAgentA2AKickoffHandler;
+}
+function registerRagFeatureHooks(hooks) {
+  ragFeatureHooks = hooks ?? {};
+}
+function createRegisteredMemory(options) {
+  return ragFeatureHooks.createMemory?.(options) ?? null;
+}
+function createRegisteredKnowledge(options) {
+  return ragFeatureHooks.createKnowledge?.(options) ?? null;
+}
+function createRegisteredMemoryTools(memory) {
+  return ragFeatureHooks.createMemoryTools?.(memory) ?? [];
+}
+async function extractRegisteredPDFText(content, filename) {
+  const text = await ragFeatureHooks.extractPDFText?.(content, filename);
+  return typeof text === "string" ? text : null;
+}
+function isRegisteredMemory(value) {
+  if (ragFeatureHooks.isMemory?.(value)) {
+    return true;
+  }
+  return isMemoryLike(value) && !isRegisteredMemoryScope(value);
+}
+function isRegisteredMemoryScope(value) {
+  if (ragFeatureHooks.isMemoryScope?.(value)) {
+    return true;
+  }
+  return isMemoryLike(value) && (readString(value, "memoryKind") === "scope" || readString(value, "memory_kind") === "scope" || typeof value.bind === "function");
+}
+function isRegisteredKnowledge(value) {
+  if (ragFeatureHooks.isKnowledge?.(value)) {
+    return true;
+  }
+  return Boolean(value) && typeof value === "object" && typeof value.query === "function";
+}
+function bindRegisteredMemoryView(value, backing) {
+  if (ragFeatureHooks.bindMemoryView) {
+    ragFeatureHooks.bindMemoryView(value, backing);
+    return;
+  }
+  if (!value || typeof value !== "object" || value === backing) {
+    return;
+  }
+  const bind = value.bind;
+  if (typeof bind === "function") {
+    bind.call(value, backing);
+  }
+}
+function extractKnowledgeContext(results) {
+  const content = results.map((result) => {
+    if (!result || typeof result !== "object" || Array.isArray(result)) {
+      return "";
+    }
+    const content2 = result.content;
+    return typeof content2 === "string" ? content2.trim() : "";
+  }).filter(Boolean).join("\n");
+  return content ? `Additional Information:
+${content}` : "";
+}
+function isMemoryLike(value) {
+  return Boolean(value) && typeof value === "object" && typeof value.recall === "function";
+}
+function readString(value, key) {
+  if (!value || typeof value !== "object") {
+    return null;
+  }
+  const candidate = value[key];
+  return typeof candidate === "string" ? candidate : null;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  applyA2AAgentWrapper,
+  applyA2AServerMethodsInjector,
+  bindRegisteredMemoryView,
+  createRegisteredKnowledge,
+  createRegisteredMemory,
+  createRegisteredMemoryTools,
+  extractKnowledgeContext,
+  extractRegisteredPDFText,
+  getLiteAgentA2AKickoffHandler,
+  isRegisteredKnowledge,
+  isRegisteredMemory,
+  isRegisteredMemoryScope,
+  registerA2AAgentWrapper,
+  registerA2AServerMethodsInjector,
+  registerLiteAgentA2AKickoffHandler,
+  registerRagFeatureHooks
+});

package/dist/feature-hooks.d.ts

@@ -0,0 +1,94 @@
+export type A2AServerMethodsInjector = (agent: unknown) => unknown;
+export type A2AAgentWrapper = (agent: unknown) => unknown;
+export type LiteAgentA2AKickoffHandler = (options: {
+    agent: unknown;
+    originalKickoff: (messages: unknown, responseFormat?: unknown, inputFiles?: unknown) => unknown;
+    messages: unknown;
+    responseFormat?: unknown;
+    inputFiles?: unknown;
+}) => unknown;
+export type EmbedderConfig = object | string | number | boolean;
+export type MemoryMatchLike = {
+    readonly record?: {
+        readonly id?: string;
+    };
+    format(): string;
+};
+export type MemoryLike = {
+    readonly readOnly?: boolean;
+    readonly read_only?: boolean;
+    readonly memoryKind?: string;
+    readonly memory_kind?: string;
+    recall(query: string, options?: Record<string, unknown>): readonly MemoryMatchLike[];
+    remember?(content: string, options?: Record<string, unknown>): unknown;
+    remember_many?(contents: readonly string[], options?: Record<string, unknown>): unknown;
+    rememberMany?(contents: readonly string[], options?: Record<string, unknown>): unknown;
+    extract_memories?(content: string): readonly string[];
+    extractMemories?(content: string): readonly string[];
+    reset?(scope?: string): unknown;
+};
+export type MemoryScopeLike = MemoryLike & {
+    readonly rootPath?: string;
+    readonly root_path?: string;
+    memory?: MemoryLike | null;
+    bind?(memory: MemoryLike): unknown;
+    _require_memory?(): MemoryLike;
+};
+export type KnowledgeSourceLike = {
+    readonly sourceType?: string;
+    readonly metadata?: Record<string, unknown>;
+    storage?: unknown;
+    chunks(): readonly string[];
+    add?(): void;
+    aadd?(): Promise<void>;
+    get_embeddings?(): readonly unknown[];
+    validate_content?(): unknown;
+};
+export type KnowledgeQueryOptions = {
+    resultsLimit?: number;
+    results_limit?: number;
+    scoreThreshold?: number | null;
+    score_threshold?: number | null;
+};
+export type KnowledgeLike = {
+    readonly sources?: readonly KnowledgeSourceLike[];
+    query(query: string | readonly string[], options?: KnowledgeQueryOptions): readonly unknown[];
+    reset?(): unknown;
+};
+export type CreateMemoryOptions = {
+    rootScope?: string;
+    root_scope?: string;
+    embedder?: EmbedderConfig | null;
+};
+export type CreateKnowledgeOptions = {
+    sources: readonly KnowledgeSourceLike[];
+    collectionName?: string | null;
+    collection_name?: string | null;
+    embedder?: EmbedderConfig | null;
+};
+export type RagFeatureHooks = {
+    createMemory?: (options?: CreateMemoryOptions) => MemoryLike;
+    createKnowledge?: (options: CreateKnowledgeOptions) => KnowledgeLike;
+    createMemoryTools?: (memory: MemoryLike | MemoryScopeLike) => readonly unknown[];
+    extractPDFText?: (content: Uint8Array, filename: string) => string | Promise<string>;
+    isMemory?: (value: unknown) => value is MemoryLike;
+    isMemoryScope?: (value: unknown) => value is MemoryScopeLike;
+    isKnowledge?: (value: unknown) => value is KnowledgeLike;
+    bindMemoryView?: (value: unknown, backing: MemoryLike) => void;
+};
+export declare function registerA2AServerMethodsInjector(injector: A2AServerMethodsInjector | null): void;
+export declare function applyA2AServerMethodsInjector<TAgent>(agent: TAgent): TAgent;
+export declare function registerA2AAgentWrapper(wrapper: A2AAgentWrapper | null): void;
+export declare function applyA2AAgentWrapper<TAgent>(agent: TAgent): TAgent;
+export declare function registerLiteAgentA2AKickoffHandler(handler: LiteAgentA2AKickoffHandler | null): void;
+export declare function getLiteAgentA2AKickoffHandler(): LiteAgentA2AKickoffHandler | null;
+export declare function registerRagFeatureHooks(hooks: RagFeatureHooks | null): void;
+export declare function createRegisteredMemory(options?: CreateMemoryOptions): MemoryLike | null;
+export declare function createRegisteredKnowledge(options: CreateKnowledgeOptions): KnowledgeLike | null;
+export declare function createRegisteredMemoryTools(memory: MemoryLike | MemoryScopeLike): readonly unknown[];
+export declare function extractRegisteredPDFText(content: Uint8Array, filename: string): Promise<string | null>;
+export declare function isRegisteredMemory(value: unknown): value is MemoryLike;
+export declare function isRegisteredMemoryScope(value: unknown): value is MemoryScopeLike;
+export declare function isRegisteredKnowledge(value: unknown): value is KnowledgeLike;
+export declare function bindRegisteredMemoryView(value: unknown, backing: MemoryLike): void;
+export declare function extractKnowledgeContext(results: readonly unknown[]): string;

package/dist/feature-hooks.js

@@ -0,0 +1,36 @@
+import {
+  applyA2AAgentWrapper,
+  applyA2AServerMethodsInjector,
+  bindRegisteredMemoryView,
+  createRegisteredKnowledge,
+  createRegisteredMemory,
+  createRegisteredMemoryTools,
+  extractKnowledgeContext,
+  extractRegisteredPDFText,
+  getLiteAgentA2AKickoffHandler,
+  isRegisteredKnowledge,
+  isRegisteredMemory,
+  isRegisteredMemoryScope,
+  registerA2AAgentWrapper,
+  registerA2AServerMethodsInjector,
+  registerLiteAgentA2AKickoffHandler,
+  registerRagFeatureHooks
+} from "./chunk-SB7ADUQA.js";
+export {
+  applyA2AAgentWrapper,
+  applyA2AServerMethodsInjector,
+  bindRegisteredMemoryView,
+  createRegisteredKnowledge,
+  createRegisteredMemory,
+  createRegisteredMemoryTools,
+  extractKnowledgeContext,
+  extractRegisteredPDFText,
+  getLiteAgentA2AKickoffHandler,
+  isRegisteredKnowledge,
+  isRegisteredMemory,
+  isRegisteredMemoryScope,
+  registerA2AAgentWrapper,
+  registerA2AServerMethodsInjector,
+  registerLiteAgentA2AKickoffHandler,
+  registerRagFeatureHooks
+};