Method CreateMemoryAdhocNote

internal/api/core/memory.go:1136–1199

(c *gin.Context)

}

func (h *BaseHandlers) CreateMemoryAdhocNote(c *gin.Context) {
	var req contract.MemoryAdhocNoteRequest
	if err := c.ShouldBindJSON(&req); err != nil {
		h.respondMemoryError(
			c,
			http.StatusBadRequest,
			fmt.Errorf("%s: decode memory ad-hoc note request: %w", h.transportName(), err),
			nil,
		)
		return
	}
	content := strings.TrimSpace(req.Content)
	if content == "" {
		err := NewMemoryValidationError(errors.New("content is required"))
		h.respondMemoryError(c, StatusForMemoryError(err), err, nil)
		return
	}
	selector := memoryAdhocSelector(req)
	resolved, err := h.resolveMemorySelector(c.Request.Context(), selector, true)
	if err != nil {
		h.respondMemoryError(c, StatusForMemoryError(err), err, nil)
		return
	}
	store, err := h.memoryRecallStoreForSelector(c.Request.Context(), resolved)
	if err != nil {
		h.respondMemoryError(c, StatusForMemoryError(err), err, nil)
		return
	}
	createdAt := h.nowUTC()
	filename := memoryAdhocFilename(req.Slug, content, createdAt)
	decision, err := store.ProposeCandidate(c.Request.Context(), memcontract.Candidate{
		WorkspaceID: resolved.WorkspaceID,
		Scope:       resolved.Scope,
		AgentName:   resolved.AgentName,
		AgentTier:   resolved.AgentTier,
		Origin:      h.memoryOrigin(),
		Content:     content,
		Frontmatter: memcontract.Header{
			Name:        "Ad Hoc Memory Note",
			Description: memoryAdhocDescription(content),
			Type:        memoryTypeForScope(resolved.Scope),
			Scope:       resolved.Scope,
			AgentName:   resolved.AgentName,
			AgentTier:   resolved.AgentTier,
		},
		Metadata: map[string]string{
			memoryMetadataTargetFilenameKey: filename,
		},
		SubmittedAt: createdAt,
	})
	if err != nil {
		h.respondMemoryError(c, StatusForMemoryError(err), err, nil)
		return
	}
	if decision.Op == memcontract.OpReject {
		h.respondDecisionRejected(c, decision)
		return
	}