@lobehub/lobehub 2.0.0-next.335 → 2.0.0-next.337

package/packages/builtin-tool-memory/src/client/components/PreferenceMemoryCard.tsx

@@ -0,0 +1,357 @@
+'use client';
+
+import { Accordion, AccordionItem, Avatar, Flexbox, Tag, Text } from '@lobehub/ui';
+import { Steps } from 'antd';
+import { createStaticStyles, cssVar } from 'antd-style';
+import { memo } from 'react';
+
+import BubblesLoading from '@/components/BubblesLoading';
+import NeuralNetworkLoading from '@/components/NeuralNetworkLoading';
+import StreamingMarkdown from '@/components/StreamingMarkdown';
+import { highlightTextStyles } from '@/styles';
+
+import type { AddPreferenceMemoryParams } from '../../types';
+
+const styles = createStaticStyles(({ css, cssVar }) => ({
+  container: css`
+    overflow: hidden;
+
+    width: 100%;
+    border: 1px solid ${cssVar.colorBorderSecondary};
+    border-radius: 16px;
+
+    background: ${cssVar.colorBgContainer};
+  `,
+  content: css`
+    padding-block: 12px;
+    padding-inline: 16px;
+  `,
+  detail: css`
+    font-size: 13px;
+    line-height: 1.6;
+    color: ${cssVar.colorTextSecondary};
+  `,
+  directive: css`
+    font-size: 14px;
+    line-height: 1.6;
+    color: ${cssVar.colorText};
+  `,
+  header: css`
+    padding-block: 10px;
+    padding-inline: 12px;
+    border-block-end: 1px solid ${cssVar.colorBorderSecondary};
+  `,
+  section: css`
+    padding: 4px;
+    border-block-start: 1px solid ${cssVar.colorBorderSecondary};
+  `,
+  stepContent: css`
+    font-size: 13px;
+    line-height: 1.6;
+    color: ${cssVar.colorTextSecondary};
+    white-space: pre-wrap;
+  `,
+  stepsContainer: css`
+    .ant-steps-item-content {
+      min-height: auto;
+    }
+
+    .ant-steps-item-description {
+      padding-block-end: 12px !important;
+    }
+  `,
+  suggestion: css`
+    padding-block: 8px;
+    padding-inline: 12px;
+    border-radius: 8px;
+
+    font-size: 13px;
+    line-height: 1.5;
+    color: ${cssVar.colorTextSecondary};
+
+    background: ${cssVar.colorFillQuaternary};
+  `,
+  summary: css`
+    font-size: 14px;
+    font-weight: 500;
+    color: ${cssVar.colorTextSecondary};
+  `,
+  tags: css`
+    padding-block-start: 8px;
+    border-block-start: 1px dashed ${cssVar.colorBorderSecondary};
+  `,
+  title: css`
+    overflow: hidden;
+    display: -webkit-box;
+    -webkit-box-orient: vertical;
+    -webkit-line-clamp: 1;
+
+    font-weight: 500;
+    color: ${cssVar.colorText};
+  `,
+}));
+
+export interface PreferenceMemoryCardProps {
+  data?: AddPreferenceMemoryParams;
+  loading?: boolean;
+}
+
+export const PreferenceMemoryCard = memo<PreferenceMemoryCardProps>(({ data, loading }) => {
+  const { summary, details, tags, title, withPreference } = data || {};
+  const { conclusionDirectives, originContext, appContext, suggestions, type } =
+    withPreference || {};
+
+  const hasContextContent =
+    originContext?.actor ||
+    originContext?.scenario ||
+    originContext?.trigger ||
+    originContext?.applicableWhen ||
+    originContext?.notApplicableWhen;
+
+  const hasAppContext = appContext?.app || appContext?.feature || appContext?.surface;
+
+  const hasSuggestions = suggestions && suggestions.length > 0;
+
+  if (
+    !summary &&
+    !details &&
+    !tags?.length &&
+    !title &&
+    !conclusionDirectives &&
+    !hasContextContent &&
+    !hasSuggestions
+  )
+    return null;
+
+  const contextItems = [
+    { avatar: '👤', content: originContext?.actor, title: 'Actor' },
+    { avatar: '🎯', content: originContext?.scenario, title: 'Scenario' },
+    { avatar: '⚡', content: originContext?.trigger, title: 'Trigger' },
+    { avatar: '✅', content: originContext?.applicableWhen, title: 'Applicable When' },
+    { avatar: '❌', content: originContext?.notApplicableWhen, title: 'Not Applicable When' },
+  ].filter((item) => item.content);
+
+  const appContextItems = [
+    { avatar: '📱', content: appContext?.app, title: 'App' },
+    { avatar: '🔧', content: appContext?.feature, title: 'Feature' },
+    { avatar: '📍', content: appContext?.surface, title: 'Surface' },
+  ].filter((item) => item.content);
+
+  return (
+    <Flexbox className={styles.container}>
+      {/* Header */}
+      <Flexbox align={'center'} className={styles.header} gap={8} horizontal>
+        <Flexbox flex={1}>
+          <div className={styles.title}>{title || 'Preference Memory'}</div>
+        </Flexbox>
+        {type && <Tag>{type}</Tag>}
+        {loading && <NeuralNetworkLoading size={20} />}
+      </Flexbox>
+
+      {/* When has context content: collapse summary */}
+      {hasContextContent || hasAppContext ? (
+        <>
+          {/* Collapsed Summary */}
+          {(summary || tags?.length) && (
+            <Accordion gap={0}>
+              <AccordionItem
+                itemKey="summary"
+                paddingBlock={8}
+                paddingInline={8}
+                styles={{
+                  base: { marginBlock: 4, marginInline: 4 },
+                }}
+                title={
+                  <Text fontSize={12} type={'secondary'} weight={500}>
+                    Summary
+                  </Text>
+                }
+              >
+                <Flexbox gap={8} paddingBlock={'8px 12px'} paddingInline={8}>
+                  {summary && <div className={styles.summary}>{summary}</div>}
+                  {details && <div className={styles.detail}>{details}</div>}
+                  {tags && tags.length > 0 && (
+                    <Flexbox className={styles.tags} gap={8} horizontal wrap={'wrap'}>
+                      {tags.map((tag, index) => (
+                        <Tag key={index}>{tag}</Tag>
+                      ))}
+                    </Flexbox>
+                  )}
+                </Flexbox>
+              </AccordionItem>
+            </Accordion>
+          )}
+
+          {/* Origin Context Steps */}
+          {hasContextContent && (
+            <Accordion className={styles.section} defaultExpandedKeys={['context']} gap={0}>
+              <AccordionItem
+                itemKey="context"
+                paddingBlock={8}
+                paddingInline={8}
+                title={
+                  <Text fontSize={12} type={'secondary'} weight={500}>
+                    Origin Context
+                  </Text>
+                }
+              >
+                <Flexbox paddingBlock={'8px 12px'} paddingInline={8}>
+                  <Steps
+                    className={styles.stepsContainer}
+                    current={null as any}
+                    direction="vertical"
+                    items={contextItems.map((item) => ({
+                      description: <div className={styles.stepContent}>{item.content}</div>,
+                      icon: (
+                        <Avatar
+                          avatar={item.avatar}
+                          shadow
+                          shape={'square'}
+                          size={20}
+                          style={{
+                            border: `1px solid ${cssVar.colorBorderSecondary}`,
+                            fontSize: 11,
+                          }}
+                        />
+                      ),
+                      title: (
+                        <Text as={'span'} fontSize={12} type={'secondary'} weight={500}>
+                          {item.title}
+                        </Text>
+                      ),
+                    }))}
+                    size="small"
+                  />
+                </Flexbox>
+              </AccordionItem>
+            </Accordion>
+          )}
+
+          {/* App Context */}
+          {hasAppContext && (
+            <Accordion className={styles.section} gap={0}>
+              <AccordionItem
+                itemKey="appContext"
+                paddingBlock={8}
+                paddingInline={8}
+                title={
+                  <Text fontSize={12} type={'secondary'} weight={500}>
+                    App Context
+                  </Text>
+                }
+              >
+                <Flexbox paddingBlock={'8px 12px'} paddingInline={8}>
+                  <Steps
+                    className={styles.stepsContainer}
+                    current={null as any}
+                    direction="vertical"
+                    items={appContextItems.map((item) => ({
+                      description: <div className={styles.stepContent}>{item.content}</div>,
+                      icon: (
+                        <Avatar
+                          avatar={item.avatar}
+                          shadow
+                          shape={'square'}
+                          size={20}
+                          style={{
+                            border: `1px solid ${cssVar.colorBorderSecondary}`,
+                            fontSize: 11,
+                          }}
+                        />
+                      ),
+                      title: (
+                        <Text as={'span'} fontSize={12} type={'secondary'} weight={500}>
+                          {item.title}
+                        </Text>
+                      ),
+                    }))}
+                    size="small"
+                  />
+                </Flexbox>
+              </AccordionItem>
+            </Accordion>
+          )}
+
+          {/* Conclusion Directive */}
+          {conclusionDirectives && (
+            <Flexbox
+              className={styles.section}
+              gap={8}
+              style={{ paddingBlock: 16, paddingInline: 12 }}
+            >
+              <Text fontSize={12} weight={500}>
+                <span className={highlightTextStyles.primary}>Directive</span>
+              </Text>
+              <div className={styles.directive}>{conclusionDirectives}</div>
+            </Flexbox>
+          )}
+
+          {/* Suggestions */}
+          {hasSuggestions && (
+            <Flexbox
+              className={styles.section}
+              gap={8}
+              style={{ paddingBlock: 16, paddingInline: 12 }}
+            >
+              <Text fontSize={12} weight={500}>
+                <span className={highlightTextStyles.info}>Suggestions</span>
+              </Text>
+              <Flexbox gap={8}>
+                {suggestions.map((suggestion, index) => (
+                  <div className={styles.suggestion} key={index}>
+                    {suggestion}
+                  </div>
+                ))}
+              </Flexbox>
+            </Flexbox>
+          )}
+        </>
+      ) : (
+        /* When no context content: show summary and details */
+        <Flexbox className={styles.content} gap={8}>
+          {!summary && loading ? (
+            <BubblesLoading />
+          ) : (
+            <>
+              {summary && <div className={styles.summary}>{summary}</div>}
+              {details && <StreamingMarkdown>{details}</StreamingMarkdown>}
+              {conclusionDirectives && (
+                <Flexbox gap={4} paddingBlock={8}>
+                  <Text fontSize={12} weight={500}>
+                    <span className={highlightTextStyles.primary}>Directive</span>
+                  </Text>
+                  <div className={styles.directive}>{conclusionDirectives}</div>
+                </Flexbox>
+              )}
+              {hasSuggestions && (
+                <Flexbox gap={8} paddingBlock={8}>
+                  <Text fontSize={12} weight={500}>
+                    <span className={highlightTextStyles.info}>Suggestions</span>
+                  </Text>
+                  <Flexbox gap={8}>
+                    {suggestions.map((suggestion, index) => (
+                      <div className={styles.suggestion} key={index}>
+                        {suggestion}
+                      </div>
+                    ))}
+                  </Flexbox>
+                </Flexbox>
+              )}
+              {tags && tags.length > 0 && (
+                <Flexbox className={styles.tags} gap={8} horizontal wrap={'wrap'}>
+                  {tags.map((tag, index) => (
+                    <Tag key={index}>{tag}</Tag>
+                  ))}
+                </Flexbox>
+              )}
+            </>
+          )}
+        </Flexbox>
+      )}
+    </Flexbox>
+  );
+});
+
+PreferenceMemoryCard.displayName = 'PreferenceMemoryCard';
+
+export default PreferenceMemoryCard;

package/packages/builtin-tool-memory/src/client/components/index.ts

@@ -1 +1,2 @@
 export { ExperienceMemoryCard, type ExperienceMemoryCardProps } from './ExperienceMemoryCard';
+export { PreferenceMemoryCard, type PreferenceMemoryCardProps } from './PreferenceMemoryCard';

package/packages/builtin-tool-memory/src/executor/index.ts

@@ -74,7 +74,7 @@ class MemoryExecutor extends BaseExecutor<typeof MemoryApiName> {
       }
 
       return {
-        content: `🧠 Context memory saved: "${params.title}"`,
+        content: `Context memory "${params.title}" saved with memoryId: "${result.memoryId}" and contextId: "${result.contextId}"`,
         state: { contextId: result.contextId, memoryId: result.memoryId },
         success: true,
       };
@@ -151,7 +151,7 @@ class MemoryExecutor extends BaseExecutor<typeof MemoryApiName> {
       }
 
       return {
-        content: `🧠 Identity memory saved: "${params.title}"`,
+        content: `Identity memory "${params.title}" saved with memoryId: "${result.memoryId}" and identityId: "${result.identityId}"`,
         state: { identityId: result.identityId, memoryId: result.memoryId },
         success: true,
       };
@@ -189,7 +189,7 @@ class MemoryExecutor extends BaseExecutor<typeof MemoryApiName> {
       }
 
       return {
-        content: `🧠 Preference memory saved: "${params.title}"`,
+        content: `Preference memory "${params.title}" saved with memoryId: "${result.memoryId}" and preferenceId: "${result.preferenceId}"`,
         state: { memoryId: result.memoryId, preferenceId: result.preferenceId },
         success: true,
       };

package/packages/builtin-tool-memory/src/systemRole.ts

@@ -54,4 +54,5 @@ Conversation language: {{language}}
 - When memory activity is warranted, explain which layers are affected, cite any matching memories you found, and justify why extraction or updates are needed.
 - When nothing qualifies, explicitly state that no memory action is required after reviewing the context.
 - Keep your reasoning concise, structured, and aligned with the conversation language.
+- **Never expose internal memory IDs** (e.g., mem_xxx, id: xxx) to users in your responses. Refer to memories by their descriptive titles or summaries instead.
 </response_expectations>`;

package/packages/context-engine/src/engine/tools/ToolArgumentsRepairer.ts

@@ -0,0 +1,129 @@
+import type { LobeToolManifest } from './types';
+
+/**
+ * JSON Schema type for tool parameters
+ */
+export interface ToolParameterSchema {
+  properties?: Record<string, unknown>;
+  required?: string[];
+  type?: string;
+}
+
+/**
+ * Safe JSON parse utility
+ */
+const safeParseJSON = <T = Record<string, unknown>>(text?: string): T | undefined => {
+  if (typeof text !== 'string') return undefined;
+  try {
+    return JSON.parse(text) as T;
+  } catch {
+    return undefined;
+  }
+};
+
+/**
+ * Tool Arguments Repairer
+ *
+ * Handles repair of malformed tool call arguments caused by LLM string escape issues.
+ *
+ * When some LLMs (like Claude haiku-4.5) output tool calls, they may produce malformed JSON
+ * where the entire content gets stuffed into the first field with escaped quotes.
+ *
+ * @example Malformed data:
+ * ```javascript
+ * { description: 'real desc", "instruction": "real instruction", "timeout": 120}' }
+ * ```
+ *
+ * @example Expected data:
+ * ```javascript
+ * { description: 'real desc', instruction: 'real instruction', timeout: 120 }
+ * ```
+ *
+ * @example Usage:
+ * ```typescript
+ * const repairer = new ToolArgumentsRepairer(manifest);
+ * const args = repairer.parse('execTask', argumentsString);
+ * ```
+ */
+export class ToolArgumentsRepairer {
+  private manifest?: LobeToolManifest;
+
+  /**
+   * Create a new ToolArgumentsRepairer
+   * @param manifest - Tool manifest for schema lookup
+   */
+  constructor(manifest?: LobeToolManifest) {
+    this.manifest = manifest;
+  }
+
+  /**
+   * Parse and repair tool call arguments
+   *
+   * @param apiName - API name
+   * @param argumentsStr - Raw arguments string from LLM
+   * @returns Parsed and repaired arguments object
+   */
+  parse(apiName: string, argumentsStr: string): Record<string, unknown> {
+    const parsed = safeParseJSON<Record<string, unknown>>(argumentsStr) || {};
+
+    // Get API schema for repair
+    const apiSchema = this.manifest?.api?.find((a) => a.name === apiName)?.parameters;
+
+    return this.repair(parsed, apiSchema);
+  }
+
+  /**
+   * Repair malformed arguments using schema
+   *
+   * @param parsed - The parsed (but potentially malformed) arguments object
+   * @param schema - The JSON schema for the tool's parameters (with required fields)
+   * @returns The repaired arguments object
+   */
+  repair(parsed: Record<string, unknown>, schema?: ToolParameterSchema): Record<string, unknown> {
+    // If no schema or no required fields, skip repair
+    if (!schema?.required || !Array.isArray(schema.required) || schema.required.length === 0) {
+      return parsed;
+    }
+
+    const keys = Object.keys(parsed);
+    const missingFields = schema.required.filter((f) => !(f in parsed));
+
+    // If no missing required fields, no need to repair
+    if (missingFields.length === 0) {
+      return parsed;
+    }
+
+    // Check if any existing field's value contains the missing field patterns
+    // This indicates the string escape issue
+    for (const key of keys) {
+      const value = parsed[key];
+      if (typeof value !== 'string') continue;
+
+      // Check if value contains patterns like `", "missingField":` or `", \"missingField\":`
+      const hasMissingFieldPattern = missingFields.some(
+        (field) => value.includes(`", "${field}":`) || value.includes(`", \\"${field}\\":`),
+      );
+
+      if (hasMissingFieldPattern) {
+        // Try to reconstruct the correct JSON
+        // The value is actually: 'realValue", "field2": "value2", ...}'
+        // So we rebuild: '{"key": "realValue", "field2": "value2", ...}'
+        try {
+          const reconstructed = `{"${key}": "${value}`;
+          const repaired = JSON.parse(reconstructed) as Record<string, unknown>;
+
+          // Verify the repair was successful - all required fields should be present
+          const stillMissing = schema.required.filter((f) => !(f in repaired));
+          if (stillMissing.length === 0) {
+            return repaired;
+          }
+        } catch {
+          // Repair failed, continue to try other approaches or return original
+        }
+      }
+    }
+
+    // Could not repair, return original parsed data
+    return parsed;
+  }
+}